@cosmicdrift/kumiko-renderer 0.239.0 → 0.241.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-renderer",
-  "version": "0.239.0",
+  "version": "0.241.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.239.0",
-    "@cosmicdrift/kumiko-headless": "0.239.0",
+    "@cosmicdrift/kumiko-framework": "0.241.0",
+    "@cosmicdrift/kumiko-headless": "0.241.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.239.0"
+    "@cosmicdrift/kumiko-locale-de": "0.241.0"
   },
   "repository": {
     "type": "git",

package/src/app/__tests__/projection-detail-shim.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, test } from "bun:test";
+import type { ProjectionDetailScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import { synthesizeProjectionDetailScreen } from "../projection-detail-shim";
+
+// Regression for the writeForm extension (fw editable-detail-screens): the
+// hard readOnly:true enforcement in synthesizeProjectionDetailScreen must
+// still apply to every ordinary fields-section, unchanged — a writeForm
+// section is the one deliberate exception (isFieldsEditSection excludes it,
+// same as relatedList/extension), it must pass through editable.
+describe("synthesizeProjectionDetailScreen", () => {
+  test("forces readOnly:true on a fields section, but leaves a writeForm section's own readOnly untouched", () => {
+    const screen: ProjectionDetailScreenDefinition = {
+      id: "order-detail",
+      type: "projectionDetail",
+      query: "orders:query:order:detail",
+      layout: {
+        sections: [
+          { title: "Basics", fields: [{ field: "name", readOnly: false }] },
+          {
+            kind: "writeForm",
+            title: "Add note",
+            fieldDefs: { note: { type: "text" } },
+            fields: [{ field: "note", readOnly: false }],
+            handler: "orders:write:add-note",
+          },
+        ],
+      },
+    };
+
+    const result = synthesizeProjectionDetailScreen(screen);
+
+    const [fieldsSection, writeFormSection] = result.layout.sections;
+    if (fieldsSection === undefined || !("fields" in fieldsSection) || "kind" in fieldsSection) {
+      throw new Error("expected the first section to stay a plain fields section");
+    }
+    expect(fieldsSection.fields[0]).toMatchObject({ field: "name", readOnly: true });
+
+    if (writeFormSection === undefined || writeFormSection.kind !== "writeForm") {
+      throw new Error("expected the second section to stay kind: writeForm, untouched");
+    }
+    expect(writeFormSection.fields[0]).toEqual({ field: "note", readOnly: false });
+  });
+});

package/src/app/__tests__/projection-detail-singleton.test.tsx

@@ -0,0 +1,191 @@
+// fw#2312: `singleton: true` marks a projectionDetail screen whose query
+// determines the shown row from the caller's session/context instead of a
+// row id in the path (a self-service "my profile"/"my data" screen has no
+// row to link to). Before this flag, ProjectionDetailBody always rendered
+// the "needs a row id in the path" error banner when `entityId` was
+// undefined (kumiko-screen.tsx) — both user-profile and user-data-rights'
+// privacy-center screen hit exactly that, unrenderable, until the flag
+// existed (fw#2312 bug report). This proves the fix, the no-flag regression
+// case stays covered, and that a stray/spoofed path id never reaches the
+// query under singleton (renderer-side half of the security requirement —
+// the boot-validator half lives in framework's projection-detail-
+// singleton.test.ts).
+
+import { describe, expect, test } from "bun:test";
+import type { ProjectionDetailScreenDefinition } 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 BannerProps,
+  type CorePrimitives,
+  type FormProps,
+  PrimitivesProvider,
+} from "../../primitives";
+import { AppFeaturesProvider } from "../app-features-context";
+import type { FeatureSchema } from "../feature-schema";
+import { KumikoScreen } from "../kumiko-screen";
+import type { NavApi } from "../nav";
+import { NavProvider } from "../nav";
+
+const noop = (): ReactNode => null;
+const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
+
+const FormWithActions: ComponentType<FormProps> = ({ children }) => (
+  <div data-testid="form-body">{children}</div>
+);
+
+const TestBanner: ComponentType<BannerProps> = ({ children, testId }) => (
+  <div data-testid={testId}>{children}</div>
+);
+
+const testPrimitives: CorePrimitives = {
+  Button: noop,
+  Banner: TestBanner,
+  Field: passChildren,
+  Input: noop,
+  DataTable: noop,
+  Form: FormWithActions,
+  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 stubDispatcher(
+  record: Readonly<Record<string, unknown>> | null,
+  queries: Array<{ type: string; payload: unknown }>,
+): Dispatcher {
+  return {
+    write: (async () => ({ isSuccess: true, data: {} })) as unknown as Dispatcher["write"],
+    query: (async (type: string, payload: unknown) => {
+      queries.push({ type, payload });
+      return { isSuccess: true, data: record };
+    }) 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: () => [],
+  };
+}
+
+function meScreen(
+  overrides?: Partial<ProjectionDetailScreenDefinition>,
+): FeatureSchema["screens"][number] {
+  return {
+    id: "profile",
+    type: "projectionDetail",
+    query: "app:query:me",
+    layout: { sections: [{ title: "s", fields: ["name"] }] },
+    ...overrides,
+  } as FeatureSchema["screens"][number];
+}
+
+function renderScreen(opts: {
+  readonly screen: FeatureSchema["screens"][number];
+  readonly entityId?: string;
+  readonly queries: Array<{ type: string; payload: unknown }>;
+  readonly record?: Readonly<Record<string, unknown>> | null;
+}): ReturnType<typeof render> {
+  const schema: FeatureSchema = { featureName: "app", entities: {}, screens: [opts.screen] };
+  const navApi: NavApi = {
+    route: { screenId: "app:screen:profile" },
+    navigate: () => {},
+    replace: () => {},
+    hrefFor: () => "",
+    searchParams: {},
+    setSearchParams: () => {},
+  };
+  return render(
+    <LocaleProvider
+      resolver={createStaticLocaleResolver({ locale: "de-DE" })}
+      fallbackBundles={[kumikoDefaultTranslations]}
+    >
+      <DispatcherProvider
+        dispatcher={stubDispatcher(
+          opts.record !== undefined ? opts.record : { id: "u1", name: "Ada" },
+          opts.queries,
+        )}
+      >
+        <AppFeaturesProvider features={[schema]}>
+          <UserRolesProvider roles={[]}>
+            <NavProvider value={navApi}>
+              <PrimitivesProvider value={testPrimitives}>
+                <KumikoScreen
+                  schema={schema}
+                  qn="app:screen:profile"
+                  {...(opts.entityId !== undefined && { entityId: opts.entityId })}
+                />
+              </PrimitivesProvider>
+            </NavProvider>
+          </UserRolesProvider>
+        </AppFeaturesProvider>
+      </DispatcherProvider>
+    </LocaleProvider>,
+  );
+}
+
+describe("projectionDetail singleton (fw#2312)", () => {
+  test("singleton + no path id renders the record instead of the missing-id banner", async () => {
+    const queries: Array<{ type: string; payload: unknown }> = [];
+    const { queryByTestId, getByTestId } = renderScreen({
+      screen: meScreen({ singleton: true }),
+      queries,
+    });
+
+    await waitFor(() => expect(getByTestId("form-body")).toBeTruthy());
+    expect(queryByTestId("kumiko-screen-projection-detail-missing-id")).toBeNull();
+    expect(queries).toEqual([{ type: "app:query:me", payload: {} }]);
+  });
+
+  test("no singleton flag + no path id still shows the missing-id banner (no regression)", async () => {
+    const queries: Array<{ type: string; payload: unknown }> = [];
+    const { getByTestId } = renderScreen({ screen: meScreen(), queries });
+
+    await waitFor(() =>
+      expect(getByTestId("kumiko-screen-projection-detail-missing-id")).toBeTruthy(),
+    );
+  });
+
+  test("singleton ignores a stray path id — the query never receives it", async () => {
+    const queries: Array<{ type: string; payload: unknown }> = [];
+    const { getByTestId } = renderScreen({
+      screen: meScreen({ singleton: true }),
+      entityId: "attacker-controlled-id",
+      queries,
+    });
+
+    await waitFor(() => expect(getByTestId("form-body")).toBeTruthy());
+    expect(queries).toEqual([{ type: "app:query:me", payload: {} }]);
+  });
+
+  test("singleton + record-not-found banner never shows the (ignored) path id", async () => {
+    const queries: Array<{ type: string; payload: unknown }> = [];
+    const { getByTestId } = renderScreen({
+      screen: meScreen({ singleton: true }),
+      entityId: "99",
+      record: null,
+      queries,
+    });
+
+    const banner = await waitFor(() => getByTestId("kumiko-screen-record-missing"));
+    expect(banner.textContent).toBe("Record not found.");
+    expect(banner.textContent).not.toContain("99");
+  });
+});

package/src/app/kumiko-screen.tsx

@@ -6,14 +6,11 @@ import type {
   EntityDefinition,
   EntityEditScreenDefinition,
   EntityListScreenDefinition,
-  IconKey,
   ListFacetSpec,
   ProjectionDetailScreenDefinition,
   ProjectionListScreenDefinition,
   RowAction,
   RowActionNavigate,
-  RowActionWriteHandler,
-  RowFieldExtractor,
   ScreenDefinition,
   ToolbarAction,
 } from "@cosmicdrift/kumiko-framework/ui-types";
@@ -39,8 +36,6 @@ import { useTranslation } from "../i18n";
 import {
   type DataTableFacet,
   type DataTableRowAction,
-  type DataTableRowActionMode,
-  shouldRenderActionsIconOnly,
   statusToneForValue,
   usePrimitives,
 } from "../primitives";
@@ -60,81 +55,20 @@ import {
 import { synthesizeProjectionEntity, synthesizeProjectionScreen } from "./projection-list-shim";
 import { lastSegment, toKebab } from "./qn";
 import { featureNameFromQualifiedScreenId, qualifyScreenId } from "./qualify-screen-id";
+import {
+  buildProjectionRowActions,
+  evalRowExtractor,
+  isWriteHandlerRowAction,
+  refetchAfterWrite,
+  resolveActionIcon,
+  rowActionModeFor,
+  runProjectionRowNavigate,
+  stringifyNavParams,
+} from "./row-actions";
 import { screenAccessAllows } from "./screen-access";
 import { SecretsEditBody } from "./secrets-edit-body";
 import { dispatcherErrorText, WriteFailedError } from "./write-failed-error";
 
-function evalRowExtractor(
-  extractor: RowFieldExtractor,
-  row: Record<string, unknown>,
-): Record<string, unknown> {
-  if ("pick" in extractor) {
-    return Object.fromEntries(extractor.pick.map((f) => [f, row[f]]));
-  }
-  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;
-}
-
-// Part B (fw-ui-defaults): id-derived default icon for actions that never
-// declared one — a screen author still gets a recognizable glyph instead of
-// a bare label. Checked against the actually registered IconKey vocabulary
-// (nav-icon.ts) — no entry for verbs without a matching icon (e.g. "start",
-// "pause").
-const ACTION_ICON_BY_ID: Readonly<Partial<Record<string, IconKey>>> = {
-  delete: "trash",
-  edit: "pencil",
-  create: "plus",
-  new: "plus",
-  add: "plus",
-  view: "eye",
-  open: "eye",
-  cancel: "x",
-  reject: "x",
-  complete: "check",
-  resolve: "check",
-  approve: "check",
-  archive: "archive",
-  publish: "upload",
-  duplicate: "copy",
-  copy: "copy",
-  download: "download",
-  refresh: "refresh",
-  retry: "refresh",
-  settings: "settings",
-  share: "share",
-  send: "send",
-};
-
-// Ids are kebab-case (RowAction.id doc) — a compound id whose full form has
-// no entry falls back to its last segment ("order-ship" -> "ship").
-function kebabLastSegment(id: string): string {
-  const idx = id.lastIndexOf("-");
-  return idx === -1 ? id : id.slice(idx + 1);
-}
-
-// Resolution order: author-declared `icon` wins, then the id-derived
-// default (full id, then its last kebab segment). `declared` is `undefined`
-// for ToolbarAction, which has no author-facing icon field.
-function resolveActionIcon(id: string, declared?: IconKey): IconKey | undefined {
-  if (declared !== undefined) return declared;
-  return ACTION_ICON_BY_ID[id] ?? ACTION_ICON_BY_ID[kebabLastSegment(id)];
-}
-
-// Row-action column mode for a resolved action set: a group where every
-// member carries an icon renders inline so `shouldRenderActionsIconOnly`
-// can collapse it to icon-only buttons (fw#2580). Anything else keeps the
-// DataTable's adaptive default (kebab past two actions) — inline text
-// buttons for an icon-less group are the very thing the collapse avoids.
-function rowActionModeFor(
-  actions: readonly DataTableRowAction[] | undefined,
-): DataTableRowActionMode | undefined {
-  if (actions === undefined || !shouldRenderActionsIconOnly(actions)) return undefined;
-  return "inline";
-}
-
 // 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
@@ -1106,26 +1040,10 @@ function buildFilterFacets(specs: readonly ResolvedFacetSpec[]): DataTableFacet[
 // passes through any field present in entity.fields, matching its
 // pre-fw#2224 behavior; only the boolean-coercion branch cares about type.
 
-function stringifyNavParams(params: Record<string, unknown>): Record<string, string | null> {
-  const out: Record<string, string | null> = {};
-  for (const [k, v] of Object.entries(params)) {
-    out[k] =
-      v === null || v === undefined ? null : Array.isArray(v) ? JSON.stringify(v) : String(v);
-  }
-  return out;
-}
-
 function isFacetI18nKey(label: string): boolean {
   return !/\s/.test(label) && (label.includes(".") || label.includes(":"));
 }
 
-async function refetchAfterWrite(refetch: () => Promise<unknown>): Promise<void> {
-  await refetch().catch((err: unknown) => {
-    // biome-ignore lint/suspicious/noConsole: refetch must not poison the write-action error path
-    console.error("kumiko-screen: refetch after write action failed", err);
-  });
-}
-
 function buildFilterPayload(
   urlFilters: Readonly<Record<string, readonly string[]>>,
   typeOf: (field: string) => string | undefined,
@@ -1953,97 +1871,31 @@ function ProjectionListBody({
 
   const filterFacets = useMemo<DataTableFacet[]>(() => buildFilterFacets(facetSpecs), [facetSpecs]);
 
+  // Entity-Targets (fw#2228) — see EntityListBody.runNavigate for why the
+  // resolution happens in the NavApi impl. Unlike there: NO row["id"]
+  // fallback — projectionList rows come from an arbitrary query projection
+  // with no guaranteed "id" field. The boot validator therefore enforces an
+  // explicit entityId for projectionList entity targets. Same helper
+  // relatedList's rowActions reuse (related-list-section.tsx) — a
+  // projectionDetail relatedList row has the identical "no guaranteed id"
+  // shape.
   const runNavigate = useCallback(
-    (action: RowActionNavigate, row: ListRowViewModel) => {
-      if (action.entity !== undefined) {
-        // Entity-Targets (fw#2228) — siehe EntityListBody.runNavigate für die
-        // Begründung, warum die Auflösung in der NavApi-Impl passiert. Anders
-        // als dort: KEIN row["id"]-Fallback — projectionList-Rows kommen aus
-        // einer beliebigen Query-Projection ohne garantiertes "id"-Feld
-        // (gleiche Begründung wie beim screen-Target unten). Der Boot-
-        // Validator erzwingt deshalb einen expliziten entityId für
-        // projectionList-entity-Targets.
-        const id = action.entityId !== undefined ? String(row.values[action.entityId] ?? "") : "";
-        if (id === "") return;
-        nav.navigate({ entity: action.entity, id });
-      } else if (action.screen !== undefined) {
-        const entityId =
-          action.entityId !== undefined ? String(row.values[action.entityId] ?? "") : undefined;
-        nav.navigate({
-          screenId: action.screen,
-          ...(entityId !== undefined && entityId !== "" && { entityId }),
-        });
-      } else {
-        return;
-      }
-      const params =
-        action.params !== undefined ? evalRowExtractor(action.params, row.values) : undefined;
-      if (params !== undefined) {
-        nav.setSearchParams(stringifyNavParams(params));
-      }
-    },
+    (action: RowActionNavigate, row: ListRowViewModel) =>
+      runProjectionRowNavigate(nav, action, row),
     [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;
-        const actionIcon = resolveActionIcon(action.id, action.icon);
-        out.push({
-          id: action.id,
-          label: effectiveTranslate(action.label),
-          ...(action.style !== undefined && { style: action.style }),
-          ...(actionIcon !== undefined && { icon: actionIcon }),
-          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 }),
-        icon: resolveActionIcon(writeAction.id, writeAction.icon),
-        ...(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),
-            );
-          }
-          // Same refetch as EntityListBody's rowActions above.
-          await refetchAfterWrite(rowsQuery.refetch);
-        },
-        ...(writeVisible !== undefined && {
-          isVisible: (row: ListRowViewModel) => evalFieldCondition(writeVisible, row.values),
-        }),
-      });
-    }
-    return out.length > 0 ? out : undefined;
-  }, [screen.rowActions, effectiveTranslate, runNavigate, dispatcher, rowsQuery.refetch]);
+  const rowActions = useMemo(
+    () =>
+      buildProjectionRowActions({
+        rowActions: screen.rowActions,
+        translate: effectiveTranslate,
+        dispatcher,
+        nav,
+        refetch: rowsQuery.refetch,
+      }),
+    [screen.rowActions, effectiveTranslate, dispatcher, nav, rowsQuery.refetch],
+  );
 
   // Same icon-only collapse as entityList (fw#2580) — projectionList rows go
   // through the identical RenderList/DataTable path.
