@cosmicdrift/kumiko-renderer 0.259.0 → 0.260.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.259.0",
+  "version": "0.260.0",
   "description": "Platform-agnostic React renderer for Kumiko screens. Contains the shared logic — primitives-contract, hooks, KumikoScreen, navigation & SSE abstractions — that any platform-specific renderer (web, native) composes. No DOM, no EventSource, no react-dom.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -15,8 +15,8 @@
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-framework": "0.259.0",
-    "@cosmicdrift/kumiko-headless": "0.259.0",
+    "@cosmicdrift/kumiko-framework": "0.260.0",
+    "@cosmicdrift/kumiko-headless": "0.260.0",
     "react": "^19.2.6",
     "temporal-polyfill": "^0.3.2",
     "zod": "^4.4.3"
@@ -27,7 +27,7 @@
     "@types/react-dom": "^19.2.3",
     "jsdom": "^29.1.1",
     "react-dom": "^19.2.6",
-    "@cosmicdrift/kumiko-locale-de": "0.259.0"
+    "@cosmicdrift/kumiko-locale-de": "0.260.0"
   },
   "repository": {
     "type": "git",

package/src/app/__tests__/action-form-shim.test.ts

@@ -48,6 +48,27 @@ describe("synthesizeActionFormScreen", () => {
     });
     expect("description" in withoutDescription).toBe(false);
   });
