@cosmicdrift/kumiko-renderer 0.359.0 → 0.361.0

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

@@ -0,0 +1,16 @@
+import type { EditFieldSpec } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { CurrentUser } from "../current-user.js";
+type NormalizedEditField = Exclude<EditFieldSpec, string>;
+/** Calendar date (`YYYY-MM-DD`) of `now` in the given IANA zone. The en-CA
+ *  locale is used only because it formats dates as year-month-day. */
+export declare function todayInTimeZone(now: Date, timeZone: string): string;
+export type EditPrefillContext = {
+    readonly now: Date;
+    /** Fallback zone when the user carries none (resolver or browser zone). */
+    readonly fallbackTimeZone: string;
+    readonly user: CurrentUser | undefined;
+};
+/** Fills empty values of fields that declare `prefill`. Only meant for the
+ *  create form: existing values (defaults, URL params, handoff) always win. */
+export declare function applyEditPrefill(initial: Readonly<Record<string, unknown>>, specs: readonly NormalizedEditField[], context: EditPrefillContext): Record<string, unknown>;
+export {};

package/dist/app/edit-prefill.js

@@ -0,0 +1,30 @@
+/** Calendar date (`YYYY-MM-DD`) of `now` in the given IANA zone. The en-CA
+ *  locale is used only because it formats dates as year-month-day. */
+export function todayInTimeZone(now, timeZone) {
+    return new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+    }).format(now);
+}
+function isEmptyValue(value) {
+    return value === undefined || value === null || value === "";
+}
+/** Fills empty values of fields that declare `prefill`. Only meant for the
+ *  create form: existing values (defaults, URL params, handoff) always win. */
+export function applyEditPrefill(initial, specs, context) {
+    const out = { ...initial };
+    for (const spec of specs) {
+        const { prefill } = spec;
+        if (prefill === undefined || !isEmptyValue(out[spec.field]))
+            continue;
+        if (prefill.kind === "today") {
+            out[spec.field] = todayInTimeZone(context.now, context.user?.timeZone ?? context.fallbackTimeZone);
+        }
+        else if (context.user !== undefined) {
+            out[spec.field] = context.user[prefill.property];
+        }
+    }
+    return out;
+}

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

@@ -0,0 +1,8 @@
+import type { RenderEditAction } from "../components/render-edit-types.js";
+export declare function primaryHeaderAction(actions: readonly RenderEditAction[], preferredId?: string): RenderEditAction | undefined;
+export type CompactHeaderPrimary = {
+    readonly action: RenderEditAction;
+    readonly iconOnly: boolean;
+};
+export declare function compactHeaderPrimary(actions: readonly RenderEditAction[], preferredId?: string): CompactHeaderPrimary | undefined;
+export declare function orderPlainHeaderActions(actions: readonly RenderEditAction[], preferredId?: string): readonly RenderEditAction[];

package/dist/app/header-actions.js

@@ -0,0 +1,31 @@
+import { needsActionConfirm } from "../components/render-edit-action-button.js";
+// The primary header action always stays a visible text button: the screen's
+// declared `primaryAction` if it is visible, else `edit`, else the first
+// `style: "primary"` action, else the first action at all.
+export function primaryHeaderAction(actions, preferredId) {
+    const preferred = preferredId !== undefined ? actions.find((a) => a.id === preferredId) : undefined;
+    return (preferred ??
+        actions.find((a) => a.id === "edit") ??
+        actions.find((a) => a.style === "primary") ??
+        actions[0]);
+}
+// A bare icon for a destructive or confirm-gated action (e.g. "x" for
+// terminate) reads as "close", so only plain icon actions may stand alone.
+function canStandAsIconButton(action) {
+    return action?.icon !== undefined && action.style !== "danger" && !needsActionConfirm(action);
+}
+// A declared, visible `primaryAction` is always the phone header's button
+// (labelled when a bare icon would mislead), so it matches the desktop header
+// and `edit` moves into the menu. Without one the pencil-style icon action
+// stays visible, falling back to the precedence-only primary.
+export function compactHeaderPrimary(actions, preferredId) {
+    const declared = preferredId !== undefined ? actions.find((a) => a.id === preferredId) : undefined;
+    if (declared !== undefined)
+        return { action: declared, iconOnly: canStandAsIconButton(declared) };
+    const iconAction = primaryHeaderAction(actions);
+    return canStandAsIconButton(iconAction) ? { action: iconAction, iconOnly: true } : undefined;
+}
+export function orderPlainHeaderActions(actions, preferredId) {
+    const preferred = preferredId !== undefined ? actions.find((a) => a.id === preferredId) : undefined;
+    return preferred === undefined ? actions : [preferred, ...actions.filter((a) => a !== preferred)];
+}

package/dist/app/kumiko-screen.js

@@ -1,5 +1,5 @@
 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 { evalFieldCondition, isRecordLocked, isWriteFormEditSection, metricField, parseRefTarget, } from "@cosmicdrift/kumiko-framework/ui-types";
 import { applyFormatSpec, 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";
@@ -8,12 +8,13 @@ import { Fragment, useCallback, useEffect, useMemo, useRef, useState } from "rea
 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, } from "../components/render-edit-action-button.js";
+import { RenderEditActionButton } from "../components/render-edit-action-button.js";
 import { RenderList } from "../components/render-list.js";
 import { useActionMenuItems } from "../components/use-action-menu-items.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 { useOptionalCurrentUser } from "../current-user.js";
 import { REFERENCE_LIST_LOOKUP_LIMIT } from "../hooks/reference-limits.js";
 import { PAGE_SIZE_OPTIONS, useListUrlState } from "../hooks/use-list-url-state.js";
 import { useQuery } from "../hooks/use-query.js";
@@ -28,10 +29,13 @@ import { useAppFeatures } from "./app-features-context.js";
 import { buildConfigEditSchema, synthesizeConfigEditEntity, synthesizeConfigEditScreen, } from "./config-edit-shim.js";
 import { useCustomScreenComponent } from "./custom-screens.js";
 import { useDashboardBody } from "./dashboard-body.js";
+import { applyEditPrefill } from "./edit-prefill.js";
 import { EntityListExpandedRow } from "./entity-list-expanded-row.js";
 import { FacetCountBridges } from "./facet-count-bridge.js";
 import { buildFormSchema } from "./form-schema.js";