@@ -2224,6 +2076,12 @@ function ProjectionDetailBody({
   const effectiveTranslate = translate ?? t;
   const nav = useNav();
   const idParam = screen.idParam ?? "id";
+  // Singleton screens ignore whatever id the path happens to carry — the
+  // server picks the row from session/context, so forwarding a path id
+  // (even a stray/spoofed one) into the query or into extension sections'
+  // entityId fallback (resolveExtensionEntityId in render-edit.tsx) would
+  // let a client-controlled value leak where none is meant to reach.
+  const effectiveEntityId = screen.singleton === true ? undefined : entityId;
   const isTabsMode = screen.layout.mode === "tabs";
   const activeSection = useMemo(() => {
     if (!isTabsMode || Tabs === undefined) return undefined;
@@ -2252,9 +2110,21 @@ function ProjectionDetailBody({
   }, [screen, activeSection]);
   const detailQuery = useQuery<Readonly<Record<string, unknown>>>(
     screen.query,
-    entityId !== undefined ? { [idParam]: entityId } : {},
+    effectiveEntityId !== undefined ? { [idParam]: effectiveEntityId } : {},
   );
 
+  // A writeForm section's handler creates a new record (see EditWriteFormSection's
+  // doc) — both the outer record (header/metrics/other sections) and a sibling
+  // relatedList section's own independently-fetched rows must reflect it. A
+  // query refetch alone only refreshes `record` below; bumping this into
+  // <RenderEdit>'s `key` forces a full remount so RelatedListSection's own
+  // useQuery call re-runs too (it has no `live` subscription of its own).
+  const [reloadNonce, setReloadNonce] = useState(0);
+  const reloadDetail = useCallback(async () => {
+    await detailQuery.refetch();
+    setReloadNonce((n) => n + 1);
+  }, [detailQuery.refetch]);
+
   // Default edit action (fw#2166): resolved cross-feature over ALL mounted
   // features, not just this feature's own schema — detailFor itself is
   // resolved cross-feature by the boot-validator (detail-screens.ts), and
@@ -2293,9 +2163,12 @@ function ProjectionDetailBody({
       label: effectiveTranslate("kumiko.actions.edit"),
       icon: resolveActionIcon("edit"),
       onPress: () =>
-        nav.navigate({ screenId: targetScreenId, ...(entityId !== undefined && { entityId }) }),
+        nav.navigate({
+          screenId: targetScreenId,
+          ...(effectiveEntityId !== undefined && { entityId: effectiveEntityId }),
+        }),
     };
-  }, [editScreen, effectiveTranslate, nav, entityId]);
+  }, [editScreen, effectiveTranslate, nav, effectiveEntityId]);
 
   const headerActions = useMemo((): readonly RenderEditAction[] | undefined => {
     const record = detailQuery.data ?? {};
@@ -2418,7 +2291,7 @@ function ProjectionDetailBody({
     detailQuery.refetch,
   ]);
 
-  if (entityId === undefined) {
+  if (effectiveEntityId === undefined && screen.singleton !== true) {
     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
@@ -2444,7 +2317,13 @@ function ProjectionDetailBody({
   if (!record) {
     return (
       <Banner padded variant="error" testId="kumiko-screen-record-missing">
-        Record <Text variant="code">{entityId}</Text> not found.
+        {screen.singleton === true ? (
+          "Record not found."
+        ) : (
+          <>
+            Record <Text variant="code">{entityId}</Text> not found.
+          </>
+        )}
       </Banner>
     );
   }
@@ -2528,12 +2407,14 @@ function ProjectionDetailBody({
   );
   return (
     <RenderEdit
+      key={`${entityId}:${reloadNonce}`}
       screen={detailScreen}
       entity={entity}
       featureName={schema.featureName}
       initial={record as FormValues}
-      entityId={entityId}
+      entityId={effectiveEntityId}
       customSubmit={async () => ({ isSuccess: true, validationBlocked: false, data: undefined })}
+      onReload={reloadDetail}
       {...(headerActions !== undefined && { actions: headerActions })}
       {...(translate !== undefined && { translate })}
       {...(hasTabs && { hideSectionTitles: true })}