@cosmicdrift/kumiko-renderer-web 1.0.0 → 2.0.0

package/src/__tests__/dashboard-screen.test.tsx

@@ -0,0 +1,393 @@
+import { describe, expect, test } from "bun:test";
+import type { DashboardScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
+import type { ExtensionSectionProps, FeatureSchema } from "@cosmicdrift/kumiko-renderer";
+import {
+  DashboardBodyProvider,
+  DispatcherProvider,
+  ExtensionSectionsProvider,
+  KumikoScreen,
+} from "@cosmicdrift/kumiko-renderer";
+import userEvent from "@testing-library/user-event";
+import type { ReactNode } from "react";
+import { WebDashboardBody } from "../app/dashboard-body";
+import { createMockDispatcher, render, screen, waitFor } from "./test-utils";
+
+const dashboardScreen: DashboardScreenDefinition = {
+  id: "overview",
+  type: "dashboard",
+  panels: [
+    {
+      kind: "stat",
+      id: "uptime",
+      label: "status:dashboard:uptime",
+      query: "status:query:monitor:uptime-stat",
+      valueField: "value",
+      subField: "sub",
+      toneField: "tone",
+    },
+    {
+      kind: "list",
+      id: "latest",
+      label: "status:dashboard:latest",
+      query: "status:query:incident:latest",
+      columns: [{ field: "name", label: "status:dashboard:col-name" }],
+    },
+  ],
+};
+
+const schema: FeatureSchema = {
+  featureName: "status",
+  entities: {},
+  screens: [dashboardScreen],
+};
+
+function makeDispatcher(): Dispatcher {
+  return createMockDispatcher({
+    query: (async (type: string) => {
+      if (type === "status:query:monitor:uptime-stat") {
+        return {
+          isSuccess: true,
+          data: { value: "99,98 %", sub: "letzte 90 Tage", tone: "positive" },
+        };
+      }
+      return {
+        isSuccess: true,
+        data: { rows: [{ id: "i1", name: "API-Ausfall" }], nextCursor: null },
+      };
+    }) as unknown as Dispatcher["query"],
+  });
+}
+
+describe("KumikoScreen dashboard", () => {
+  test("ohne registrierten Body → Placeholder-Banner", () => {
+    render(
+      <DispatcherProvider dispatcher={makeDispatcher()}>
+        <KumikoScreen schema={schema} qn="status:screen:overview" />
+      </DispatcherProvider>,
+    );
+    expect(screen.getByTestId("kumiko-screen-dashboard-placeholder")).toBeTruthy();
+  });
+
+  test("WebDashboardBody rendert Stat- und List-Panels aus den Queries", async () => {
+    render(
+      <DispatcherProvider dispatcher={makeDispatcher()}>
+        <DashboardBodyProvider value={WebDashboardBody}>
+          <KumikoScreen schema={schema} qn="status:screen:overview" />
+        </DashboardBodyProvider>
+      </DispatcherProvider>,
+    );
+
+    await waitFor(() => expect(screen.getByText("99,98 %")).toBeTruthy());
+    expect(screen.getByTestId("dashboard-overview")).toBeTruthy();
+    // Stat-Panel: Label (Key-Fallback), Wert, Sub-Zeile aus dem Query-Record.
+    expect(screen.getByText("status:dashboard:uptime")).toBeTruthy();
+    expect(screen.getByText("letzte 90 Tage")).toBeTruthy();
+    // List-Panel: Row aus der paged envelope.
+    await waitFor(() => expect(screen.getByText("API-Ausfall")).toBeTruthy());
+  });
+});
+
+const richScreen: DashboardScreenDefinition = {
+  id: "rich",
+  type: "dashboard",
+  filter: {
+    id: "region",
+    label: "widgets:dashboard:filter-region",
+    kind: "select",
+    options: [
+      { value: "eu", label: "widgets:dashboard:filter-region-eu" },
+      { value: "us", label: "widgets:dashboard:filter-region-us" },
+    ],
+  },
+  panels: [
+    {
+      kind: "stat",
+      id: "kpi",
+      label: "widgets:dashboard:kpi",
+      query: "widgets:query:metrics:kpi",
+      valueField: "value",
+      deltaField: "delta",
+      deltaDirectionField: "deltaDirection",
+      deltaToneField: "deltaTone",
+      icon: { react: { __component: "rich-dashboard-kpi-icon" } },
+      accentColor: "#123456",
+    },
+    {
+      kind: "stat-group",
+      id: "net-worth",
+      label: "widgets:dashboard:net-worth",
+      stats: [
+        {
+          kind: "stat",
+          id: "assets",
+          label: "widgets:dashboard:assets",
+          query: "widgets:query:metrics:assets",
+          valueField: "value",
+        },
+      ],
+    },
+    {
+      kind: "feed",
+      id: "upcoming",
+      label: "widgets:dashboard:upcoming",
+      query: "widgets:query:metrics:upcoming",
+    },
+    {
+      kind: "progress-list",
+      id: "goal-progress",
+      label: "widgets:dashboard:goal-progress",
+      query: "widgets:query:metrics:goal-progress",
+    },
+    {
+      kind: "custom",
+      id: "custom-panel",
+      component: { react: { __component: "rich-dashboard-custom" } },
+    },
+  ],
+};
+
+const richSchema: FeatureSchema = {
+  featureName: "widgets",
+  entities: {},
+  screens: [richScreen],
+};
+
+describe("KumikoScreen dashboard — neue Panel-Kinds", () => {
+  test("stat-group rendert Sektions-Titel + genestete Stat-Panels", async () => {
+    const dispatcher = createMockDispatcher({
+      query: (async (type: string) => {
+        if (type === "widgets:query:metrics:assets") {
+          return { isSuccess: true, data: { value: "120.000 €" } };
+        }
+        return { isSuccess: true, data: {} };
+      }) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <DashboardBodyProvider value={WebDashboardBody}>
+          <KumikoScreen schema={richSchema} qn="widgets:screen:rich" />
+        </DashboardBodyProvider>
+      </DispatcherProvider>,
+    );
+    expect(screen.getByText("widgets:dashboard:net-worth")).toBeTruthy();
+    await waitFor(() => expect(screen.getByText("120.000 €")).toBeTruthy());
+  });
+
+  test("feed-Panel rendert primary/trailing-Zeilen", async () => {
+    const dispatcher = createMockDispatcher({
+      query: (async (type: string) => {
+        if (type === "widgets:query:metrics:upcoming") {
+          return {
+            isSuccess: true,
+            data: { rows: [{ primary: "Zinsanpassung", trailing: "Aug 2026" }] },
+          };
+        }
+        return { isSuccess: true, data: {} };
+      }) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <DashboardBodyProvider value={WebDashboardBody}>
+          <KumikoScreen schema={richSchema} qn="widgets:screen:rich" />
+        </DashboardBodyProvider>
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.getByText("Zinsanpassung")).toBeTruthy());
+    expect(screen.getByText("Aug 2026")).toBeTruthy();
+  });
+
+  test("progress-list-Panel rendert Label/Wert + Fortschrittsbalken", async () => {
+    const dispatcher = createMockDispatcher({
+      query: (async (type: string) => {
+        if (type === "widgets:query:metrics:goal-progress") {
+          return {
+            isSuccess: true,
+            data: { rows: [{ label: "Baudarlehen", value: "42.000 € offen", fraction: 0.71 }] },
+          };
+        }
+        return { isSuccess: true, data: {} };
+      }) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <DashboardBodyProvider value={WebDashboardBody}>
+          <KumikoScreen schema={richSchema} qn="widgets:screen:rich" />
+        </DashboardBodyProvider>
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.getByText("Baudarlehen")).toBeTruthy());
+    const bar = screen.getByRole("progressbar");
+    expect(bar.getAttribute("aria-valuenow")).toBe("71");
+  });
+
+  test("custom-Panel: registrierte Komponente rendert mit screenId + filterParams", async () => {
+    function CustomEcho({ screenId, filterParams }: ExtensionSectionProps): ReactNode {
+      return (
+        <div data-testid="custom-echo">
+          {screenId}:{String(filterParams?.["region"] ?? "none")}
+        </div>
+      );
+    }
+    const dispatcher = createMockDispatcher();
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <ExtensionSectionsProvider value={{ "rich-dashboard-custom": CustomEcho }}>
+          <DashboardBodyProvider value={WebDashboardBody}>
+            <KumikoScreen schema={richSchema} qn="widgets:screen:rich" />
+          </DashboardBodyProvider>
+        </ExtensionSectionsProvider>
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.getByTestId("custom-echo")).toBeTruthy());
+    expect(screen.getByTestId("custom-echo").textContent).toBe("rich:none");
+  });
+
+  test("custom-Panel: unregistrierte Komponente rendert nichts, wirft nicht", async () => {
+    const dispatcher = createMockDispatcher();
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <DashboardBodyProvider value={WebDashboardBody}>
+          <KumikoScreen schema={richSchema} qn="widgets:screen:rich" />
+        </DashboardBodyProvider>
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.getByTestId("dashboard-panel-kpi")).toBeTruthy());
+    expect(screen.queryByTestId("custom-echo")).toBeNull();
+  });
+
+  test("stat-Panel: Delta-Chip rendert nur wenn value+direction geliefert werden", async () => {
+    const dispatcher = createMockDispatcher({
+      query: (async (type: string) => {
+        if (type === "widgets:query:metrics:kpi") {
+          return {
+            isSuccess: true,
+            data: {
+              value: "92.753 €",
+              delta: "23 %",
+              deltaDirection: "down",
+              deltaTone: "positive",
+            },
+          };
+        }
+        return { isSuccess: true, data: {} };
+      }) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <DashboardBodyProvider value={WebDashboardBody}>
+          <KumikoScreen schema={richSchema} qn="widgets:screen:rich" />
+        </DashboardBodyProvider>
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.getByText("92.753 €")).toBeTruthy());
+    expect(screen.getByText("↓23 %")).toBeTruthy();
+  });
+
+  test("stat-Panel: registriertes Icon rendert, unregistriertes rendert nichts (kein Crash)", async () => {
+    function KpiIcon(): ReactNode {
+      return <svg data-testid="kpi-icon" />;
+    }
+    const dispatcher = createMockDispatcher({
+      query: (async (type: string) => {
+        if (type === "widgets:query:metrics:kpi") {
+          return { isSuccess: true, data: { value: "92.753 €" } };
+        }
+        return { isSuccess: true, data: {} };
+      }) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <ExtensionSectionsProvider value={{ "rich-dashboard-kpi-icon": KpiIcon }}>
+          <DashboardBodyProvider value={WebDashboardBody}>
+            <KumikoScreen schema={richSchema} qn="widgets:screen:rich" />
+          </DashboardBodyProvider>
+        </ExtensionSectionsProvider>
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.getByTestId("kpi-icon")).toBeTruthy());
+  });
+
+  test("stat-Panel: unregistriertes Icon rendert nichts, wirft nicht", async () => {
+    const dispatcher = createMockDispatcher({
+      query: (async (type: string) => {
+        if (type === "widgets:query:metrics:kpi") {
+          return { isSuccess: true, data: { value: "92.753 €" } };
+        }
+        return { isSuccess: true, data: {} };
+      }) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <DashboardBodyProvider value={WebDashboardBody}>
+          <KumikoScreen schema={richSchema} qn="widgets:screen:rich" />
+        </DashboardBodyProvider>
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.getByText("92.753 €")).toBeTruthy());
+    expect(screen.queryByTestId("kpi-icon")).toBeNull();
+    // #931: unregistriertes Icon darf auch keinen leeren, akzentgefärbten
+    // Chip-Wrapper rendern (StatCard gated den Span auf icon !== undefined).
+    const card = screen.getByTestId("dashboard-panel-kpi");
+    expect(card.querySelector('[style*="123456"]')).toBeNull();
+  });
+
+  test("stat-Panel: fehlende deltaDirection unterdrückt den Chip (kein Crash)", async () => {
+    const dispatcher = createMockDispatcher({
+      query: (async (type: string) => {
+        if (type === "widgets:query:metrics:kpi") {
+          return { isSuccess: true, data: { value: "92.753 €" } };
+        }
+        return { isSuccess: true, data: {} };
+      }) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <DashboardBodyProvider value={WebDashboardBody}>
+          <KumikoScreen schema={richSchema} qn="widgets:screen:rich" />
+        </DashboardBodyProvider>
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.getByText("92.753 €")).toBeTruthy());
+    expect(screen.queryByText("23 %")).toBeNull();
+  });
+
+  test("Filter-Wechsel refetcht Stat- UND Feed-Panel mit neuem Payload", async () => {
+    const calls: { readonly type: string; readonly payload: unknown }[] = [];
+    const dispatcher = createMockDispatcher({
+      query: (async (type: string, payload: unknown) => {
+        calls.push({ type, payload });
+        const region = (payload as { readonly region?: string } | undefined)?.region;
+        if (type === "widgets:query:metrics:kpi") {
+          return { isSuccess: true, data: { value: region === "us" ? "38.120 $" : "92.753 €" } };
+        }
+        if (type === "widgets:query:metrics:upcoming") {
+          return {
+            isSuccess: true,
+            data: {
+              rows: [{ primary: region === "us" ? "US-Event" : "EU-Event" }],
+            },
+          };
+        }
+        return { isSuccess: true, data: {} };
+      }) as unknown as Dispatcher["query"],
+    });
+    const user = userEvent.setup();
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <DashboardBodyProvider value={WebDashboardBody}>
+          <KumikoScreen schema={richSchema} qn="widgets:screen:rich" />
+        </DashboardBodyProvider>
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.getByText("92.753 €")).toBeTruthy());
+    await waitFor(() => expect(screen.getByText("EU-Event")).toBeTruthy());
+
+    await user.click(screen.getByTestId("combobox-dashboard-filter-region"));
+    const usOption = await screen.findByText("widgets:dashboard:filter-region-us");
+    await user.click(usOption);
+
+    await waitFor(() => expect(screen.getByText("38.120 $")).toBeTruthy());
+    await waitFor(() => expect(screen.getByText("US-Event")).toBeTruthy());
+  });
+});

