@cosmicdrift/kumiko-renderer 0.328.0 → 0.329.0

package/dist/app/kumiko-screen.js

@@ -0,0 +1,2206 @@
+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 { fieldLabelKey, fieldOptionLabelKey, isSafeHref } from "@cosmicdrift/kumiko-headless";
+import { resolveActionIcon } from "@cosmicdrift/kumiko-types/action-icon";
+import { TENANT_CURRENCY_CONFIG_KEY } from "@cosmicdrift/kumiko-types/fields";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+import { extractCreatedId, extractIdField } from "../components/reference-create-dialog.js";
+import { RenderEdit, } from "../components/render-edit.js";
+import { needsActionConfirm, RenderEditActionButton, RenderEditActionConfirmDialog, } from "../components/render-edit-action-button.js";
+import { RenderList } from "../components/render-list.js";
+import { useDispatcher, useOptionalDispatcher } from "../context/dispatcher-context.js";
+import { useUserRoles } from "../context/user-roles-context.js";
+import { PAGE_SIZE_OPTIONS, useListUrlState } from "../hooks/use-list-url-state.js";
+import { useQuery } from "../hooks/use-query.js";
+import { useLocale, useOptionalTimeZone, useTranslation } from "../i18n.js";
+import { InsideDrawerProvider, useInsideDrawer } from "../inside-drawer.js";
+import { PageHeaderSlotAvailableProvider, usePageHeaderSlotAvailable, } from "../page-header-slot.js";
+import { statusToneForOptionTone, statusToneForValue, usePrimitives, } from "../primitives.js";
+import { screenFillsHeight } from "../screen-fills-height.js";
+import { synthesizeActionFormEntity, synthesizeActionFormScreen } from "./action-form-shim.js";
+import { useAppFeatures } from "./app-features-context.js";
+import { synthesizeConfigEditEntity, synthesizeConfigEditScreen } from "./config-edit-shim.js";
+import { useCustomScreenComponent } from "./custom-screens.js";
+import { useDashboardBody } from "./dashboard-body.js";
+import { buildFormSchema } from "./form-schema.js";
+import { layoutFieldNames } from "./layout-fields.js";
+import { buildDateRangePayload, buildFilterFacets, buildFilterPayload, clampDateRange, mergeReferenceFacetOptions, readDateRange, resolveDateRangeFacets, resolveProjectionFacetSpecs, } from "./list-facets.js";
+import { useInitialValuesHandoff, useNav } from "./nav.js";
+import { synthesizeProjectionDetailEntity, synthesizeProjectionDetailScreen, } from "./projection-detail-shim.js";
+import { synthesizeProjectionEntity, synthesizeProjectionScreen } from "./projection-list-shim.js";
+import { lastSegment, toKebab } from "./qn.js";
+import { featureNameFromQualifiedScreenId, qualifyScreenId } from "./qualify-screen-id.js";
+import { ReferenceFacetBridges } from "./reference-facet-bridge.js";
+import { navigateToReturn, navigateToReturnOr, navigateWithReturnTo, ReturnHostProvider, useReturnHost, useReturnTarget, } from "./return-to.js";
+import { buildDefaultEditRowAction, buildProjectionRowActions, buildProjectionToolbarActions, buildRecordActions, evalRowExtractor, isWriteHandlerRowAction, navigateActionSearchParams, refetchAfterWrite, runProjectionRowNavigate, } from "./row-actions.js";
+import { findEditScreenFor, navigateTargetAllows, screenAccessAllows } from "./screen-access.js";
+import { SecretMintBody } from "./secret-mint-body.js";
+import { SecretsEditBody } from "./secrets-edit-body.js";
+import { dispatcherErrorText, WriteFailedError } from "./write-failed-error.js";
+export { qualifyScreenId };
+/** Mirrors qualifyScreenId for nav QNs (registry form `<feature>:nav:<short-id>`).
+ *  Callers building QNs (e.g. the WorkspaceShell resolver) should use this instead of string-concat, so a QN-schema change only touches one place. */
+export function qualifyNavId(featureName, navId) {
+    return `${featureName}:nav:${navId}`;
+}
+export { screenAccessAllows };
+export function KumikoScreen({ schema, qn, translate, entityId, onRowClick, onCopyLink, }) {
+    const { Banner, Text } = usePrimitives();
+    const userRoles = useUserRoles();
+    const outerHost = useReturnHost();
+    const screen = useMemo(() => schema.screens.find((s) => qualifyScreenId(schema.featureName, s.id) === qn), [schema.featureName, schema.screens, qn]);
+    // Computed before the early returns below — hooks must run unconditionally.
+    const ownHost = useMemo(() => ({
+        screenId: screen !== undefined ? lastSegment(screen.id) : "",
+        ...(entityId !== undefined && { entityId }),
+    }), [screen, entityId]);
+    if (!screen) {
+        return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-not-found", children: ["Screen not found: ", _jsx(Text, { variant: "code", children: qn })] }));
+    }
+    if (!screenAccessAllows(screen.access, userRoles)) {
+        return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-access-denied", children: ["Access denied: ", _jsx(Text, { variant: "code", children: qn })] }));
+    }
+    const body = renderScreenBody({ schema, screen, translate, entityId, onRowClick, onCopyLink });
+    // An embedded screen (e.g. a dashboard panel) keeps its parent's host and
+    // must not portal its page header into the shell that hosts the outer screen.
+    if (outerHost !== undefined) {
+        return _jsx(PageHeaderSlotAvailableProvider, { value: false, children: body });
+    }
+    return _jsx(ReturnHostProvider, { value: ownHost, children: body });
+}
+function renderScreenBody({ schema, screen, translate, entityId, onRowClick, onCopyLink, }) {
+    switch (screen.type) {
+        case "entityEdit":
+            return (_jsx(EntityEditScreen, { schema: schema, screen: screen, translate: translate, ...(entityId !== undefined && { entityId }), ...(onCopyLink !== undefined && { onCopyLink }) }));
+        case "entityList":
+            return (_jsx(EntityListScreen, { schema: schema, screen: screen, translate: translate, ...(onRowClick !== undefined && { onRowClick }) }));
+        case "projectionList":
+            return (_jsx(ProjectionListBody, { schema: schema, screen: screen, translate: translate, ...(onRowClick !== undefined && { onRowClick }) }));
+        case "projectionDetail":
+            return (_jsx(ProjectionDetailBody, { schema: schema, screen: screen, translate: translate, ...(entityId !== undefined && { entityId }) }, entityId ?? "no-entity"));
+        case "dashboard":
+            return (_jsx(DashboardScreenBody, { featureName: schema.featureName, screen: screen, translate: translate }));
+        case "actionForm":
+            return _jsx(ActionFormBody, { schema: schema, screen: screen, translate: translate });
+        case "secretMint":
+            return _jsx(SecretMintBody, { schema: schema, screen: screen, translate: translate });
+        case "configEdit":
+            return _jsx(ConfigEditBody, { schema: schema, screen: screen, translate: translate });
+        case "secretsEdit":
+            return _jsx(SecretsEditBody, { screen: screen, translate: translate });
+        case "custom":
+            return _jsx(CustomScreenBody, { screenId: screen.id, featureName: schema.featureName });
+    }
+}
+// Injection-Body für dashboard-Screens: die Panel-Implementierung (StatCard,
+// Charts) ist plattform-spezifisch und kommt aus dem DashboardBody-Context
+// (renderer-web registriert die Web-Variante in createKumikoApp).
+function DashboardScreenBody({ featureName, screen, translate, }) {
+    const { Banner, Text } = usePrimitives();
+    const Body = useDashboardBody();
+    if (Body === undefined) {
+        return (_jsxs(Banner, { padded: true, variant: "info", testId: "kumiko-screen-dashboard-placeholder", children: ["Dashboard screen ", _jsx(Text, { variant: "code", children: screen.id }), " \u2014 kein Dashboard-Body registriert (createKumikoApp aus ", _jsx(Text, { variant: "code", children: "kumiko-renderer-web" }), " wired ihn automatisch)."] }));
+    }
+    return (_jsx(Body, { featureName: featureName, screen: screen, ...(translate !== undefined && { translate }) }));
+}
+// Lookup-Body für custom-screens: schaut die Component aus dem
+// CustomScreens-Context (gefüttert von clientFeatures.components in
+// createKumikoApp). Wenn weder Provider gemounted noch screenId
+// registriert ist, fällt es auf einen error-Banner zurück statt leer zu
+// rendern — der Screen ist per URL erreichbar sobald das Server-Feature
+// gemountet ist, unabhängig davon ob ein Client-Plugin existiert
+// (kumiko-framework#2025).
+function CustomScreenBody({ screenId, featureName, }) {
+    const { Banner, Text } = usePrimitives();
+    const Component = useCustomScreenComponent(screenId);
+    if (Component === undefined) {
+        return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-custom-placeholder", children: ["Custom screen ", _jsx(Text, { variant: "code", children: screenId }), " (Feature", " ", _jsx(Text, { variant: "code", children: featureName }), ") hat keine Component in", " ", _jsx(Text, { variant: "code", children: "clientFeatures.components" }), " \u2014 das Web-Client-Plugin des Features (siehe ", _jsxs(Text, { variant: "code", children: [featureName, "/web/client-plugin.tsx"] }), ") fehlt in", " ", _jsx(Text, { variant: "code", children: "clientFeatures" }), "."] }));
+    }
+    return _jsx(Component, {});
+}
+// ---- entity-edit ----
+// Derives `<feature>:write:<entity>:<verb>` from the screen's entity
+// and the schema's feature name. Matches qualifyEntityName / toKebab in
+// packages/framework/src/engine/qualified-name.ts so camelCase entity
+// ids (e.g. driverModel) resolve to server QNs (driver-model:create).
+function entityWriteCommand(featureName, entity, verb) {
+    return `${toKebab(featureName)}:write:${toKebab(entity)}:${verb}`;
+}
+// Default "success → zurück zur Liste"-Navigation. Findet den ersten
+// entityList-Screen für die Entity und navigiert dahin. Wird von
+// Create/Update/Delete genauso verwendet — alle drei haben "fertig
+// editiert, raus hier" als sinnvolles Default-Verhalten.
+function useNavigateToListAfter(schema, entityName) {
+    const nav = useNav();
+    return useCallback(() => {
+        const list = schema.screens.find((s) => s.type === "entityList" && s.entity === entityName);
+        if (!list)
+            return;
+        // schema.screens.id ist QN-form (registry-stamped); nav.navigate
+        // erwartet Short-Form. Sonst landet die URL doppelt-qualifiziert.
+        nav.navigate({ screenId: lastSegment(list.id) });
+    }, [nav, schema.screens, entityName]);
+}
+// Default "+ Neu"-Navigation für die List-Toolbar: findet den ersten
+// entityEdit-Screen ohne entityId-Anhang und navigiert dorthin.
+// Returns undefined wenn kein Edit-Screen registriert ist — RenderList
+// rendert dann keinen + Neu Button.
+//
+// Schema-Screens kommen mit qualifizierten ids ("publicstatus:screen:
+// component-edit") aus der Registry; lastSegment strippt den Prefix
+// für nav.navigate (siehe ./qn.ts für Doku).
+function pageSizeOptionsFor(currentLimit) {
+    return PAGE_SIZE_OPTIONS.includes(currentLimit)
+        ? PAGE_SIZE_OPTIONS
+        : [...PAGE_SIZE_OPTIONS, currentLimit].sort((a, b) => a - b);
+}
+function useNavigateToCreateFor(schema, entityName) {
+    const nav = useNav();
+    const host = useReturnHost();
+    const editScreenId = useMemo(() => {
+        // allowCreate:false = update-only Edit-Screen (Create läuft über einen
+        // Lifecycle-Write) — der zählt nicht als „+ Neu"-Ziel. singleton:true
+        // öffnet ohne entityId den vorhandenen Record (EntityEditSingletonBody)
+        // statt eines leeren Create-Forms — zählt aus demselben Grund nicht.
+        const edit = schema.screens.find((s) => s.type === "entityEdit" &&
+            s.entity === entityName &&
+            s.allowCreate !== false &&
+            s.singleton !== true);
+        return edit !== undefined ? lastSegment(edit.id) : undefined;
+    }, [schema.screens, entityName]);
+    const navigate = useCallback(() => {
+        if (editScreenId !== undefined)
+            navigateWithReturnTo(nav, { screenId: editScreenId }, host);
+    }, [nav, editScreenId, host]);
+    return editScreenId !== undefined ? navigate : undefined;
+}
+// `defaultCurrency` is entityEdit-only — it enables the `{amount, currency}`
+// write shape (fw#1923); config-edit's plain-number contract needs bare `0`.
+// `moneyCurrencyOverrides` (fw#2933) replaces `defaultCurrency` per field name
+// — used for a `money` field that declares `currency: { kind: "tenant" }`, so
+// its empty initial value carries the tenant's own currency instead of the
+// entity-wide default.
+export function buildInitialValues(fields, defaultCurrency, moneyCurrencyOverrides) {
+    const out = {};
+    for (const [name, def] of Object.entries(fields)) {
+        const shape = def;
+        if (shape.default !== undefined) {
+            out[name] = shape.default;
+            continue;
+        }
+        if (shape.type === "embedded" && shape.multiple === true) {
+            out[name] = [];
+            continue;
+        }
+        if (shape.type === "money") {
+            const currency = moneyCurrencyOverrides?.[name] ?? defaultCurrency;
+            if (currency !== undefined) {
+                out[name] = { amount: 0, currency };
+                continue;
+            }
+        }
+        out[name] =
+            shape.type === "boolean"
+                ? false
+                : shape.type === "number" || shape.type === "money"
+                    ? 0
+                    : shape.type === "multiSelect"
+                        ? []
+                        : "";
+    }
+    return out;
+}
+// A `money` field opts a currently-empty value into the tenant-settings
+// bundle's per-tenant currency (fw#2933) via `currency: { kind: "tenant" }`
+// on its FieldDefinition. Read structurally — renderer only depends on the
+// client-safe FieldDefinition subset, not the concrete MoneyFieldDef/
+// MoneyCurrencySource types, same idiom as the other field-shape narrowings
+// in this file (PrefillFieldShape etc.).
+function tenantCurrencyMoneyFieldNames(fields) {
+    const names = [];
+    for (const [name, def] of Object.entries(fields)) {
+        const shape = def;
+        if (shape.type === "money" && shape.currency?.kind === "tenant")
+            names.push(name);
+    }
+    return names;
+}
+// Resolves what a tenant-declared money field's currency should be, from the
+// same `config:query:values` query ConfigEditBody already uses. Never falls
+// back to "EUR" while the query is genuinely still in flight (fw#2933) — a
+// screen with no tenant-declared money field, or a query that errored or
+// returned no value for the key, resolves immediately instead of blocking.
+function resolveTenantCurrency(fieldNames, query, fallback) {
+    if (fieldNames.length === 0)
+        return { status: "not-needed" };
+    if (query.error)
+        return { status: "ready", currency: fallback };
+    if (query.data === null)
+        return { status: "loading" };
+    const raw = query.data[TENANT_CURRENCY_CONFIG_KEY]?.value;
+    return { status: "ready", currency: typeof raw === "string" && raw !== "" ? raw : fallback };
+}
+// An entity-less form screen has no `entity.defaultCurrency` to fall back on,
+// so a tenant-declared field whose config query errors or returns no value
+// lands here — same last resort as the entityEdit path's `?? "EUR"`.
+const ACTION_FORM_CURRENCY_FALLBACK = "EUR";
+// Shared by the update payload shape and the server-error path prefix so both can't drift.
+const UPDATE_CHANGES_KEY = "changes";
+// A money field naming a fixed ISO code (`currency: { kind: "literal", code }`,
+// fw#2839) resolves with no query at all. Read structurally, same idiom as
+// tenantCurrencyMoneyFieldNames above.
+export function literalCurrencyOverrides(fields) {
+    const out = {};
+    for (const [name, def] of Object.entries(fields)) {
+        const shape = def;
+        const code = shape.currency?.code;
+        if (shape.type === "money" && shape.currency?.kind === "literal" && code !== undefined) {
+            out[name] = code;
+        }
+    }
+    return out;
+}
+// Per-field currency for the money fields that declare their own source: a
+// literal code resolves synchronously (fw#2839), a `{ kind: "tenant" }` field
+// needs the tenant-settings config query and makes the caller hold the form
+// until it lands (fw#2933) — seeding the fallback meanwhile would render, and
+// on a fast click submit, the wrong currency. Callers pass the tenant field
+// names themselves because an edit form only needs the fetch for fields the
+// record has no stored value for.
+function useMoneyCurrencyOverrides(fields, tenantFieldNames, fallback) {
+    const query = useQuery("config:query:values", {}, { enabled: tenantFieldNames.length > 0 });
+    const resolution = resolveTenantCurrency(tenantFieldNames, query, fallback);
+    const resolvedTenantCurrency = resolution.status === "ready" ? resolution.currency : undefined;
+    const overrides = useMemo(() => {
+        const out = { ...literalCurrencyOverrides(fields) };
+        if (resolvedTenantCurrency !== undefined) {
+            for (const name of tenantFieldNames)
+                out[name] = resolvedTenantCurrency;
+        }
+        return Object.keys(out).length > 0 ? out : undefined;
+    }, [fields, tenantFieldNames, resolvedTenantCurrency]);
+    return { overrides, loading: resolution.status === "loading" };
+}
+function multiSelectOptionValues(shape) {
+    if (shape.options === undefined || shape.options.length === 0)
+        return undefined;
+    return new Set(shape.options.map((o) => (typeof o === "string" ? o : o.value)));
+}
+// The currency now comes from a user-controlled URL param and reaches
+// `Intl.NumberFormat`, which throws a RangeError on a malformed code — reject
+// it here instead of crashing the form render.
+const CURRENCY_CODE_PATTERN = /^[A-Za-z]{3}$/;
+function isMoneyValue(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const { amount, currency } = value;
+    return (typeof amount === "number" &&
+        Number.isFinite(amount) &&
+        typeof currency === "string" &&
+        CURRENCY_CODE_PATTERN.test(currency));
+}
+const ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+function formatSummaryValue(value, locale) {
+    if (isMoneyValue(value)) {
+        return new Intl.NumberFormat(locale, { style: "currency", currency: value.currency }).format(value.amount);
+    }
+    if (typeof value === "number")
+        return value.toLocaleString(locale);
+    if (typeof value === "string" && ISO_DATE_PATTERN.test(value)) {
+        return new Date(`${value}T00:00:00Z`).toLocaleDateString(locale, {
+            year: "numeric",
+            month: "2-digit",
+            day: "2-digit",
+            timeZone: "UTC",
+        });
+    }
+    return value === null || value === undefined ? "" : String(value);
+}
+function resolveActionFormSummary(summary, prefill, translate, locale) {
+    if (summary === undefined)
+        return undefined;
+    const params = Object.fromEntries(Object.entries(prefill ?? {}).map(([name, value]) => [name, formatSummaryValue(value, locale)]));
+    return {
+        title: translate(summary.title, params),
+        ...(summary.subtitle !== undefined && { subtitle: translate(summary.subtitle, params) }),
+    };
+}
+function parseJsonOrRaw(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}
+function warnPrefillParam(message) {
+    // biome-ignore lint/suspicious/noConsole: dev-warning for an authoring error
+    console.warn(`[kumiko] ${message}`);
+}
+// An actionForm has no entity and thus no defaultCurrency, so a bare-number
+// prefill would stay a number the handler's zod schema rejects (fw#2763).
+function coerceMoneyValue(raw, fieldName, defaultCurrency) {
+    if (raw === null || raw === undefined)
+        return undefined;
+    const value = typeof raw === "string" ? parseJsonOrRaw(raw) : raw;
+    if (value === null)
+        return undefined;
+    if (isMoneyValue(value))
+        return { amount: value.amount, currency: value.currency.toUpperCase() };
+    if (typeof value === "object") {
+        warnPrefillParam(`money field "${fieldName}" got an object without a usable {amount, currency} shape — the prefill is ignored.`);
+        return undefined;
+    }
+    const amount = Number(typeof value === "number" ? value : raw);
+    if (!Number.isFinite(amount))
+        return undefined;
+    if (defaultCurrency !== undefined)
+        return { amount, currency: defaultCurrency };
+    warnPrefillParam(`money field "${fieldName}" was prefilled with a bare number and no currency is available — pass {"amount":<number>,"currency":"<ISO code>"} as the param value, otherwise the handler's schema rejects the submit.`);
+    return amount;
+}
+const EMBEDDED_LIST_PREFILL_ROW_LIMIT = 500;
+function coerceEmbeddedCell(value, cell) {
+    switch (cell.type) {
+        case "number":
+        case "decimal":
+            return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+        case "money":
+            // Row cells are signed minor units; the currency lives on the head, so a
+            // top-level `{amount, currency}` in major units would land 100x off.
+            return typeof value === "number" && Number.isSafeInteger(value) ? value : undefined;
+        case "boolean":
+            return typeof value === "boolean" ? value : undefined;
+        case "select":
+            return typeof value === "string" && (cell.options ?? []).includes(value) ? value : undefined;
+        default:
+            return typeof value === "string" ? value : undefined;
+    }
+}
+// A partially coerced list is the hazard the prefill exists to avoid: the
+// handler replaces the list whole, so half a list overwrites the rest.
+function coerceEmbeddedListRows(raw, fieldName, schema, maxItems) {
+    const parsed = parseJsonOrRaw(raw);
+    if (!Array.isArray(parsed)) {
+        warnPrefillParam(`embedded-list field "${fieldName}" was prefilled with something that is not a JSON array — the prefill is ignored.`);
+        return undefined;
+    }
+    if (parsed.length > (maxItems ?? EMBEDDED_LIST_PREFILL_ROW_LIMIT)) {
+        warnPrefillParam(`embedded-list field "${fieldName}" was prefilled with ${parsed.length} rows, more than it accepts — the prefill is ignored.`);
+        return undefined;
+    }
+    const rows = [];
+    for (const candidate of parsed) {
+        if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) {
+            warnPrefillParam(`embedded-list field "${fieldName}" was prefilled with a row that is not an object — the prefill is ignored.`);
+            return undefined;
+        }
+        const cellEntries = [];
+        for (const [cellName, cell] of Object.entries(schema)) {
+            const cellValue = candidate[cellName];
+            if (cellValue === undefined || cellValue === null)
+                continue;
+            const coerced = coerceEmbeddedCell(cellValue, cell);
+            if (coerced === undefined) {
+                warnPrefillParam(`embedded-list field "${fieldName}" was prefilled with a cell "${cellName}" the sub-schema rejects — the prefill is ignored.`);
+                return undefined;
+            }
+            cellEntries.push([cellName, coerced]);
+        }
+        rows.push(Object.fromEntries(cellEntries));
+    }
+    return rows;
+}
+function coercePrefillString(raw, name, shape, fallback, defaultCurrency, moneyCurrencyOverrides) {
+    if (shape.type === "number") {
+        const parsed = Number(raw);
+        return Number.isNaN(parsed) ? fallback : parsed;
+    }
+    if (shape.type === "money") {
+        const coerced = coerceMoneyValue(raw, name, moneyCurrencyOverrides?.[name] ?? defaultCurrency);
+        return coerced === undefined ? fallback : coerced;
+    }
+    if (shape.type === "boolean")
+        return raw === "true";
+    if (shape.type === "multiSelect") {
+        // Row-action navigate stringifies arrays via String(arr) → "a,b" (or
+        // JSON when the navigate helper JSON.stringifies). Try JSON first
+        // (even without a "[" prefix), then comma-split; filter against
+        // field.options when present so unknown values never reach the form.
+        const optionValues = multiSelectOptionValues(shape);
+        const splitComma = () => raw === ""
+            ? []
+            : raw
+                .split(",")
+                .map((s) => s.trim())
+                .filter(Boolean);
+        let values;
+        try {
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                values = parsed.map((v) => String(v));
+            }
+            else if (typeof parsed === "string") {
+                values = [parsed];
+            }
+            else {
+                values = splitComma();
+            }
+        }
+        catch {
+            values = splitComma();
+        }
+        return optionValues !== undefined ? values.filter((v) => optionValues.has(v)) : values;
+    }
+    if (shape.type === "embedded" && shape.multiple === true) {
+        return coerceEmbeddedListRows(raw, name, shape.schema ?? {}, shape.maxItems) ?? fallback;
+    }
+    return raw;
+}
+export function mergeSearchParamsIntoInitial(fields, sources) {
+    const { searchParams, renderableFields, defaultCurrency, moneyCurrencyOverrides, drawerOverrides, handoffValues, } = sources;
+    const urlPrefillFields = new Set(sources.urlPrefillFields ?? []);
+    const defaults = buildInitialValues(fields, defaultCurrency, moneyCurrencyOverrides);
+    const merged = { ...defaults };
+    for (const [name, fieldDef] of Object.entries(fields)) {
+        if (renderableFields !== undefined && !renderableFields.has(name))
+            continue;
+        const shape = fieldDef;
+        // Neither gate is lifted by an allowlist entry or a handoff.
+        if (shape.sensitive === true)
+            continue;
+        if (shape.format === "password")
+            continue;
+        if (drawerOverrides !== undefined && name in drawerOverrides) {
+            merged[name] = drawerOverrides[name];
+            continue;
+        }
+        const handedOff = handoffValues !== undefined && Object.hasOwn(handoffValues, name)
+            ? handoffValues[name]
+            : undefined;
+        if (handedOff !== undefined) {
+            merged[name] =
+                typeof handedOff === "string"
+                    ? coercePrefillString(handedOff, name, shape, defaults[name], defaultCurrency, moneyCurrencyOverrides)
+                    : handedOff;
+            continue;
+        }
+        if (!urlPrefillFields.has(name))
+            continue;
+        const raw = searchParams[name];
+        if (raw === undefined)
+            continue;
+        merged[name] = coercePrefillString(raw, name, shape, defaults[name], defaultCurrency, moneyCurrencyOverrides);
+    }
+    return merged;
+}
+function EntityEditScreen({ schema, screen, translate, entityId, onCopyLink, }) {
+    const { Banner, Text } = usePrimitives();
+    const entity = schema.entities[screen.entity];
+    if (!entity) {
+        return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-entity-missing", children: ["Entity ", _jsx(Text, { variant: "code", children: screen.entity }), " referenced by screen", " ", _jsx(Text, { variant: "code", children: screen.id }), " not registered in the schema."] }));
+    }
+    // Split into create-body / update-body so the update-only hooks
+    // (useQuery(detail)) don't fire in create mode, and vice versa.
+    // Same shape as EntityListScreen.
+    if (entityId !== undefined) {
+        return (_jsx(EntityEditUpdateBody, { schema: schema, screen: screen, entity: entity, entityId: entityId, ...(translate !== undefined && { translate }), ...(onCopyLink !== undefined && { onCopyLink }) }));
+    }
+    if (screen.singleton === true) {
+        return (_jsx(EntityEditSingletonBody, { schema: schema, screen: screen, entity: entity, ...(translate !== undefined && { translate }), ...(onCopyLink !== undefined && { 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();
+    const returnTargetParam = useReturnTarget(screen.id);
+    // A singleton stays on its own screen after saving (onSaved/refetch) —
+    // returnTo would fight that.
+    const returnTarget = screen.singleton === true ? undefined : returnTargetParam;
+    const entityDefaultCurrency = entity.defaultCurrency ?? "EUR";
+    // A money field declaring `currency: { kind: "tenant" }` (fw#2933) resolves
+    // its empty-value currency from the tenant-settings config key instead of
+    // entityDefaultCurrency — `enabled` keeps the query a no-op for entities
+    // 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, {
+        searchParams: nav.searchParams,
+        urlPrefillFields: screen.urlPrefillFields,
+        renderableFields: layoutFieldNames(screen),
+        defaultCurrency: entityDefaultCurrency,
+        ...(moneyCurrencyOverrides !== undefined && { moneyCurrencyOverrides }),
+        ...(handoffValues !== undefined && { handoffValues }),
+    }), [
+        entity.fields,
+        nav.searchParams,
+        screen,
+        entityDefaultCurrency,
+        moneyCurrencyOverrides,
+        handoffValues,
+    ]);
+    const formSchema = useMemo(() => buildFormSchema(entity, screen), [entity, screen]);
+    const writeCommand = entityWriteCommand(schema.featureName, screen.entity, "create");
+    const navigateToList = useNavigateToListAfter(schema, screen.entity);
+    const handleCancel = useCallback(() => navigateToReturnOr(nav, returnTarget, navigateToList), [nav, returnTarget, navigateToList]);
+    // Create's write-handler success payload doesn't flatly expose a parent FK
+    // (`{ kind, id, data, … }`), so an object-form redirect's `idFrom` falls
+    // back to the values just submitted to the handler.
+    const controlsRef = useRef(null);
+    const handleControlsReady = useCallback((controls) => {
+        controlsRef.current = controls;
+    }, []);
+    const handleSubmitted = useCallback((result) => {
+        if (!result.isSuccess)
+            return;
+        const redirect = screen.redirect;
+        if (redirect !== undefined) {
+            if (returnToWinsOverRedirect(returnTarget, redirect, schema, appFeatures)) {
+                navigateToReturn(nav, returnTarget);
+            }
+            else if (typeof redirect === "string") {
+                // String form unchanged: always carries the newly created
+                // record's own id, regardless of the target screen's type. The
+                // object form resolves like actionForm's — a child record's own id
+                // is useless for a parent-detail redirect.
+                const entityId = extractCreatedId(result.data);
+                nav.navigate({
+                    screenId: lastSegment(redirect),
+                    ...(entityId !== undefined && { entityId }),
+                });
+            }
+            else {
+                const { screenId, entityId } = resolveRedirectTarget(redirect, result.data, schema, appFeatures, controlsRef.current?.getValues());
+                nav.navigate({ screenId, ...(entityId !== undefined && { entityId }) });
+            }
+        }
+        else {
+            navigateToReturnOr(nav, returnTarget, navigateToList);
+            onSaved?.();
+        }
+    }, [nav, screen.redirect, schema, appFeatures, navigateToList, onSaved, returnTarget]);
+    // 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" }));
+    }
+    // Deliberately no `actions` prop here: `screen.actions` targets an
+    // EXISTING record (publish/archive/duplicate and friends), which the
+    // create branch has none of yet — see EntityEditUpdateForm for the
+    // wired-up counterpart.
+    return (_jsx(RenderEdit, { screen: screen, entity: entity, featureName: schema.featureName, initial: initial, schema: formSchema, writeCommand: writeCommand, onSubmit: handleSubmitted, onControlsReady: handleControlsReady, onCancel: handleCancel, ...(screenFillsHeight(screen) && { fillScreenHeight: true }), ...(screen.submitLabel !== undefined && { submitLabel: screen.submitLabel }), ...(translate !== undefined && { translate }) }));
+}
+// Update body: loads the existing record via `<feature>:query:<entity>:detail`,
+// then mounts a form pre-filled with the server values and dispatches
+// `<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, Text } = usePrimitives();
+    const t = useTranslation();
+    const effectiveTranslate = translate ?? t;
+    const detailQn = `${toKebab(schema.featureName)}:query:${toKebab(screen.entity)}:detail`;
+    const detailQuery = useQuery(detailQn, { id: entityId });
+    if (detailQuery.loading && detailQuery.data === null) {
+        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+    }
+    if (detailQuery.error) {
+        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(detailQuery.error, effectiveTranslate) }));
+    }
+    const record = detailQuery.data;
+    if (!record) {
+        return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-record-missing", children: ["Record ", _jsx(Text, { variant: "code", children: entityId }), " not found."] }));
+    }
+    // Record-version als React-key: bei "Neu laden" refetched detail,
+    // liefert neue version, und das Form remountet komplett. Ohne den
+    // Key-Wechsel bliebe der useForm-Controller lifetime-scoped auf
+    // der ursprünglichen version sitzen — der buildPayload würde
+    // weiter die stale version stampen und der Konflikt-Recovery wäre
+    // kaputt.
+    const recordKey = record.version ?? 1;
+    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}`));
+}
+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
+    // captured once and stamped into every update payload — if a
+    // concurrent writer bumps it, the server returns a version-conflict
+    // error and the user reloads.
+    const recordVersion = record.version ?? 1;
+    const entityDefaultCurrency = entity.defaultCurrency ?? "EUR";
+    // A money field declaring `currency: { kind: "tenant" }` (fw#2933) resolves
+    // its empty-value currency from the tenant-settings config key instead of
+    // entityDefaultCurrency — `enabled` keeps the query a no-op for entities
+    // without any such field. A record's own stored value (below) always wins
+    // over this, regardless of the declaration.
+    //
+    // Only fields the record itself has no value for need the fetch at all —
+    // an already-set tenant-declared field keeps its own stored currency and
+    // must never block the form on this query.
+    const tenantCurrencyFieldNames = useMemo(() => tenantCurrencyMoneyFieldNames(entity.fields).filter((name) => record[name] === null || record[name] === undefined), [entity.fields, record]);
+    const { overrides: moneyCurrencyOverrides, loading: currencyLoading } = useMoneyCurrencyOverrides(entity.fields, tenantCurrencyFieldNames, entityDefaultCurrency);
+    const initial = useMemo(() => {
+        const out = {};
+        for (const name of Object.keys(entity.fields)) {
+            out[name] =
+                record[name] ??
+                    buildInitialValues({ [name]: entity.fields[name] }, entityDefaultCurrency, moneyCurrencyOverrides)[name];
+        }
+        return out;
+    }, [entity.fields, entityDefaultCurrency, moneyCurrencyOverrides, record]);
+    const formSchema = useMemo(() => buildFormSchema(entity, screen), [entity, screen]);
+    // Extension-Werte (z.B. customFields-jsonb) an extension-sections geben,
+    // damit sie beim Edit den Bestand zeigen statt write-only zu sein.
+    const extensionInitialValues = useMemo(() => {
+        const cf = record["customFields"];
+        return cf !== null && typeof cf === "object" && !Array.isArray(cf)
+            ? cf
+            : undefined;
+    }, [record]);
+    const writeCommand = entityWriteCommand(schema.featureName, screen.entity, "update");
+    const deleteCommand = entityWriteCommand(schema.featureName, screen.entity, "delete");
+    const buildPayload = useMemo(() => (snap) => ({
+        id: entityId,
+        version: recordVersion,
+        [UPDATE_CHANGES_KEY]: snap.changes,
+    }), [entityId, recordVersion]);
+    const nav = useNav();
+    const appFeatures = useAppFeatures();
+    const dispatcher = useDispatcher();
+    const t = useTranslation();
+    const effectiveTranslate = translate ?? t;
+    const navigateToList = useNavigateToListAfter(schema, screen.entity);
+    const userRoles = useUserRoles();
+    const host = useReturnHost();
+    const returnTargetParam = useReturnTarget(screen.id);
+    // A singleton stays on its own screen after saving (onSaved/refetch) —
+    // returnTo would fight that.
+    const returnTarget = screen.singleton === true ? undefined : returnTargetParam;
+    const { drawerAction, drawerScreen, drawerInitialValues, openDrawer, closeDrawer } = useDrawerAction(schema);
+    // Header action buttons (fw entityEdit-actions) — same shape/dispatch
+    // pattern as ProjectionDetailBody.headerActions above (the edited record
+    // stands in for the "row"), minus the cross-feature defaultEditAction
+    // lookup that doesn't apply here (this screen already IS the edit form).
+    const buildSectionActions = useCallback((actions) => buildRecordActions({
+        actions,
+        record,
+        translate: effectiveTranslate,
+        nav,
+        host,
+        dispatcher,
+        openDrawer,
+        onWriteSuccess: onReload,
+        defaultScreenTargetEntityId: entityId,
+    }), [record, effectiveTranslate, nav, host, dispatcher, openDrawer, onReload, entityId]);
+    const headerActions = useMemo(() => buildSectionActions(screen.actions ?? []), [buildSectionActions, screen.actions]);
+    const handleSubmitted = useCallback((result) => {
+        if (!result.isSuccess)
+            return;
+        const redirect = screen.redirect;
+        if (redirect !== undefined) {
+            if (returnToWinsOverRedirect(returnTarget, redirect, schema, appFeatures)) {
+                navigateToReturn(nav, returnTarget);
+            }
+            else if (typeof redirect === "string") {
+                // String form unchanged: navigates without an entityId, same as
+                // before the object form existed. The object form resolves like
+                // actionForm's — the update handler's success payload usually
+                // reports only this record's own id (event-store-executor-write.ts),
+                // so a parent FK named by `idFrom` falls back to the already-loaded
+                // `record`.
+                nav.navigate({ screenId: lastSegment(redirect) });
+            }
+            else {
+                const { screenId, entityId: targetEntityId } = resolveRedirectTarget(redirect, result.data, schema, appFeatures, record);
+                nav.navigate({
+                    screenId,
+                    ...(targetEntityId !== undefined && { entityId: targetEntityId }),
+                });
+            }
+        }
+        else {
+            navigateToReturnOr(nav, returnTarget, navigateToList);
+            onSaved?.();
+        }
+    }, [nav, screen.redirect, schema, appFeatures, record, navigateToList, onSaved, returnTarget]);
+    const handleCancel = useCallback(() => navigateToReturnOr(nav, returnTarget, navigateToList), [nav, returnTarget, navigateToList]);
+    const handleDelete = useCallback(async () => {
+        const res = await dispatcher.write(deleteCommand, { id: entityId });
+        if (res.isSuccess) {
+            // Never return onto the just-deleted record.
+            const target = returnTarget?.entityId !== entityId ? returnTarget : undefined;
+            navigateToReturnOr(nav, target, navigateToList);
+            onDeleted?.();
+        }
+    }, [dispatcher, deleteCommand, entityId, navigateToList, onDeleted, returnTarget, nav]);
+    // Never seed a tenant-declared money field with entityDefaultCurrency while
+    // its real tenant currency is still in flight (fw#2933) — wait instead. A
+    // 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 (_jsxs(_Fragment, { children: [_jsx(RenderEdit, { screen: screen, entity: entity, featureName: schema.featureName, initial: initial, 
+                // 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, ...(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 }), buildSectionActions: buildSectionActions }), _jsx(DrawerHost, { schema: schema, drawerAction: drawerAction, drawerScreen: drawerScreen, ...(drawerInitialValues !== undefined && { drawerInitialValues }), userRoles: userRoles, ...(translate !== undefined && { translate }), onClose: closeDrawer, onSuccess: () => {
+                    closeDrawer();
+                    void onReload();
+                } })] }));
+}
+// Singleton entities (`singleton: true`, exactly one record per tenant):
+// EntityEditScreen reaches here only without an entityId. Resolve the
+// 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" }));
+    }
+    if (listQuery.error) {
+        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(listQuery.error, effectiveTranslate) }));
+    }
+    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 (_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
+// both the same way, since a create submit there would hit an
+// unregistered `<entity>:create` handler.
+function EntityEditCreateOrDisabled({ schema, screen, entity, translate, onSaved, }) {
+    const { Banner, Text } = usePrimitives();
+    if (screen.allowCreate === false) {
+        return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-create-disabled", children: ["Screen ", _jsx(Text, { variant: "code", children: screen.id }), " is update-only (allowCreate: false) \u2014 open it from a row action with an entity id."] }));
+    }
+    return (_jsx(EntityEditCreateBody, { schema: schema, screen: screen, entity: entity, ...(translate !== undefined && { translate }), ...(onSaved !== undefined && { onSaved }) }));
+}
+// ---- entity-list ----
+function entityQueryCommand(featureName, entity, verb) {
+    return `${toKebab(featureName)}:query:${toKebab(entity)}:${verb}`;
+}
+// Payload for the server-side list query handler (LIST_PAYLOAD_SCHEMA):
+// search/sort/sortDirection/limit + offset/totalCount for pager mode OR
+// cursor for infinite scroll. Shared by EntityListBody and
+// ProjectionListBody so the two branches can't drift on this shape
+// (fw#2165) — entity-only additions (screen.filter, faceted filters) are
+// layered on top by the caller instead of living in here.
+export function buildListQueryPayload(state) {
+    const payload = { limit: state.limit };
+    if (state.search !== "")
+        payload["search"] = state.search;
+    if (state.sort !== null) {
+        payload["sort"] = state.sort.field;
+        payload["sortDirection"] = state.sort.dir;
+    }
+    if (state.usePager) {
+        // page=1 → offset=0, page=2 → offset=limit, etc. Server clamps itself
+        // when offset >= total.
+        const offset = (state.page - 1) * state.limit;
+        if (offset > 0)
+            payload["offset"] = offset;
+        // totalCount: extra COUNT(*) so the pager can render "Page X of Y".
+        payload["totalCount"] = true;
+    }
+    else if (state.useInfinite && state.cursor !== undefined) {
+        payload["cursor"] = state.cursor;
+    }
+    return payload;
+}
+// entityList adapter — one DataTableFacet per filterable select/boolean
+// entity field, labels via the standard field/option i18n convention.
+function resolveEntityFacetSpecs(fields, featureName, entityName, translate) {
+    const out = [];
+    for (const [field, rawDef] of Object.entries(fields)) {
+        // entity.fields ist am Renderer-Layer schwach getypt (Record<string,
+        // unknown>, vom Schema deserialisiert) — Boundary-Cast wie buildInitialValues.
+        const def = rawDef;
+        if (def.filterable !== true)
+            continue;
+        const label = translate(fieldLabelKey(featureName, entityName, field));
+        if (def.type === "select" && Array.isArray(def.options)) {
+            out.push({
+                field,
+                type: "select",
+                label,
+                options: def.options.map((value) => ({
+                    value,
+                    label: translate(fieldOptionLabelKey(featureName, entityName, field, value)),
+                })),
+            });
+        }
+        else if (def.type === "boolean") {
+            out.push({
+                field,
+                type: "boolean",
+                label,
+                options: [
+                    {
+                        value: "true",
+                        label: translate(fieldOptionLabelKey(featureName, entityName, field, "true")),
+                    },
+                    {
+                        value: "false",
+                        label: translate(fieldOptionLabelKey(featureName, entityName, field, "false")),
+                    },
+                ],
+            });
+        }
+        else if (def.type === "reference" && def.entity !== undefined) {
+            const target = parseRefTarget(def.entity, featureName);
+            out.push({
+                field,
+                type: "reference",
+                label,
+                options: [],
+                reference: {
+                    refEntity: target.entityName,
+                    refFeature: target.featureName,
+                    labelField: def.labelField ?? "id",
+                },
+            });
+        }
+    }
+    return out;
+}
+function useDrawerAction(schema) {
+    const [drawerState, setDrawerState] = useState(null);
+    const drawerAction = drawerState?.action ?? null;
+    const drawerScreen = useMemo(() => {
+        if (drawerAction === null)
+            return undefined;
+        // Same same-feature, short-id resolution as runNavigate — the drawer's
+        // `screen` reference is scoped to schema.screens, not cross-feature.
+        return schema.screens.find((s) => s.type === "actionForm" && lastSegment(s.id) === drawerAction.screen);
+    }, [drawerAction, schema.screens]);
+    const openDrawer = useCallback((action, initialValues) => setDrawerState({ action, initialValues }), []);
+    const closeDrawer = useCallback(() => setDrawerState(null), []);
+    return {
+        drawerAction,
+        drawerScreen,
+        drawerInitialValues: drawerState?.initialValues,
+        openDrawer,
+        closeDrawer,
+    };
+}
+function DrawerHost({ schema, drawerAction, drawerScreen, drawerInitialValues, userRoles, translate, onClose, onSuccess, }) {
+    const { Drawer, Banner, Text, Dialog } = usePrimitives();
+    const t = useTranslation();
+    const effectiveTranslate = translate ?? t;
+    const [hasUnsavedInput, setHasUnsavedInput] = useState(false);
+    const [confirmDiscardOpen, setConfirmDiscardOpen] = useState(false);
+    const closeAndReset = useCallback(() => {
+        setHasUnsavedInput(false);
+        setConfirmDiscardOpen(false);
+        onClose();
+    }, [onClose]);
+    const requestClose = useCallback(() => {
+        if (hasUnsavedInput)
+            setConfirmDiscardOpen(true);
+        else
+            closeAndReset();
+    }, [hasUnsavedInput, closeAndReset]);
+    // Drawer is an optional Core-Primitive (additive rollout) — same "skip +
+    // warn once" precedent as rowActions without a mounted DispatcherProvider
+    // above, instead of crashing when a web app hasn't upgraded its
+    // createKumikoApp wiring yet.
+    useEffect(() => {
+        if (drawerAction !== null && Drawer === undefined) {
+            // biome-ignore lint/suspicious/noConsole: dev-warning for a setup error
+            console.warn(`[kumiko] toolbarAction "${drawerAction.id}" is kind:"drawer", but no <Drawer> primitive is registered — it will not open. createKumikoApp() from kumiko-renderer-web wires it automatically.`);
+        }
+    }, [drawerAction, Drawer]);
+    if (drawerAction === null || Drawer === undefined)
+        return null;
+    // Access mirrors kind:"navigate" exactly: the toolbar button itself stays
+    // visible either way (same as navigate — access is enforced at the
+    // target, not by hiding the trigger), but the drawer shows the same
+    // "Access denied" state KumikoScreen's top-level gate would show for a
+    // direct hit on that screen, never the form.
+    const allowed = screenAccessAllows(drawerScreen?.access, userRoles);
+    return (_jsxs(_Fragment, { children: [_jsx(Drawer, { open: true, onOpenChange: (open) => {
+                    if (!open)
+                        requestClose();
+                }, title: effectiveTranslate(drawerAction.label), testId: `toolbar-drawer-${drawerAction.id}`, children: _jsx(PageHeaderSlotAvailableProvider, { value: false, children: _jsx(InsideDrawerProvider, { value: true, children: drawerScreen === undefined ? (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-toolbar-drawer-not-found", children: ["Screen not found: ", _jsx(Text, { variant: "code", children: drawerAction.screen })] })) : !allowed ? (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-toolbar-drawer-access-denied", children: ["Access denied: ", _jsx(Text, { variant: "code", children: drawerAction.screen })] })) : (_jsx(ActionFormBody, { schema: schema, screen: drawerScreen, ...(translate !== undefined && { translate }), ...(drawerInitialValues !== undefined && {
+                                initialOverrides: drawerInitialValues,
+                            }), onSuccess: () => {
+                                setHasUnsavedInput(false);
+                                onSuccess();
+                            }, onCancelOverride: requestClose, onDirtyChange: setHasUnsavedInput, submitLabelFallback: drawerAction.label })) }) }) }), _jsx(Dialog, { open: confirmDiscardOpen, onOpenChange: setConfirmDiscardOpen, title: t("kumiko.drawer.discard.title"), description: t("kumiko.drawer.discard.body"), confirmLabel: t("kumiko.drawer.discard.confirm"), cancelLabel: t("kumiko.drawer.discard.cancel"), variant: "danger", initialFocus: "cancel", onConfirm: closeAndReset, testId: "drawer-discard-dialog" })] }));
+}
+function EntityListScreen({ schema, screen, translate, onRowClick, }) {
+    const { Banner, Text } = usePrimitives();
+    const entity = schema.entities[screen.entity];
+    if (!entity) {
+        return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-entity-missing", children: ["Entity ", _jsx(Text, { variant: "code", children: screen.entity }), " referenced by screen", " ", _jsx(Text, { variant: "code", children: screen.id }), " not registered in the schema."] }));
+    }
+    // Entity resolved — mount the inner component so useQuery only fires
+    // when there's actually something to render. A missing entity is a
+    // dev-error state; no point hitting the server for it.
+    return (_jsx(EntityListBody, { schema: schema, screen: screen, entity: entity, ...(translate !== undefined && { translate }), ...(onRowClick !== undefined && { onRowClick }) }));
+}
+function EntityListBody({ schema, screen, entity, translate, onRowClick, }) {
+    const featureName = schema.featureName;
+    const onCreate = useNavigateToCreateFor(schema, screen.entity);
+    const { Banner } = usePrimitives();
+    const queryType = entityQueryCommand(featureName, screen.entity, "list");
+    const nav = useNav();
+    const host = useReturnHost();
+    const userRoles = useUserRoles();
+    const appFeatures = useAppFeatures();
+    const { drawerAction, drawerScreen, drawerInitialValues, openDrawer, closeDrawer } = useDrawerAction(schema);
+    const defaultEditScreen = useMemo(() => findEditScreenFor(screen.entity, appFeatures, userRoles), [appFeatures, screen.entity, userRoles]);
+    // URL-State: sort/dir/q/page leben unter dem screen.id-Namespace
+    // (`/orders?orders.sort=createdAt&orders.dir=desc&orders.q=acme`),
+    // damit zwei Lists auf derselben Route nicht über dieselben
+    // Query-Keys streiten. Default-Sort aus der Screen-Def gewinnt nur
+    // wenn URL keinen sort hat — Author-Default vs User-Choice.
+    const urlState = useListUrlState(screen.id);
+    const effectiveSort = urlState.sort ?? screen.defaultSort ?? null;
+    const limit = urlState.pageSize ?? screen.pageSize ?? 50;
+    const paginationMode = screen.pagination ?? "pages";
+    const usePager = paginationMode === "pages";
+    const useInfinite = paginationMode === "infinite";
+    // Infinite-Scroll: lokaler State akkumuliert rows über mehrere
+    // useQuery-Aufrufe (statt replacen wie bei Pager). cursor wechselt
+    // wenn der User den Bottom-Sentinel erreicht; bei sort/q-Change
+    // resetten wir alles, da die Insert-Order der akkumulierten Rows
+    // sonst inkonsistent ist mit der neuen Sortierung.
+    const [accumulated, setAccumulated] = useState([]);
+    const [cursor, setCursor] = useState(undefined);
+    const [hasMore, setHasMore] = useState(true);
+    // Ref damit der useEffect-Cleanup nicht alten state sieht.
+    const sortQRef = useRef("");
+    const sortQKey = `${urlState.q}|${effectiveSort?.field ?? ""}|${effectiveSort?.dir ?? ""}`;
+    // Bei sort/q-Wechsel rows + cursor reseten — vor dem nächsten useQuery
+    // damit der Reload mit cursor=undefined startet.
+    useEffect(() => {
+        if (!useInfinite)
+            return;
+        if (sortQRef.current === sortQKey)
+            return;
+        sortQRef.current = sortQKey;
+        setAccumulated([]);
+        setCursor(undefined);
+        setHasMore(true);
+    }, [useInfinite, sortQKey]);
+    // User-gewählte Faceted-Filter aus dem URL-State → payload.filters.
+    // typeOf liest den Field-Type direkt aus entity.fields (nicht gated auf
+    // filterable — bewusst permissiv, siehe buildFilterPayload-Doc).
+    const filterPayload = useMemo(() => buildFilterPayload(urlState.filters, (field) => {
+        // entity.fields ist am Renderer-Layer schwach getypt (vom Schema
+        // deserialisiert) — Boundary-Cast wie buildInitialValues.
+        const def = entity.fields[field];
+        return def?.type;
+    }), [urlState.filters, entity.fields]);
+    // Entity-only additions (screen.filter, faceted filters) layer on top of
+    // the shared buildListQueryPayload — projectionList has neither.
+    const queryPayload = useMemo(() => {
+        const payload = buildListQueryPayload({
+            limit,
+            search: urlState.q,
+            sort: effectiveSort,
+            usePager,
+            page: urlState.page,
+            useInfinite,
+            cursor,
+        });
+        // Screen-Filter (Tier 2.7c) — vom Author am Schema deklariert,
+        // unabhängig vom User-q-Search. Mehrere Buckets derselben Entity
+        // ("Upcoming" / "Active" / "Past") nutzen unterschiedliche filter
+        // bei gleichem Query-Handler.
+        if (screen.filter !== undefined) {
+            payload["filter"] = screen.filter;
+        }
+        if (filterPayload.length > 0) {
+            payload["filters"] = filterPayload;
+        }
+        return payload;
+    }, [
+        limit,
+        urlState.q,
+        effectiveSort,
+        screen.filter,
+        filterPayload,
+        usePager,
+        urlState.page,
+        useInfinite,
+        cursor,
+    ]);
+    const rowsQuery = useQuery(queryType, queryPayload, { live: true });
+    const refreshRowsAfterWrite = useCallback(async () => {
+        if (useInfinite) {
+            setAccumulated([]);
+            setCursor(undefined);
+            setHasMore(true);
+            return;
+        }
+        await refetchAfterWrite(rowsQuery.refetch);
+    }, [useInfinite, rowsQuery.refetch]);
+    // Infinite-Scroll: bei jedem erfolgreichen Result die rows appenden +
+    // hasMore aus nextCursor ableiten. Live-Updates (postgres NOTIFY) und
+    // initiale Loads laufen beide hier durch — das useEffect-Dep-Array
+    // pinnt die Dedup auf dem letzten verarbeiteten data-Pointer.
+    const lastDataRef = useRef(null);
+    useEffect(() => {
+        if (!useInfinite)
+            return;
+        const data = rowsQuery.data;
+        if (data === null)
+            return;
+        if (data === lastDataRef.current)
+            return;
+        lastDataRef.current = data;
+        setAccumulated((prev) => {
+            // Wenn cursor undefined ist, ist das die erste Page nach
+            // sort/q-Change → komplett ersetzen statt anhängen. Sonst dedupe
+            // auf id falls Live-Updates einen Eintrag in der nächsten Page
+            // bringen die schon angehängt war.
+            if (cursor === undefined)
+                return data.rows;
+            const seen = new Set(prev.map((r) => r["id"]));
+            const fresh = data.rows.filter((r) => !seen.has(r["id"]));
+            return [...prev, ...fresh];
+        });
+        setHasMore(data.nextCursor !== null);
+    }, [rowsQuery.data, useInfinite, cursor]);
+    const loadMore = useCallback(() => {
+        if (!useInfinite)
+            return;
+        if (rowsQuery.loading)
+            return;
+        const data = rowsQuery.data;
+        if (data?.nextCursor === undefined || data.nextCursor === null)
+            return;
+        setCursor(data.nextCursor);
+    }, [useInfinite, rowsQuery.loading, rowsQuery.data]);
+    // RowActions: Schema-Form (handler-QN + i18n-Key) → Resolved-Form
+    // (dispatcher-Call + translated Strings). dispatcher.write kennt den
+    // User intern (JWT-Cookie). Schema kann sowohl raw-Strings als auch
+    // i18n-Keys enthalten — translate() returnt den Key wenn das Bundle
+    // ihn nicht kennt (Convention überall im Renderer).
+    // Hooks-Reihenfolge: ALLE Hooks vor early-return für loading/error,
+    // sonst kollidieren die Hook-Slots zwischen Renders.
+    const t = useTranslation();
+    const effectiveTranslate = translate ?? t;
+    // Faceted-Filter: ein Dropdown pro filterable select/boolean/reference-Feld.
+    // Labels + select-Option-Labels über dieselbe i18n-Konvention wie die
+    // Spalten-Header (fieldLabelKey / :option:<value>); reference-Felder laden
+    // ihre Optionen asynchron über ReferenceFacetBridges.
+    const entityFacetSpecs = useMemo(() => resolveEntityFacetSpecs(entity.fields, featureName, screen.entity, effectiveTranslate), [entity.fields, featureName, screen.entity, effectiveTranslate]);
+    const [entityReferenceFacetOptions, setEntityReferenceFacetOptions] = useState({});
+    const handleEntityFacetOptions = useCallback((field, options) => setEntityReferenceFacetOptions((prev) => prev[field] === options ? prev : { ...prev, [field]: options }), []);
+    const filterFacets = useMemo(() => buildFilterFacets(mergeReferenceFacetOptions(entityFacetSpecs, entityReferenceFacetOptions)), [entityFacetSpecs, entityReferenceFacetOptions]);
+    // Soft-Dispatcher: in Tests die ohne DispatcherProvider mounten,
+    // bleibt rowActions undefined statt zu crashen. Echte Apps haben
+    // den Provider via createKumikoApp — wenn nicht, ist es vermutlich
+    // ein Setup-Fehler, also einmal warnen damit der Author das findet
+    // (sonst rendert die Action-Spalte still nichts und der "warum sind
+    // meine Buttons weg?"-Debug ist teuer).
+    const dispatcher = useOptionalDispatcher();
+    const hasRowActions = screen.rowActions !== undefined && screen.rowActions.length > 0;
+    useEffect(() => {
+        if (hasRowActions && dispatcher === undefined) {
+            // biome-ignore lint/suspicious/noConsole: dev-warning für Setup-Fehler
+            console.warn(`[kumiko] Screen "${screen.id}" deklariert rowActions, aber kein <DispatcherProvider> ist mounted — die Action-Spalte wird nicht gerendert. createKumikoApp() wired den Provider automatisch.`);
+        }
+    }, [hasRowActions, dispatcher, screen.id]);
+    // Discriminated Union: writeHandler (default) dispatched einen Server-
+    // Handler, navigate ruft nav.navigate() ggf. mit URL-Search-Params aus
+    // params(row). nav lebt schon weiter unten in EntityListBody-Scope.
+    // Gemeinsame navigate-Ausführung: sowohl das "…"-Aktionsmenü (rowActions) als
+    // auch der Row-Body-Klick (rowClick) laufen hierdurch — ein Pfad, damit beide
+    // nicht auseinanderdriften.
+    const runNavigate = useCallback((action, row) => {
+        if (action.entity !== undefined) {
+            // Entity-Targets (fw#2228) lösen sich erst in der NavApi-Impl gegen
+            // ALLE Features auf (resolveTarget in renderer-web/nav.tsx) — dieses
+            // Package kennt nur `schema` (das eine aufrufende Feature) und kann
+            // detailFor cross-feature nicht selbst nachschlagen.
+            const explicit = action.entityId !== undefined ? String(row.values[action.entityId] ?? "") : undefined;
+            // Same-entity only — cross-entity targets must declare entityId (boot-validator).
+            const fallback = action.entity === screen.entity ? String(row.values["id"] ?? "") : undefined;
+            const id = explicit ?? fallback ?? "";
+            if (id === "")
+                return;
+            const params = navigateActionSearchParams(action, row.values);
+            navigateWithReturnTo(nav, { entity: action.entity, id }, host, params);
+        }
+        else if (action.screen !== undefined) {
+            // Default entityId für entityEdit-Targets: row["id"] wenn kein expliziter
+            // entityId-Feldname gesetzt ist. Nur für Targets DERSELBEN Entity — sonst
+            // bekäme ein Cross-Entity-Edit-Screen die falsche row.id injiziert.
+            const targetIsEntityEdit = schema.screens.some((s) => s.type === "entityEdit" &&
+                s.entity === screen.entity &&
+                lastSegment(s.id) === action.screen);
+            const explicit = action.entityId !== undefined ? String(row.values[action.entityId] ?? "") : undefined;
+            const fallback = targetIsEntityEdit ? String(row.values["id"] ?? "") : undefined;
+            const entityId = explicit ?? fallback;
+            const target = {
+                screenId: action.screen,
+                ...(entityId !== undefined && entityId !== "" && { entityId }),
+            };
+            // setSearchParams nimmt string|null — komplexe Werte zu String (der Reader
+            // kennt via URL nur Strings). Known-edge: zielt die Action auf den
+            // AKTUELLEN pathname, mergen die Params auf den alten ?-String (für
+            // Row-Actions praktisch nicht erreichbar, Pfad differiert).
+            const params = navigateActionSearchParams(action, row.values);
+            navigateWithReturnTo(nav, target, host, params);
+        }
+    }, [nav, schema.screens, screen.entity, host]);
+    const rowActions = useMemo(() => {
+        const declared = screen.rowActions ?? [];
+        // Prepended unless a declared rowAction already has id "edit" — declared wins.
+        const declaredHasEdit = declared.some((a) => a.id === "edit");
+        const defaultEditRowAction = declaredHasEdit
+            ? undefined
+            : buildDefaultEditRowAction(defaultEditScreen);
+        const effectiveActions = defaultEditRowAction !== undefined ? [defaultEditRowAction, ...declared] : declared;
+        if (effectiveActions.length === 0)
+            return undefined;
+        return effectiveActions
+            .map((action) => {
+            // navigate-Variante braucht keinen Dispatcher; nav ist
+            // immer da (Provider von createKumikoApp).
+            if (action.kind === "navigate") {
+                const navigateAction = action;
+                const actionVisible = action.visible;
+                const actionIcon = resolveActionIcon(action.id, action.icon);
+                return {
+                    id: action.id,
+                    label: effectiveTranslate(action.label),
+                    ...(action.style !== undefined && { style: action.style }),
+                    confirmRequired: false,
+                    ...(navigateAction.rowClick === true && { rowClick: true }),
+                    ...(actionIcon !== undefined && { icon: actionIcon }),
+                    onTrigger: (row) => runNavigate(navigateAction, row),
+                    ...(actionVisible !== undefined && {
+                        isVisible: (row) => evalFieldCondition(actionVisible, row.values),
+                    }),
+                };
+            }
+            if (action.kind === "drawer") {
+                const drawerAction = action;
+                const actionVisible = action.visible;
+                const actionIcon = resolveActionIcon(action.id, action.icon);
+                return {
+                    id: action.id,
+                    label: effectiveTranslate(action.label),
+                    ...(action.style !== undefined && { style: action.style }),
+                    confirmRequired: false,
+                    ...(actionIcon !== undefined && { icon: actionIcon }),
+                    onTrigger: (row) => {
+                        const initialValues = drawerAction.params !== undefined
+                            ? evalRowExtractor(drawerAction.params, row.values)
+                            : undefined;
+                        openDrawer(drawerAction, initialValues);
+                    },
+                    ...(actionVisible !== undefined && {
+                        isVisible: (row) => evalFieldCondition(actionVisible, row.values),
+                    }),
+                };
+            }
+            if (dispatcher === undefined)
+                return null;
+            if (!isWriteHandlerRowAction(action))
+                return null;
+            const writeAction = action;
+            const writeActionVisible = writeAction.visible;
+            return {
+                id: writeAction.id,
+                label: effectiveTranslate(writeAction.label),
+                style: writeAction.style,
+                icon: resolveActionIcon(writeAction.id, writeAction.icon),
+                confirm: writeAction.confirm !== undefined ? effectiveTranslate(writeAction.confirm) : undefined,
+                confirmLabel: writeAction.confirmLabel !== undefined
+                    ? effectiveTranslate(writeAction.confirmLabel)
+                    : undefined,
+                onTrigger: async (row) => {
+                    const buildPayload = writeAction.payload;
+                    const payload = buildPayload !== undefined
+                        ? evalRowExtractor(buildPayload, row.values)
+                        : { id: row.values["id"] };
+                    const result = await dispatcher.write(writeAction.handler, payload);
+                    // write() wirft nicht — Failure-Result MUSS hier zum Error
+                    // werden, sonst schließt der Confirm-Dialog kommentarlos und
+                    // der User sieht "nichts passiert" (Prod-Bug 2026-06-07).
+                    if (!result.isSuccess) {
+                        throw new WriteFailedError(result.error, dispatcherErrorText(result.error, effectiveTranslate));
+                    }
+                    await refreshRowsAfterWrite();
+                },
+                isVisible: writeActionVisible !== undefined
+                    ? (row) => evalFieldCondition(writeActionVisible, row.values)
+                    : undefined,
+            };
+        })
+            .filter((a) => a !== null);
+    }, [
+        screen.rowActions,
+        defaultEditScreen,
+        effectiveTranslate,
+        dispatcher,
+        runNavigate,
+        refreshRowsAfterWrite,
+        openDrawer,
+    ]);
+    // ToolbarActions: Schema → Resolved-Form (analog rowActions), shared with
+    // projectionList and relatedList sections via buildProjectionToolbarActions.
+    const toolbarActions = useMemo(() => buildProjectionToolbarActions({
+        toolbarActions: screen.toolbarActions,
+        translate: effectiveTranslate,
+        dispatcher,
+        nav,
+        refetch: refreshRowsAfterWrite,
+        openDrawer,
+        host,
+    }), [
+        screen.toolbarActions,
+        effectiveTranslate,
+        nav,
+        host,
+        dispatcher,
+        refreshRowsAfterWrite,
+        openDrawer,
+    ]);
+    if (rowsQuery.loading && rowsQuery.data === null) {
+        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+    }
+    if (rowsQuery.error) {
+        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(rowsQuery.error, effectiveTranslate) }));
+    }
+    // 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
+    // it.
+    // Row-Body-Klick: eine explizit als rowClick markierte navigate-rowAction
+    // gewinnt (deklarierte Author-Absicht "Klick auf die Zeile tut X"). Ohne Flag
+    // bleibt der Pfad unverändert — create-app's entityEdit-Default bzw. ein vom
+    // App-Author gesetztes onRowClick.
+    const rowClickAction = screen.rowActions?.find((a) => a.kind === "navigate" && a.rowClick === true);
+    const wrappedOnRowClick = rowClickAction
+        ? (row) => runNavigate(rowClickAction, row)
+        : onRowClick !== undefined
+            ? (row) => onRowClick(row, screen.entity)
+            : undefined;
+    // Searchable default: explicit author choice wins, otherwise auto-on when
+    // the entity has searchable fields (dead toolbar slot otherwise — the
+    // server search index has nothing to filter). Gated on
+    // schema.searchAdapterMissing !== true regardless of source (explicit or
+    // auto) — a search bar the server can't serve would 422 at request-time
+    // (#2032); matches the boot-time check in api/server.ts (#2051).
+    const searchable = schema.searchAdapterMissing !== true &&
+        (screen.searchable ??
+            Object.values(entity.fields).some((f) => "searchable" in f && f.searchable === true));
+    // Pager-Props nur bei pagination="pages" zusammenstellen. Server-
+    // total kommt async — bis es da ist, rendert RenderList die Tabelle
+    // ohne Pager (Pager hat eine eigene total>0-Guard).
+    const total = rowsQuery.data?.total;
+    const pager = usePager && total !== undefined
+        ? {
+            page: urlState.page,
+            limit,
+            total,
+            onPageChange: urlState.setPage,
+            pageSizeOptions: pageSizeOptionsFor(limit),
+            onPageSizeChange: urlState.setPageSize,
+        }
+        : undefined;
+    // 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(RenderList, { screen: screen, entity: entity, rows: renderRows, featureName: featureName, searchable: searchable, searchValue: urlState.q, onSearchChange: urlState.setQ, sort: effectiveSort, onSortChange: urlState.setSort, screenPadding: true, ...(screenFillsHeight(screen) && { scrollBody: true }), ...(pager !== undefined && { pager }), ...(rowActions !== undefined && { rowActions }), ...(toolbarActions !== undefined && toolbarActions.length > 0 && { toolbarActions }), ...(useInfinite && {
+                    onReachEnd: loadMore,
+                    loadingMore: rowsQuery.loading,
+                    hasMore,
+                }), ...(onCreate !== undefined && { onCreate }), ...(translate !== undefined && { translate }), ...(wrappedOnRowClick !== undefined && { onRowClick: wrappedOnRowClick }), ...(filterFacets.length > 0 && {
+                    filterFacets,
+                    filterValues: urlState.filters,
+                    onFilterChange: urlState.setFilter,
+                    onFilterReset: urlState.clearFilters,
+                }) }), _jsx(DrawerHost, { schema: schema, drawerAction: drawerAction, drawerScreen: drawerScreen, ...(drawerInitialValues !== undefined && { drawerInitialValues }), userRoles: userRoles, ...(translate !== undefined && { translate }), onClose: closeDrawer, onSuccess: () => {
+                    closeDrawer();
+                    void rowsQuery.refetch();
+                } })] }));
+}
+// ---- projection-list ----
+// Like entityList, but the list query comes DIRECTLY from `screen.query`
+// (instead of being derived from an entity) — cross-feature capable.
+// search/sort/pagination reuse the same URL-state + buildListQueryPayload
+// wiring as EntityListBody; which of them are actually offered is derived
+// from the query handler's Zod schema at buildAppSchema time (fw#2165), not
+// declared here. Pages-mode pagination only — infinite-scroll accumulation
+// isn't wired for projectionList.
+function ProjectionListBody({ schema, screen, translate, onRowClick, }) {
+    const { Banner, Text } = usePrimitives();
+    const t = useTranslation();
+    const nav = useNav();
+    const host = useReturnHost();
+    const dispatcher = useOptionalDispatcher();
+    const effectiveTranslate = translate ?? t;
+    const userRoles = useUserRoles();
+    const appFeatures = useAppFeatures();
+    const { drawerAction, drawerScreen, drawerInitialValues, openDrawer, closeDrawer } = useDrawerAction(schema);
+    const defaultEditScreen = useMemo(() => {
+        const detailFor = screen.detailFor;
+        if (detailFor === undefined)
+            return undefined;
+        return findEditScreenFor(detailFor, appFeatures, userRoles);
+    }, [appFeatures, screen.detailFor, userRoles]);
+    // searchable/sortable/paginated are derived at buildAppSchema time from the
+    // query handler's Zod schema (fw#2165) — not authored on the screen.
+    const searchable = screen.searchable ?? false;
+    const sortable = screen.sortable ?? false;
+    const paginated = screen.paginated ?? false;
+    const entity = useMemo(() => synthesizeProjectionEntity(screen.columns, sortable), [screen.columns, sortable]);
+    const listScreen = useMemo(() => synthesizeProjectionScreen(screen), [screen]);
+    const urlState = useListUrlState(screen.id);
+    // Gated on the derived capability, not just on whether URL-state happens to
+    // carry a value — a stale/hand-crafted URL (?…q=x on a non-searchable
+    // screen) must not smuggle a param the query's Zod schema doesn't accept.
+    const activeSearch = searchable ? urlState.q : "";
+    const activeSort = sortable ? (urlState.sort ?? screen.defaultSort ?? null) : null;
+    const limit = urlState.pageSize ?? screen.pageSize ?? 50;
+    // Pages-mode only (see header comment) — an author-set pagination:
+    // "infinite" on a paginated projectionList is silently a no-op today.
+    const usePager = paginated && (screen.pagination ?? "pages") === "pages";
+    // Facets (fw#2224) — a projectionList has no entity, so screen.facets is
+    // the only field inventory; resolveProjectionFacetSpecs reshapes +
+    // translates its explicit labels into the same ResolvedFacetSpec the
+    // entityList adapter produces, so both feed the same
+    // buildFilterFacets/buildFilterPayload.
+    const facetSpecs = useMemo(() => resolveProjectionFacetSpecs(screen.facets, effectiveTranslate, schema.featureName), [screen.facets, effectiveTranslate, schema.featureName]);
+    const [projectionReferenceFacetOptions, setProjectionReferenceFacetOptions] = useState({});
+    const handleProjectionFacetOptions = useCallback((field, options) => setProjectionReferenceFacetOptions((prev) => prev[field] === options ? prev : { ...prev, [field]: options }), []);
+    const resolvedFacetSpecs = useMemo(() => mergeReferenceFacetOptions(facetSpecs, projectionReferenceFacetOptions), [facetSpecs, projectionReferenceFacetOptions]);
+    const filterPayload = useMemo(() => buildFilterPayload(urlState.filters, (field) => facetSpecs.find((spec) => spec.field === field)?.type), [urlState.filters, facetSpecs]);
+    // dateRange facets (fw#3104) bypass `filters` entirely — their two bounds
+    // become the top-level query params the facet declares, resolved from a
+    // calendar date to an instant in the viewer's zone.
+    const timeZone = useOptionalTimeZone();
+    const dateRangeSpecs = useMemo(() => resolveDateRangeFacets(screen.facets, effectiveTranslate), [screen.facets, effectiveTranslate]);
+    const dateRangePayload = useMemo(() => buildDateRangePayload(dateRangeSpecs, urlState.filters, timeZone), [dateRangeSpecs, urlState.filters, timeZone]);
+    const queryPayload = useMemo(() => {
+        const payload = buildListQueryPayload({
+            limit,
+            search: activeSearch,
+            sort: activeSort,
+            usePager,
+            page: urlState.page,
+            useInfinite: false,
+            cursor: undefined,
+        });
+        // Gated on screen.filter/screen.facets being declared (not just on
+        // urlState/filterPayload happening to carry a value) — same rule as
+        // activeSearch/activeSort above: a stale URL must not smuggle a param
+        // the bound query's Zod schema doesn't accept (fw#2165 pattern).
+        if (screen.filter !== undefined) {
+            payload["filter"] = screen.filter;
+        }
+        if (screen.facets !== undefined && filterPayload.length > 0) {
+            payload["filters"] = filterPayload;
+        }
+        Object.assign(payload, dateRangePayload);
+        return payload;
+    }, [
+        limit,
+        activeSearch,
+        activeSort,
+        usePager,
+        urlState.page,
+        screen.filter,
+        screen.facets,
+        filterPayload,
+        dateRangePayload,
+    ]);
+    const rowsQuery = useQuery(screen.query, queryPayload, { live: true });
+    const filterFacets = useMemo(() => buildFilterFacets(resolvedFacetSpecs), [resolvedFacetSpecs]);
+    const dateRangeFacets = useMemo(() => dateRangeSpecs.map((spec) => ({
+        field: spec.field,
+        label: spec.label,
+        ...readDateRange(urlState.filters, spec.field),
+    })), [dateRangeSpecs, urlState.filters]);
+    const handleDateRangeChange = useCallback((field, bound, value) => {
+        urlState.setDateRange(field, clampDateRange(readDateRange(urlState.filters, field), bound, value));
+    }, [urlState.setDateRange, urlState.filters]);
+    // Entity-Targets (fw#2228) — see EntityListBody.runNavigate for why the
+    // resolution happens in the NavApi impl. Unlike there: NO row["id"]
+    // fallback — projectionList rows come from an arbitrary query projection
+    // with no guaranteed "id" field. The boot validator therefore enforces an
+    // explicit entityId for projectionList entity targets. Same helper
+    // relatedList's rowActions reuse (related-list-section.tsx) — a
+    // projectionDetail relatedList row has the identical "no guaranteed id"
+    // shape.
+    const runNavigate = useCallback((action, row) => runProjectionRowNavigate(nav, action, row, host), [nav, host]);
+    const defaultEditRowAction = useMemo(() => buildDefaultEditRowAction(defaultEditScreen), [defaultEditScreen]);
+    const rowActions = useMemo(() => buildProjectionRowActions({
+        rowActions: screen.rowActions,
+        translate: effectiveTranslate,
+        dispatcher,
+        nav,
+        refetch: rowsQuery.refetch,
+        openDrawer,
+        defaultEditRowAction,
+        host,
+    }), [
+        screen.rowActions,
+        effectiveTranslate,
+        dispatcher,
+        nav,
+        rowsQuery.refetch,
+        openDrawer,
+        defaultEditRowAction,
+        host,
+    ]);
+    const toolbarActions = useMemo(() => buildProjectionToolbarActions({
+        toolbarActions: screen.toolbarActions,
+        translate: effectiveTranslate,
+        dispatcher,
+        nav,
+        refetch: rowsQuery.refetch,
+        openDrawer,
+        host,
+    }), [
+        screen.toolbarActions,
+        effectiveTranslate,
+        nav,
+        host,
+        dispatcher,
+        rowsQuery.refetch,
+        openDrawer,
+    ]);
+    if (rowsQuery.loading && rowsQuery.data === null) {
+        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+    }
+    if (rowsQuery.error) {
+        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(rowsQuery.error, effectiveTranslate) }));
+    }
+    // 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
+    // is needed to inspect the actual wire shape before trusting it.
+    const rawRowsData = rowsQuery.data;
+    if (rawRowsData !== null && !Array.isArray(rawRowsData.rows)) {
+        return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-projection-list-bad-shape", children: ["Screen ", _jsx(Text, { variant: "code", children: screen.id }), " query", " ", _jsx(Text, { variant: "code", children: screen.query }), " did not return a PagedRows envelope; a projectionList query must return ", _jsx(Text, { variant: "code", children: "{ rows, nextCursor }" }), "."] }));
+    }
+    const rowClickAction = screen.rowActions?.find((a) => a.kind === "navigate" && a.rowClick === true);
+    const wrappedOnRowClick = rowClickAction
+        ? (row) => runNavigate(rowClickAction, row)
+        : onRowClick !== undefined
+            ? (row) => onRowClick(row, listScreen.entity)
+            : undefined;
+    // Same pager-construction as EntityListBody: no Pager UI until the
+    // server-provided `total` arrives (guards pagination="pages" without
+    // totalCount support, see fw#2165 report on solon's leaseOverviewHandler).
+    const total = rowsQuery.data?.total;
+    const pager = usePager && total !== undefined
+        ? {
+            page: urlState.page,
+            limit,
+            total,
+            onPageChange: urlState.setPage,
+            pageSizeOptions: pageSizeOptionsFor(limit),
+            onPageSizeChange: urlState.setPageSize,
+        }
+        : undefined;
+    return (_jsxs(_Fragment, { children: [_jsx(ReferenceFacetBridges, { specs: facetSpecs, onOptions: handleProjectionFacetOptions }), _jsx(RenderList, { screen: listScreen, entity: entity, rows: rowsQuery.data?.rows ?? [], featureName: schema.featureName, searchable: searchable, searchValue: urlState.q, onSearchChange: urlState.setQ, sort: activeSort, onSortChange: urlState.setSort, screenPadding: true, ...(screenFillsHeight(listScreen) && { scrollBody: true }), ...(pager !== undefined && { pager }), ...(rowActions !== undefined && { rowActions }), ...(toolbarActions !== undefined && { toolbarActions }), ...(translate !== undefined && { translate }), ...(wrappedOnRowClick !== undefined && { onRowClick: wrappedOnRowClick }), ...(filterFacets.length > 0 && {
+                    filterFacets,
+                    onFilterChange: urlState.setFilter,
+                }), ...(dateRangeFacets.length > 0 && {
+                    dateRangeFacets,
+                    onDateRangeChange: handleDateRangeChange,
+                }), ...((filterFacets.length > 0 || dateRangeFacets.length > 0) && {
+                    filterValues: urlState.filters,
+                    onFilterReset: urlState.clearFilters,
+                }) }), _jsx(DrawerHost, { schema: schema, drawerAction: drawerAction, drawerScreen: drawerScreen, ...(drawerInitialValues !== undefined && { drawerInitialValues }), userRoles: userRoles, ...(translate !== undefined && { translate }), onClose: closeDrawer, onSuccess: () => {
+                    closeDrawer();
+                    void rowsQuery.refetch();
+                } })] }));
+}
+function metricLabelKey(metric, fieldLabels) {
+    if (typeof metric !== "string" && metric.label !== undefined)
+        return metric.label;
+    return fieldLabels?.[metricField(metric)];
+}
+function metricNavigateSpec(metric) {
+    return typeof metric === "string" ? undefined : metric.navigate;
+}
+// Reuses runProjectionRowNavigate (row-actions.ts) instead of re-deriving
+// navigate execution — a metric click has the same entity/screen/params
+// shape as a RowActionNavigate, minus the fields (id, label, style) that
+// function never reads.
+function runMetricNavigate(nav, navigate, record, host) {
+    // tab alone (no screen/entity) stays on the current record and just
+    // activates that tab — no route change, so runProjectionRowNavigate
+    // (which always navigates) doesn't apply here.
+    if (navigate.screen === undefined && navigate.entity === undefined) {
+        if (navigate.tab !== undefined)
+            nav.setSearchParams({ tab: navigate.tab });
+        return;
+    }
+    const base = { kind: "navigate", id: "metric-navigate", label: "" };
+    const action = navigate.entity !== undefined
+        ? {
+            ...base,
+            entity: navigate.entity,
+            ...(navigate.entityId !== undefined && { entityId: navigate.entityId }),
+            ...(navigate.params !== undefined && { params: navigate.params }),
+            ...(navigate.tab !== undefined && { tab: navigate.tab }),
+        }
+        : navigate.screen !== undefined
+            ? {
+                ...base,
+                screen: navigate.screen,
+                ...(navigate.entityId !== undefined && { entityId: navigate.entityId }),
+                ...(navigate.params !== undefined && { params: navigate.params }),
+                ...(navigate.tab !== undefined && { tab: navigate.tab }),
+            }
+            : undefined;
+    if (action === undefined)
+        return;
+    runProjectionRowNavigate(nav, action, { id: "", values: record }, host);
+}
+// Absolute http(s) check for RecordHeaderSpec.subtitleHref — deliberately
+// stricter than isSafeHref (which also allows relative paths and mailto:),
+// since a relative/mailto value here should render as plain text, not a
+// "_blank" external link.
+function isAbsoluteHttpUrl(value) {
+    return /^https?:\/\//i.test(value) && isSafeHref(value);
+}
+function headerStatusTone(header, record) {
+    if (header.status === undefined)
+        return undefined;
+    const value = String(record[header.status] ?? "");
+    const declared = header.statusTones !== undefined && Object.hasOwn(header.statusTones, value)
+        ? header.statusTones[value]
+        : undefined;
+    return declared !== undefined ? statusToneForOptionTone(declared) : statusToneForValue(value);
+}
+function resolveSubtitleHref(header, record) {
+    if (header?.subtitleHref === undefined)
+        return undefined;
+    const value = record[header.subtitleHref];
+    return typeof value === "string" && isAbsoluteHttpUrl(value) ? value : undefined;
+}
+// Projection-Detail-Body — read-only single-row inspector über eine explizite
+// Query statt einer Entity (siehe projection-detail-shim.ts für die Schulden-
+// Doku). Fetcht selbst über `screen.query` + `idParam` (analog zu
+// EntityEditUpdateBody, das die Query-QN aus der Entity-Convention ableitet —
+// hier ist die QN Author-explizit, wie bei ProjectionListBody). Rendert über
+// RenderEdit MIT customSubmit-No-Op statt writeCommand: hasEditableSection()
+// blendet den Save-Button aus (jedes Feld ist readOnly), und selbst ein
+// 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, }) {
+    const t = useTranslation();
+    const [pendingAction, setPendingAction] = useState(null);
+    const trigger = async (action) => {
+        onError(null);
+        try {
+            await action.onPress();
+        }
+        catch (e) {
+            onError(e instanceof Error ? e.message : String(e));
+        }
+    };
+    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))) }));
+    }
+    const primary = primaryHeaderAction(actions);
+    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((action) => ({
+                    id: action.id,
+                    label: action.label,
+                    ...(action.icon !== undefined && { icon: action.icon }),
+                    variant: action.style === "danger" ? "danger" : "default",
+                    onSelect: () => {
+                        if (needsActionConfirm(action)) {
+                            setPendingAction(action);
+                        }
+                        else {
+                            void trigger(action);
+                        }
+                    },
+                })) }), pendingAction !== null && (_jsx(RenderEditActionConfirmDialog, { action: pendingAction, open: true, onOpenChange: (open) => {
+                    if (!open)
+                        setPendingAction(null);
+                }, onConfirm: async () => {
+                    const action = pendingAction;
+                    setPendingAction(null);
+                    await trigger(action);
+                }, Dialog: Dialog }))] }));
+}
+function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
+    const { Banner, Button, Dialog, Text, Grid, GridCell, Card, Tabs, StatusBadge, Metric, MetricBand, PageHeader, Link, ActionOverflowMenu, } = usePrimitives();
+    const t = useTranslation();
+    const pageHeaderSlotAvailable = usePageHeaderSlotAvailable();
+    const effectiveTranslate = translate ?? t;
+    const nav = useNav();
+    const idParam = screen.idParam ?? "id";
+    // Singleton screens ignore whatever id the path happens to carry — the
+    // server picks the row from session/context, so forwarding a path id
+    // (even a stray/spoofed one) into the query or into extension sections'
+    // entityId fallback (resolveExtensionEntityId in render-edit.tsx) would
+    // let a client-controlled value leak where none is meant to reach.
+    const effectiveEntityId = screen.singleton === true ? undefined : entityId;
+    const isTabsMode = screen.layout.mode === "tabs";
+    const activeSection = useMemo(() => {
+        if (!isTabsMode || Tabs === undefined)
+            return undefined;
+        const tabParam = nav.searchParams["tab"];
+        return (screen.layout.sections.find((section) => section.id === tabParam) ?? screen.layout.sections[0]);
+    }, [isTabsMode, Tabs, screen.layout.sections, nav.searchParams]);
+    const hasTabs = isTabsMode && Tabs !== undefined && activeSection !== undefined;
+    // Tabs is an optional Core-Primitive: without it the screen falls back to
+    // the stacked all-sections layout instead of silently truncating to section 1.
+    useEffect(() => {
+        if (isTabsMode && Tabs === undefined) {
+            // biome-ignore lint/suspicious/noConsole: dev-warning for a setup error
+            console.warn(`[kumiko] screen "${screen.id}" uses layout.mode: "tabs", but no <Tabs> primitive is registered — the tab strip will not render. createKumikoApp() from kumiko-renderer-web wires it automatically.`);
+        }
+    }, [isTabsMode, Tabs, screen.id]);
+    const entity = useMemo(() => synthesizeProjectionDetailEntity(screen.layout), [screen.layout]);
+    const detailScreen = useMemo(() => {
+        const source = activeSection !== undefined
+            ? { ...screen, layout: { ...screen.layout, sections: [activeSection] } }
+            : screen;
+        return synthesizeProjectionDetailScreen(source);
+    }, [screen, activeSection]);
+    const detailQuery = useQuery(screen.query, effectiveEntityId !== undefined ? { [idParam]: effectiveEntityId } : {});
+    // A writeForm section's handler creates a new record (see EditWriteFormSection's
+    // doc) — both the outer record (header/metrics/other sections) and a sibling
+    // relatedList section's own independently-fetched rows must reflect it. A
+    // query refetch alone only refreshes `record` below; bumping this into
+    // <RenderEdit>'s `key` forces a full remount so RelatedListSection's own
+    // useQuery call re-runs too (it has no `live` subscription of its own).
+    const [reloadNonce, setReloadNonce] = useState(0);
+    const reloadDetail = useCallback(async () => {
+        await detailQuery.refetch();
+        setReloadNonce((n) => n + 1);
+    }, [detailQuery.refetch]);
+    // Header actions render directly via RenderEditActionButton (fw#2713,
+    // headerActions moved out of RenderEdit's footer) — this component owns
+    // the failure-surfacing state RenderEdit used to own for them.
+    const [actionError, setActionError] = useState(null);
+    // Default edit action (fw#2166): resolved cross-feature over ALL mounted
+    // features, not just this feature's own schema — detailFor itself is
+    // resolved cross-feature by the boot-validator (detail-screens.ts), and
+    // the motivating case is a projectionDetail whose query belongs to one
+    // feature while the entity's entityEdit screen lives in another. Unlike
+    // useNavigateToCreateFor this must NOT filter on allowCreate/singleton —
+    // those gate create-targets, we're resolving an update-target by a
+    // known id.
+    const appFeatures = useAppFeatures();
+    const userRoles = useUserRoles();
+    const dispatcher = useOptionalDispatcher();
+    const host = useReturnHost();
+    const { drawerAction, drawerScreen, drawerInitialValues, openDrawer, closeDrawer } = useDrawerAction(schema);
+    const editScreen = useMemo(() => {
+        const detailFor = screen.detailFor;
+        if (detailFor === undefined)
+            return undefined;
+        return findEditScreenFor(detailFor, appFeatures, userRoles);
+    }, [appFeatures, screen.detailFor, userRoles]);
+    const defaultEditAction = useMemo(() => {
+        if (editScreen === undefined)
+            return undefined;
+        // editScreen.id is registry-qualified ("feature:screen:contact-edit");
+        // nav.navigate expects the short form (see useNavigateToCreateFor above).
+        const targetScreenId = lastSegment(editScreen.id);
+        return {
+            id: "edit",
+            label: effectiveTranslate("kumiko.actions.edit"),
+            icon: resolveActionIcon("edit"),
+            onPress: () => {
+                const target = {
+                    screenId: targetScreenId,
+                    ...(effectiveEntityId !== undefined && { entityId: effectiveEntityId }),
+                };
+                navigateWithReturnTo(nav, target, host);
+            },
+        };
+    }, [editScreen, effectiveTranslate, nav, effectiveEntityId, host]);
+    // a navigate-screen action targeting an entityEdit screen for the
+    // SAME entity this projectionDetail shows (screen.detailFor) defaults its
+    // entityId to the shown record's own id — without this fallback the target
+    // opens an empty create-form instead of the shown record, silently.
+    // Searched cross-feature, consistent with editScreen above.
+    const sameEntityScreenId = useCallback((targetScreen) => {
+        const record = detailQuery.data ?? {};
+        const targetIsEntityEditSameEntity = screen.detailFor !== undefined &&
+            appFeatures.some((feature) => feature.screens.some((s) => s.type === "entityEdit" &&
+                s.entity === screen.detailFor &&
+                lastSegment(s.id) === targetScreen));
+        return targetIsEntityEditSameEntity ? String(record["id"] ?? "") : undefined;
+    }, [detailQuery.data, screen.detailFor, appFeatures]);
+    const buildSectionActions = useCallback((actions) => buildRecordActions({
+        actions,
+        record: detailQuery.data ?? {},
+        translate: effectiveTranslate,
+        nav,
+        host,
+        dispatcher,
+        openDrawer,
+        onWriteSuccess: detailQuery.refetch,
+        sameEntityScreenId,
+    }), [
+        detailQuery.data,
+        detailQuery.refetch,
+        effectiveTranslate,
+        nav,
+        host,
+        dispatcher,
+        openDrawer,
+        sameEntityScreenId,
+    ]);
+    const headerActions = useMemo(() => {
+        const declaredHasEdit = screen.actions?.some((a) => a.id === "edit") === true;
+        const resolved = buildRecordActions({
+            actions: screen.actions ?? [],
+            record: detailQuery.data ?? {},
+            translate: effectiveTranslate,
+            nav,
+            host,
+            dispatcher,
+            openDrawer,
+            onWriteSuccess: detailQuery.refetch,
+            sameEntityScreenId,
+        });
+        if (defaultEditAction === undefined || declaredHasEdit)
+            return resolved;
+        return [defaultEditAction, ...(resolved ?? [])];
+    }, [
+        screen.actions,
+        defaultEditAction,
+        effectiveTranslate,
+        nav,
+        host,
+        dispatcher,
+        detailQuery.data,
+        detailQuery.refetch,
+        openDrawer,
+        sameEntityScreenId,
+    ]);
+    if (effectiveEntityId === undefined && screen.singleton !== true) {
+        return (_jsxs(Banner, { padded: true, variant: "error", testId: "kumiko-screen-projection-detail-missing-id", children: ["Screen ", _jsx(Text, { variant: "code", children: screen.id }), " (projectionDetail) needs a row id in the path \u2014 open it from a row action."] }));
+    }
+    if (detailQuery.loading && detailQuery.data === null) {
+        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+    }
+    if (detailQuery.error) {
+        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(detailQuery.error, effectiveTranslate) }));
+    }
+    const record = detailQuery.data;
+    if (!record) {
+        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-record-missing", children: screen.singleton === true ? ("Record not found.") : (_jsxs(_Fragment, { children: ["Record ", _jsx(Text, { variant: "code", children: entityId }), " not found."] })) }));
+    }
+    const hasHeader = screen.header !== undefined;
+    const hasMetrics = screen.metrics !== undefined && screen.metrics.length > 0;
+    // ?? [] rather than threading `headerActions !== undefined` through every
+    // use below — an empty array is a safe no-op for .map/.length.
+    const headerActionsList = headerActions ?? [];
+    const hasHeaderActions = headerActionsList.length > 0;
+    // Grouped into the head Card alongside title/status/metrics (fw#2713):
+    // these are actions on the record the head shows, not on whichever tab is
+    // open, so they must stay in place across tab switches instead of
+    // trailing the active tab's content in the card footer.
+    const headerActionsContent = hasHeaderActions && (_jsx(Grid, { columns: "auto", testId: "kumiko-screen-projection-detail-actions", children: _jsx(HeaderActionsBar, { actions: headerActionsList, Button: Button, Dialog: Dialog, ActionOverflowMenu: ActionOverflowMenu, onError: setActionError }) }));
+    const hasHeaderCard = hasHeader || hasMetrics || hasHeaderActions;
+    // Rendered as RenderEdit's headerRegion (not as JSX siblings before it) so
+    // this shares the same page padding/width as the record's edit card below
+    // it, instead of sitting flush against the screen edge (fw record-screen
+    // header polish).
+    const header = screen.header;
+    const subtitleHref = resolveSubtitleHref(header, record);
+    // Plain Text, not Heading — the Card title slot already renders as its own
+    // heading element (h3); nesting another heading (h1) inside it is invalid HTML.
+    const headerTitleSlot = header !== undefined ? (header.status !== undefined ? (_jsxs(Grid, { columns: "auto", children: [_jsx(Text, { testId: "kumiko-screen-projection-detail-title", children: String(record[header.title] ?? "") }), StatusBadge !== undefined ? (_jsx(StatusBadge, { value: String(record[header.status] ?? ""), tone: headerStatusTone(header, record), testId: "kumiko-screen-projection-detail-status" })) : (_jsx(Text, { testId: "kumiko-screen-projection-detail-status", children: String(record[header.status] ?? "") }))] })) : (_jsx(Text, { testId: "kumiko-screen-projection-detail-title", children: String(record[header.title] ?? "") }))) : undefined;
+    const headerSubtitleSlot = header?.subtitle !== undefined ? (subtitleHref !== undefined ? (_jsx(Link, { href: subtitleHref, target: "_blank", testId: "kumiko-screen-projection-detail-subtitle", children: String(record[header.subtitle] ?? "") })) : (_jsx(Text, { variant: "muted", testId: "kumiko-screen-projection-detail-subtitle", children: String(record[header.subtitle] ?? "") }))) : undefined;
+    // slots.header shares the header card with the actions (one card, actions
+    // top right) instead of rendering as an unframed block above it.
+    const metricItems = screen.metrics?.map((metric) => {
+        const field = metricField(metric);
+        const labelKey = metricLabelKey(metric, screen.fieldLabels);
+        const label = labelKey !== undefined ? effectiveTranslate(labelKey) : field;
+        const value = String(record[field] ?? "");
+        const testId = `kumiko-screen-projection-detail-metric-${field}`;
+        const navigate = metricNavigateSpec(metric);
+        const onPress = navigate !== undefined && navigateTargetAllows(navigate, appFeatures, userRoles)
+            ? () => runMetricNavigate(nav, navigate, record, host)
+            : undefined;
+        return Metric !== undefined ? (_jsx(Metric, { label: label, value: value, testId: testId, ...(onPress !== undefined && { onPress }) }, field)) : (_jsxs(GridCell, { children: [_jsx(Text, { variant: "small", testId: `${testId}-label`, children: label }), _jsx(Text, { testId: `${testId}-value`, children: value })] }, field));
+    });
+    // Metrics are a dl band when the primitive exists; the old Grid stays as the fallback.
+    const metricsBlock = (subtitle) => MetricBand !== undefined ? (_jsx(MetricBand, { testId: "kumiko-screen-projection-detail-metrics", subtitle: subtitle, children: metricItems })) : (_jsx(Grid, { columns: screen.metrics?.length ?? 1, testId: "kumiko-screen-projection-detail-metrics", children: metricItems }));
+    const usesPageHeaderSlot = pageHeaderSlotAvailable && PageHeader !== undefined;
+    const actionErrorBanner = actionError !== null && (_jsx(Banner, { variant: "error", testId: "render-edit-action-error", children: actionError }));
+    const renderHeaderContent = (headerSlot) => (_jsxs(_Fragment, { children: [usesPageHeaderSlot && headerSlot === undefined ? (_jsxs(_Fragment, { children: [_jsx(PageHeader, { ...(header !== undefined && { title: String(record[header.title] ?? "") }), ...(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 }) })),
+                        }) }), (hasMetrics || headerSubtitleSlot !== undefined) &&
+                        (MetricBand !== undefined || hasMetrics) &&
+                        metricsBlock(headerSubtitleSlot), actionErrorBanner] })) : ((hasHeaderCard || headerSlot !== undefined) && (_jsxs(Card, { slots: {
+                    ...(headerTitleSlot !== undefined && { title: headerTitleSlot }),
+                    ...(headerSubtitleSlot !== undefined && { subtitle: headerSubtitleSlot }),
+                    ...(headerSlot !== undefined && { headerContent: headerSlot }),
+                    ...(hasHeaderActions && { headerActions: headerActionsContent }),
+                }, children: [hasMetrics && metricsBlock(), actionErrorBanner] }))), hasTabs && activeSection !== undefined && (_jsx(Tabs, { testId: "kumiko-screen-projection-detail-tabs", items: screen.layout.sections.map((section) => {
+                    const countField = isWriteFormEditSection(section) ? undefined : section.countField;
+                    const countValue = countField !== undefined ? record[countField] : undefined;
+                    const count = typeof countValue === "number" && Number.isFinite(countValue)
+                        ? countValue
+                        : undefined;
+                    return {
+                        id: section.id ?? "",
+                        label: effectiveTranslate(section.title ?? section.id ?? ""),
+                        ...(count !== undefined && { count }),
+                    };
+                }), activeId: activeSection.id ?? "", onSelect: (id) => nav.setSearchParams({ tab: id }) }))] }));
+    return (_jsxs(_Fragment, { children: [_jsx(RenderEdit, { screen: detailScreen, entity: entity, featureName: schema.featureName, initial: record, entityId: effectiveEntityId, customSubmit: async () => ({ isSuccess: true, validationBlocked: false, data: undefined }), onReload: reloadDetail, onRelatedListDrawerAction: openDrawer, ...(translate !== undefined && { translate }), ...(hasTabs && { hideSectionTitles: true }), ...(screenFillsHeight(screen) && { fillScreenHeight: true }), ...((hasHeaderCard || hasTabs || screen.slots?.header !== undefined) && {
+                    headerRegion: renderHeaderContent,
+                }), buildSectionActions: buildSectionActions, valueDisplay: screen.valueDisplay ?? "text" }, `${entityId}:${reloadNonce}`), _jsx(DrawerHost, { schema: schema, drawerAction: drawerAction, drawerScreen: drawerScreen, ...(drawerInitialValues !== undefined && { drawerInitialValues }), userRoles: userRoles, ...(translate !== undefined && { translate }), onClose: closeDrawer, onSuccess: () => {
+                    closeDrawer();
+                    void reloadDetail();
+                } })] }));
+}
+// ---- actionForm (Tier 2.7d) ----
+function redirectScreenTarget(redirect) {
+    return typeof redirect === "string" ? redirect : redirect.screen;
+}
+// Checks this schema first, then every mounted feature — the target may live
+// in another (cross-feature) feature than the redirect's own screen.
+function findRedirectTargetScreen(redirect, schema, appFeatures) {
+    const redirectScreen = redirectScreenTarget(redirect);
+    const targetId = lastSegment(redirectScreen);
+    const targetFeatureName = featureNameFromQualifiedScreenId(redirectScreen);
+    return (schema.screens.find((s) => lastSegment(s.id) === targetId) ??
+        (targetFeatureName !== undefined
+            ? appFeatures
+                .find((f) => f.featureName === targetFeatureName)
+                ?.screens.find((s) => lastSegment(s.id) === targetId)
+            : appFeatures.flatMap((f) => f.screens).find((s) => lastSegment(s.id) === targetId)));
+}
+// A redirect to a record screen ("show the result") is a deliberate forward
+// navigation and keeps precedence over returnTo.
+function redirectTargetsRecord(redirect, schema, appFeatures) {
+    const target = findRedirectTargetScreen(redirect, schema, appFeatures);
+    return (target !== undefined && (target.type === "entityEdit" || target.type === "projectionDetail"));
+}
+// Type-guard form narrows `returnTarget` for the caller's subsequent
+// navigateToReturn(nav, returnTarget) call.
+function returnToWinsOverRedirect(returnTarget, redirect, schema, appFeatures) {
+    return returnTarget !== undefined && !redirectTargetsRecord(redirect, schema, appFeatures);
+}
+// Resolves an object-form redirect to a nav target — shared by
+// actionForm and entityEdit (create + update) so the id
+// carries over identically regardless of which screen type triggered it.
+// `carriesId` gates entityId on the TARGET screen type: a redirect to a
+// list screen never gets an id attached, matching actionForm's original
+// behavior. The id itself prefers the write-handler's success payload
+// (`submittedData`) and falls back to `fallbackRecord` — the entityEdit
+// update path's already-loaded record, or the create path's just-submitted
+// form values — both of which carry fields (e.g. a parent FK) the CRUD
+// write executor's success payload doesn't flatly expose.
+function resolveRedirectTarget(redirect, submittedData, schema, appFeatures, fallbackRecord) {
+    const redirectScreen = redirectScreenTarget(redirect);
+    const idField = typeof redirect === "string" ? "id" : redirect.idFrom;
+    const targetId = lastSegment(redirectScreen);
+    const target = findRedirectTargetScreen(redirect, schema, appFeatures);
+    const carriesId = target !== undefined && (target.type === "entityEdit" || target.type === "projectionDetail");
+    if (!carriesId)
+        return { screenId: targetId, entityId: undefined };
+    const entityId = extractIdField(submittedData, idField) ??
+        (fallbackRecord !== undefined ? extractIdField(fallbackRecord, idField) : undefined);
+    return { screenId: targetId, entityId };
+}
+// Action-Form-Body — non-CRUD Write-Handler-driven Form. Re-uses
+// RenderEdit über synthetisierte EntityDefinition + EntityEditScreen-
+// Definition (siehe action-form-shim.ts für die Schulden-Doku). Die
+// Form-Mechanik (useForm, RenderEdit, DefaultInput, Banner, Submit-
+// Button) ist identisch zu entityEdit, nur der Submit-Pfad wechselt
+// vom CRUD-verb auf den Author-deklarierten handler-QN +
+// payloadMode="values" (alle Form-Werte schicken statt nur Changes).
+function ActionFormBody({ schema, screen, translate, initialOverrides, onSuccess, onCancelOverride, onDirtyChange, submitLabelFallback, }) {
+    const nav = useNav();
+    const appFeatures = useAppFeatures();
+    const insideDrawer = useInsideDrawer();
+    const locale = useLocale().locale();
+    const { Banner } = usePrimitives();
+    // Unused when drawer-hosted — onSuccess/onCancelOverride win below first.
+    const returnTarget = useReturnTarget(screen.id);
+    const synthEntity = useMemo(() => synthesizeActionFormEntity(screen.fields), [screen.fields]);
+    const synthScreen = useMemo(() => synthesizeActionFormScreen(screen), [screen]);
+    const pendingHandoff = useInitialValuesHandoff(screen.id);
+    // A drawer-hosted form is not a navigation target, so it never takes a handoff.
+    const handoffValues = onSuccess === undefined ? pendingHandoff : undefined;
+    // This screen has no entity, so a money field here declares its own currency
+    // source (fw#2839, boot-enforced) — without one the form would seed a bare
+    // `0` the handler's schema rejects. ACTION_FORM_CURRENCY_FALLBACK only
+    // applies when a tenant-declared field's config query errors or holds no
+    // value, matching the entityEdit path's behaviour (fw#2937).
+    const tenantCurrencyFieldNames = useMemo(() => tenantCurrencyMoneyFieldNames(screen.fields), [screen.fields]);
+    const { overrides: moneyCurrencyOverrides, loading: currencyLoading } = useMoneyCurrencyOverrides(screen.fields, tenantCurrencyFieldNames, ACTION_FORM_CURRENCY_FALLBACK);
+    const initial = useMemo(() => mergeSearchParamsIntoInitial(screen.fields, {
+        searchParams: nav.searchParams,
+        urlPrefillFields: screen.urlPrefillFields,
+        renderableFields: layoutFieldNames(synthScreen),
+        ...(moneyCurrencyOverrides !== undefined && { moneyCurrencyOverrides }),
+        ...(initialOverrides !== undefined && { drawerOverrides: initialOverrides }),
+        ...(handoffValues !== undefined && { handoffValues }),
+    }), [
+        screen.fields,
+        screen.urlPrefillFields,
+        nav.searchParams,
+        synthScreen,
+        moneyCurrencyOverrides,
+        initialOverrides,
+        handoffValues,
+    ]);
+    const t = useTranslation();
+    const effectiveTranslate = translate ?? t;
+    const summary = useMemo(() => resolveActionFormSummary(screen.summary, initialOverrides, effectiveTranslate, locale), [screen.summary, initialOverrides, effectiveTranslate, locale]);
+    const handleSubmitted = useCallback((result) => {
+        if (!result.isSuccess)
+            return;
+        if (onSuccess !== undefined) {
+            onSuccess();
+            return;
+        }
+        // Without a redirect the form stays put; returnTo only replaces an existing
+        // navigation, and never one to a record screen (see redirectTargetsRecord).
+        if (screen.redirect !== undefined) {
+            if (returnToWinsOverRedirect(returnTarget, screen.redirect, schema, appFeatures)) {
+                navigateToReturn(nav, returnTarget);
+            }
+            else {
+                const { screenId, entityId } = resolveRedirectTarget(screen.redirect, result.data, schema, appFeatures);
+                nav.navigate({ screenId, ...(entityId !== undefined && { entityId }) });
+            }
+        }
+    }, [nav, screen.redirect, onSuccess, schema, appFeatures, returnTarget]);
+    // Cancel ist nur sinnvoll wenn ein Navigations-Ziel existiert —
+    // sonst hätte der Button nirgendwo hin zu navigieren. cancelTarget
+    // gewinnt über redirect; `false` schaltet den Button explizit ab
+    // (Single-Action-Screens, wo Cancel nur Submit-ohne-Senden wäre).
+    // returnTo wins over the declared target when both are present.
+    const handleCancel = useMemo(() => {
+        if (onCancelOverride !== undefined)
+            return onCancelOverride;
+        const target = screen.cancelTarget ??
+            (screen.redirect !== undefined ? redirectScreenTarget(screen.redirect) : undefined);
+        if (target === undefined || target === false)
+            return undefined;
+        return () => navigateToReturnOr(nav, returnTarget, () => nav.navigate({ screenId: lastSegment(target) }));
+    }, [nav, screen.redirect, screen.cancelTarget, onCancelOverride, returnTarget]);
+    // 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(RenderEdit, { screen: synthScreen, entity: synthEntity, featureName: schema.featureName, initial: initial, 
+        // 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
+        // sie Kontext ziehen könnten.
+        extensionInitialValues: initial, writeCommand: screen.handler, payloadMode: "values", onSubmit: handleSubmitted, ...(handleCancel !== undefined && { onCancel: handleCancel }), ...(onDirtyChange !== undefined && { onDirtyChange }), ...((insideDrawer || screenFillsHeight(screen)) && { fillScreenHeight: true }), ...((screen.submitLabel ?? submitLabelFallback) !== undefined && {
+            submitLabel: screen.submitLabel ?? submitLabelFallback,
+        }), ...(screen.submitStyle !== undefined && { submitVariant: screen.submitStyle }), ...(summary !== undefined && { summary }), ...(translate !== undefined && { translate }) }));
+}
+// A money-typed config-edit field renders through RenderField's entityEdit
+// `{amount, currency}` payload shape (render-field.tsx, #1923), but
+// `ConfigKeyType` (write-helpers.ts validateType) only ever knows
+// number/boolean/text/select — a config value is always a bare scalar.
+// Unwrap back to the amount before it hits config:write:set.
+function unwrapMoneyValue(value) {
+    if (typeof value === "object" && value !== null && "amount" in value) {
+        const amount = value.amount;
+        if (typeof amount === "number")
+            return amount;
+    }
+    return value;
+}
+function ConfigEditBody({ schema, screen, translate, }) {
+    const { Banner, ConfigCascadeView } = usePrimitives();
+    const t = useTranslation();
+    const effectiveTranslate = translate ?? t;
+    const dispatcher = useDispatcher();
+    // Detail-Load: config:query:values returnt ALLE Keys des Tenants.
+    // Wir mappen via screen.configKeys von short → qualified-name auf
+    // unsere Form-Field-Werte.
+    const valuesQuery = useQuery("config:query:values", {});
+    const cascadeQuery = useQuery("config:query:cascade", {});
+    const synthEntity = useMemo(() => synthesizeConfigEditEntity(screen.fields), [screen.fields]);
+    const synthScreen = useMemo(() => synthesizeConfigEditScreen(screen), [screen]);
+    // Initial-Values: pro Field-Name den Wert aus `values[qualifiedKey]`
+    // abholen. Fehlt der Key auf dem Server (= noch nie gesetzt), nutzen
+    // wir den Field-Default (createTextField/createNumberField/...).
+    // String-coerce nur für Text-Fields; andere Types sollten in der
+    // Response bereits Native-Type sein.
+    const initial = useMemo(() => {
+        if (valuesQuery.data === null)
+            return null;
+        const out = {};
+        const defaults = buildInitialValues(screen.fields); // @cast-boundary render-helper
+        for (const [shortName, fieldDef] of Object.entries(screen.fields)) {
+            const qualified = screen.configKeys[shortName];
+            if (qualified === undefined) {
+                // Author hat ein Field deklariert ohne Mapping — nimm Default.
+                // Boot-Validator pinnt das, sollte nie zur Runtime greifen.
+                out[shortName] = defaults[shortName];
+                continue;
+            }
+            const stored = valuesQuery.data[qualified]?.value;
+            if (stored === undefined) {
+                out[shortName] = defaults[shortName];
+                continue;
+            }
+            const ftype = fieldDef.type;
+            // Field-Type-Coercion: config-Werte sind string|number|boolean,
+            // aber der Form-State erwartet das passende Field-Native-Type.
+            if (ftype === "number" || ftype === "money") {
+                out[shortName] = typeof stored === "number" ? stored : Number(stored);
+            }
+            else if (ftype === "boolean") {
+                out[shortName] = typeof stored === "boolean" ? stored : stored === "true";
+            }
+            else {
+                out[shortName] = typeof stored === "string" ? stored : String(stored);
+            }
+        }
+        return out;
+    }, [valuesQuery.data, screen.fields, screen.configKeys]);
+    // Cascade-Lookup: qualifiedKey → ConfigCascade für die
+    // Cascade-Anzeige unter jedem Feld. Defensive `levels`-Shape-Check
+    // damit fremde Query-Mocks (z.B. configEdit-Unit-Tests die nur
+    // `config:query:values` mocken) nicht durch das Cascade-Rendering
+    // crashen.
+    const cascades = useMemo(() => {
+        if (!cascadeQuery.data)
+            return {};
+        const out = {};
+        for (const [shortName, qualified] of Object.entries(screen.configKeys)) {
+            const cascade = cascadeQuery.data[qualified];
+            if (cascade && Array.isArray(cascade.levels))
+                out[shortName] = cascade;
+        }
+        return out;
+    }, [cascadeQuery.data, screen.configKeys]);
+    // Multi-Write Submit: ein einzelner /api/batch Call mit N
+    // config:write:set Commands. Server-side ist batch atomic
+    // (transaktional: alle Writes in einer DB-TX, all-or-nothing) und
+    // browser-side ist es genau eine HTTP-Roundtrip — kein Race zwischen
+    // mehreren in-flight fetches die der Browser bei page.reload mid-
+    // submit aborten könnte. Promise.all von N separaten dispatcher.write-
+    // Calls war fragil: server bekommt + commited alle N, aber das
+    // Browser-Connection-Pool gibt sporadisch "Failed to fetch" für
+    // einzelne Responses zurück, customSubmit returnt failure obwohl der
+    // Write durch ist, das Form bleibt dirty.
+    const customSubmit = useCallback(async (snapshot) => {
+        const commands = [];
+        for (const [shortName, value] of Object.entries(snapshot.changes)) {
+            const qualified = screen.configKeys[shortName];
+            if (qualified === undefined)
+                continue;
+            const ftype = screen.fields[shortName]?.type;
+            commands.push({
+                type: "config:write:set",
+                payload: {
+                    key: qualified,
+                    value: ftype === "money" ? unwrapMoneyValue(value) : value,
+                    scope: screen.scope,
+                },
+            });
+        }
+        if (commands.length === 0) {
+            return { validationBlocked: false, isSuccess: true, data: undefined };
+        }
+        const result = await dispatcher.batch(commands);
+        if (!result.isSuccess) {
+            return { validationBlocked: false, isSuccess: false, error: result.error };
+        }
+        // Cascade-Disclosure + Maskenwerte nach dem Write nachziehen, sonst
+        // bleibt die Anzeige stale bis Reload — gleiche refetch-Calls wie onReset.
+        // allSettled: der Write ist schon committed, ein gescheitertes Refetch
+        // (stale Anzeige) darf das Erfolgsergebnis nicht in einen Fehler kippen.
+        await Promise.allSettled([valuesQuery.refetch?.(), cascadeQuery.refetch?.()]);
+        return { validationBlocked: false, isSuccess: true, data: undefined };
+    }, [
+        dispatcher,
+        screen.configKeys,
+        screen.fields,
+        screen.scope,
+        valuesQuery.refetch,
+        cascadeQuery.refetch,
+    ]);
+    // Cascade-Disclosure (#429): Trigger sitzt in der Label-Row, das Panel
+    // unter dem Input — zwei getrennte Render-Slots teilen sich den
+    // expanded-State, der daher hier (pro Feld) statt in der Komponente lebt.
+    const [expandedFields, setExpandedFields] = useState(new Set());
+    const toggleExpanded = useCallback((fieldName) => {
+        setExpandedFields((prev) => {
+            const next = new Set(prev);
+            if (next.has(fieldName))
+                next.delete(fieldName);
+            else
+                next.add(fieldName);
+            return next;
+        });
+    }, []);
+    if (valuesQuery.loading && valuesQuery.data === null) {
+        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+    }
+    if (valuesQuery.error) {
+        return (_jsx(Banner, { padded: true, variant: "error", testId: "kumiko-screen-error", children: dispatcherErrorText(valuesQuery.error, effectiveTranslate) }));
+    }
+    if (initial === null) {
+        return (_jsx(Banner, { padded: true, variant: "loading", testId: "kumiko-screen-loading", children: "Loading\u2026" }));
+    }
+    return (_jsx(RenderEdit, { screen: synthScreen, entity: synthEntity, featureName: schema.featureName, initial: initial, customSubmit: customSubmit, ...(screen.submitLabel !== undefined && { submitLabel: screen.submitLabel }), ...(translate !== undefined && { translate }), labelAppendix: (fieldName) => {
+            const cascade = cascades[fieldName];
+            if (cascade === undefined)
+                return undefined;
+            return (_jsx(ConfigCascadeView, { slot: "trigger", cascade: cascade, screenScope: screen.scope, expanded: expandedFields.has(fieldName), onToggle: () => toggleExpanded(fieldName) }));
+        }, fieldAppendix: (fieldName) => {
+            const cascade = cascades[fieldName];
+            // Panel nur rendern wenn aufgeklappt — sonst kein leerer Abstand
+            // unter dem Input.
+            if (cascade === undefined || !expandedFields.has(fieldName))
+                return undefined;
+            return (_jsx(ConfigCascadeView, { slot: "panel", cascade: cascade, screenScope: screen.scope, expanded: true, qualifiedKey: screen.configKeys[fieldName], onReset: async (key, scope) => {
+                    await dispatcher.write("config:write:reset", { key, scope });
+                    await Promise.allSettled([valuesQuery.refetch?.(), cascadeQuery.refetch?.()]);
+                } }));
+        } }));
+}