+
+  test("carries slots through so RenderEdit can mount header/footer slots on an actionForm", () => {
+    const withSlots = synthesizeActionFormScreen({
+      id: "invite-user",
+      type: "actionForm",
+      handler: "users:write:invite-user",
+      layout: { sections: [{ title: "Invite", fields: ["email"] }] },
+      fields: { email: { type: "text" } },
+      slots: { footer: { react: { __component: "f" } } },
+    });
+    expect(withSlots.slots).toEqual({ footer: { react: { __component: "f" } } });
+
+    const withoutSlots = synthesizeActionFormScreen({
+      id: "invite-user",
+      type: "actionForm",
+      handler: "users:write:invite-user",
+      layout: { sections: [{ title: "Invite", fields: ["email"] }] },
+      fields: { email: { type: "text" } },
+    });
+    expect("slots" in withoutSlots).toBe(false);
+  });
 });
 
 describe("synthesizeSecretMintConfirmScreen (fw#2838)", () => {

package/src/app/__tests__/row-default-edit-action.test.tsx

@@ -0,0 +1,324 @@
+// kumiko-screen-akte-bedienkonzept: entityList and projectionList rowActions
+// get a default "Edit" row action for free when the row's entity has a
+// visible entityEdit screen — same cross-feature resolution as
+// projectionDetail's header defaultEditAction (fw#2166), reused here via
+// findEditScreenFor (screen-access.ts). Declared rowActions with id "edit"
+// win; access-gating and a missing entityEdit screen both suppress the
+// default. Mirrors entity-list-row-action-entity-target.test.tsx's harness.
+
+import { describe, expect, test } from "bun:test";
+import type {
+  EntityDefinition,
+  EntityEditScreenDefinition,
+  EntityListScreenDefinition,
+  ProjectionListScreenDefinition,
+} from "@cosmicdrift/kumiko-framework/ui-types";
+import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
+import { render, waitFor } from "@testing-library/react";
+import type { ComponentType, ReactNode } from "react";
+import { DispatcherProvider } from "../../context/dispatcher-context";
+import { UserRolesProvider } from "../../context/user-roles-context";
+import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
+import { kumikoDefaultTranslations } from "../../i18n-defaults";
+import {
+  type CorePrimitives,
+  type DataTableProps,
+  type DataTableRowAction,
+  PrimitivesProvider,
+} from "../../primitives";
+import { AppFeaturesProvider } from "../app-features-context";
+import type { FeatureSchema } from "../feature-schema";
+import { KumikoScreen } from "../kumiko-screen";
+import type { NavTarget } from "../nav";
+import { NavProvider } from "../nav";
+
+function stubDispatcher(rows: readonly Record<string, unknown>[]): Dispatcher {
+  return {
+    write: (async () => ({ isSuccess: true, data: {} })) as unknown as Dispatcher["write"],
+    query: (async () => ({
+      isSuccess: true,
+      data: { rows, nextCursor: null, total: rows.length },
+    })) as unknown as Dispatcher["query"],
+    batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
+    statusStore: {
+      getState: () => "online",
+      subscribe: () => () => {},
+    } as unknown as Dispatcher["statusStore"],
+    async *stream() {},
+    pendingWrites: () => [],
+    pendingFiles: () => [],
+  };
+}
+
+type Captured = {
+  readonly rowActions: readonly DataTableRowAction[] | undefined;
+  readonly rowCount: number;
+};
+let captured: Captured = { rowActions: undefined, rowCount: 0 };
+const captureDataTable: ComponentType<DataTableProps> = (props) => {
+  captured = { rowActions: props.rowActions, rowCount: props.rows.length };
+  return null;
+};
+const noop = (): ReactNode => null;
+const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
+
+const testPrimitives: CorePrimitives = {
+  Button: noop,
+  Banner: passChildren,
+  Field: passChildren,
+  Input: noop,
+  DataTable: captureDataTable,
+  Form: passChildren,
+  Section: passChildren,
+  Card: passChildren,
+  Grid: passChildren,
+  GridCell: passChildren,
+  Text: passChildren,
+  Heading: noop,
+  Dialog: noop,
+  Modal: noop,
+  Lightbox: noop,
+  ConfigSourceBadge: noop,
+  ConfigCascadeView: noop,
+  Link: noop,
+};
+
+function editScreen(entity: string, roles?: readonly string[]): EntityEditScreenDefinition {
+  return {
+    id: "app:screen:rent-edit",
+    type: "entityEdit",
+    entity,
+    layout: { sections: [{ columns: 1, fields: ["name"] }] },
+    ...(roles !== undefined && { access: { roles } }),
+  };
+}
+
+function requireAction(id: string): DataTableRowAction {
+  const action = captured.rowActions?.find((a) => a.id === id);
+  if (!action) throw new Error(`expected the '${id}' row action to be captured`);
+  return action;
+}
+
+function renderScreen(
+  schema: FeatureSchema,
+  qn: string,
+  navigateSpy: (target: NavTarget) => void,
+  userRoles: readonly string[],
+): void {
+  render(
+    <LocaleProvider
+      resolver={createStaticLocaleResolver({ locale: "en" })}
+      fallbackBundles={[kumikoDefaultTranslations]}
+    >
+      <DispatcherProvider dispatcher={stubDispatcher([{ id: "row-1", name: "Alice" }])}>
+        <AppFeaturesProvider features={[schema]}>
+          <UserRolesProvider roles={userRoles}>
+            <NavProvider
+              value={{
+                route: undefined,
+                navigate: navigateSpy,
+                replace: () => {},
+                hrefFor: () => "",
+                searchParams: {},
+                setSearchParams: () => {},
+              }}
+            >
+              <PrimitivesProvider value={testPrimitives}>
+                <KumikoScreen schema={schema} qn={qn} />
+              </PrimitivesProvider>
+            </NavProvider>
+          </UserRolesProvider>
+        </AppFeaturesProvider>
+      </DispatcherProvider>
+    </LocaleProvider>,
+  );
+}
+
+const entity: EntityDefinition = {
+  fields: {
+    name: { type: "text", maxLength: 50, required: false, searchable: false, sortable: false },
+  },
+};
+
+describe("entityList default edit row action", () => {
+  function schemaWith(
+    rowActions?: EntityListScreenDefinition["rowActions"],
+    includeEdit = true,
+  ): FeatureSchema {
+    const listScreen: EntityListScreenDefinition = {
+      id: "rent-list",
+      type: "entityList",
+      entity: "rent",
+      columns: ["name"],
+      ...(rowActions !== undefined && { rowActions }),
+    };
+    return {
+      featureName: "app",
+      entities: { rent: entity },
+      screens: includeEdit ? [listScreen, editScreen("rent")] : [listScreen],
+    };
+  }
+
+  test("adds a default edit action at the first position when an entityEdit screen exists", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    const navigateCalls: NavTarget[] = [];
+    renderScreen(schemaWith(undefined), "app:screen:rent-list", (t) => navigateCalls.push(t), []);
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    expect(captured.rowActions?.[0]?.id).toBe("edit");
+    expect(captured.rowActions?.[0]?.label).toBe("Edit");
+
+    await requireAction("edit").onTrigger({
+      id: "row-1",
+      values: { id: "row-1", name: "Alice" },
+    });
+    expect(navigateCalls).toEqual([{ screenId: "rent-edit", entityId: "row-1" }]);
+  });
+
+  test("a declared rowAction with id 'edit' wins — no doubling", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    renderScreen(
+      schemaWith([{ kind: "navigate", id: "edit", label: "custom-edit", screen: "rent-edit" }]),
+      "app:screen:rent-list",
+      () => {},
+      [],
+    );
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    const editActions = captured.rowActions?.filter((a) => a.id === "edit") ?? [];
+    expect(editActions).toHaveLength(1);
+    // "custom-edit" has no translation registered, so translate() returns
+    // the raw key — proving this is the declared action, not the default
+    // (whose label is the translated "kumiko.actions.edit" → "Edit").
+    expect(editActions[0]?.label).toBe("custom-edit");
+  });
+
+  test("no entityEdit screen for the entity → no default edit action", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    renderScreen(schemaWith(undefined, false), "app:screen:rent-list", () => {}, []);
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    expect(captured.rowActions?.some((a) => a.id === "edit") ?? false).toBe(false);
+  });
+
+  test("access denied to the entityEdit screen → no default edit action", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    const listScreen: EntityListScreenDefinition = {
+      id: "rent-list",
+      type: "entityList",
+      entity: "rent",
+      columns: ["name"],
+    };
+    const schema: FeatureSchema = {
+      featureName: "app",
+      entities: { rent: entity },
+      screens: [listScreen, editScreen("rent", ["admin"])],
+    };
+    renderScreen(schema, "app:screen:rent-list", () => {}, []);
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    expect(captured.rowActions?.some((a) => a.id === "edit") ?? false).toBe(false);
+  });
+});
+
+describe("projectionList default edit row action", () => {
+  function schemaWith(
+    rowActions?: ProjectionListScreenDefinition["rowActions"],
+    includeEdit = true,
+  ): FeatureSchema {
+    const listScreen: ProjectionListScreenDefinition = {
+      id: "rent-projection-list",
+      type: "projectionList",
+      query: "app:query:rent:list",
+      detailFor: "rent",
+      columns: [{ field: "name", label: "Name" }],
+      ...(rowActions !== undefined && { rowActions }),
+    };
+    return {
+      featureName: "app",
+      entities: {},
+      screens: includeEdit ? [listScreen, editScreen("rent")] : [listScreen],
+    };
+  }
+
+  test("adds a default edit action at the first position when detailFor resolves an entityEdit screen", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    const navigateCalls: NavTarget[] = [];
+    renderScreen(
+      schemaWith(undefined),
+      "app:screen:rent-projection-list",
+      (t) => navigateCalls.push(t),
+      [],
+    );
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    expect(captured.rowActions?.[0]?.id).toBe("edit");
+    expect(captured.rowActions?.[0]?.label).toBe("Edit");
+
+    await requireAction("edit").onTrigger({
+      id: "row-1",
+      values: { id: "row-1", name: "Alice" },
+    });
+    expect(navigateCalls).toEqual([{ screenId: "rent-edit", entityId: "row-1" }]);
+  });
+
+  test("a declared rowAction with id 'edit' wins — no doubling", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    renderScreen(
+      schemaWith([{ kind: "navigate", id: "edit", label: "custom-edit", screen: "rent-edit" }]),
+      "app:screen:rent-projection-list",
+      () => {},
+      [],
+    );
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    const editActions = captured.rowActions?.filter((a) => a.id === "edit") ?? [];
+    expect(editActions).toHaveLength(1);
+    expect(editActions[0]?.label).toBe("custom-edit");
+  });
+
+  test("no detailFor → no default edit action", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    const listScreen: ProjectionListScreenDefinition = {
+      id: "rent-projection-list",
+      type: "projectionList",
+      query: "app:query:rent:list",
+      columns: [{ field: "name", label: "Name" }],
+    };
+    const schema: FeatureSchema = {
+      featureName: "app",
+      entities: {},
+      screens: [listScreen, editScreen("rent")],
+    };
+    renderScreen(schema, "app:screen:rent-projection-list", () => {}, []);
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    expect(captured.rowActions?.some((a) => a.id === "edit") ?? false).toBe(false);
+  });
+
+  test("access denied to the entityEdit screen → no default edit action", async () => {
+    captured = { rowActions: undefined, rowCount: 0 };
+    renderScreen(
+      {
+        featureName: "app",
+        entities: {},
+        screens: [
+          {
+            id: "rent-projection-list",
+            type: "projectionList",
+            query: "app:query:rent:list",
+            detailFor: "rent",
+            columns: [{ field: "name", label: "Name" }],
+          },
+          editScreen("rent", ["admin"]),
+        ],
+      },
+      "app:screen:rent-projection-list",
+      () => {},
+      [],
+    );
+    await waitFor(() => expect(captured.rowCount).toBe(1));
+
+    expect(captured.rowActions?.some((a) => a.id === "edit") ?? false).toBe(false);
+  });
+});