-import { hiddenRequiredFieldsFilled, layoutFieldNames } from "./layout-fields.js";
+import { compactHeaderPrimary, orderPlainHeaderActions, primaryHeaderAction, } from "./header-actions.js";
+import { hiddenRequiredFieldsFilled, layoutEditFields, layoutFieldNames } from "./layout-fields.js";
+import { 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";
@@ -651,20 +655,24 @@ function EntityEditCreateBody({ schema, screen, entity, translate, onSaved, }) {
     // without any such field.
     const tenantCurrencyFieldNames = useMemo(() => tenantCurrencyMoneyFieldNames(entity.fields), [entity.fields]);
     const { overrides: moneyCurrencyOverrides, loading: currencyLoading } = useMoneyCurrencyOverrides(entity.fields, tenantCurrencyFieldNames, entityDefaultCurrency);
-    const initial = useMemo(() => mergeSearchParamsIntoInitial(entity.fields, {
+    const currentUser = useOptionalCurrentUser();
+    const fallbackTimeZone = useOptionalTimeZone();
+    const initial = useMemo(() => applyEditPrefill(mergeSearchParamsIntoInitial(entity.fields, {
         searchParams: nav.searchParams,
         urlPrefillFields: screen.urlPrefillFields,
         renderableFields: layoutFieldNames(screen),
         defaultCurrency: entityDefaultCurrency,
         ...(moneyCurrencyOverrides !== undefined && { moneyCurrencyOverrides }),
         ...(handoffValues !== undefined && { handoffValues }),
-    }), [
+    }), layoutEditFields(screen), { now: new Date(), fallbackTimeZone, user: currentUser }), [
         entity.fields,
         nav.searchParams,
         screen,
         entityDefaultCurrency,
         moneyCurrencyOverrides,
         handoffValues,
+        currentUser,
+        fallbackTimeZone,
     ]);
     const formSchema = useMemo(() => buildFormSchema(entity, screen, "create"), [entity, screen]);
     const writeCommand = entityWriteCommand(schema.featureName, screen.entity, "create");
@@ -697,8 +705,7 @@ function EntityEditCreateBody({ schema, screen, entity, translate, onSaved, }) {
                 });
             }
             else {
-                const { screenId, entityId } = resolveRedirectTarget(redirect, result.data, schema, appFeatures, controlsRef.current?.getValues());
-                nav.navigate({ screenId, ...(entityId !== undefined && { entityId }) });
+                navigateToRedirectTarget(nav, resolveRedirectTarget(redirect, result.data, schema, appFeatures, controlsRef.current?.getValues()));
             }
         }
         else {
@@ -929,14 +936,21 @@ function EntityEditUpdateForm({ schema, screen, entity, entityId, record, onRelo
     if (currencyLoading) {
         return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
     }
-    return (_jsxs(_Fragment, { children: [_jsx(RenderEdit, { screen: screen, entity: entity, featureName: schema.featureName, initial: initial, 
+    // Evaluated against the stored record only, so typing in a form can never
+    // flip the screen between editable and view.
+    // Either condition shows the view: the server rejects saves of a locked record
+    // whatever the screen says, so a screen condition can only add read-only, never lift it.
+    // A record without the lock field counts as locked (isRecordLocked), matching the server.
+    const viewMode = (screen.readOnly !== undefined && evalFieldCondition(screen.readOnly, record)) ||
+        isRecordLocked(entity.lockedWhen, record);
+    return (_jsxs(_Fragment, { children: [_jsx(RenderEdit, { screen: screen, entity: entity, featureName: schema.featureName, initial: initial, ...(viewMode && { viewMode: true }), 
                 // Real route id for the extension section (set-value UI): the update
                 // form deliberately keeps `id` out of the form values, so the section
                 // needs it explicitly — otherwise it renders in create mode.
                 entityId: entityId, 
                 // Stored customFields for the extension section, so editing shows the
                 // persisted values instead of behaving write-only.
-                extensionInitialValues: extensionInitialValues, schema: formSchema, writeCommand: writeCommand, payloadMode: "changes", buildPayload: buildPayload, serverFieldPathPrefix: `${UPDATE_CHANGES_KEY}.`, onSubmit: handleSubmitted, onDirtyChange: setFormDirty, ...(screen.allowDelete !== false && { onDelete: handleDelete }), onCancel: handleCancel, onReload: () => void onReload(), ...(screenFillsHeight(screen) && { fillScreenHeight: true }), ...(screen.submitLabel !== undefined && { submitLabel: screen.submitLabel }), ...(translate !== undefined && { translate }), ...(onCopyLink !== undefined && { onCopyLink }), ...(headerActions !== undefined && { actions: headerActions }), ...(headerMenuActions !== undefined && { menuActions: headerMenuActions }), buildSectionActions: buildSectionActions }), _jsx(DrawerHost, { schema: schema, drawerAction: drawerAction, drawerScreen: drawerScreen, ...(drawerInitialValues !== undefined && { drawerInitialValues }), userRoles: userRoles, ...(translate !== undefined && { translate }), onClose: closeDrawer, onSuccess: () => {
+                extensionInitialValues: extensionInitialValues, schema: formSchema, writeCommand: writeCommand, payloadMode: "changes", buildPayload: buildPayload, serverFieldPathPrefix: `${UPDATE_CHANGES_KEY}.`, onSubmit: handleSubmitted, onDirtyChange: setFormDirty, ...(screen.allowDelete !== false && !viewMode && { onDelete: handleDelete }), onCancel: handleCancel, onReload: () => void onReload(), ...(screenFillsHeight(screen) && { fillScreenHeight: true }), ...(screen.submitLabel !== undefined && { submitLabel: screen.submitLabel }), ...(translate !== undefined && { translate }), ...(onCopyLink !== undefined && { onCopyLink }), ...(headerActions !== undefined && { actions: headerActions }), ...(headerMenuActions !== undefined && { menuActions: headerMenuActions }), buildSectionActions: buildSectionActions }), _jsx(DrawerHost, { schema: schema, drawerAction: drawerAction, drawerScreen: drawerScreen, ...(drawerInitialValues !== undefined && { drawerInitialValues }), userRoles: userRoles, ...(translate !== undefined && { translate }), onClose: closeDrawer, onSuccess: () => {
                     closeDrawer();
                     void onReload();
                 } })] }));
@@ -1478,6 +1492,13 @@ function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
         refreshRowsAfterWrite,
         openDrawer,
     ]);
+    const emptyContent = useListEmptyContent(screen.emptyState, effectiveTranslate, {
+        nav,
+        host,
+        dispatcher,
+        openDrawer,
+        onWriteSuccess: refreshRowsAfterWrite,
+    });
     // Expandable rows: open state is keyed by row id, so it survives refetch,
     // sort and page changes. Several rows can be open at once.
     const expandableRow = screen.expandableRow;
@@ -1554,7 +1575,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, refreshNonce: facetCountRefreshNonce }), _jsx(RenderList, { screen: screen, entity: entity, rows: renderRows, featureName: featureName, searchable: searchable, searchValue: urlState.q, onSearchChange: urlState.setQ, sort: effectiveSort, onSortChange: urlState.setSort, ...(isEmbeddedScreen
+    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 && {
+                    description: effectiveTranslate(screen.description),
+                }), ...(emptyContent !== undefined && { emptyContent }), 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,
@@ -1730,6 +1753,13 @@ function ProjectionListBody({ schema, screen, translate, onRowClick, }) {
         rowsQuery.refetch,
         openDrawer,
     ]);
+    const emptyContent = useListEmptyContent(screen.emptyState, effectiveTranslate, {
+        nav,
+        host,
+        dispatcher,
+        openDrawer,
+        onWriteSuccess: rowsQuery.refetch,
+    });
     if (rowsQuery.loading && rowsQuery.data === null) {
         return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
     }
@@ -1764,7 +1794,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, ...(isEmbeddedScreen
+    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 && {
+                    description: effectiveTranslate(screen.description),
+                }), ...(emptyContent !== undefined && { emptyContent }), 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,
@@ -1873,7 +1905,7 @@ function buildSubtitleParts(parts, record, nav, appFeatures, userRoles, host) {
 function headerStatusTone(header, record) {
     if (header.status === undefined)
         return undefined;
-    const value = String(record[header.status] ?? "");
+    const value = String(record[header.statusToneField ?? header.status] ?? "");
     const declared = header.statusTones !== undefined && Object.hasOwn(header.statusTones, value)
         ? header.statusTones[value]
         : undefined;
@@ -1896,40 +1928,28 @@ function resolveSubtitleHref(header, record) {
 // natives Form-Submit (Enter-Keypress) würde ohne customSubmit gegen
 // controller.submit() ohne submit-config throwen — der No-Op macht diesen
 // Pfad harmlos statt ihn dem Zufall zu überlassen.
-// The primary header action always stays a visible text button — `edit` if
-// declared, else the first `style: "primary"` action, else the first action
-// at all. One step longer than row actions' `primaryRowAction` (renderer-web
-// primitives/index.tsx): rows don't declare `style: "primary"`.
-function primaryHeaderAction(actions) {
-    return (actions.find((a) => a.id === "edit") ?? actions.find((a) => a.style === "primary") ?? actions[0]);
-}
 // Header actions bar (A7): <=2 actions render as plain buttons; >2 with an
 // `ActionOverflowMenu` primitive collapse to the primary button plus a menu
 // for the rest — same rule as RowActionsCell for table rows. Owns confirm
 // state for menu items: RenderEditActionButton already owns a per-button
 // confirm dialog for the always-visible primary action, but a menu item has
 // no button of its own to carry one.
-function HeaderActionsBar({ actions, Button, Dialog, ActionOverflowMenu, onError, collapseAfterPrimary = false, compact = false, PageHeader, }) {
+function HeaderActionsBar({ actions, Button, Dialog, ActionOverflowMenu, onError, collapseAfterPrimary = false, compact = false, preferredPrimaryId, PageHeader, }) {
     const t = useTranslation();
     const { toMenuItem, confirmDialog: pendingActionDialog } = useActionMenuItems({
         Dialog,
         onError,
     });
     if (compact && PageHeader !== undefined) {
-        const primary = primaryHeaderAction(actions);
-        // A bare icon for a destructive or confirm-gated action (e.g. "x" for terminate)
-        // reads as "close"; such actions go to the labelled menu instead.
-        const iconPrimary = primary?.icon !== undefined && primary.style !== "danger" && !needsActionConfirm(primary)
-            ? primary
-            : undefined;
-        const overflowActions = actions.filter((a) => a !== iconPrimary);
-        return (_jsxs(_Fragment, { children: [iconPrimary !== undefined && (_jsx(RenderEditActionButton, { action: iconPrimary, Button: Button, Dialog: Dialog, iconOnly: true, onError: onError }, iconPrimary.id)), overflowActions.length > 0 && (_jsx(PageHeader, { overflowItems: overflowActions.map(toMenuItem) })), pendingActionDialog] }));
+        const compactPrimary = compactHeaderPrimary(actions, preferredPrimaryId);
+        const overflowActions = actions.filter((a) => a !== compactPrimary?.action);
+        return (_jsxs(_Fragment, { children: [compactPrimary !== undefined && (_jsx(RenderEditActionButton, { action: compactPrimary.action, Button: Button, Dialog: Dialog, iconOnly: compactPrimary.iconOnly, compactLabel: true, onError: onError }, compactPrimary.action.id)), overflowActions.length > 0 && (_jsx(PageHeader, { overflowItems: overflowActions.map(toMenuItem) })), pendingActionDialog] }));
     }
     const maxPlainButtons = collapseAfterPrimary ? 1 : 2;
     if (actions.length <= maxPlainButtons || ActionOverflowMenu === undefined) {
-        return (_jsx(_Fragment, { children: actions.map((action) => (_jsx(RenderEditActionButton, { action: action, Button: Button, Dialog: Dialog, hideIcon: true, onError: onError }, action.id))) }));
+        return (_jsx(_Fragment, { children: orderPlainHeaderActions(actions, preferredPrimaryId).map((action) => (_jsx(RenderEditActionButton, { action: action, Button: Button, Dialog: Dialog, hideIcon: true, onError: onError }, action.id))) }));
     }
-    const primary = primaryHeaderAction(actions);
+    const primary = primaryHeaderAction(actions, preferredPrimaryId);
     const rest = actions.filter((a) => a.id !== primary?.id);
     return (_jsxs(_Fragment, { children: [primary !== undefined && (_jsx(RenderEditActionButton, { action: primary, Button: Button, Dialog: Dialog, hideIcon: true, onError: onError }, primary.id)), _jsx(ActionOverflowMenu, { label: t("kumiko.list.row-actions.more"), testId: "kumiko-screen-projection-detail-actions-overflow", items: rest.map(toMenuItem) }), pendingActionDialog] }));
 }
@@ -2172,7 +2192,7 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
     // 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 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, ...(screen.primaryAction !== undefined && { preferredPrimaryId: screen.primaryAction }) }) }));
     // 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
@@ -2207,15 +2227,19 @@ function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
     const metricsBlock = (subtitle, lead) => MetricBand !== undefined ? (_jsx(MetricBand, { testId: "kumiko-screen-projection-detail-metrics", subtitle: subtitle, ...(lead !== undefined && { lead }), children: metricItems })) : (_jsx(Grid, { columns: screen.metrics?.length ?? 1, testId: "kumiko-screen-projection-detail-metrics", children: metricItems }));
     const usesPageHeaderSlot = pageHeaderSlotAvailable && PageHeader !== undefined;
     const pageHeaderCompact = pageHeaderCompactContext && usesPageHeaderSlot;
+    // The phone shell header clips a long status mid-word, so on phones the badge
+    // sits in the body instead of the shell header slot.
+    const statusBadge = header?.status !== undefined && StatusBadge !== undefined ? (_jsx(StatusBadge, { value: String(record[header.status] ?? ""), tone: headerStatusTone(header, record), testId: "kumiko-screen-projection-detail-status" })) : undefined;
+    // Lives in the band's subtitle row so it shares the metrics' horizontal inset.
+    const bandSubtitle = pageHeaderCompact && statusBadge !== undefined ? (_jsxs(_Fragment, { children: [_jsx(Grid, { columns: "auto", testId: "kumiko-screen-projection-detail-status-row", children: statusBadge }), headerSubtitleSlot] })) : (headerSubtitleSlot);
     const actionErrorBanner = actionError !== null && (_jsx(Banner, { variant: "error", testId: "render-edit-action-error", children: actionError }));
-    const renderHeaderContent = (headerSlot) => (_jsxs(_Fragment, { children: [usesPageHeaderSlot ? (_jsxs(_Fragment, { children: [_jsx(PageHeader, { ...(header !== undefined && { title: String(record[header.title] ?? "") }), ...(header === undefined && recordTitle !== undefined && { title: recordTitle }), ...(header?.status !== undefined &&
-                            StatusBadge !== undefined && {
-                            status: (_jsx(StatusBadge, { value: String(record[header.status] ?? ""), tone: headerStatusTone(header, record), testId: "kumiko-screen-projection-detail-status" })),
-                        }), ...(hasHeaderActions && {
-                            actions: (_jsx(Grid, { columns: "auto", testId: "kumiko-screen-projection-detail-actions", children: _jsx(HeaderActionsBar, { actions: headerActionsList, Button: Button, Dialog: Dialog, ActionOverflowMenu: ActionOverflowMenu, onError: setActionError, collapseAfterPrimary: true, compact: pageHeaderCompact, PageHeader: PageHeader }) })),
-                        }) }), MetricBand === undefined && headerSubtitleSlot, MetricBand === undefined && headerSlot, (hasMetrics || headerSubtitleSlot !== undefined || headerSlot !== undefined) &&
+    const renderHeaderContent = (headerSlot) => (_jsxs(_Fragment, { children: [usesPageHeaderSlot ? (_jsxs(_Fragment, { children: [_jsx(PageHeader, { ...(header !== undefined && { title: String(record[header.title] ?? "") }), ...(header === undefined && recordTitle !== undefined && { title: recordTitle }), ...(!pageHeaderCompact && statusBadge !== undefined && { status: statusBadge }), ...(hasHeaderActions && {
+                            actions: (_jsx(Grid, { columns: "auto", testId: "kumiko-screen-projection-detail-actions", children: _jsx(HeaderActionsBar, { actions: headerActionsList, Button: Button, Dialog: Dialog, ActionOverflowMenu: ActionOverflowMenu, onError: setActionError, collapseAfterPrimary: true, compact: pageHeaderCompact, PageHeader: PageHeader, ...(screen.primaryAction !== undefined && {
+                                        preferredPrimaryId: screen.primaryAction,
+                                    }) }) })),
+                        }) }), MetricBand === undefined && bandSubtitle, MetricBand === undefined && headerSlot, (hasMetrics || bandSubtitle !== undefined || headerSlot !== undefined) &&
                         (MetricBand !== undefined || hasMetrics) &&
-                        metricsBlock(headerSubtitleSlot, MetricBand !== undefined ? headerSlot : undefined), actionErrorBanner] })) : ((hasHeaderCard || headerSlot !== undefined || recordTitle !== undefined) && (_jsxs(Card, { slots: {
+                        metricsBlock(bandSubtitle, MetricBand !== undefined ? headerSlot : undefined), actionErrorBanner] })) : ((hasHeaderCard || headerSlot !== undefined || recordTitle !== undefined) && (_jsxs(Card, { slots: {
                     ...(headerTitleSlot !== undefined && { title: headerTitleSlot }),
                     ...(headerTitleSlot === undefined &&
                         recordTitle !== undefined && { title: recordTitle }),
@@ -2309,10 +2333,24 @@ function resolveRedirectTarget(redirect, submittedData, schema, appFeatures, fal
     const target = findRedirectTargetScreen(redirect, schema, appFeatures);
     const carriesId = target !== undefined && (target.type === "entityEdit" || target.type === "projectionDetail");
     if (!carriesId)
-        return { screenId: targetId, entityId: undefined };
+        return { screenId: targetId, entityId: undefined, tab: undefined };
     const entityId = extractIdField(submittedData, idField) ??
         (fallbackRecord !== undefined ? extractIdField(fallbackRecord, idField) : undefined);
-    return { screenId: targetId, entityId };
+    return {
+        screenId: targetId,
+        entityId,
+        tab: typeof redirect === "string" ? undefined : redirect.tab,
+    };
+}
+function navigateToRedirectTarget(nav, target) {
+    const navTarget = {
+        screenId: target.screenId,
+        ...(target.entityId !== undefined && { entityId: target.entityId }),
+    };
+    if (target.tab === undefined)
+        nav.navigate(navTarget);
+    else
+        nav.navigate(navTarget, { searchParams: { tab: target.tab } });
 }
 // Success navigation for a configured redirect — shared by entityEdit's
 // save and writeHandler record actions. The string form navigates without an
@@ -2328,8 +2366,7 @@ function navigateAfterRedirect(options) {
         nav.navigate({ screenId: lastSegment(redirect) });
         return;
     }
-    const { screenId, entityId } = resolveRedirectTarget(redirect, resultData, schema, appFeatures, record);
-    nav.navigate({ screenId, ...(entityId !== undefined && { entityId }) });
+    navigateToRedirectTarget(nav, resolveRedirectTarget(redirect, resultData, schema, appFeatures, record));
 }
 // The update payload nests the saved projection under `data`; a changed
 // parent FK lives there, not in the pre-edit `record`.
@@ -2423,8 +2460,7 @@ function ActionFormBody({ schema, screen, translate, initialOverrides, onSuccess
                 navigateToReturn(nav, returnTarget);
             }
             else {
-                const { screenId, entityId } = resolveRedirectTarget(screen.redirect, result.data, schema, appFeatures);
-                nav.navigate({ screenId, ...(entityId !== undefined && { entityId }) });
+                navigateToRedirectTarget(nav, resolveRedirectTarget(screen.redirect, result.data, schema, appFeatures));
             }
         }
     }, [

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

@@ -0,0 +1,8 @@
+import type { ListEmptyStateSpec } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { Translate } from "@cosmicdrift/kumiko-headless";
+import type { ListEmptyStateContent } from "../components/list-empty-state.js";
+import { buildRecordActions } from "./row-actions.js";
+type ActionBindings = Pick<Parameters<typeof buildRecordActions>[0], "nav" | "host" | "dispatcher" | "openDrawer" | "onWriteSuccess">;
+export declare function useListEmptyContent(spec: ListEmptyStateSpec | undefined, translate: Translate, bindings: ActionBindings): ListEmptyStateContent | undefined;
+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

@@ -0,0 +1,42 @@
+import { useMemo } from "react";
+import { buildRecordActions } from "./row-actions.js";
+const NO_RECORD = {};
+// An empty list has no row, so the action is resolved against an empty record.
+export function useListEmptyContent(spec, translate, bindings) {
+    const { nav, host, dispatcher, openDrawer, onWriteSuccess } = bindings;
+    return useMemo(() => {
+        if (spec === undefined)
+            return undefined;
+        const action = spec.action === undefined
+            ? undefined
+            : buildRecordActions({
+                actions: [spec.action],
+                record: NO_RECORD,
+                translate,
+                nav,
+                host,
+                dispatcher,
+                openDrawer,
+                onWriteSuccess,
+            })?.[0];
+        return {
+            title: translate(spec.title),
+            ...(spec.description !== undefined && { description: translate(spec.description) }),
+            ...(action !== undefined && { action }),
+        };
+    }, [spec, translate, nav, host, dispatcher, openDrawer, onWriteSuccess]);
+}
+// Facets with a default are only "narrowed" once the user moved off that default.
+export function isListNarrowed(search, filters, defaultFilters = {}) {
+    if (search.trim() !== "")
+        return true;
+    const fields = new Set([...Object.keys(filters), ...Object.keys(defaultFilters)]);
+    for (const field of fields) {
+        const current = filters[field] ?? [];
+        const baseline = defaultFilters[field] ?? [];
+        if (current.length !== baseline.length || current.some((v) => !baseline.includes(v))) {
+            return true;
+        }
+    }
+    return false;
+}

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

@@ -141,6 +141,7 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
                 type: cell.type,
                 required: cell.required,
                 derived: isDerived,
+                ...(cell.readOnly === true && { readOnly: true }),
                 referenceOptions,
                 referenceLoading: query?.loading ?? false,
             };
@@ -151,8 +152,10 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
             type: cell.type,
             required: cell.required,
             derived: isDerived,
+            ...(cell.readOnly === true && { readOnly: true }),
             ...(cell.options !== undefined && { options: cell.options }),
             ...(cell.optionLabels !== undefined && { optionLabels: cell.optionLabels }),
+            ...(cell.display !== undefined && { display: cell.display }),
         };
     });
     const totals = (field.embeddedListTotals ?? []).map((subFieldName) => {
@@ -222,6 +225,7 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
     }
     function handlePasteCells(rowIndex, columnIndex, grid) {
         const maxItems = field.embeddedListMaxItems;
+        const fixedRows = field.embeddedListFixedRows === true;
         const nextRows = [...rows];
         const touchedIndices = new Set();
         let droppedRows = 0;
@@ -229,7 +233,7 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
         grid.forEach((gridRow, gridRowOffset) => {
             const targetRowIndex = rowIndex + gridRowOffset;
             if (targetRowIndex >= nextRows.length) {
-                if (maxItems !== undefined && nextRows.length >= maxItems) {
+                if (fixedRows || (maxItems !== undefined && nextRows.length >= maxItems)) {
                     droppedRows += 1;
                     return;
                 }
@@ -241,7 +245,7 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
             let updatedRow = { ...targetRow };
             gridRow.forEach((text, gridColOffset) => {
                 const column = columns[columnIndex + gridColOffset];
-                if (column === undefined)
+                if (column === undefined || column.readOnly === true)
                     return;
                 const coerced = coerceCellValue(column, text, field.embeddedListCurrency ?? "EUR");
                 // Also covers an unparseable money paste (e.g. mangled thousands
@@ -263,5 +267,5 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
         const recomputed = nextRows.map((row, i) => touchedIndices.has(i) ? withRecomputedDerived(row, derived, cells) : row);
         onChange(recomputed);
     }
-    return (_jsx(EmbeddedListInput, { id: id, columns: columns, rows: rows, totals: totals, currency: field.embeddedListCurrency, disabled: field.readOnly, minItems: field.embeddedListMinItems, maxItems: field.embeddedListMaxItems, listIssues: combinedListIssues, rowIssues: rowIssues, cellIssues: cellIssues, onCellChange: handleCellChange, onAddRow: handleAddRow, onRemoveRow: handleRemoveRow, onDuplicateRow: handleDuplicateRow, onMoveRow: handleMoveRow, onPasteCells: handlePasteCells, addLabel: t("kumiko.field.embedded-list.add-row"), removeLabel: t("kumiko.field.embedded-list.remove-row"), duplicateLabel: t("kumiko.field.embedded-list.duplicate-row"), moveUpLabel: t("kumiko.field.embedded-list.move-up"), moveDownLabel: t("kumiko.field.embedded-list.move-down"), emptyLabel: t("kumiko.field.embedded-list.empty"), emptyCtaLabel: t("kumiko.field.embedded-list.empty-cta"), testId: id }));
+    return (_jsx(EmbeddedListInput, { id: id, columns: columns, rows: rows, totals: totals, currency: field.embeddedListCurrency, disabled: field.readOnly, fixedRows: field.embeddedListFixedRows, minItems: field.embeddedListMinItems, maxItems: field.embeddedListMaxItems, listIssues: combinedListIssues, rowIssues: rowIssues, cellIssues: cellIssues, onCellChange: handleCellChange, onAddRow: handleAddRow, onRemoveRow: handleRemoveRow, onDuplicateRow: handleDuplicateRow, onMoveRow: handleMoveRow, onPasteCells: handlePasteCells, addLabel: t("kumiko.field.embedded-list.add-row"), actionsLabel: t("kumiko.field.embedded-list.actions"), removeLabel: t("kumiko.field.embedded-list.remove-row"), duplicateLabel: t("kumiko.field.embedded-list.duplicate-row"), moveUpLabel: t("kumiko.field.embedded-list.move-up"), moveDownLabel: t("kumiko.field.embedded-list.move-down"), emptyLabel: t("kumiko.field.embedded-list.empty"), emptyCtaLabel: t("kumiko.field.embedded-list.empty-cta"), testId: id }));
 }

package/dist/components/file-list-field.d.ts

@@ -0,0 +1,10 @@
+import type { EditFieldViewModel } from "@cosmicdrift/kumiko-headless";
+import type { ReactNode } from "react";
+export type FileListFieldProps = {
+    readonly field: EditFieldViewModel;
+    readonly id: string;
+    readonly kind: "file" | "image";
+    readonly onChange: (value: readonly string[]) => void;
+    readonly hasError: boolean;
+};
+export declare function FileListField({ field, id, kind, onChange, hasError, }: FileListFieldProps): ReactNode;

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

@@ -0,0 +1,49 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useTranslation } from "../i18n.js";
+import { usePrimitives } from "../primitives.js";
+function isFileIdList(value) {
+    return Array.isArray(value);
+}
+function readFileIds(value) {
+    if (!isFileIdList(value))
+        return [];
+    return value.filter((entry) => typeof entry === "string" && entry !== "");
+}
+export function FileListField({ field, id, kind, onChange, hasError, }) {
+    const { Input, Button, Grid, GridCell, Text } = usePrimitives();
+    const t = useTranslation();
+    const fileIds = readFileIds(field.value);
+    const disabled = field.readOnly;
+    const canAdd = !disabled && (field.maxCount === undefined || fileIds.length < field.maxCount);
+    const inputProps = {
+        kind,
+        name: field.field,
+        disabled,
+        hasError,
+        ...(field.accept !== undefined && { accept: field.accept }),
+        ...(field.maxSize !== undefined && { maxSize: field.maxSize }),
+        ...(field.entityType !== undefined && { entityType: field.entityType }),
+        ...(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 }),
+    };
+    function move(fromIndex, toIndex) {
+        const next = [...fileIds];
+        const [moved] = next.splice(fromIndex, 1);
+        if (moved === undefined)
+            return;
+        next.splice(toIndex, 0, moved);
+        onChange(next);
+    }
+    return (_jsxs(Grid, { columns: 1, testId: `${id}-file-list`, children: [fileIds.length === 0 && _jsx(Text, { variant: "muted", children: t("kumiko.field.file-list.empty") }), fileIds.map((fileId, index) => (_jsxs(GridCell, { children: [_jsx(Input, { ...inputProps, id: `${id}-${index}`, value: fileId, onChange: (next) => {
+                            if (next === null)
+                                onChange(fileIds.filter((_, i) => i !== index));
+                            else
+                                onChange(fileIds.map((existing, i) => (i === index ? next : existing)));
+                        } }), !disabled && (_jsxs(Grid, { columns: "auto", children: [index > 0 && (_jsx(Button, { variant: "ghost", size: "icon", icon: "chevron-up", ariaLabel: t("kumiko.field.file-list.move-up"), testId: `${id}-${index}-move-up`, onClick: () => move(index, index - 1) })), index < fileIds.length - 1 && (_jsx(Button, { variant: "ghost", size: "icon", icon: "chevron-down", ariaLabel: t("kumiko.field.file-list.move-down"), testId: `${id}-${index}-move-down`, onClick: () => move(index, index + 1) }))] }))] }, fileId))), canAdd && (_jsxs(GridCell, { children: [_jsx(Text, { variant: "muted", children: t("kumiko.field.file-list.add") }), _jsx(Input, { ...inputProps, id: `${id}-add`, value: null, onChange: (next) => {
+                            if (next !== null)
+                                onChange([...fileIds, next]);
+                        } })] }, "add"))] }));
+}

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

@@ -0,0 +1,14 @@
+import { type ReactNode } from "react";
+import type { RenderEditAction } from "./render-edit-types.js";
+export type ListEmptyStateContent = {
+    readonly title: string;
+    readonly description?: string;
+    readonly action?: RenderEditAction;
+};
+export declare function ListEmptyStateBody({ content, narrowed, 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;
+    readonly createButton: ReactNode;
+    readonly translate: (key: string) => string;
+}): ReactNode;

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

@@ -0,0 +1,12 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { usePrimitives } from "../primitives.js";
+import { RenderEditActionButton } from "./render-edit-action-button.js";
+export function ListEmptyStateBody({ content, narrowed, createButton, translate, }) {
+    const { Text, Button, Dialog, Banner } = usePrimitives();
+    const [actionError, setActionError] = useState(null);
+    if (narrowed)
+        return _jsx(Text, { children: translate("kumiko.list.empty.filtered") });
+    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/render-edit-action-button.d.ts

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

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

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

package/dist/components/render-edit-types.d.ts

@@ -160,12 +160,14 @@ export type RenderEditProps<TValues extends FormValues, TCtx = unknown> = {
      *  no way to force-disable an arbitrary registered component. Omitting
      *  this prop keeps unchanged behavior.
      *
-     *  ponytail: direct-consumer only — kumiko-screen.tsx's RenderEdit call
-     *  sites pass explicit prop lists without a spread and never forward
-     *  `disabled`, so a screen-driven app can't set the locked state today.
-     *  Upgrade path if that's needed: thread a screen-spec flag through to
-     *  `EntityEditCreateBody`/`EntityEditEditBody`. */
+     *  Screen-driven read-only is `viewMode`, not this flag. */
     readonly disabled?: boolean;
+    /** Read-only view of an existing record (`EntityEditScreenDefinition.readOnly`):
+     *  every field is disabled, no submit, discard or dirty footer, and the title
+     *  resolves `screen:<id>.view.title` first. The host omits `onDelete`; record
+     *  actions and cancel stay. UI only: server-side protection is the access
+     *  rules and write handlers. */
+    readonly viewMode?: boolean;
     /** Renders the fields without RenderEdit's own action bar (save, cancel,
      *  delete, copy-link). For hosts that put those controls into their own
      *  chrome — a drawer footer, a wizard shell — and drive the write through

package/dist/components/render-edit.js

@@ -224,7 +224,9 @@ function resolveTitleTemplate(template, values, translate, fallback) {
     return translate(template, values);
 }
 export function RenderEdit(props) {
-    const { screen, entity, featureName, initial, writeCommand, translate: translateProp, ctx, schema, onSubmit, payloadMode = "values", buildPayload, serverFieldPathPrefix, onDelete, onCancel, onReload, refreshToken, onDirtyChange, onCopyLink, actions, menuActions, onRelatedListDrawerAction, submitLabel, submitVariant, submitWithoutChanges, footerActions, summary, labelAppendix, fieldAppendix, fieldAppendixPlacement, fieldDescription, fieldAccent, markChangedFields = false, entityId: entityIdProp, extensionInitialValues, onChange, onControlsReady, fields: fieldsFilter, disabled = false, hideActions, valueDisplay = "form", hideSectionTitles, fillScreenHeight, dirtyFooter, validateOnChange, headerRegion, buildSectionActions, leadContent, submitBlocked = false, } = props;
+    const { screen, entity, featureName, initial, writeCommand, translate: translateProp, ctx, schema, onSubmit, payloadMode = "values", buildPayload, serverFieldPathPrefix, onDelete, onCancel, onReload, refreshToken, onDirtyChange, onCopyLink, actions, menuActions, onRelatedListDrawerAction, submitLabel, submitVariant, submitWithoutChanges, footerActions, summary, labelAppendix, fieldAppendix, fieldAppendixPlacement, fieldDescription, fieldAccent, markChangedFields = false, entityId: entityIdProp, extensionInitialValues, onChange, onControlsReady, fields: fieldsFilter, disabled: disabledProp = false, viewMode = false, hideActions, valueDisplay = "form", hideSectionTitles, fillScreenHeight, dirtyFooter, validateOnChange, headerRegion, buildSectionActions, leadContent, submitBlocked = false, } = props;
+    // View mode is a locked form, so everything keyed on `disabled` follows.
+    const disabled = disabledProp || viewMode;
     const i18nScreenId = props.i18nScreenId ?? screen.id;
     const { customSubmit } = props;
     // Translate-Fallback: wenn der Caller keine Translate-Fn übergibt,
@@ -631,7 +633,17 @@ export function RenderEdit(props) {
         translate,
         featureName,
         mode: writeVerb,
-    }), [screen, entity, snapshot.values, translate, featureName, writeVerb]);
+        ...(!isCreateMode && entityIdProp != null && { entityId: entityIdProp }),
+    }), [
+        screen,
+        entity,
+        snapshot.values,
+        translate,
+        featureName,
+        writeVerb,
+        isCreateMode,
+        entityIdProp,
+    ]);
     const filteredSections = useMemo(
     // A fully-hidden "fields" section (every field in it currently
     // condition-hidden) must not occupy a wizard step; it would render
@@ -1121,10 +1133,11 @@ export function RenderEdit(props) {
     // draw a no-op Save. Extension registrations still get their Save, since
     // persistExtensions() runs on the customSubmit path too.
     const isFieldlessSubmitForm = isFieldless && screen.entity !== PROJECTION_DETAIL_ENTITY;
-    const showsSubmit = isFormEditable ||
-        hasExtensionRegistrations ||
-        isFieldlessSubmitForm ||
-        submitWithoutChanges !== undefined;
+    const showsSubmit = !viewMode &&
+        (isFormEditable ||
+            hasExtensionRegistrations ||
+            isFieldlessSubmitForm ||
+            submitWithoutChanges !== undefined);
     const footerSlot = screen.slots?.footer;
     // An unregistered footer component renders null, so only a resolvable one may
     // count as an action (else read-only screens get an empty footer strip).
@@ -1150,6 +1163,7 @@ export function RenderEdit(props) {
     // Edit-mode screen forms always carry the dirty status (0 = quiet "No unsaved
     // changes"); wizards keep the status-only-when-dirty behaviour.
     const hasDirtyFooter = !isWizard &&
+        !viewMode &&
         (dirtyFooter === true || (isScreenForm && !isCreate && headerRegion === undefined));
     const unsavedCount = !hasDirtyFooter
         ? undefined
@@ -1180,7 +1194,7 @@ export function RenderEdit(props) {
                             ? "kumiko.form.saveChanges"
                             : "kumiko.actions.save")) })), writeFormFooterAction] }));
     // Title + Subtitle, create/edit-bewusst. i18n-Keys (mode = "create"|"edit"):
-    //   screen:<id>.<mode>.title / .<mode>.subtitle
+    //   screen:<id>.<mode>.title / .<mode>.subtitle  (mode = "create"|"edit"|"view")
     // Fallback-Kette: mode-spezifisch → generisch (screen:<id>.title/.subtitle).
     // title falls back to screenId; subtitle falls back to screen.description,
     // itself run through translate() so an i18n key (the established
@@ -1189,7 +1203,7 @@ export function RenderEdit(props) {
     // prose, same as it does for an unknown key (fw#2723 review). Same slot
     // section.description already fills for a section. Falls back to
     // undefined (no subtitle) when neither is set.
-    const formMode = isCreate ? "create" : "edit";
+    const formMode = isCreate ? "create" : viewMode ? "view" : "edit";
     const recordTitle = !isCreate && screen.recordTitleField !== undefined
         ? resolveRecordTitle(initial[screen.recordTitleField])
         : undefined;

package/dist/components/render-field.js

@@ -15,6 +15,7 @@ import { useLocale, useTranslation } from "../i18n.js";
 import { usePrimitives } from "../primitives.js";
 import { AvailabilityOptionsMultiSelect, AvailabilityOptionsSelect, staticSelectOptions, } from "./availability-options-select.js";
 import { EmbeddedListField } from "./embedded-list-field.js";
+import { FileListField } from "./file-list-field.js";
 import { MultiSelectCheckboxes } from "./multi-select-checkboxes.js";
 import { QueryOptionsSelect } from "./query-options-select.js";
 import { ReferenceCreateDialog } from "./reference-create-dialog.js";
@@ -45,7 +46,7 @@ export function RenderField({ field, issues, onChange, featureName, labelAppendi
     // Komponente gemountet werden (nicht als pure render-Call).
     const control = field.readOnly && field.renderer !== undefined ? (_jsx(FieldRendererOutput, { field: field, renderer: field.renderer, appLocale: appLocale, ...(row !== undefined && { row }) })) : field.type === "embedded" && field.embeddedListCells !== undefined ? (_jsx(EmbeddedListField, { field: field, id: id, onChange: onChange, allIssues: allIssues ?? {}, featureName: featureName ?? "" })) : field.type === "reference" ? (readOnlyText ? (_jsx(ReadOnlyReferenceValue, { field: field, featureName: featureName ?? "" })) : (_jsx(ReferenceInput, { field: field, id: id, hasError: hasError, onChange: onChange, Input: Input, featureName: featureName ?? "" }))) : field.type === "select" && field.selectOptionsQuery !== undefined && !readOnlyText ? (_jsx(QueryOptionsSelect, { field: field, query: field.selectOptionsQuery.query, payload: field.selectOptionsQuery.payload, row: row ?? { [field.field]: field.value }, id: id, hasError: hasError, onChange: onChange })) : field.type === "select" &&
         field.selectOptionsAvailabilityQuery !== undefined &&
-        !readOnlyText ? (_jsx(AvailabilityOptionsSelect, { field: field, query: field.selectOptionsAvailabilityQuery.query, payload: field.selectOptionsAvailabilityQuery.payload, row: row ?? { [field.field]: field.value }, id: id, hasError: hasError, onChange: onChange })) : readOnlyText && !isComplexFieldType(field.type) ? (_jsx(Text, { testId: `field-value-${field.field}`, children: readOnlyDisplayText(field, appLocale, t) })) : field.type === "text" && field.writeOnly === true && !readOnlyText ? (_jsx(WriteOnlyTextInput, { field: field, id: id, hasError: hasError, onChange: onChange, changed: changed === true })) : (renderInput({
+        !readOnlyText ? (_jsx(AvailabilityOptionsSelect, { field: field, query: field.selectOptionsAvailabilityQuery.query, payload: field.selectOptionsAvailabilityQuery.payload, row: row ?? { [field.field]: field.value }, id: id, hasError: hasError, onChange: onChange })) : readOnlyText && !isComplexFieldType(field.type) && !isFileFieldType(field.type) ? (_jsx(Text, { testId: `field-value-${field.field}`, children: readOnlyDisplayText(field, appLocale, t) })) : field.type === "text" && field.writeOnly === true && !readOnlyText ? (_jsx(WriteOnlyTextInput, { field: field, id: id, hasError: hasError, onChange: onChange, changed: changed === true })) : (renderInput({
         field,
         id,
         hasError,
@@ -276,11 +277,16 @@ function ReadOnlyReferenceValue({ field, featureName, }) {
     return _jsx(Text, { testId: `field-value-${field.field}`, children: labels.join(", ") });
 }
 // Field types whose read display already isn't a boxed "disabled input" look
-// (embedded/jsonb render as an info Banner, files/images as an unsupported-
-// type Banner) — `readOnlyDisplayText` doesn't cover these, they keep going
-// through `renderInput`'s existing Banner branch in text-display mode too.
+// (embedded/jsonb render as an info Banner) — `readOnlyDisplayText` doesn't
+// cover these, they keep going through `renderInput`'s existing Banner branch
+// in text-display mode too.
 function isComplexFieldType(type) {
-    return type === "embedded" || type === "jsonb" || type === "files" || type === "images";
+    return type === "embedded" || type === "jsonb";
+}
+// Read-only file fields keep their (disabled) widget: it shows a thumbnail or
+// the file name, where plain text could only show the FileRef UUID.
+function isFileFieldType(type) {
+    return type === "file" || type === "image" || type === "files" || type === "images";
 }
 // Mirrors ACTION_ICON_BY_ID (kumiko-screen.tsx) for fields: only names with
 // an unambiguous matching FieldIconKey are listed here, everything else
@@ -383,22 +389,21 @@ function renderInput({ field, id, hasError, onChange, Input, appLocale, Banner,
         case "image": {
             const kind = field.type === "image" ? "image" : "file";
             const fileId = typeof field.value === "string" && field.value !== "" ? field.value : null;
-            return (_jsx(Input, { kind: kind, ...common, value: fileId, onChange: (v) => onChange(v), ...(field.accept !== undefined && { accept: field.accept }), ...(field.maxSize !== undefined && { maxSize: field.maxSize }), ...(field.entityType !== undefined && { entityType: field.entityType }), ...(field.fieldName !== undefined && { fieldName: field.fieldName }), ...(field.imageVariant !== undefined && { imageVariant: field.imageVariant }), ...(field.capture !== undefined && { capture: field.capture }) }));
+            return (_jsx(Input, { kind: kind, ...common, value: fileId, onChange: (v) => onChange(v), ...(field.accept !== undefined && { accept: field.accept }), ...(field.maxSize !== undefined && { maxSize: field.maxSize }), ...(field.entityType !== undefined && { entityType: field.entityType }), ...(field.entityId !== undefined && { entityId: field.entityId }), ...(field.fieldName !== undefined && { fieldName: field.fieldName }), ...(field.imageVariant !== undefined && { imageVariant: field.imageVariant }), ...(field.capture !== undefined && { capture: field.capture }) }));
         }
+        case "files":
+        case "images":
+            return (_jsx(FileListField, { field: field, id: id, kind: field.type === "images" ? "image" : "file", hasError: hasError, onChange: (ids) => onChange(ids) }));
         // embedded (without embeddedListCells — that's embeddedList, which has
         // had its own EmbeddedListField widget since #1838) and jsonb carry
-        // arbitrary objects; files/images carry a FileRef-UUID array and have
-        // no multi-upload widget yet (deliberately deferred, #1925). Without a
-        // dedicated widget these must NOT fall through to a text input:
-        // stringValue() turns them into "[object Object]" / a comma-joined
-        // string, and saving that overwrites the real data with the mangled
-        // string (#1834). A `required: true` on any of these is caught loudly
+        // arbitrary objects. Without a dedicated widget these must NOT fall
+        // through to a text input: stringValue() turns them into
+        // "[object Object]" and saving that overwrites the real data with the
+        // mangled string (#1834). A `required: true` on either is caught loudly
         // at boot (validateNoWidgetRequiredField in the framework package)
         // instead of silently failing here.
         case "embedded":
-        case "jsonb":
-        case "files":
-        case "images": {
+        case "jsonb": {
             const hasValue = field.value !== undefined && field.value !== null && field.value !== "";
             return (_jsxs(Banner, { id: id, variant: "info", children: [t("kumiko.field.unsupported"), hasValue &&
                         (JsonView !== undefined ? (_jsx(JsonView, { value: field.value, testId: `field-value-${field.field}` })) : (_jsx(Text, { variant: "code", children: JSON.stringify(field.value) })))] }));
@@ -556,9 +561,6 @@ function readOnlyDisplayText(field, appLocale, t) {
                 .map((v) => (typeof v === "string" ? (labels?.[v] ?? v) : stringValue(v)))
                 .join(", ");
         }
-        case "file":
-        case "image":
-            return typeof value === "string" ? value : "—";
         default:
             return stringValue(value);
     }

package/dist/components/render-list.d.ts

@@ -3,6 +3,7 @@ import type { ListRowViewModel, Translate } from "@cosmicdrift/kumiko-headless";
 import { type ReactNode } from "react";
 import type { ListSort } from "../hooks/use-list-url-state.js";
 import { type DataTableDateRangeFacet, type DataTableFacet, type DataTableProps, type DataTableRowAction, type DataTableRowActionMode, type DataTableRowGrouping } from "../primitives.js";
+import { type ListEmptyStateContent } from "./list-empty-state.js";
 export type RenderListProps = {
     readonly screen: EntityListScreenDefinition;
     readonly entity: EntityDefinition;
@@ -27,8 +28,12 @@ export type RenderListProps = {
     /** Placeholder für das Search-Input. Default kommt aus dem i18n-
      *  Bundle (`kumiko.list.search-placeholder`). */
     readonly searchPlaceholder?: string;
-    /** Hint at the left of the toolbar when there is no search box (already translated). */
+    /** Hint at the left of the toolbar (already translated). */
     readonly description?: string;
+    /** Author-declared replacement for the default empty box (already translated). */
+    readonly emptyContent?: ListEmptyStateContent;
+    /** Search or filters changed the result; the empty box then says "no matches". */
+    readonly narrowed?: boolean;
     /** Plural-forms key for the footer count noun; default is the entity's `:noun` convention key. */
     readonly itemNounKey?: string;
     /** Aktueller Search-Term (vom URL-State / Parent). RenderList puffert

package/dist/components/render-list.js

@@ -6,6 +6,7 @@ import { useReferenceLookup } from "../hooks/use-reference-lookup.js";
 import { useTranslation } from "../i18n.js";
 import { usePageHeaderCompact, usePageHeaderSlotAvailable } from "../page-header-slot.js";
 import { shouldRenderActionsIconOnly, usePrimitives, } from "../primitives.js";
+import { ListEmptyStateBody } from "./list-empty-state.js";
 import { needsActionConfirm } from "./render-edit-action-button.js";
 const SEARCH_DEBOUNCE_MS = 300;
 // Icon-less actions are promoted too (with a "plus" fallback at the call site).
@@ -13,12 +14,12 @@ function isHeaderPromotableToolbarAction(action) {
     return action.style === "primary" && !needsActionConfirm(action);
 }
 export function RenderList(props) {
-    const { screen, entity, rows, featureName, translate: translateProp, onRowClick, emptyState, onCreate, createLabel, searchable = false, searchPlaceholder, description, itemNounKey, searchValue, onSearchChange, sort, onSortChange, pager, onReachEnd, loadingMore, hasMore, rowActions, rowActionMode, rowGrouping, rowTone, toolbarActions, filterFacets, filterValues, onFilterChange, onFilterReset, dateRangeFacets, onDateRangeChange, chromeless, scrollBody, screenPadding, expandedRowIds, onToggleRowExpanded, renderExpandedRow, } = props;
+    const { screen, entity, rows, featureName, translate: translateProp, onRowClick, emptyState, onCreate, createLabel, searchable = false, searchPlaceholder, description, emptyContent, narrowed = false, itemNounKey, searchValue, onSearchChange, sort, onSortChange, pager, onReachEnd, loadingMore, hasMore, rowActions, rowActionMode, rowGrouping, rowTone, toolbarActions, filterFacets, filterValues, onFilterChange, onFilterReset, dateRangeFacets, onDateRangeChange, chromeless, scrollBody, screenPadding, expandedRowIds, onToggleRowExpanded, renderExpandedRow, } = props;
     // Wie RenderEdit: Translate-Fallback aus dem i18next-Context, sonst
     // wären Column-Header raw i18n-Keys.
     const t = useTranslation();
     const translate = translateProp ?? t;
-    const { DataTable, Button, Dialog, Input, Text, Banner, PageHeader } = usePrimitives();
+    const { DataTable, Button, Dialog, Input, Banner, PageHeader } = usePrimitives();
     const pageHeaderSlotAvailable = usePageHeaderSlotAvailable();
     const pageHeaderCompact = usePageHeaderCompact();
     const createInPageHeader = onCreate !== undefined && PageHeader !== undefined && pageHeaderSlotAvailable;
@@ -168,7 +169,7 @@ export function RenderList(props) {
     // Wenn weder onCreate noch ein Override gegeben ist, fällt die
     // DataTable auf den DataTable-Default zurück (`kumiko.list.no-entries`).
     const composedEmptyState = emptyState ??
-        (onCreate !== undefined ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: translate("kumiko.list.empty.title") }), _jsx(Text, { variant: "small", children: translate("kumiko.list.empty.hint") }), _jsx(Button, { variant: "primary", icon: "plus", onClick: onCreate, testId: "render-list-empty-create", children: effectiveCreateLabel })] })) : undefined);
+        (onCreate !== undefined || emptyContent !== undefined || narrowed ? (_jsx(ListEmptyStateBody, { content: emptyContent, narrowed: narrowed, translate: translate, createButton: onCreate !== undefined && !narrowed ? (_jsx(Button, { variant: "primary", icon: "plus", onClick: onCreate, testId: "render-list-empty-create", children: effectiveCreateLabel })) : undefined })) : undefined);
     // Title-Resolution: ein konventioneller i18n-Key `screen:<id>.title`.
     // Wenn das Bundle den Key kennt, schöner Titel; sonst kommt der
     // screenId selber raus (kein "Untitled"-Fallback — der App-Dev sieht
@@ -177,7 +178,7 @@ export function RenderList(props) {
     const resolvedTitle = translate(titleKey);
     const toolbarTitle = resolvedTitle === titleKey ? screen.id : resolvedTitle;
     // ListSort = DataTableSort (use-list-url-state aliased) — kein Cast nötig.
-    return (_jsxs(_Fragment, { children: [createInPageHeader && PageHeader !== undefined && _jsx(PageHeader, { actions: createButton }), promotedActionButton !== undefined && PageHeader !== undefined && (_jsx(PageHeader, { actions: promotedActionButton })), referenceColumns.map((rc) => (_jsx(ReferenceLookupBridge, { field: rc.field, refEntity: rc.refEntity, labelField: rc.labelField, featureName: rc.refFeature, onMap: handleLookupMap }, rc.field))), _jsx(DataTable, { columns: enrichedVm.columns, rows: enrichedVm.rows, toolbarTitle: toolbarTitle, ...(onRowClick !== undefined && { onRowClick }), ...(composedEmptyState !== undefined && { emptyState: composedEmptyState }), ...(toolbarStart !== undefined && { toolbarStart }), ...(description !== undefined && !searchable && { toolbarDescription: description }), ...(toolbarEnd !== undefined && { toolbarEnd }), ...(sort !== undefined && { sort }), ...(onSortChange !== undefined && { onSortChange }), ...(pager !== undefined && { pager }), ...(onReachEnd !== undefined && { onReachEnd }), ...(loadingMore !== undefined && { loadingMore }), ...(hasMore !== undefined && { hasMore }), ...(itemNoun !== undefined && { itemNoun }), ...(rowActions !== undefined && { rowActions }), ...(rowActionMode !== undefined && { rowActionMode }), ...(rowGrouping !== undefined && { rowGrouping }), ...(rowTone !== undefined && { rowTone }), ...(filterFacets !== undefined && { filterFacets }), ...(filterValues !== undefined && { filterValues }), ...(onFilterChange !== undefined && { onFilterChange }), ...(onFilterReset !== undefined && { onFilterReset }), ...(dateRangeFacets !== undefined && { dateRangeFacets }), ...(onDateRangeChange !== undefined && { onDateRangeChange }), ...(chromeless !== undefined && { chromeless }), ...(scrollBody !== undefined && { scrollBody }), ...(screenPadding !== undefined && { screenPadding }), ...(expandedRowIds !== undefined && { expandedRowIds }), ...(onToggleRowExpanded !== undefined && { onToggleRowExpanded }), ...(renderExpandedRow !== undefined && { renderExpandedRow }), testId: "render-list-table" })] }));
+    return (_jsxs(_Fragment, { children: [createInPageHeader && PageHeader !== undefined && _jsx(PageHeader, { actions: createButton }), promotedActionButton !== undefined && PageHeader !== undefined && (_jsx(PageHeader, { actions: promotedActionButton })), referenceColumns.map((rc) => (_jsx(ReferenceLookupBridge, { field: rc.field, refEntity: rc.refEntity, labelField: rc.labelField, featureName: rc.refFeature, onMap: handleLookupMap }, rc.field))), _jsx(DataTable, { columns: enrichedVm.columns, rows: enrichedVm.rows, toolbarTitle: toolbarTitle, ...(onRowClick !== undefined && { onRowClick }), ...(composedEmptyState !== undefined && { emptyState: composedEmptyState }), ...(toolbarStart !== undefined && { toolbarStart }), ...(description !== undefined && { toolbarDescription: description }), ...(toolbarEnd !== undefined && { toolbarEnd }), ...(sort !== undefined && { sort }), ...(onSortChange !== undefined && { onSortChange }), ...(pager !== undefined && { pager }), ...(onReachEnd !== undefined && { onReachEnd }), ...(loadingMore !== undefined && { loadingMore }), ...(hasMore !== undefined && { hasMore }), ...(itemNoun !== undefined && { itemNoun }), ...(rowActions !== undefined && { rowActions }), ...(rowActionMode !== undefined && { rowActionMode }), ...(rowGrouping !== undefined && { rowGrouping }), ...(rowTone !== undefined && { rowTone }), ...(filterFacets !== undefined && { filterFacets }), ...(filterValues !== undefined && { filterValues }), ...(onFilterChange !== undefined && { onFilterChange }), ...(onFilterReset !== undefined && { onFilterReset }), ...(dateRangeFacets !== undefined && { dateRangeFacets }), ...(onDateRangeChange !== undefined && { onDateRangeChange }), ...(chromeless !== undefined && { chromeless }), ...(scrollBody !== undefined && { scrollBody }), ...(screenPadding !== undefined && { screenPadding }), ...(expandedRowIds !== undefined && { expandedRowIds }), ...(onToggleRowExpanded !== undefined && { onToggleRowExpanded }), ...(renderExpandedRow !== undefined && { renderExpandedRow }), testId: "render-list-table" })] }));
 }
 // Header-Slot in der Listen-Toolbar (toolbarEnd): `screen.slots.header` ist
 // eine PlatformComponent (`{ react: { __component: "X" } }`), aufgelöst über

package/dist/current-user.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from "react";
+/** The signed-in user as the renderer sees it. Provided by the auth layer
+ *  (auth-email-password's SessionProvider); absent in apps without one. */
+export type CurrentUser = {
+    readonly id: string;
+    readonly email: string;
+    readonly displayName: string;
+    /** Effective IANA zone of the user (override, else tenant). */
+    readonly timeZone?: string;
+};
+export declare function CurrentUserProvider({ user, children, }: {
+    readonly user: CurrentUser | undefined;
+    readonly children: ReactNode;
+}): ReactNode;
+/** Non-throwing: undefined outside a provider or while signed out. */
+export declare function useOptionalCurrentUser(): CurrentUser | undefined;

package/dist/current-user.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const CurrentUserContext = createContext(undefined);
+export function CurrentUserProvider({ user, children, }) {
+    return _jsx(CurrentUserContext.Provider, { value: user, children: children });
+}
+/** Non-throwing: undefined outside a provider or while signed out. */
+export function useOptionalCurrentUser() {
+    return useContext(CurrentUserContext);
+}

package/dist/i18n-defaults.js

@@ -45,6 +45,17 @@ export const kumikoDefaultTranslations = {
         "kumiko.field.writeOnly.setPlaceholder": "Set — leave empty to keep it",
         "kumiko.field.writeOnly.undo": "Undo",
         "kumiko.field.writeOnly.willRemove": "Removed on save",
+        "kumiko.field.embedded-list.actions": "Actions",
+        "kumiko.field.embedded-list.cell-label": "{column}, row {row}",
+        "kumiko.field.file-list.add": "Add file",
+        "kumiko.field.file-list.move-up": "Move file up",
+        "kumiko.field.file-list.move-down": "Move file down",
+        "kumiko.field.file-list.empty": "No files yet.",
+        "kumiko.field.file-upload.attached": "File attached",
+        "kumiko.field.file-upload.change": "Change",
+        "kumiko.field.file-upload.failed": "Upload failed",
+        "kumiko.field.file-upload.remove": "Remove",
+        "kumiko.field.file-upload.upload": "Upload",
         "kumiko.field.embedded-list.add-row": "Add row",
         "kumiko.field.embedded-list.remove-row": "Remove row",
         "kumiko.field.embedded-list.duplicate-row": "Duplicate row",
@@ -58,6 +69,7 @@ export const kumikoDefaultTranslations = {
         "kumiko.field.multiSelect.deselect-all": "Deselect all",
         "kumiko.list.search-placeholder": "Search…",
         "kumiko.list.empty.title": "No entries yet.",
+        "kumiko.list.empty.filtered": "No entries match the current search or filters.",
         "kumiko.list.empty.hint": "Create the first one to get started.",
         "kumiko.list.no-entries": "No entries.",
         "kumiko.record.not-found.title": "This record was not found.",
@@ -242,6 +254,7 @@ export const kumikoDefaultTranslations = {
         "errors.conflict": "Conflict — the operation could not be completed.",
         "errors.versionConflict": "The record was modified in the meantime. Reload and try again.",
         "errors.preconditionFailed": "The record changed in the meantime. Reload and try again.",
+        "errors.recordLocked": "This record is locked and can no longer be changed.",
         "errors.uniqueViolation": "This entry already exists.",
         "errors.unprocessable": "The request could not be processed.",
         "errors.unconfigured": "This feature isn't configured yet.",

package/dist/index.d.ts

@@ -48,6 +48,8 @@ export { DraftStorageProvider, useDraftStorage } from "./context/draft-storage-c
 export { EmbeddedScreenProvider, useIsEmbeddedScreen } from "./context/embedded-screen-context.js";
 export type { UserRolesProviderProps } from "./context/user-roles-context.js";
 export { UserRolesProvider, useUserRoles } from "./context/user-roles-context.js";
+export type { CurrentUser } from "./current-user.js";
+export { CurrentUserProvider, useOptionalCurrentUser } from "./current-user.js";
 export { formatWhen } from "./format-when.js";
 export { REFERENCE_COMBOBOX_LIMIT, REFERENCE_LIST_LOOKUP_LIMIT, REFERENCE_SEARCH_DEBOUNCE_MS, } from "./hooks/reference-limits.js";
 export type { AiTextActionState, AiTextMode, AiTextRewriteStyle, AiTextRunPayload, AiTextRunResult, AiTextUsage, UseAiTextActionResult, UseCompletionResult, } from "./hooks/use-ai-text.js";

package/dist/index.js

@@ -37,6 +37,7 @@ export { DispatcherProvider, useDispatcher, useDispatcherStatus, useOptionalDisp
 export { DraftStorageProvider, useDraftStorage } from "./context/draft-storage-context.js";
 export { EmbeddedScreenProvider, useIsEmbeddedScreen } from "./context/embedded-screen-context.js";
 export { UserRolesProvider, useUserRoles } from "./context/user-roles-context.js";
+export { CurrentUserProvider, useOptionalCurrentUser } from "./current-user.js";
 export { formatWhen } from "./format-when.js";
 export { REFERENCE_COMBOBOX_LIMIT, REFERENCE_LIST_LOOKUP_LIMIT, REFERENCE_SEARCH_DEBOUNCE_MS, } from "./hooks/reference-limits.js";
 export { AI_TEXT_RUN_QN, useAiTextAction, useCompletion } from "./hooks/use-ai-text.js";

package/dist/primitives.d.ts

@@ -295,6 +295,9 @@ export type InputProps = {
     readonly name: string;
     /** FileRef-UUID (gespeicherte Datei) oder null (kein Upload). */
     readonly value: string | null;
+    /** Implementations must offer their own remove control that calls
+     *  `onChange(null)`: FileListField relies on it to drop a file from an
+     *  `images`/`files` field. */
     readonly onChange: (fileId: string | null) => void;
     readonly disabled?: boolean;
     readonly required?: boolean;
@@ -305,6 +308,9 @@ export type InputProps = {
     /** Für den Upload-POST `/api/files` — der Endpoint prüft maxSize/accept
      *  gegen die Field-Def von (entityType, fieldName). */
     readonly entityType?: string;
+    /** Must be sent as the `entityId` part of the upload so the FileRef is
+     *  attached to the record (qr overlays and access guards need it). */
+    readonly entityId?: string;
     readonly fieldName?: string;
     /** Only for kind:"image" — variant name for the preview
      *  (`/api/files/:id/variant/:name`). Absent → the original. */
@@ -755,9 +761,14 @@ export type EmbeddedListColumn = {
     /** Read-only, value supplied by the caller (already computed from
      *  sibling cells) — not directly user-editable. */
     readonly derived: boolean;
+    /** Shown but not editable by the user; unlike `derived` it is not computed. */
+    readonly readOnly?: boolean;
     /** Only for `type: "select"`. */
     readonly options?: readonly string[];
     readonly optionLabels?: Readonly<Record<string, string>>;
+    /** Only for `type: "select"`; `"radio"` renders segmented buttons, the
+     *  default is a dropdown. */
+    readonly display?: "radio" | "dropdown";
     /** Only for `type: "reference"` — pre-fetched by the caller, ONE query
      *  per column shared across every row (not one query per cell). */
     readonly referenceOptions?: readonly {
@@ -791,6 +802,8 @@ export type EmbeddedListInputProps = {
     /** Whole-list read-only (e.g. a released invoice) — hides row-mutation
      *  affordances and disables every cell. */
     readonly disabled?: boolean;
+    /** Rows are fixed: no add, remove, duplicate or move; cells stay editable. */
+    readonly fixedRows?: boolean;
     readonly minItems?: number;
     readonly maxItems?: number;
     /** Shown under the whole list (e.g. under the totals row). */
@@ -810,6 +823,8 @@ export type EmbeddedListInputProps = {
      *  handling wired up. */
     readonly onPasteCells?: (rowIndex: number, columnIndex: number, grid: readonly (readonly string[])[]) => void;
     readonly addLabel: string;
+    /** Accessible name of the (otherwise headerless) row-actions column. */
+    readonly actionsLabel: string;
     readonly removeLabel: string;
     readonly duplicateLabel: string;
     readonly moveUpLabel: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.359.0",
+  "version": "0.361.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.359.0",
-    "@cosmicdrift/kumiko-headless": "0.359.0",
-    "@cosmicdrift/kumiko-types": "0.359.0",
+    "@cosmicdrift/kumiko-framework": "0.361.0",
+    "@cosmicdrift/kumiko-headless": "0.361.0",
+    "@cosmicdrift/kumiko-types": "0.361.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.359.0"
+    "@cosmicdrift/kumiko-locale-de": "0.361.0"
   },
   "repository": {
     "type": "git",

package/src/changes.json

@@ -1,4 +1,47 @@
 [
+  {
+    "version": "0.361.0",
+    "type": "improvement",
+    "title": "Create form prefill and CurrentUserProvider",
+    "detail": "EntityEditCreateBody applies prefill to empty initial values. New exports CurrentUser, CurrentUserProvider and useOptionalCurrentUser."
+  },
+  {
+    "version": "0.361.0",
+    "type": "improvement",
+    "title": "Read-only view mode for entityEdit",
+    "detail": "RenderEdit takes viewMode, which disables all fields and removes submit, discard, delete and the dirty footer while keeping record actions and cancel. The update body sets it when screen.readOnly holds for the record and resolves screen:<id>.view.title before screen:<id>.title."
+  },
+  {
+    "version": "0.361.0",
+    "type": "improvement",
+    "title": "EmbeddedListColumn.readOnly and EmbeddedListInput fixedRows",
+    "detail": "EmbeddedListField forwards both, skips readOnly columns when pasting and never appends rows from a paste when rows are fixed."
+  },
+  {
+    "version": "0.361.0",
+    "type": "improvement",
+    "title": "EmbeddedListColumn.display",
+    "detail": "EmbeddedListField forwards the select display to the EmbeddedListInput primitive."
+  },
+  {
+    "version": "0.361.0",
+    "type": "improvement",
+    "title": "entityEdit shows locked records as a view",
+    "detail": "EntityEditUpdateForm shows the view when screen.readOnly matches or entity.lockedWhen matches or its field is missing from the record. Adds the default string errors.recordLocked."
+  },
+  {
+    "version": "0.361.0",
+    "type": "breaking",
+    "title": "Searchable lists show their description as its own row",
+    "detail": "An entityList or projectionList with search used to hide its description. It now renders as a muted row below the toolbar, the same as on lists without search.",
+    "migration": "Look at lists that set description together with search. Drop descriptions that were only kept as a hint for developers, or move the text into emptyState if it explains an empty list."
+  },
+  {
+    "version": "0.360.0",
+    "type": "improvement",
+    "title": "FileListField edits images and files fields",
+    "detail": "RenderField renders type images and files as FileListField instead of the unsupported banner. One tile per stored FileRef id with move up, move down and remove buttons, one trailing empty tile to add a file (hidden at maxCount or when read-only). It is built from Input kind file or image, Button and the layout primitives, passes accept, maxSize, entityType, entityId, fieldName, imageVariant and capture to every tile, and reads only string ids from the stored value. The read-only text display of these fields lists the ids. New i18n keys kumiko.field.file-list.add, move-up, move-down and empty; kumiko.field.file-upload.upload, change, remove, attached and failed; kumiko.field.embedded-list.actions and cell-label. The file and image Input kinds accept entityId. EmbeddedListInput has a new required actionsLabel prop."
+  },
   {
     "version": "0.357.0",
     "type": "improvement",