package/src/__tests__/default-app-shell.test.tsx

@@ -7,9 +7,11 @@
 // pinst dass DefaultAppShell user nun akzeptiert UND durchreicht.
 
 import { describe, expect, test } from "bun:test";
+import type { EntityListScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
 import type { FeatureSchema } from "@cosmicdrift/kumiko-renderer";
+import { DispatcherProvider, KumikoScreen } from "@cosmicdrift/kumiko-renderer";
 import { DefaultAppShell } from "../layout/default-app-shell";
-import { render, screen } from "./test-utils";
+import { createMockDispatcher, render, screen } from "./test-utils";
 
 function makeSchema(): FeatureSchema {
   return {
@@ -84,3 +86,47 @@ describe("DefaultAppShell headerActions-Slot (Topbar rechts)", () => {
     expect(document.querySelector("[data-kumiko-layout='header-actions']")).toBeNull();
   });
 });
+
+// DefaultAppShell threads `user.roles` into a UserRolesProvider around
+// children (#1203) — KumikoScreen reads that to gate role-restricted
+// screens at render time, not just in nav.
+describe("DefaultAppShell wires user.roles into children for screen-level access (#1203)", () => {
+  const restrictedScreen: EntityListScreenDefinition = {
+    id: "restricted",
+    type: "entityList",
+    entity: "x",
+    columns: [],
+    access: { roles: ["SystemAdmin"] },
+  };
+  const restrictedSchema: FeatureSchema = {
+    featureName: "showcase",
+    entities: {},
+    screens: [restrictedScreen],
+  } as FeatureSchema;
+
+  test("no user prop → role-gated screen child shows access-denied", () => {
+    render(
+      <DispatcherProvider dispatcher={createMockDispatcher()}>
+        <DefaultAppShell brand={<span>Brand</span>} schema={restrictedSchema}>
+          <KumikoScreen schema={restrictedSchema} qn="showcase:screen:restricted" />
+        </DefaultAppShell>
+      </DispatcherProvider>,
+    );
+    expect(screen.getByTestId("kumiko-screen-access-denied")).toBeTruthy();
+  });
+
+  test("user prop with matching role → role-gated screen child renders", () => {
+    render(
+      <DispatcherProvider dispatcher={createMockDispatcher()}>
+        <DefaultAppShell
+          brand={<span>Brand</span>}
+          schema={restrictedSchema}
+          user={{ id: "u1", roles: ["SystemAdmin"] }}
+        >
+          <KumikoScreen schema={restrictedSchema} qn="showcase:screen:restricted" />
+        </DefaultAppShell>
+      </DispatcherProvider>,
+    );
+    expect(screen.queryByTestId("kumiko-screen-access-denied")).toBeNull();
+  });
+});

package/src/__tests__/form-action-bar.test.tsx

@@ -120,6 +120,15 @@ describe("DefaultSection Card-Standard (subtitle + actions-Footer)", () => {
     expect(actions.textContent).toContain("Übernehmen");
   });
 
+  test('standalone: variant="destructive" adds a destructive border, default variant does not', () => {
+    render(
+      <Section testId="danger" title="Danger zone" variant="destructive">
+        <div>x</div>
+      </Section>,
+    );
+    expect(screen.getByTestId("danger").className).toContain("border-destructive/40");
+  });
+
   test("title-only standalone (Bestands-Consumer) hat keinen Divider mehr", () => {
     render(
       <Section testId="legacy" title="Stammdaten">

package/src/__tests__/kumiko-screen.test.tsx

@@ -13,6 +13,7 @@ import {
   KumikoScreen,
   kumikoDefaultTranslations,
   NavProvider,
+  UserRolesProvider,
 } from "@cosmicdrift/kumiko-renderer";
 import userEvent from "@testing-library/user-event";
 import { createMockDispatcher, fireEvent, render, screen, waitFor } from "./test-utils";
@@ -41,10 +42,18 @@ const listScreen: EntityListScreenDefinition = {
   columns: ["title", "count", "done"],
 };
 
+const restrictedListScreen: EntityListScreenDefinition = {
+  id: "task-list-restricted",
+  type: "entityList",
+  entity: "task",
+  columns: ["title"],
+  access: { roles: ["Admin"] },
+};
+
 const schema: FeatureSchema = {
   featureName: "tasks",
   entities: { task: taskEntity },
-  screens: [editScreen, listScreen],
+  screens: [editScreen, listScreen, restrictedListScreen],
 };
 
 function makeDispatcher(overrides: Partial<Dispatcher> = {}): Dispatcher {
@@ -67,6 +76,39 @@ describe("KumikoScreen", () => {
     expect(screen.getByTestId("kumiko-screen-not-found")).toBeTruthy();
   });
 
+  test("role-gated screen, no UserRolesProvider mounted → access-denied placeholder", () => {
+    render(
+      <DispatcherProvider dispatcher={makeDispatcher()}>
+        <KumikoScreen schema={schema} qn="tasks:screen:task-list-restricted" />
+      </DispatcherProvider>,
+    );
+    expect(screen.getByTestId("kumiko-screen-access-denied")).toBeTruthy();
+  });
+
+  test("role-gated screen, user without matching role → access-denied placeholder", () => {
+    render(
+      <DispatcherProvider dispatcher={makeDispatcher()}>
+        <UserRolesProvider roles={["Viewer"]}>
+          <KumikoScreen schema={schema} qn="tasks:screen:task-list-restricted" />
+        </UserRolesProvider>
+      </DispatcherProvider>,
+    );
+    expect(screen.getByTestId("kumiko-screen-access-denied")).toBeTruthy();
+  });
+
+  test("role-gated screen, user with matching role → renders normally", async () => {
+    render(
+      <DispatcherProvider dispatcher={makeDispatcher()}>
+        <UserRolesProvider roles={["Admin"]}>
+          <KumikoScreen schema={schema} qn="tasks:screen:task-list-restricted" />
+        </UserRolesProvider>
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.queryByTestId("kumiko-screen-loading")).toBeNull());
+    expect(screen.queryByTestId("kumiko-screen-access-denied")).toBeNull();
+    expect(screen.getByTestId("render-list-table-toolbar")).toBeTruthy();
+  });
+
   test("entityEdit → renders RenderEdit form for the screen's entity", () => {
     render(
       <DispatcherProvider dispatcher={makeDispatcher()}>
@@ -314,6 +356,68 @@ describe("KumikoScreen", () => {
     expect(screen.queryByTestId("render-edit-delete")).toBeNull();
   });
 
+  // Issue #912 — Copy-Link-Action. KumikoScreen threads an already-bound
+  // onCopyLink callback down to RenderEdit (the actual URL-build/clipboard
+  // impl lives in renderer-web's RoutedScreen, outside this test — here we
+  // only verify the wiring: button renders in update-mode, fires the
+  // callback, and shows the "copied" label afterwards).
+  test("entityEdit update-mode: Copy-Link-Button feuert onCopyLink + zeigt 'copied'-Label", async () => {
+    const user = userEvent.setup();
+    const onCopyLink = mock(() => Promise.resolve());
+    const dispatcher = makeDispatcher({
+      query: (async () => ({
+        isSuccess: true,
+        data: { id: "task-1", version: 1, title: "loaded", count: 3, done: false },
+      })) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <KumikoScreen
+          schema={schema}
+          qn="tasks:screen:task-edit"
+          entityId="task-1"
+          onCopyLink={onCopyLink}
+        />
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.queryByTestId("kumiko-screen-loading")).toBeNull());
+
+    const button = screen.getByTestId("render-edit-copy-link");
+    expect(button.textContent).toBe("Copy link");
+    await user.click(button);
+    expect(onCopyLink).toHaveBeenCalledTimes(1);
+    await waitFor(() => expect(button.textContent).toBe("Copied!"));
+  });
+
+  test("entityEdit create-mode: kein Copy-Link-Button (keine entity-id → kein Permalink)", () => {
+    render(
+      <DispatcherProvider dispatcher={makeDispatcher()}>
+        <KumikoScreen
+          schema={schema}
+          qn="tasks:screen:task-edit"
+          onCopyLink={() => Promise.resolve()}
+        />
+      </DispatcherProvider>,
+    );
+    expect(screen.queryByTestId("render-edit-copy-link")).toBeNull();
+  });
+
+  test("entityEdit update-mode ohne onCopyLink-Prop: kein Copy-Link-Button", async () => {
+    const dispatcher = makeDispatcher({
+      query: (async () => ({
+        isSuccess: true,
+        data: { id: "task-1", version: 1, title: "loaded", count: 3, done: false },
+      })) as unknown as Dispatcher["query"],
+    });
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <KumikoScreen schema={schema} qn="tasks:screen:task-edit" entityId="task-1" />
+      </DispatcherProvider>,
+    );
+    await waitFor(() => expect(screen.queryByTestId("kumiko-screen-loading")).toBeNull());
+    expect(screen.queryByTestId("render-edit-copy-link")).toBeNull();
+  });
+
   test("entityEdit update-mode: version_conflict → Banner + 'Neu laden' triggert detail-refetch", async () => {
     let detailCalls = 0;
     const dispatcher = makeDispatcher({
@@ -370,6 +474,56 @@ describe("KumikoScreen", () => {
     expect(screen.queryByTestId("render-edit-form-error")).toBeNull();
   });
 
+  test("entityEdit update-mode: query-Error zeigt übersetzten Text statt rohem i18nKey (issue #1193)", async () => {
+    const dispatcher = makeDispatcher({
+      query: (async () => ({
+        isSuccess: false,
+        error: {
+          code: "access_denied",
+          httpStatus: 403,
+          i18nKey: "errors.access.denied",
+          message: "",
+        },
+      })) as unknown as Dispatcher["query"],
+    });
+
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <KumikoScreen schema={schema} qn="tasks:screen:task-edit" entityId="task-1" />
+      </DispatcherProvider>,
+    );
+
+    await waitFor(() => expect(screen.queryByTestId("kumiko-screen-error")).toBeTruthy());
+    const bannerText = screen.getByTestId("kumiko-screen-error").textContent;
+    expect(bannerText).toBe(kumikoDefaultTranslations["en"]?.["errors.access.denied"] ?? "");
+    expect(bannerText).not.toBe("errors.access.denied");
+  });
+
+  test("entityList: query-Error zeigt übersetzten Text statt rohem i18nKey (issue #1193)", async () => {
+    const dispatcher = makeDispatcher({
+      query: (async () => ({
+        isSuccess: false,
+        error: {
+          code: "access_denied",
+          httpStatus: 403,
+          i18nKey: "errors.access.denied",
+          message: "",
+        },
+      })) as unknown as Dispatcher["query"],
+    });
+
+    render(
+      <DispatcherProvider dispatcher={dispatcher}>
+        <KumikoScreen schema={schema} qn="tasks:screen:task-list" />
+      </DispatcherProvider>,
+    );
+
+    await waitFor(() => expect(screen.queryByTestId("kumiko-screen-error")).toBeTruthy());
+    const bannerText = screen.getByTestId("kumiko-screen-error").textContent;
+    expect(bannerText).toBe(kumikoDefaultTranslations["en"]?.["errors.access.denied"] ?? "");
+    expect(bannerText).not.toBe("errors.access.denied");
+  });
+
   // RowActions-Mapping (Tier 2.7a Resolution-Layer): pinst dass
   // EntityListBody die Schema-Form (handler-QN, label-i18nKey, payload-
   // builder, visible-Function, confirmLabel) zu DataTableRowAction