package/src/app/action-form-shim.ts

@@ -50,6 +50,9 @@ export function synthesizeActionFormScreen(
     layout: screen.layout,
     ...(screen.description !== undefined && { description: screen.description }),
     ...(screen.access !== undefined && { access: screen.access }),
+    // Only ActionFormScreenDefinition carries slots — SecretMintScreenDefinition
+    // has none, so `in` is the narrowing (no cast).
+    ...("slots" in screen && screen.slots !== undefined && { slots: screen.slots }),
   };
 }
 

package/src/app/extension-sections.tsx

@@ -4,6 +4,7 @@
 // PlatformComponent über dieselbe Registry auf und mountet die passende
 // Component — die Bundled-Feature-/App-Component lädt + persistiert dann
 // ihre eigenen Daten (z.B. custom-fields, oder ein eigenständiger Chart).
+// The entityEdit footer slot (`screen.slots.footer`) mounts through it too.
 //
 // Mounting analog zu CustomScreensProvider — createKumikoApp im
 // renderer-web sammelt alle clientFeatures.extensionSectionComponents und
@@ -66,6 +67,14 @@ export type ExtensionSectionProps = {
    *  `snapshot.errors` on the field instead of a collective message.
    *  Undefined outside entityEdit sections. */
   readonly validate?: () => boolean;
+  /** Whether the host form has unsaved changes. Only set in the entityEdit
+   *  footer slot (`screen.slots.footer`); undefined in all other mounts. */
+  readonly hasUnsavedChanges?: boolean;
+  /** Current wizard step, only set for `layout.mode === "wizard"` forms.
+   *  Only set in the entityEdit footer slot (`screen.slots.footer`);
+   *  undefined in all other mounts, and undefined there too for a
+   *  non-wizard form. */
+  readonly wizardStep?: { readonly index: number; readonly isLast: boolean };
 };
 
 export type ExtensionSectionComponent = ComponentType<ExtensionSectionProps>;

package/src/app/kumiko-screen.tsx

