@cosmicdrift/kumiko-renderer 1.0.0 → 2.0.0

package/src/app/kumiko-screen.tsx

@@ -1,10 +1,14 @@
 import type { ConfigCascade } from "@cosmicdrift/kumiko-framework/engine";
 import type {
+  AccessRule,
   ActionFormScreenDefinition,
   ConfigEditScreenDefinition,
+  DashboardScreenDefinition,
   EntityDefinition,
   EntityEditScreenDefinition,
   EntityListScreenDefinition,
+  ProjectionDetailScreenDefinition,
+  ProjectionListScreenDefinition,
   RowAction,
   RowActionNavigate,
   RowActionWriteHandler,
@@ -26,6 +30,7 @@ import { type ReactNode, useCallback, useEffect, useMemo, useRef, useState } fro
 import { RenderEdit } from "../components/render-edit";
 import { RenderList, type ToolbarActionButton } from "../components/render-list";
 import { useDispatcher, useOptionalDispatcher } from "../context/dispatcher-context";
+import { useUserRoles } from "../context/user-roles-context";
 import { useListUrlState } from "../hooks/use-list-url-state";
 import { useQuery } from "../hooks/use-query";
 import { useTranslation } from "../i18n";
@@ -33,9 +38,15 @@ import { type DataTableFacet, type DataTableRowAction, usePrimitives } from "../
 import { synthesizeActionFormEntity, synthesizeActionFormScreen } from "./action-form-shim";
 import { synthesizeConfigEditEntity, synthesizeConfigEditScreen } from "./config-edit-shim";
 import { useCustomScreenComponent } from "./custom-screens";
+import { useDashboardBody } from "./dashboard-body";
 import type { FeatureSchema } from "./feature-schema";
 import { useNav } from "./nav";
-import { lastSegment } from "./qn";
+import {
+  synthesizeProjectionDetailEntity,
+  synthesizeProjectionDetailScreen,
+} from "./projection-detail-shim";
+import { synthesizeProjectionEntity, synthesizeProjectionScreen } from "./projection-list-shim";
+import { lastSegment, toKebab } from "./qn";
 import { dispatcherErrorText, WriteFailedError } from "./write-failed-error";
 
 function evalRowExtractor(
@@ -48,6 +59,10 @@ function evalRowExtractor(
   return Object.fromEntries(Object.entries(extractor.map).map(([to, from]) => [to, row[from]]));
 }
 
+function isWriteHandlerRowAction(action: RowAction): action is RowActionWriteHandler {
+  return action.kind === "writeHandler" || action.kind === undefined;
+}
+
 // KumikoScreen picks up a ScreenDefinition from the schema by qn and
 // routes it to the right renderer based on `screen.type`. Command
 // qualification (`<feature>:write:<entity>:create` etc.) happens here
@@ -61,10 +76,11 @@ export type KumikoScreenProps = {
   readonly schema: FeatureSchema;
   readonly qn: string;
   readonly translate?: Translate;
-  // Optional entity-id. Only meaningful for entityEdit screens — when
-  // set, the edit screen loads the existing record via the detail
-  // query and submits an update command (`write:<entity>:update`)
-  // instead of a create. For entityList/custom screens it's ignored.
+  // Optional entity-id / row-id. Meaningful for entityEdit screens — when
+  // set, the edit screen loads the existing record via the detail query and
+  // submits an update command (`write:<entity>:update`) instead of a create.
+  // Also required for projectionDetail screens (which row to fetch — no
+  // create mode exists there). For entityList/custom screens it's ignored.
   readonly entityId?: string;
   // Fires when the user clicks a row on an entityList screen. The
   // second argument is the screen's entity name, threaded through so
@@ -73,6 +89,12 @@ export type KumikoScreenProps = {
   // createKumikoApp does exactly that; override to open a drawer,
   // inline-expand, etc.
   readonly onRowClick?: (row: ListRowViewModel, entityName: string) => void;
+  // Copy-Link-Action auf entityEdit-Update-Screens (Issue #912). Bereits
+  // vollständig gebunden (URL-Bau + Clipboard) — createKumikoApp/RoutedScreen
+  // liefert die Default-Impl, dieses platform-neutrale Package baut selbst
+  // keine URLs/Clipboard-Calls (guard-renderer-boundaries). Nur in
+  // update-mode sichtbar (entityId muss gesetzt sein).
+  readonly onCopyLink?: () => Promise<void> | void;
 };
 
 // Build the qualified name the registry would stamp on screen ingest:
@@ -92,14 +114,32 @@ export function qualifyNavId(featureName: string, navId: string): string {
   return `${featureName}:nav:${navId}`;
 }
 
+// Minimal role-gate for the screen-render path (#1203 — nav filtering via
+// filterByAccess in workspace-shell.tsx hid role-gated screens from the
+// menu, but a direct URL/screenQn hit reached KumikoScreen unchecked).
+// Duplicated instead of imported from framework/engine's hasAccess (pulls
+// server-side deps) — same bundle-purity reasoning as headless/nav's
+// resolve.ts:userCanSee, which this mirrors.
+export function screenAccessAllows(
+  access: AccessRule | undefined,
+  userRoles: readonly string[] | undefined,
+): boolean {
+  if (!access) return true;
+  if ("openToAll" in access) return access.openToAll;
+  if (userRoles === undefined) return false;
+  return access.roles.some((role) => userRoles.includes(role));
+}
+
 export function KumikoScreen({
   schema,
   qn,
   translate,
   entityId,
   onRowClick,
+  onCopyLink,
 }: KumikoScreenProps): ReactNode {
   const { Banner, Text } = usePrimitives();
+  const userRoles = useUserRoles();
   const screen = useMemo(
     () =>
       schema.screens.find(
@@ -116,6 +156,14 @@ export function KumikoScreen({
     );
   }
 
+  if (!screenAccessAllows(screen.access, userRoles)) {
+    return (
+      <Banner padded variant="error" testId="kumiko-screen-access-denied">
+        Access denied: <Text variant="code">{qn}</Text>
+      </Banner>
+    );
+  }
+
   switch (screen.type) {
     case "entityEdit":
       return (
@@ -124,6 +172,7 @@ export function KumikoScreen({
           screen={screen}
           translate={translate}
           {...(entityId !== undefined && { entityId })}
+          {...(onCopyLink !== undefined && { onCopyLink })}
         />
       );
     case "entityList":
@@ -135,6 +184,26 @@ export function KumikoScreen({
           {...(onRowClick !== undefined && { onRowClick })}
         />
       );
+    case "projectionList":
+      return (
+        <ProjectionListBody
+          schema={schema}
+          screen={screen}
+          translate={translate}
+          {...(onRowClick !== undefined && { onRowClick })}
+        />
+      );
+    case "projectionDetail":
+      return (
+        <ProjectionDetailBody
+          schema={schema}
+          screen={screen}
+          translate={translate}
+          {...(entityId !== undefined && { entityId })}
+        />
+      );
+    case "dashboard":
+      return <DashboardScreenBody screen={screen} translate={translate} />;
     case "actionForm":
       return <ActionFormBody schema={schema} screen={screen} translate={translate} />;
     case "configEdit":
@@ -144,6 +213,29 @@ export function KumikoScreen({
   }
 }
 
+// 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({
+  screen,
+  translate,
+}: {
+  readonly screen: DashboardScreenDefinition;
+  readonly translate?: Translate;
+}): ReactNode {
+  const { Banner, Text } = usePrimitives();
+  const Body = useDashboardBody();
+  if (Body === undefined) {
+    return (
+      <Banner padded variant="info" testId="kumiko-screen-dashboard-placeholder">
+        Dashboard screen <Text variant="code">{screen.id}</Text> — kein Dashboard-Body registriert
+        (createKumikoApp aus <Text variant="code">kumiko-renderer-web</Text> wired ihn automatisch).
+      </Banner>
+    );
+  }
+  return <Body 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
@@ -166,15 +258,15 @@ function CustomScreenBody({ screenId }: { readonly screenId: string }): ReactNod
 // ---- entity-edit ----
 
 // Derives `<feature>:write:<entity>:<verb>` from the screen's entity
-// and the schema's feature name. Matches the qualification rule in
-// packages/framework/src/engine/qualified-name.ts so the server-side
-// handler resolves without extra wiring.
+// 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: string,
   entity: string,
   verb: "create" | "update" | "delete",
 ): string {
-  return `${featureName}:write:${entity}:${verb}`;
+  return `${toKebab(featureName)}:write:${toKebab(entity)}:${verb}`;
 }
 
 // Default "success → zurück zur Liste"-Navigation. Findet den ersten
@@ -249,11 +341,13 @@ function EntityEditScreen({
   screen,
   translate,
   entityId,
+  onCopyLink,
 }: {
   readonly schema: FeatureSchema;
   readonly screen: EntityEditScreenDefinition;
   readonly translate?: Translate;
   readonly entityId?: string;
+  readonly onCopyLink?: () => Promise<void> | void;
 }): ReactNode {
   const { Banner, Text } = usePrimitives();
   const entity = schema.entities[screen.entity];
@@ -276,6 +370,7 @@ function EntityEditScreen({
         entity={entity}
         entityId={entityId}
         {...(translate !== undefined && { translate })}
+        {...(onCopyLink !== undefined && { onCopyLink })}
       />
     );
   }
@@ -345,15 +440,19 @@ function EntityEditUpdateBody({
   entity,
   entityId,
   translate,
+  onCopyLink,
 }: {
   readonly schema: FeatureSchema;
   readonly screen: EntityEditScreenDefinition;
   readonly entity: EntityDefinition;
   readonly entityId: string;
   readonly translate?: Translate;
+  readonly onCopyLink?: () => Promise<void> | void;
 }): ReactNode {
   const { Banner, Text } = usePrimitives();
-  const detailQn = `${schema.featureName}:query:${screen.entity}:detail`;
+  const t = useTranslation();
+  const effectiveTranslate = translate ?? t;
+  const detailQn = `${toKebab(schema.featureName)}:query:${toKebab(screen.entity)}:detail`;
   const detailQuery = useQuery<Readonly<Record<string, unknown>>>(detailQn, { id: entityId });
 
   if (detailQuery.loading && detailQuery.data === null) {
@@ -366,7 +465,7 @@ function EntityEditUpdateBody({
   if (detailQuery.error) {
     return (
       <Banner padded variant="error" testId="kumiko-screen-error">
-        {detailQuery.error.i18nKey}
+        {dispatcherErrorText(detailQuery.error, effectiveTranslate)}
       </Banner>
     );
   }
@@ -395,6 +494,7 @@ function EntityEditUpdateBody({
       record={record}
       onReload={detailQuery.refetch}
       {...(translate !== undefined && { translate })}
+      {...(onCopyLink !== undefined && { onCopyLink })}
     />
   );
 }
@@ -407,6 +507,7 @@ function EntityEditUpdateForm({
   record,
   onReload,
   translate,
+  onCopyLink,
 }: {
   readonly schema: FeatureSchema;
   readonly screen: EntityEditScreenDefinition;
@@ -415,6 +516,7 @@ function EntityEditUpdateForm({
   readonly record: Readonly<Record<string, unknown>>;
   readonly onReload: () => Promise<void> | void;
   readonly translate?: Translate;
+  readonly onCopyLink?: () => Promise<void> | void;
 }): ReactNode {
   // Seed the form with the server values for the entity's declared
   // fields; anything else (id, tenant_id, created_at…) stays out of
@@ -490,6 +592,7 @@ function EntityEditUpdateForm({
       onReload={() => void onReload()}
       {...(screen.submitLabel !== undefined && { submitLabel: screen.submitLabel })}
       {...(translate !== undefined && { translate })}
+      {...(onCopyLink !== undefined && { onCopyLink })}
     />
   );
 }
@@ -497,7 +600,7 @@ function EntityEditUpdateForm({
 // ---- entity-list ----
 
 function entityQueryCommand(featureName: string, entity: string, verb: "list"): string {
-  return `${featureName}:query:${entity}:${verb}`;
+  return `${toKebab(featureName)}:query:${toKebab(entity)}:${verb}`;
 }
 
 // Server-side entity-query-handlers return the paged envelope
@@ -741,10 +844,19 @@ function EntityListBody({
         out.push({
           field,
           label,
-          // ponytail: Yes/No literal — boolean-Facet-Labels i18n'en wenn eine App es braucht
           options: [
-            { value: "true", label: "Yes" },
-            { value: "false", label: "No" },
+            {
+              value: "true",
+              label: effectiveTranslate(
+                `${featureName}:entity:${screen.entity}:field:${field}:option:true`,
+              ),
+            },
+            {
+              value: "false",
+              label: effectiveTranslate(
+                `${featureName}:entity:${screen.entity}:field:${field}:option:false`,
+              ),
+            },
           ],
         });
       }
@@ -830,8 +942,8 @@ function EntityListBody({
           };
         }
         if (dispatcher === undefined) return null;
-        if (action.kind !== "writeHandler" && action.kind !== undefined) return null;
-        const writeAction = action as RowActionWriteHandler;
+        if (!isWriteHandlerRowAction(action)) return null;
+        const writeAction = action;
         const writeActionVisible = writeAction.visible;
         return {
           id: writeAction.id,
@@ -899,7 +1011,16 @@ function EntityListBody({
           }),
           onTrigger: async () => {
             const payload = action.payload ?? {};
-            await dispatcher.write(action.handler, payload);
+            const result = await dispatcher.write(action.handler, payload);
+            // Gleicher Surfacing-Zwang wie bei rowActions (Prod-Bug
+            // 2026-06-07): ein verschlucktes Failure-Result sah wie
+            // "nichts passiert" aus.
+            if (!result.isSuccess) {
+              throw new WriteFailedError(
+                result.error,
+                dispatcherErrorText(result.error, effectiveTranslate),
+              );
+            }
           },
         };
       })
@@ -916,7 +1037,7 @@ function EntityListBody({
   if (rowsQuery.error) {
     return (
       <Banner padded variant="error" testId="kumiko-screen-error">
-        {rowsQuery.error.i18nKey}
+        {dispatcherErrorText(rowsQuery.error, effectiveTranslate)}
       </Banner>
     );
   }
@@ -995,6 +1116,271 @@ function EntityListBody({
   );
 }
 
+// ---- projection-list ----
+
+// Wie entityList, aber die List-Query kommt DIREKT aus `screen.query` (statt aus
+// der Entity abgeleitet) — dadurch cross-feature-fähig. v1 bewusst schlank:
+// rendert die Query-Rows mit den (explizit gelabelten) Columns + navigate-
+// RowActions/Row-Klick. Kein Server-Sort/-Pagination/-Facetten (eine Projection-
+// Query hat dafür keinen garantierten Contract) — die kommen bei Bedarf später.
+function ProjectionListBody({
+  schema,
+  screen,
+  translate,
+  onRowClick,
+}: {
+  readonly schema: FeatureSchema;
+  readonly screen: ProjectionListScreenDefinition;
+  readonly translate?: Translate;
+  readonly onRowClick?: (row: ListRowViewModel, entityName: string) => void;
+}): ReactNode {
+  const { Banner } = usePrimitives();
+  const t = useTranslation();
+  const nav = useNav();
+  const dispatcher = useOptionalDispatcher();
+  const effectiveTranslate = translate ?? t;
+  const entity = useMemo(() => synthesizeProjectionEntity(screen.columns), [screen.columns]);
+  const listScreen = useMemo(() => synthesizeProjectionScreen(screen), [screen]);
+  const rowsQuery = useQuery<PagedRows>(screen.query, {}, { live: true });
+
+  const runNavigate = useCallback(
+    (action: RowActionNavigate, row: ListRowViewModel) => {
+      const entityId =
+        action.entityId !== undefined ? String(row.values[action.entityId] ?? "") : undefined;
+      nav.navigate({
+        screenId: action.screen,
+        ...(entityId !== undefined && entityId !== "" && { entityId }),
+      });
+      const params =
+        action.params !== undefined ? evalRowExtractor(action.params, row.values) : undefined;
+      if (params !== undefined) {
+        const stringified: Record<string, string | null> = {};
+        for (const [k, v] of Object.entries(params)) {
+          stringified[k] = v === null || v === undefined ? null : String(v);
+        }
+        nav.setSearchParams(stringified);
+      }
+    },
+    [nav],
+  );
+
+  const rowActions = useMemo((): readonly DataTableRowAction[] | undefined => {
+    if (screen.rowActions === undefined) return undefined;
+    const out: DataTableRowAction[] = [];
+    for (const action of screen.rowActions) {
+      if (action.kind === "navigate") {
+        const navigateAction = action;
+        const visible = action.visible;
+        out.push({
+          id: action.id,
+          label: effectiveTranslate(action.label),
+          ...(action.style !== undefined && { style: action.style }),
+          onTrigger: (row: ListRowViewModel) => runNavigate(navigateAction, row),
+          ...(visible !== undefined && {
+            isVisible: (row: ListRowViewModel) => evalFieldCondition(visible, row.values),
+          }),
+        });
+        continue;
+      }
+      // writeHandler (default-kind) — gleicher Dispatch-Pfad wie entityList:
+      // Failure-Result MUSS zum Error werden (sonst schließt der Confirm-
+      // Dialog kommentarlos).
+      if (dispatcher === undefined) continue;
+      const writeAction = action;
+      const writeVisible = writeAction.visible;
+      out.push({
+        id: writeAction.id,
+        label: effectiveTranslate(writeAction.label),
+        ...(writeAction.style !== undefined && { style: writeAction.style }),
+        ...(writeAction.confirm !== undefined && {
+          confirm: effectiveTranslate(writeAction.confirm),
+        }),
+        ...(writeAction.confirmLabel !== undefined && {
+          confirmLabel: effectiveTranslate(writeAction.confirmLabel),
+        }),
+        onTrigger: async (row: ListRowViewModel) => {
+          const payload =
+            writeAction.payload !== undefined
+              ? evalRowExtractor(writeAction.payload, row.values)
+              : { id: row.values["id"] };
+          const result = await dispatcher.write(writeAction.handler, payload);
+          if (!result.isSuccess) {
+            throw new WriteFailedError(
+              result.error,
+              dispatcherErrorText(result.error, effectiveTranslate),
+            );
+          }
+        },
+        ...(writeVisible !== undefined && {
+          isVisible: (row: ListRowViewModel) => evalFieldCondition(writeVisible, row.values),
+        }),
+      });
+    }
+    return out.length > 0 ? out : undefined;
+  }, [screen.rowActions, effectiveTranslate, runNavigate, dispatcher]);
+
+  const toolbarActions = useMemo((): readonly ToolbarActionButton[] | undefined => {
+    if (screen.toolbarActions === undefined) return undefined;
+    const out: ToolbarActionButton[] = [];
+    for (const action of screen.toolbarActions) {
+      if (action.kind === "navigate") {
+        const target = action.screen;
+        out.push({
+          id: action.id,
+          label: effectiveTranslate(action.label),
+          ...(action.style !== undefined && { style: action.style }),
+          onTrigger: () => nav.navigate({ screenId: target }),
+        });
+        continue;
+      }
+      // writeHandler — analog entityList; ohne Dispatcher skippen statt crashen.
+      if (dispatcher === undefined) continue;
+      out.push({
+        id: action.id,
+        label: effectiveTranslate(action.label),
+        ...(action.style !== undefined && { style: action.style }),
+        ...(action.confirm !== undefined && { confirm: effectiveTranslate(action.confirm) }),
+        ...(action.confirmLabel !== undefined && {
+          confirmLabel: effectiveTranslate(action.confirmLabel),
+        }),
+        onTrigger: async () => {
+          const result = await dispatcher.write(action.handler, action.payload ?? {});
+          // Gleicher Surfacing-Zwang wie bei rowActions (Prod-Bug
+          // 2026-06-07): ein verschlucktes Failure-Result sah wie
+          // "nichts passiert" aus.
+          if (!result.isSuccess) {
+            throw new WriteFailedError(
+              result.error,
+              dispatcherErrorText(result.error, effectiveTranslate),
+            );
+          }
+        },
+      });
+    }
+    return out.length > 0 ? out : undefined;
+  }, [screen.toolbarActions, effectiveTranslate, nav, dispatcher]);
+
+  if (rowsQuery.loading && rowsQuery.data === null) {
+    return (
+      <Banner padded variant="loading" testId="kumiko-screen-loading">
+        Loading…
+      </Banner>
+    );
+  }
+  if (rowsQuery.error) {
+    return (
+      <Banner padded variant="error" testId="kumiko-screen-error">
+        {dispatcherErrorText(rowsQuery.error, effectiveTranslate)}
+      </Banner>
+    );
+  }
+
+  const rowClickAction = screen.rowActions?.find(
+    (a): a is RowActionNavigate => a.kind === "navigate" && a.rowClick === true,
+  );
+  const wrappedOnRowClick = rowClickAction
+    ? (row: ListRowViewModel) => runNavigate(rowClickAction, row)
+    : onRowClick !== undefined
+      ? (row: ListRowViewModel) => onRowClick(row, listScreen.entity)
+      : undefined;
+
+  return (
+    <RenderList
+      screen={listScreen}
+      entity={entity}
+      rows={rowsQuery.data?.rows ?? []}
+      featureName={schema.featureName}
+      searchable={screen.searchable ?? false}
+      sort={screen.defaultSort ?? null}
+      {...(rowActions !== undefined && { rowActions })}
+      {...(toolbarActions !== undefined && { toolbarActions })}
+      {...(translate !== undefined && { translate })}
+      {...(wrappedOnRowClick !== undefined && { onRowClick: wrappedOnRowClick })}
+    />
+  );
+}
+
+// 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.
+function ProjectionDetailBody({
+  schema,
+  screen,
+  translate,
+  entityId,
+}: {
+  readonly schema: FeatureSchema;
+  readonly screen: ProjectionDetailScreenDefinition;
+  readonly translate?: Translate;
+  readonly entityId?: string;
+}): ReactNode {
+  const { Banner, Text } = usePrimitives();
+  const t = useTranslation();
+  const effectiveTranslate = translate ?? t;
+  const nav = useNav();
+  const idParam = screen.idParam ?? "id";
+  const entity = useMemo(() => synthesizeProjectionDetailEntity(screen.layout), [screen.layout]);
+  const detailScreen = useMemo(() => synthesizeProjectionDetailScreen(screen), [screen]);
+  const detailQuery = useQuery<Readonly<Record<string, unknown>>>(
+    screen.query,
+    entityId !== undefined ? { [idParam]: entityId } : {},
+  );
+
+  const navigateToList = useCallback(() => {
+    if (screen.listScreenId === undefined) return;
+    nav.navigate({ screenId: screen.listScreenId });
+  }, [nav, screen.listScreenId]);
+
+  if (entityId === undefined) {
+    return (
+      <Banner padded variant="error" testId="kumiko-screen-projection-detail-missing-id">
+        Screen <Text variant="code">{screen.id}</Text> (projectionDetail) needs a row id in the path
+        — open it from a row action.
+      </Banner>
+    );
+  }
+  if (detailQuery.loading && detailQuery.data === null) {
+    return (
+      <Banner padded variant="loading" testId="kumiko-screen-loading">
+        Loading…
+      </Banner>
+    );
+  }
+  if (detailQuery.error) {
+    return (
+      <Banner padded variant="error" testId="kumiko-screen-error">
+        {dispatcherErrorText(detailQuery.error, effectiveTranslate)}
+      </Banner>
+    );
+  }
+  const record = detailQuery.data;
+  if (!record) {
+    return (
+      <Banner padded variant="error" testId="kumiko-screen-record-missing">
+        Record <Text variant="code">{entityId}</Text> not found.
+      </Banner>
+    );
+  }
+  return (
+    <RenderEdit
+      screen={detailScreen}
+      entity={entity}
+      featureName={schema.featureName}
+      initial={record as FormValues}
+      entityId={entityId}
+      customSubmit={async () => ({ isSuccess: true, validationBlocked: false, data: undefined })}
+      onCancel={screen.listScreenId !== undefined ? navigateToList : undefined}
+      {...(translate !== undefined && { translate })}
+    />
+  );
+}
 // ---- actionForm (Tier 2.7d) ----
 
 // Action-Form-Body — non-CRUD Write-Handler-driven Form. Re-uses
@@ -1115,6 +1501,8 @@ function ConfigEditBody({
   readonly translate?: Translate;
 }): ReactNode {
   const { Banner, ConfigCascadeView } = usePrimitives();
+  const t = useTranslation();
+  const effectiveTranslate = translate ?? t;
   const dispatcher = useDispatcher();
 
   // Detail-Load: config:query:values returnt ALLE Keys des Tenants.
@@ -1239,7 +1627,7 @@ function ConfigEditBody({
   if (valuesQuery.error) {
     return (
       <Banner padded variant="error" testId="kumiko-screen-error">
-        {valuesQuery.error.i18nKey}
+        {dispatcherErrorText(valuesQuery.error, effectiveTranslate)}
       </Banner>
     );
   }