@@ -1,5 +1,6 @@
 import type { ConfigCascade } from "@cosmicdrift/kumiko-framework/engine";
 import type {
+  ActionFormRedirect,
   ActionFormScreenDefinition,
   ConfigEditScreenDefinition,
   DashboardScreenDefinition,
@@ -73,6 +74,7 @@ import { synthesizeProjectionEntity, synthesizeProjectionScreen } from "./projec
 import { lastSegment, toKebab } from "./qn";
 import { featureNameFromQualifiedScreenId, qualifyScreenId } from "./qualify-screen-id";
 import {
+  buildDefaultEditRowAction,
   buildProjectionRowActions,
   evalRowExtractor,
   isWriteHandlerRowAction,
@@ -81,7 +83,7 @@ import {
   runProjectionRowNavigate,
   stringifyNavParams,
 } from "./row-actions";
-import { screenAccessAllows } from "./screen-access";
+import { findEditScreenFor, screenAccessAllows } from "./screen-access";
 import { SecretMintBody } from "./secret-mint-body";
 import { SecretsEditBody } from "./secrets-edit-body";
 import { dispatcherErrorText, WriteFailedError } from "./write-failed-error";
@@ -685,6 +687,7 @@ function EntityEditCreateBody({
   readonly onSaved?: () => void;
 }): ReactNode {
   const nav = useNav();
+  const appFeatures = useAppFeatures();
   const initial = useMemo(
     () =>
       mergeSearchParamsIntoInitial(
@@ -702,17 +705,31 @@ function EntityEditCreateBody({
     (result: SubmitResult<unknown>) => {
       if (!result.isSuccess) return;
       if (screen.redirect !== undefined) {
-        const entityId = extractCreatedId(result.data);
-        nav.navigate({
-          screenId: lastSegment(screen.redirect),
-          ...(entityId !== undefined && { entityId }),
-        });
+        // 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.
+        if (typeof screen.redirect === "string") {
+          const entityId = extractCreatedId(result.data);
+          nav.navigate({
+            screenId: lastSegment(screen.redirect),
+            ...(entityId !== undefined && { entityId }),
+          });
+          return;
+        }
+        const { screenId, entityId } = resolveRedirectTarget(
+          screen.redirect,
+          result.data,
+          schema,
+          appFeatures,
+        );
+        nav.navigate({ screenId, ...(entityId !== undefined && { entityId }) });
         return;
       }
       navigateToList();
       onSaved?.();
     },
-    [nav, screen.redirect, navigateToList, onSaved],
+    [nav, screen.redirect, schema, appFeatures, navigateToList, onSaved],
   );
   // Deliberately no `actions` prop here: `screen.actions` targets an
   // EXISTING record (publish/archive/duplicate and friends), which the
@@ -885,6 +902,7 @@ function EntityEditUpdateForm({
   );
 
   const nav = useNav();
+  const appFeatures = useAppFeatures();
   const dispatcher = useDispatcher();
   const t = useTranslation();
   const effectiveTranslate = translate ?? t;
@@ -1007,13 +1025,30 @@ function EntityEditUpdateForm({
     (result: SubmitResult<unknown>) => {
       if (!result.isSuccess) return;
       if (screen.redirect !== undefined) {
-        nav.navigate({ screenId: lastSegment(screen.redirect) });
+        // 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`.
+        if (typeof screen.redirect === "string") {
+          nav.navigate({ screenId: lastSegment(screen.redirect) });
+          return;
+        }
+        const { screenId, entityId } = resolveRedirectTarget(
+          screen.redirect,
+          result.data,
+          schema,
+          appFeatures,
+          record,
+        );
+        nav.navigate({ screenId, ...(entityId !== undefined && { entityId }) });
         return;
       }
       navigateToList();
       onSaved?.();
     },
-    [nav, screen.redirect, navigateToList, onSaved],
+    [nav, screen.redirect, schema, appFeatures, record, navigateToList, onSaved],
   );
   const handleDelete = useCallback(async () => {
     const res = await dispatcher.write(deleteCommand, { id: entityId });
@@ -1449,8 +1484,13 @@ function EntityListBody({
   const queryType = entityQueryCommand(featureName, screen.entity, "list");
   const nav = useNav();
   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`),
@@ -1672,8 +1712,16 @@ function EntityListBody({
   );
 
   const rowActions = useMemo(() => {
-    if (screen.rowActions === undefined) return undefined;
-    return screen.rowActions
+    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: readonly RowAction[] =
+      defaultEditRowAction !== undefined ? [defaultEditRowAction, ...declared] : declared;
+    if (effectiveActions.length === 0) return undefined;
+    return effectiveActions
       .map((action: RowAction): DataTableRowAction | null => {
         // navigate-Variante braucht keinen Dispatcher; nav ist
         // immer da (Provider von createKumikoApp).
@@ -1757,6 +1805,7 @@ function EntityListBody({
       .filter((a: DataTableRowAction | null): a is DataTableRowAction => a !== null);
   }, [
     screen.rowActions,
+    defaultEditScreen,
     effectiveTranslate,
     dispatcher,
     runNavigate,
@@ -1967,8 +2016,14 @@ function ProjectionListBody({
   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.
@@ -2060,6 +2115,11 @@ function ProjectionListBody({
     [nav],
   );
 
+  const defaultEditRowAction = useMemo(
+    () => buildDefaultEditRowAction(defaultEditScreen),
+    [defaultEditScreen],
+  );
+
   const rowActions = useMemo(
     () =>
       buildProjectionRowActions({
@@ -2069,8 +2129,17 @@ function ProjectionListBody({
         nav,
         refetch: rowsQuery.refetch,
         openDrawer,
+        defaultEditRowAction,
       }),
-    [screen.rowActions, effectiveTranslate, dispatcher, nav, rowsQuery.refetch, openDrawer],
+    [
+      screen.rowActions,
+      effectiveTranslate,
+      dispatcher,
+      nav,
+      rowsQuery.refetch,
+      openDrawer,
+      defaultEditRowAction,
+    ],
   );
 
   const toolbarActions = useMemo((): readonly ToolbarActionButton[] | undefined => {
@@ -2242,6 +2311,13 @@ function runMetricNavigate(
   navigate: MetricNavigate,
   record: Readonly<Record<string, unknown>>,
 ): void {
+  // 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" as const, id: "metric-navigate", label: "" };
   const action: RowActionNavigate | undefined =
     navigate.entity !== undefined
@@ -2261,6 +2337,7 @@ function runMetricNavigate(
         : undefined;
   if (action === undefined) return;
   runProjectionRowNavigate(nav, action, { id: "", values: record });
+  if (navigate.tab !== undefined) nav.setSearchParams({ tab: navigate.tab });
 }
 
 // Absolute http(s) check for RecordHeaderSpec.subtitleHref — deliberately
@@ -2496,19 +2573,7 @@ function ProjectionDetailBody({
   const editScreen = useMemo(() => {
     const detailFor = screen.detailFor;
     if (detailFor === undefined) return undefined;
-    for (const feature of appFeatures) {
-      // Access-check is part of the find predicate, not a filter applied
-      // after the first match — two entityEdit screens for the same entity
-      // where the first is role-gated must not hide an accessible second one.
-      const match = feature.screens.find(
-        (s): s is EntityEditScreenDefinition =>
-          s.type === "entityEdit" &&
-          s.entity === detailFor &&
-          screenAccessAllows(s.access, userRoles),
-      );
-      if (match !== undefined) return match;
-    }
-    return undefined;
+    return findEditScreenFor(detailFor, appFeatures, userRoles);
   }, [appFeatures, screen.detailFor, userRoles]);
   const defaultEditAction = useMemo((): RenderEditAction | undefined => {
     if (editScreen === undefined) return undefined;
@@ -2740,39 +2805,42 @@ function ProjectionDetailBody({
         <Card>
           {header !== undefined && (
             <>
-              <Heading variant="page" testId="kumiko-screen-projection-detail-title">
-                {String(record[header.title] ?? "")}
-              </Heading>
-              {(header.subtitle !== undefined || header.status !== undefined) && (
+              {header.status !== undefined ? (
                 <Grid columns="auto">
-                  {header.subtitle !== undefined &&
-                    (subtitleHref !== undefined ? (
-                      <Link
-                        href={subtitleHref}
-                        target="_blank"
-                        testId="kumiko-screen-projection-detail-subtitle"
-                      >
-                        {String(record[header.subtitle] ?? "")}
-                      </Link>
-                    ) : (
-                      <Text variant="muted" testId="kumiko-screen-projection-detail-subtitle">
-                        {String(record[header.subtitle] ?? "")}
-                      </Text>
-                    ))}
-                  {header.status !== undefined &&
-                    (StatusBadge !== undefined ? (
-                      <StatusBadge
-                        value={String(record[header.status] ?? "")}
-                        tone={statusToneForValue(String(record[header.status] ?? ""))}
-                        testId="kumiko-screen-projection-detail-status"
-                      />
-                    ) : (
-                      <Text testId="kumiko-screen-projection-detail-status">
-                        {String(record[header.status] ?? "")}
-                      </Text>
-                    ))}
+                  <Heading variant="page" testId="kumiko-screen-projection-detail-title">
+                    {String(record[header.title] ?? "")}
+                  </Heading>
+                  {StatusBadge !== undefined ? (
+                    <StatusBadge
+                      value={String(record[header.status] ?? "")}
+                      tone={statusToneForValue(String(record[header.status] ?? ""))}
+                      testId="kumiko-screen-projection-detail-status"
+                    />
+                  ) : (
+                    <Text testId="kumiko-screen-projection-detail-status">
+                      {String(record[header.status] ?? "")}
+                    </Text>
+                  )}
                 </Grid>
+              ) : (
+                <Heading variant="page" testId="kumiko-screen-projection-detail-title">
+                  {String(record[header.title] ?? "")}
+                </Heading>
               )}
+              {header.subtitle !== undefined &&
+                (subtitleHref !== undefined ? (
+                  <Link
+                    href={subtitleHref}
+                    target="_blank"
+                    testId="kumiko-screen-projection-detail-subtitle"
+                  >
+                    {String(record[header.subtitle] ?? "")}
+                  </Link>
+                ) : (
+                  <Text variant="muted" testId="kumiko-screen-projection-detail-subtitle">
+                    {String(record[header.subtitle] ?? "")}
+                  </Text>
+                ))}
             </>
           )}
           {hasMetrics && (
@@ -2881,6 +2949,45 @@ function redirectScreenTarget(
   return typeof redirect === "string" ? redirect : redirect.screen;
 }
 
+// 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.
+// The target screen may live in another feature (cross-feature QN), so
+// resolution checks this schema first, then every mounted feature — same
+// fallback order as the create-dialog's reference-field screen lookup.
+// `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, which has fields (e.g. a parent FK)
+// the CRUD write executor's success payload doesn't flatly expose.
+function resolveRedirectTarget(
+  redirect: string | ActionFormRedirect,
+  submittedData: unknown,
+  schema: FeatureSchema,
+  appFeatures: readonly FeatureSchema[],
+  fallbackRecord?: Readonly<Record<string, unknown>>,
+): { readonly screenId: string; readonly entityId: string | undefined } {
+  const redirectScreen = redirectScreenTarget(redirect);
+  const idField = typeof redirect === "string" ? "id" : redirect.idFrom;
+  const targetId = lastSegment(redirectScreen);
+  const targetFeatureName = featureNameFromQualifiedScreenId(redirectScreen);
+  const target =
+    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));
+  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
@@ -2939,39 +3046,16 @@ function ActionFormBody({
       // Author entscheidet bewusst ob "stay on form" (default) oder
       // "back to list" (typisch bei Create-style Aktionen).
       if (screen.redirect !== undefined) {
-        const redirectScreen = redirectScreenTarget(screen.redirect);
-        const idField = typeof screen.redirect === "string" ? "id" : screen.redirect.idFrom;
-        const targetId = lastSegment(redirectScreen);
-        const targetFeatureName = featureNameFromQualifiedScreenId(redirectScreen);
-        // A qualified redirect target may live in a different feature than
-        // this screen's own schema (fw#2485) — resolve over all mounted
-        // features (own schema first, cheap and provider-independent) same
-        // as ProjectionDetailBody's cross-feature editScreen lookup above.
-        // A screen id is only unique WITHIN a feature, so once the QN names
-        // a feature, the fallback must look inside THAT feature, not just
-        // take the first short-id match across every mounted feature — two
-        // features can easily share an id like "list" or "edit".
-        const target =
-          schema.screens.find((s) => lastSegment(s.id) === targetId) ??
-          (targetFeatureName !== undefined
-            ? appFeatures
-                .find((f) => f.featureName === targetFeatureName)
-                ?.screens.find((s) => lastSegment(s.id) === targetId)
-            : // Bare short-id redirect (no feature prefix) names no feature to
-              // pick by — fall back to the pre-fw#2485 best-effort match by
-              // short id across all mounted features.
-              appFeatures.flatMap((f) => f.screens).find((s) => lastSegment(s.id) === targetId));
-        const entityId = extractIdField(result.data, idField);
-        const carriesId =
-          target !== undefined &&
-          (target.type === "entityEdit" || target.type === "projectionDetail");
-        nav.navigate({
-          screenId: targetId,
-          ...(carriesId && entityId !== undefined && { entityId }),
-        });
+        const { screenId, entityId } = resolveRedirectTarget(
+          screen.redirect,
+          result.data,
+          schema,
+          appFeatures,
+        );
+        nav.navigate({ screenId, ...(entityId !== undefined && { entityId }) });
       }
     },
-    [nav, screen.redirect, onSuccess, schema.screens, appFeatures],
+    [nav, screen.redirect, onSuccess, schema, appFeatures],
   );
   // Cancel ist nur sinnvoll wenn ein Navigations-Ziel existiert —
   // sonst hätte der Button nirgendwo hin zu navigieren. cancelTarget

package/src/app/row-actions.ts

@@ -1,4 +1,5 @@
 import type {
+  EntityEditScreenDefinition,
   IconKey,
   RowAction,
   RowActionDrawer,
@@ -10,8 +11,25 @@ import { evalFieldCondition } from "@cosmicdrift/kumiko-framework/ui-types";
 import type { Dispatcher, ListRowViewModel, Translate } from "@cosmicdrift/kumiko-headless";
 import type { DataTableRowAction } from "../primitives";
 import type { NavApi } from "./nav";
+import { lastSegment } from "./qn";
 import { dispatcherErrorText, WriteFailedError } from "./write-failed-error";
 
+// entityId is explicit: the edit screen may live in another feature than
+// the row source, where the same-feature fallback would miss it.
+export function buildDefaultEditRowAction(
+  editScreen: EntityEditScreenDefinition | undefined,
+  idColumn = "id",
+): RowActionNavigate | undefined {
+  if (editScreen === undefined) return undefined;
+  return {
+    kind: "navigate",
+    id: "edit",
+    label: "kumiko.actions.edit",
+    screen: lastSegment(editScreen.id),
+    entityId: idColumn,
+  };
+}
+
 export function evalRowExtractor(
   extractor: RowFieldExtractor,
   row: Record<string, unknown>,
@@ -206,6 +224,51 @@ function buildDrawerRowAction(
   };
 }
 
+// Prepends defaultEditRowAction unless a declared action already claims id
+// "edit" — declared wins.
+function mergeDefaultEditAction(
+  rowActions: readonly RowAction[] | undefined,
+  defaultEditRowAction: RowActionNavigate | undefined,
+): readonly RowAction[] {
+  const declaredHasEdit = rowActions?.some((a) => a.id === "edit") === true;
+  return defaultEditRowAction !== undefined && !declaredHasEdit
+    ? [defaultEditRowAction, ...(rowActions ?? [])]
+    : (rowActions ?? []);
+}
+
+function buildWriteHandlerRowAction(
+  action: RowActionWriteHandler,
+  translate: Translate,
+  refetch: () => Promise<unknown>,
+  dispatcher: Dispatcher,
+): DataTableRowAction {
+  const writeVisible = action.visible;
+  return {
+    id: action.id,
+    label: translate(action.label),
+    ...(action.style !== undefined && { style: action.style }),
+    icon: resolveActionIcon(action.id, action.icon),
+    ...(action.confirm !== undefined && { confirm: translate(action.confirm) }),
+    ...(action.confirmLabel !== undefined && {
+      confirmLabel: translate(action.confirmLabel),
+    }),
+    onTrigger: async (row: ListRowViewModel) => {
+      const payload =
+        action.payload !== undefined
+          ? evalRowExtractor(action.payload, row.values)
+          : { id: row.values["id"] };
+      const result = await dispatcher.write(action.handler, payload);
+      if (!result.isSuccess) {
+        throw new WriteFailedError(result.error, dispatcherErrorText(result.error, translate));
+      }
+      await refetchAfterWrite(refetch);
+    },
+    ...(writeVisible !== undefined && {
+      isVisible: (row: ListRowViewModel) => evalFieldCondition(writeVisible, row.values),
+    }),
+  };
+}
+
 // Builds the DataTable-ready row-action set for a query-driven row source
 // (projectionList, relatedList) — navigate dispatches through
 // runProjectionRowNavigate, writeHandler dispatches through the shared
@@ -223,11 +286,15 @@ export function buildProjectionRowActions(options: {
    *  without onOpenDrawer) drop drawer actions and get a dev warning —
    *  mirrors the `dispatcher === undefined` skip below for writeHandler. */
   readonly openDrawer?: OpenDrawer;
+  /** Prepended unless a declared action already has id "edit" — declared wins. */
+  readonly defaultEditRowAction?: RowActionNavigate;
 }): readonly DataTableRowAction[] | undefined {
-  const { rowActions, translate, dispatcher, nav, refetch, openDrawer } = options;
-  if (rowActions === undefined) return undefined;
+  const { rowActions, translate, dispatcher, nav, refetch, openDrawer, defaultEditRowAction } =
+    options;
+  const effectiveActions = mergeDefaultEditAction(rowActions, defaultEditRowAction);
+  if (effectiveActions.length === 0) return undefined;
   const out: DataTableRowAction[] = [];
-  for (const action of rowActions) {
+  for (const action of effectiveActions) {
     if (action.kind === "navigate") {
       out.push(buildNavigateRowAction(action, translate, nav));
       continue;
@@ -243,32 +310,7 @@ export function buildProjectionRowActions(options: {
     // writeHandler (default-kind) — a swallowed failure result must become a
     // thrown error (fw prod-bug 2026-06-07), same as every other write path.
     if (dispatcher === undefined) continue;
-    const writeAction = action;
-    const writeVisible = writeAction.visible;
-    out.push({
-      id: writeAction.id,
-      label: translate(writeAction.label),
-      ...(writeAction.style !== undefined && { style: writeAction.style }),
-      icon: resolveActionIcon(writeAction.id, writeAction.icon),
-      ...(writeAction.confirm !== undefined && { confirm: translate(writeAction.confirm) }),
-      ...(writeAction.confirmLabel !== undefined && {
-        confirmLabel: translate(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, translate));
-        }
-        await refetchAfterWrite(refetch);
-      },
-      ...(writeVisible !== undefined && {
-        isVisible: (row: ListRowViewModel) => evalFieldCondition(writeVisible, row.values),
-      }),
-    });
+    out.push(buildWriteHandlerRowAction(action, translate, refetch, dispatcher));
   }
   return out.length > 0 ? out : undefined;
 }

package/src/app/screen-access.ts

@@ -1,4 +1,8 @@
-import type { AccessRule } from "@cosmicdrift/kumiko-framework/ui-types";
+import type {
+  AccessRule,
+  EntityEditScreenDefinition,
+  FeatureSchema,
+} from "@cosmicdrift/kumiko-framework/ui-types";
 
 // Minimal role-gate for the screen-render path (#1203 — nav filtering via
 // filterByAccess in workspace-shell.tsx hid role-gated screens from the
@@ -17,3 +21,20 @@ export function screenAccessAllows(
   if (userRoles === undefined) return false;
   return access.roles.some((role) => userRoles.includes(role));
 }
+
+// Searches all mounted features, and access is part of the predicate so a
+// role-gated first match can't hide an accessible second one.
+export function findEditScreenFor(
+  entity: string,
+  appFeatures: readonly FeatureSchema[],
+  userRoles: readonly string[] | undefined,
+): EntityEditScreenDefinition | undefined {
+  for (const feature of appFeatures) {
+    const match = feature.screens.find(
+      (s): s is EntityEditScreenDefinition =>
+        s.type === "entityEdit" && s.entity === entity && screenAccessAllows(s.access, userRoles),
+    );
+    if (match !== undefined) return match;
+  }
+  return undefined;
+}

package/src/components/__tests__/related-list-section.test.tsx

@@ -1,10 +1,13 @@
 import { describe, expect, spyOn, test } from "bun:test";
-import type { RowAction } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { EntityEditScreenDefinition, RowAction } from "@cosmicdrift/kumiko-framework/ui-types";
 import type { Dispatcher, EditRelatedListSectionViewModel } from "@cosmicdrift/kumiko-headless";
 import { fireEvent, render, screen as rtlScreen, waitFor } from "@testing-library/react";
 import type { ComponentType, ReactNode } from "react";
+import { AppFeaturesProvider } from "../../app/app-features-context";
+import type { FeatureSchema } from "../../app/feature-schema";
 import { type NavApi, NavProvider } from "../../app/nav";
 import { DispatcherProvider } from "../../context/dispatcher-context";
+import { UserRolesProvider } from "../../context/user-roles-context";
 import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
 import { kumikoDefaultTranslations } from "../../i18n-defaults";
 import {
@@ -938,3 +941,118 @@ describe("RelatedListSection — search + facets (fw#2740)", () => {
     ]);
   });
 });
+
+// Same findEditScreenFor/buildDefaultEditRowAction resolution as
+// entityList/projectionList, driven by rowClick.entity and rowClick.idColumn.
+describe("RelatedListSection — default edit row action", () => {
+  function editScreen(entity: string, roles?: readonly string[]): EntityEditScreenDefinition {
+    return {
+      id: "lease:screen:item-edit",
+      type: "entityEdit",
+      entity,
+      layout: { sections: [{ columns: 1, fields: ["name"] }] },
+      ...(roles !== undefined && { access: { roles } }),
+    };
+  }
+
+  function renderWithFeatures(
+    section: EditRelatedListSectionViewModel,
+    dispatcher: Dispatcher,
+    features: readonly FeatureSchema[],
+    userRoles: readonly string[] = [],
+    nav: NavApi = stubNav().nav,
+  ) {
+    return render(
+      <LocaleProvider
+        resolver={createStaticLocaleResolver({ locale: "en-US" })}
+        fallbackBundles={[kumikoDefaultTranslations]}
+      >
+        <DispatcherProvider dispatcher={dispatcher}>
+          <AppFeaturesProvider features={features}>
+            <UserRolesProvider roles={userRoles}>
+              <PrimitivesProvider value={testPrimitives()}>
+                <NavProvider value={nav}>
+                  <RelatedListSection section={section} parentId="order-1" featureName="orders" />
+                </NavProvider>
+              </PrimitivesProvider>
+            </UserRolesProvider>
+          </AppFeaturesProvider>
+        </DispatcherProvider>
+      </LocaleProvider>,
+    );
+  }
+
+  const sectionWithRowClick: EditRelatedListSectionViewModel = {
+    kind: "relatedList",
+    title: "Positions",
+    query: "lease:query:items:list",
+    columns: [{ field: "name" }],
+    rowClick: { entity: "item" },
+  };
+
+  test("adds a default edit action at the first position when rowClick.entity resolves an entityEdit screen", async () => {
+    const { dispatcher } = stubDispatcher();
+    const { nav, navigations } = stubNav();
+    const schema: FeatureSchema = {
+      featureName: "lease",
+      entities: {},
+      screens: [editScreen("item")],
+    };
+    renderWithFeatures(sectionWithRowClick, dispatcher, [schema], [], nav);
+
+    await waitFor(() => expect(rtlScreen.getByTestId("row-r1")).toBeTruthy());
+    const editButton = rtlScreen.getByTestId("action-edit-r1");
+    expect(editButton.textContent).toBe("Edit");
+
+    fireEvent.click(editButton);
+    await waitFor(() => expect(navigations).toHaveLength(1));
+    expect(navigations[0]).toEqual({ screenId: "item-edit", entityId: "r1" });
+  });
+
+  test("a declared rowAction with id 'edit' wins — no doubling", async () => {
+    const { dispatcher } = stubDispatcher();
+    const schema: FeatureSchema = {
+      featureName: "lease",
+      entities: {},
+      screens: [editScreen("item")],
+    };
+    renderWithFeatures(
+      {
+        ...sectionWithRowClick,
+        rowActions: [{ kind: "navigate", id: "edit", label: "custom-edit", screen: "item-edit" }],
+      },
+      dispatcher,
+      [schema],
+    );
+
+    await waitFor(() => expect(rtlScreen.getByTestId("row-r1")).toBeTruthy());
+    expect(rtlScreen.queryAllByTestId("action-edit-r1")).toHaveLength(1);
+    expect(rtlScreen.getByTestId("action-edit-r1").textContent).toBe("custom-edit");
+  });
+
+  test("no rowClick.entity → no default edit action", async () => {
+    const { dispatcher } = stubDispatcher();
+    const schema: FeatureSchema = {
+      featureName: "lease",
+      entities: {},
+      screens: [editScreen("item")],
+    };
+    renderWithFeatures({ ...sectionWithRowClick, rowClick: undefined }, dispatcher, [schema]);
+
+    await waitFor(() => expect(rtlScreen.getByTestId("row-r1")).toBeTruthy());
+    expect(rtlScreen.queryByTestId("action-edit-r1")).toBeNull();
+  });
+
+  test("access denied to the entityEdit screen → no default edit action", async () => {
+    const { dispatcher } = stubDispatcher();
+    const schema: FeatureSchema = {
+      featureName: "lease",
+      entities: {},
+      screens: [editScreen("item", ["admin"])],
+    };
+    renderWithFeatures(sectionWithRowClick, dispatcher, [schema]);
+
+    await waitFor(() => expect(rtlScreen.getByTestId("row-r1")).toBeTruthy());
+    expect(rtlScreen.queryByTestId("action-edit-r1")).toBeNull();
+  });
+});

package/src/components/related-list-section.tsx

@@ -11,15 +11,22 @@ import type {
   Translate,
 } from "@cosmicdrift/kumiko-headless";
 import { type ReactNode, useCallback, useMemo, useState } from "react";
+import { useAppFeatures } from "../app/app-features-context";
 import {
   buildFilterFacets,
   buildFilterPayload,
   resolveProjectionFacetSpecs,
 } from "../app/list-facets";
 import { useNav } from "../app/nav";
-import { buildProjectionRowActions, runProjectionRowNavigate } from "../app/row-actions";
+import {
+  buildDefaultEditRowAction,
+  buildProjectionRowActions,
+  runProjectionRowNavigate,
+} from "../app/row-actions";
+import { findEditScreenFor } from "../app/screen-access";
 import { dispatcherErrorText } from "../app/write-failed-error";
 import { useOptionalDispatcher } from "../context/dispatcher-context";
+import { useUserRoles } from "../context/user-roles-context";
 import type { ListSort } from "../hooks/use-list-url-state";
 import { useQuery } from "../hooks/use-query";
 import { useTranslation } from "../i18n";
@@ -79,6 +86,17 @@ export function RelatedListSection({
   const effectiveTranslate = translate ?? t;
   const nav = useNav();
   const dispatcher = useOptionalDispatcher();
+  const appFeatures = useAppFeatures();
+  const userRoles = useUserRoles();
+  const defaultEditScreen = useMemo(() => {
+    const targetEntity = section.rowClick?.entity;
+    if (targetEntity === undefined) return undefined;
+    return findEditScreenFor(targetEntity, appFeatures, userRoles);
+  }, [appFeatures, section.rowClick, userRoles]);
+  const defaultEditRowAction = useMemo(
+    () => buildDefaultEditRowAction(defaultEditScreen, section.rowClick?.idColumn ?? "id"),
+    [defaultEditScreen, section.rowClick],
+  );
 
   const entity = useMemo(() => synthesizeRelatedListEntity(section.columns), [section.columns]);
   const listScreen = useMemo(
@@ -195,8 +213,17 @@ export function RelatedListSection({
         nav,
         refetch: rowsQuery.refetch,
         openDrawer: onOpenDrawer,
+        defaultEditRowAction,
       }),
-    [section.rowActions, effectiveTranslate, dispatcher, nav, rowsQuery.refetch, onOpenDrawer],
+    [
+      section.rowActions,
+      effectiveTranslate,
+      dispatcher,
+      nav,
+      rowsQuery.refetch,
+      onOpenDrawer,
+      defaultEditRowAction,
+    ],
   );
 
   // A truncated fetch means `sortedRows` is a sort of a partial set, not of

package/src/components/render-edit.tsx

@@ -1,6 +1,7 @@
 import type {
   EntityEditScreenDefinition,
   FieldCondition,
+  PlatformComponent,
 } from "@cosmicdrift/kumiko-framework/ui-types";
 import {
   evalFieldCondition,
@@ -190,6 +191,53 @@ function ExtensionSectionMount({
   );
 }
 
+// Resolves an entityEdit slot's (`screen.slots.header` / `.footer`)
+// `{ react: { __component: "X" } }` marker via the same ExtensionSectionsProvider
+// registry as ExtensionSectionMount / ListHeaderSlotMount and mounts it. One
+// component for both slots — header passes no hasUnsavedChanges/wizardStep,
+// footer does. Own component for rules-of-hooks (useExtensionSectionComponent
+// must not run conditionally inside RenderEdit's render body).
+function EditSlotMount({
+  slot,
+  slotName,
+  screenId,
+  entityName,
+  entityId,
+  values,
+  hasUnsavedChanges,
+  wizardStep,
+}: {
+  readonly slot: PlatformComponent;
+  readonly slotName: "header" | "footer";
+  readonly screenId: string;
+  readonly entityName: string;
+  readonly entityId: string | null;
+  readonly values: Readonly<Record<string, unknown>>;
+  readonly hasUnsavedChanges?: boolean;
+  readonly wizardStep?: { readonly index: number; readonly isLast: boolean };
+}): ReactNode {
+  const name = extensionSectionName(slot);
+  const Component = useExtensionSectionComponent(name);
+  useEffect(() => {
+    if (name !== undefined && Component === undefined) {
+      // biome-ignore lint/suspicious/noConsole: dev warning for a setup error
+      console.warn(
+        `[kumiko] Edit ${slotName} slot component "${name}" on screen "${screenId}" is not registered in clientFeatures.extensionSectionComponents — the ${slotName} slot renders nothing.`,
+      );
+    }
+  }, [name, Component, screenId, slotName]);
+  if (Component === undefined) return null;
+  return (
+    <Component
+      entityName={entityName}
+      entityId={entityId}
+      values={values}
+      {...(hasUnsavedChanges !== undefined && { hasUnsavedChanges })}
+      {...(wizardStep !== undefined && { wizardStep })}
+    />
+  );
+}
+
 export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
   props: RenderEditProps<TValues, TCtx>,
 ): ReactNode {
@@ -1016,6 +1064,30 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
       )}
     </>
   );
+  const headerSlot = screen.slots?.header;
+  const headerSlotMount =
+    headerSlot !== undefined ? (
+      <EditSlotMount
+        slot={headerSlot}
+        slotName="header"
+        screenId={screen.id}
+        entityName={vm.entityName}
+        entityId={resolveExtensionEntityId(entityIdProp, vm.id)}
+        values={snapshot.values}
+      />
+    ) : undefined;
+  // Slot renders above the caller's own headerRegion; without slots.header
+  // this is bit-identical to the plain headerRegion prop below.
+  const formHeaderRegion =
+    headerSlotMount !== undefined ? (
+      <>
+        {headerSlotMount}
+        {headerRegion}
+      </>
+    ) : (
+      headerRegion
+    );
+  const footerSlot = screen.slots?.footer;
   // Mirrors every branch inside formActions below — without this guard
   // DefaultForm renders an empty footer strip (border + padding, no content)
   // on read-only detail screens, since `actions` would otherwise always be
@@ -1024,7 +1096,8 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
     (isWizard && currentStep > 0) ||
     (isWizard && !isLastWizardStep) ||
     ((isFormEditable || hasExtensionRegistrations || isFieldless) &&
-      (!isWizard || isLastWizardStep));
+      (!isWizard || isLastWizardStep)) ||
+    footerSlot !== undefined;
   const formActions = (
     <>
       {isWizard && currentStep > 0 && (
@@ -1038,6 +1111,18 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
           {translate("kumiko.actions.back")}
         </Button>
       )}
+      {footerSlot !== undefined && (
+        <EditSlotMount
+          slot={footerSlot}
+          slotName="footer"
+          screenId={screen.id}
+          entityName={vm.entityName}
+          entityId={resolveExtensionEntityId(entityIdProp, vm.id)}
+          values={snapshot.values}
+          hasUnsavedChanges={snapshot.isDirty || extensionDirty}
+          wizardStep={isWizard ? { index: currentStep, isLast: isLastWizardStep } : undefined}
+        />
+      )}
       {isWizard && !isLastWizardStep && (
         <Button
           type="submit"
@@ -1108,7 +1193,7 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
         testId="render-edit-form"
         stickyActions={isWizard}
         {...(screen.layout.width !== undefined && { width: screen.layout.width })}
-        {...(headerRegion !== undefined && { headerRegion })}
+        {...(formHeaderRegion !== undefined && { headerRegion: formHeaderRegion })}
         {...(fillHeight && { fillHeight })}
         {...(hideSectionTitles === true && { chromeless: true })}
       >

package/src/primitives.tsx

@@ -476,6 +476,9 @@ export type InputProps =
       /** Read-only Textarea. Nicht `disabled` — bleibt fokussier-/
        *  kopierbar (analog zu kind:"text"). */
       readonly readOnly?: boolean;
+      /** Ctrl/Cmd+Enter submits instead of inserting a newline. Plain
+       *  Enter still inserts a newline. */
+      readonly onSubmitShortcut?: () => void;
     };
 
 // Sort-Wire-Format. `null`-State unterscheidet "User hat noch nichts