@cosmicdrift/kumiko-renderer 0.270.0 → 0.274.0

package/src/app/list-facets.ts

@@ -1,21 +1,46 @@
 // Split from kumiko-screen.tsx: related-list-section.tsx renders through
 // kumiko-screen.tsx, so importing this back from there would be a require cycle.
+
 import type { ListFacetSpec } from "@cosmicdrift/kumiko-framework/ui-types";
+import { parseRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
 import type { Translate } from "@cosmicdrift/kumiko-headless";
 import type { DataTableFacet } from "../primitives";
 
 // One resolved facet, independent of where the type info came from — an
 // entity field (entityList) or an explicit ListFacetSpec (projectionList,
-// fw#2224). Shared by buildFilterFacets/buildFilterPayload below so both
-// screen types build their query-payload filters and DataTable facet-UI
-// through the same code, instead of two copies that can drift.
+// relatedList). Shared by buildFilterFacets/buildFilterPayload so all list
+// screens build filters and facet UI through one code path.
 export type ResolvedFacetSpec = {
   readonly field: string;
-  readonly type: "select" | "boolean";
+  readonly type: "select" | "boolean" | "reference";
   readonly label: string;
+  /** Empty for a "reference" facet until `ReferenceFacetBridges` resolves it
+   *  at render time, unlike select/boolean's author-declared options. */
   readonly options: readonly { readonly value: string; readonly label: string }[];
+  /** Present only for a "reference" facet — the resolved lookup target
+   *  `ReferenceFacetBridges` needs to fetch its options. */
+  readonly reference?: {
+    readonly refEntity: string;
+    readonly refFeature: string;
+    readonly labelField: string;
+  };
 };
 
+// Fills in a "reference" spec's initially-empty `options` from the
+// field-keyed options ReferenceFacetBridges resolved, shared by every caller.
+export function mergeReferenceFacetOptions(
+  specs: readonly ResolvedFacetSpec[],
+  optionsByField: Readonly<
+    Record<string, readonly { readonly value: string; readonly label: string }[]>
+  >,
+): ResolvedFacetSpec[] {
+  return specs.map((spec) =>
+    spec.reference !== undefined
+      ? { ...spec, options: optionsByField[spec.field] ?? spec.options }
+      : spec,
+  );
+}
+
 export function buildFilterFacets(specs: readonly ResolvedFacetSpec[]): DataTableFacet[] {
   return specs.map((spec) => ({ field: spec.field, label: spec.label, options: spec.options }));
 }
@@ -56,35 +81,53 @@ export function buildFilterPayload(
   return out;
 }
 
-// projectionList adapter — a projectionList has no entity/i18n convention to
-// derive labels from, so ListFacetSpec carries every label explicitly
+// projectionList/relatedList adapter — neither has an entity/i18n convention
+// to derive labels from, so ListFacetSpec carries every label explicitly
 // (fw#2224). Labels may be raw display strings or i18n keys; run them
 // through translate like entity facets (passthrough when the key is missing).
+// `featureName` resolves a reference facet's `entity` target the same way
+// ListColumnSpec.refEntity does (same-feature short name, or "feature:entity").
 export function resolveProjectionFacetSpecs(
   facets: readonly ListFacetSpec[] | undefined,
   translate: Translate,
+  featureName: string,
 ): ResolvedFacetSpec[] {
   if (facets === undefined) return [];
   const tr = (label: string): string => (isFacetI18nKey(label) ? translate(label) : label);
-  return facets.map((facet) =>
-    facet.type === "select"
-      ? {
-          field: facet.field,
-          type: "select",
-          label: tr(facet.label),
-          options: facet.options.map((opt) => ({
-            value: opt.value,
-            label: tr(opt.label),
-          })),
-        }
-      : {
-          field: facet.field,
-          type: "boolean",
-          label: tr(facet.label),
-          options: [
-            { value: "true", label: tr(facet.trueLabel) },
-            { value: "false", label: tr(facet.falseLabel) },
-          ],
-        },
-  );
+  return facets.map((facet): ResolvedFacetSpec => {
+    if (facet.type === "select") {
+      return {
+        field: facet.field,
+        type: "select",
+        label: tr(facet.label),
+        options: facet.options.map((opt) => ({
+          value: opt.value,
+          label: tr(opt.label),
+        })),
+      };
+    }
+    if (facet.type === "boolean") {
+      return {
+        field: facet.field,
+        type: "boolean",
+        label: tr(facet.label),
+        options: [
+          { value: "true", label: tr(facet.trueLabel) },
+          { value: "false", label: tr(facet.falseLabel) },
+        ],
+      };
+    }
+    const target = parseRefTarget(facet.entity, featureName);
+    return {
+      field: facet.field,
+      type: "reference",
+      label: tr(facet.label),
+      options: [],
+      reference: {
+        refEntity: target.entityName,
+        refFeature: target.featureName,
+        labelField: facet.labelField ?? "id",
+      },
+    };
+  });
 }

package/src/app/reference-facet-bridge.tsx

@@ -0,0 +1,58 @@
+// One bridge component per reference facet, mirroring ReferenceLookupBridge —
+// facet count varies per screen, so the hook can't be called in a loop.
+import { type ReactNode, useEffect } from "react";
+import { useReferenceLookup } from "../hooks/use-reference-lookup";
+import type { ResolvedFacetSpec } from "./list-facets";
+
+export type ReferenceFacetOption = { readonly value: string; readonly label: string };
+
+function ReferenceFacetOptionsBridge({
+  field,
+  refEntity,
+  refFeature,
+  labelField,
+  onOptions,
+}: {
+  readonly field: string;
+  readonly refEntity: string;
+  readonly refFeature: string;
+  readonly labelField: string;
+  readonly onOptions: (field: string, options: readonly ReferenceFacetOption[]) => void;
+}): ReactNode {
+  const lookup = useReferenceLookup(refFeature, refEntity, labelField);
+  useEffect(() => {
+    if (lookup.loading) return;
+    onOptions(
+      field,
+      [...lookup.map.entries()].map(([value, label]) => ({ value, label })),
+    );
+  }, [lookup.loading, lookup.map, field, onOptions]);
+  return null;
+}
+
+// One invisible bridge per "reference" facet spec, each publishing its
+// resolved options back via `onOptions` once loaded.
+export function ReferenceFacetBridges({
+  specs,
+  onOptions,
+}: {
+  readonly specs: readonly ResolvedFacetSpec[];
+  readonly onOptions: (field: string, options: readonly ReferenceFacetOption[]) => void;
+}): ReactNode {
+  const referenceSpecs = specs.filter((spec) => spec.reference !== undefined);
+  if (referenceSpecs.length === 0) return null;
+  return (
+    <>
+      {referenceSpecs.map((spec) => (
+        <ReferenceFacetOptionsBridge
+          key={spec.field}
+          field={spec.field}
+          refEntity={spec.reference?.refEntity ?? ""}
+          refFeature={spec.reference?.refFeature ?? ""}
+          labelField={spec.reference?.labelField ?? "id"}
+          onOptions={onOptions}
+        />
+      ))}
+    </>
+  );
+}

package/src/app/return-to.tsx

@@ -0,0 +1,128 @@
+import type { ScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import { createContext, type ReactNode, useContext, useMemo } from "react";
+import { useUserRoles } from "../context/user-roles-context";
+import { useAppFeatures } from "./app-features-context";
+import type { FeatureSchema } from "./feature-schema";
+import { type NavApi, type ScreenTarget, useNav } from "./nav";
+import { lastSegment } from "./qn";
+import { screenAccessAllows } from "./screen-access";
+
+// A search param, not nav/route state, so it survives a full page reload
+// and a copied/shared URL.
+export const RETURN_TO_PARAM = "returnTo";
+
+export type ReturnHost = {
+  readonly screenId: string;
+  readonly entityId?: string;
+};
+
+export function formatReturnTo(host: ReturnHost): string {
+  return host.entityId !== undefined ? `${host.screenId}/${host.entityId}` : host.screenId;
+}
+
+// {} when target IS host — pushPath no-ops on the same path, so the param
+// would land on the current page instead of the one being left.
+export function returnToParams(
+  host: ReturnHost | undefined,
+  target: ScreenTarget,
+): Readonly<Record<string, string>> {
+  if (host === undefined) return {};
+  if (lastSegment(target.screenId) === host.screenId && target.entityId === host.entityId) {
+    return {};
+  }
+  return { [RETURN_TO_PARAM]: formatReturnTo(host) };
+}
+
+export function navigateWithReturnTo(
+  nav: NavApi,
+  target: ScreenTarget,
+  host: ReturnHost | undefined,
+  params?: Readonly<Record<string, string | null>>,
+): void {
+  nav.navigate(target);
+  const merged: Record<string, string | null> = {
+    ...(params ?? {}),
+    ...returnToParams(host, target),
+  };
+  if (Object.keys(merged).length > 0) {
+    nav.setSearchParams(merged);
+  }
+}
+
+// "%" is left alone — route entityIds come raw from the path and can carry it.
+const UNSAFE_ENTITY_ID_PATTERN = /[\\?#\s]/;
+
+// Every failure branch returns undefined so a malformed or stale value falls
+// back to the caller's own default instead of throwing.
+export function resolveReturnTarget(
+  raw: string | undefined,
+  ownScreenId: string,
+  features: readonly FeatureSchema[],
+  userRoles: readonly string[] | undefined,
+): ScreenTarget | undefined {
+  if (raw === undefined || raw === "") return undefined;
+  const segments = raw.split("/");
+  if (segments.length !== 1 && segments.length !== 2) return undefined;
+  if (segments.some((segment) => segment === "")) return undefined;
+  const [screenId, entityId] = segments;
+  if (screenId === undefined || screenId.includes(":")) return undefined;
+  if (screenId === lastSegment(ownScreenId)) return undefined;
+
+  let matched: ScreenDefinition | undefined;
+  for (const feature of features) {
+    matched = feature.screens.find((s) => lastSegment(s.id) === screenId);
+    if (matched !== undefined) break;
+  }
+  if (matched === undefined) return undefined;
+  if (!screenAccessAllows(matched.access, userRoles)) return undefined;
+
+  if (entityId !== undefined) {
+    if (entityId === "." || entityId === "..") return undefined;
+    if (UNSAFE_ENTITY_ID_PATTERN.test(entityId)) return undefined;
+    let decodedEntityId: string;
+    try {
+      decodedEntityId = decodeURIComponent(entityId);
+    } catch {
+      return undefined;
+    }
+    if (decodedEntityId === "." || decodedEntityId === "..") return undefined;
+    if (UNSAFE_ENTITY_ID_PATTERN.test(decodedEntityId) || decodedEntityId.includes("/")) {
+      return undefined;
+    }
+    if (matched.type !== "entityEdit" && matched.type !== "projectionDetail") return undefined;
+  }
+  if (matched.type === "projectionDetail" && matched.singleton !== true && entityId === undefined) {
+    return undefined;
+  }
+
+  return { screenId, ...(entityId !== undefined && { entityId }) };
+}
+
+const ReturnHostContext = createContext<ReturnHost | undefined>(undefined);
+
+export function ReturnHostProvider({
+  value,
+  children,
+}: {
+  readonly value: ReturnHost;
+  readonly children: ReactNode;
+}): ReactNode {
+  return <ReturnHostContext.Provider value={value}>{children}</ReturnHostContext.Provider>;
+}
+
+export function useReturnHost(): ReturnHost | undefined {
+  return useContext(ReturnHostContext);
+}
+
+// Reads through useNav().searchParams (reactive), not a useState snapshot —
+// a later setSearchParams call must not leave this stale.
+export function useReturnTarget(ownScreenId: string): ScreenTarget | undefined {
+  const nav = useNav();
+  const features = useAppFeatures();
+  const userRoles = useUserRoles();
+  const raw = nav.searchParams[RETURN_TO_PARAM];
+  return useMemo(
+    () => resolveReturnTarget(raw, ownScreenId, features, userRoles),
+    [raw, ownScreenId, features, userRoles],
+  );
+}

package/src/app/row-actions.ts

@@ -1,17 +1,21 @@
 import type {
   EntityEditScreenDefinition,
   IconKey,
+  RelatedListToolbarAction,
   RowAction,
   RowActionDrawer,
   RowActionNavigate,
   RowActionWriteHandler,
   RowFieldExtractor,
+  ToolbarAction,
 } from "@cosmicdrift/kumiko-framework/ui-types";
 import { evalFieldCondition } from "@cosmicdrift/kumiko-framework/ui-types";
 import type { Dispatcher, ListRowViewModel, Translate } from "@cosmicdrift/kumiko-headless";
+import type { ToolbarActionButton } from "../components/render-list";
 import type { DataTableRowAction } from "../primitives";
-import type { NavApi } from "./nav";
+import type { NavApi, ScreenTarget } from "./nav";
 import { lastSegment } from "./qn";
+import { navigateWithReturnTo, type ReturnHost } from "./return-to";
 import { dispatcherErrorText, WriteFailedError } from "./write-failed-error";
 
 // entityId is explicit: the edit screen may live in another feature than
@@ -137,35 +141,40 @@ export function runProjectionRowNavigate(
   nav: NavApi,
   action: RowActionNavigate,
   row: ListRowViewModel,
+  host: ReturnHost | undefined,
 ): void {
   if (action.entity !== undefined) {
     const id = action.entityId !== undefined ? String(row.values[action.entityId] ?? "") : "";
     // skip: no entityId column on this row — nothing to navigate to.
     if (id === "") return;
     nav.navigate({ entity: action.entity, id });
+    const params =
+      action.params !== undefined ? evalRowExtractor(action.params, row.values) : undefined;
+    if (params !== undefined) {
+      nav.setSearchParams(stringifyNavParams(params));
+    }
   } else if (action.screen !== undefined) {
     const entityId =
       action.entityId !== undefined ? String(row.values[action.entityId] ?? "") : undefined;
-    nav.navigate({
+    const target: ScreenTarget = {
       screenId: action.screen,
       ...(entityId !== undefined && entityId !== "" && { entityId }),
-    });
-  } else {
-    // skip: neither entity nor screen set — the boot-validator rejects this
-    // shape (resolveRowActionNavigateTarget), so this only guards types.
-    return;
-  }
-  const params =
-    action.params !== undefined ? evalRowExtractor(action.params, row.values) : undefined;
-  if (params !== undefined) {
-    nav.setSearchParams(stringifyNavParams(params));
+    };
+    const params =
+      action.params !== undefined
+        ? stringifyNavParams(evalRowExtractor(action.params, row.values))
+        : undefined;
+    navigateWithReturnTo(nav, target, host, params);
   }
+  // skip: neither entity nor screen set — the boot-validator rejects this
+  // shape (resolveRowActionNavigateTarget), so this only guards types.
 }
 
 function buildNavigateRowAction(
   action: RowActionNavigate,
   translate: Translate,
   nav: NavApi,
+  host: ReturnHost | undefined,
 ): DataTableRowAction {
   const { visible } = action;
   const actionIcon = resolveActionIcon(action.id, action.icon);
@@ -175,7 +184,7 @@ function buildNavigateRowAction(
     ...(action.style !== undefined && { style: action.style }),
     confirmRequired: false,
     ...(actionIcon !== undefined && { icon: actionIcon }),
-    onTrigger: (row: ListRowViewModel) => runProjectionRowNavigate(nav, action, row),
+    onTrigger: (row: ListRowViewModel) => runProjectionRowNavigate(nav, action, row, host),
     ...(visible !== undefined && {
       isVisible: (row: ListRowViewModel) => evalFieldCondition(visible, row.values),
     }),
@@ -187,18 +196,21 @@ type OpenDrawer = (
   initialValues: Readonly<Record<string, unknown>> | undefined,
 ) => void;
 
-// buildProjectionRowActions runs inside a useMemo (re-evaluated on every dep
-// change), so this dedupes the "openDrawer not wired" warning per action id
-// instead of firing on every recompute.
-const warnedDrawerRowActionIds = new Set<string>();
+// Dedupes the "openDrawer not wired" warning per action id, since the
+// builders re-run inside a useMemo on every dep change.
+const warnedDrawerActionIds = new Set<string>();
 
-function warnDrawerActionDropped(actionId: string): void {
+function warnDrawerActionDropped(
+  actionKind: "rowAction" | "toolbarAction",
+  actionId: string,
+): void {
+  const key = `${actionKind}:${actionId}`;
   // skip: already warned for this id — suppresses the repeat, not the warning itself.
-  if (warnedDrawerRowActionIds.has(actionId)) return;
-  warnedDrawerRowActionIds.add(actionId);
+  if (warnedDrawerActionIds.has(key)) return;
+  warnedDrawerActionIds.add(key);
   // biome-ignore lint/suspicious/noConsole: dev-warning for a setup error
   console.warn(
-    `[kumiko] rowAction "${actionId}" is kind:"drawer", but the host did not wire openDrawer (RelatedListSection: pass onOpenDrawer) — it will not render.`,
+    `[kumiko] ${actionKind} "${actionId}" is kind:"drawer", but the host did not wire openDrawer (RelatedListSection: pass onOpenDrawer) — it will not render.`,
   );
 }
 
@@ -288,20 +300,29 @@ export function buildProjectionRowActions(options: {
   readonly openDrawer?: OpenDrawer;
   /** Prepended unless a declared action already has id "edit" — declared wins. */
   readonly defaultEditRowAction?: RowActionNavigate;
+  readonly host: ReturnHost | undefined;
 }): readonly DataTableRowAction[] | undefined {
-  const { rowActions, translate, dispatcher, nav, refetch, openDrawer, defaultEditRowAction } =
-    options;
+  const {
+    rowActions,
+    translate,
+    dispatcher,
+    nav,
+    refetch,
+    openDrawer,
+    defaultEditRowAction,
+    host,
+  } = options;
   const effectiveActions = mergeDefaultEditAction(rowActions, defaultEditRowAction);
   if (effectiveActions.length === 0) return undefined;
   const out: DataTableRowAction[] = [];
   for (const action of effectiveActions) {
     if (action.kind === "navigate") {
-      out.push(buildNavigateRowAction(action, translate, nav));
+      out.push(buildNavigateRowAction(action, translate, nav, host));
       continue;
     }
     if (action.kind === "drawer") {
       if (openDrawer === undefined) {
-        warnDrawerActionDropped(action.id);
+        warnDrawerActionDropped("rowAction", action.id);
         continue;
       }
       out.push(buildDrawerRowAction(action, translate, openDrawer));
@@ -314,3 +335,141 @@ export function buildProjectionRowActions(options: {
   }
   return out.length > 0 ? out : undefined;
 }
+
+type OpenToolbarDrawer = (action: ToolbarAction & { readonly kind: "drawer" }) => void;
+
+function buildNavigateToolbarAction(
+  action: RelatedListToolbarAction & { readonly kind: "navigate" },
+  translate: Translate,
+  nav: NavApi,
+  host: ReturnHost | undefined,
+  prefill: Readonly<Record<string, unknown>> | undefined,
+  record: Readonly<Record<string, unknown>> | undefined,
+): ToolbarActionButton {
+  const actionIcon = resolveActionIcon(action.id);
+  const target: ScreenTarget = { screenId: action.screen };
+  return {
+    id: action.id,
+    label: translate(action.label),
+    ...(action.style !== undefined && { style: action.style }),
+    confirmRequired: false,
+    ...(actionIcon !== undefined && { icon: actionIcon }),
+    onTrigger: () => {
+      // A declared `params` extractor (evaluated against the relatedList's
+      // parent record) replaces the caller's implicit prefill (e.g. a
+      // relatedList's `{ [parentParam]: parentId }` or, with `parentFilter`
+      // set, `{ [parentFilter.field]: parentId }`) rather than merging
+      // with it — same "params present → drop the default" rule as
+      // rowActions.
+      const resolvedParams =
+        action.params !== undefined && record !== undefined
+          ? evalRowExtractor(action.params, record)
+          : prefill;
+      const params = resolvedParams !== undefined ? stringifyNavParams(resolvedParams) : undefined;
+      navigateWithReturnTo(nav, target, host, params);
+    },
+  };
+}
+
+function buildDrawerToolbarAction(
+  action: ToolbarAction & { readonly kind: "drawer" },
+  translate: Translate,
+  openDrawer: OpenToolbarDrawer,
+): ToolbarActionButton {
+  const actionIcon = resolveActionIcon(action.id);
+  return {
+    id: action.id,
+    label: translate(action.label),
+    ...(action.style !== undefined && { style: action.style }),
+    confirmRequired: false,
+    ...(actionIcon !== undefined && { icon: actionIcon }),
+    onTrigger: () => openDrawer(action),
+  };
+}
+
+function buildWriteHandlerToolbarAction(
+  action: ToolbarAction & { readonly kind: "writeHandler" },
+  translate: Translate,
+  refetch: () => Promise<unknown>,
+  dispatcher: Dispatcher,
+): ToolbarActionButton {
+  const actionIcon = resolveActionIcon(action.id);
+  return {
+    id: action.id,
+    label: translate(action.label),
+    ...(action.style !== undefined && { style: action.style }),
+    ...(actionIcon !== undefined && { icon: actionIcon }),
+    ...(action.confirm !== undefined && { confirm: translate(action.confirm) }),
+    ...(action.confirmLabel !== undefined && {
+      confirmLabel: translate(action.confirmLabel),
+    }),
+    onTrigger: async () => {
+      const result = await dispatcher.write(action.handler, action.payload ?? {});
+      if (!result.isSuccess) {
+        throw new WriteFailedError(result.error, dispatcherErrorText(result.error, translate));
+      }
+      await refetchAfterWrite(refetch);
+    },
+  };
+}
+
+// Shared by entityList, projectionList, and relatedList toolbars so the
+// three call sites can't drift apart.
+export function buildProjectionToolbarActions(options: {
+  readonly toolbarActions: readonly RelatedListToolbarAction[] | undefined;
+  readonly translate: Translate;
+  readonly dispatcher: Dispatcher | undefined;
+  readonly nav: NavApi;
+  readonly refetch: () => Promise<unknown>;
+  /** Omitted callers drop drawer-kind toolbar actions and get a dev warning,
+   *  mirroring the rowActions behavior above. */
+  readonly openDrawer?: OpenToolbarDrawer;
+  /** Search params set on the target after a navigate-kind action, e.g. a
+   *  relatedList's parent id for create-form prefill. */
+  readonly navigatePrefill?: Readonly<Record<string, unknown>>;
+  /** The relatedList's parent record — only a relatedList caller has one.
+   *  Enables `visible`/`params` (RelatedListToolbarAction), evaluated
+   *  against it exactly like header actions/RowAction.visible. Plain
+   *  entityList/projectionList toolbars have no record and omit this. */
+  readonly record?: Readonly<Record<string, unknown>>;
+  readonly host: ReturnHost | undefined;
+}): readonly ToolbarActionButton[] | undefined {
+  const {
+    toolbarActions,
+    translate,
+    dispatcher,
+    nav,
+    refetch,
+    openDrawer,
+    navigatePrefill,
+    record,
+    host,
+  } = options;
+  if (toolbarActions === undefined) return undefined;
+  const out: ToolbarActionButton[] = [];
+  for (const action of toolbarActions) {
+    if (
+      action.visible !== undefined &&
+      record !== undefined &&
+      !evalFieldCondition(action.visible, record)
+    ) {
+      continue;
+    }
+    if (action.kind === "navigate") {
+      out.push(buildNavigateToolbarAction(action, translate, nav, host, navigatePrefill, record));
+      continue;
+    }
+    if (action.kind === "drawer") {
+      if (openDrawer === undefined) {
+        warnDrawerActionDropped("toolbarAction", action.id);
+        continue;
+      }
+      out.push(buildDrawerToolbarAction(action, translate, openDrawer));
+      continue;
+    }
+    // writeHandler — skip without a dispatcher instead of crashing (same as rowActions).
+    if (dispatcher === undefined) continue;
+    out.push(buildWriteHandlerToolbarAction(action, translate, refetch, dispatcher));
+  }
+  return out.length > 0 ? out : undefined;
+}

package/src/app/secret-mint-body.tsx

@@ -14,6 +14,7 @@ import { buildInitialValues, mergeSearchParamsIntoInitial } from "./kumiko-scree
 import { layoutFieldNames } from "./layout-fields";
 import { useInitialValuesHandoff, useNav } from "./nav";
 import { lastSegment } from "./qn";
+import { useReturnTarget } from "./return-to";
 
 export type SecretMintBodyProps = {
   readonly schema: FeatureSchema;
@@ -57,6 +58,7 @@ function isBlank(value: unknown): boolean {
 // that gets rendered, never in the confirm form's own values.
 export function SecretMintBody({ schema, screen, translate }: SecretMintBodyProps): ReactNode {
   const nav = useNav();
+  const returnTarget = useReturnTarget(screen.id);
   const { Card, Heading, Banner, Button, Text, Grid, GridCell, SecretReveal } = usePrimitives();
   const t = useTranslation();
   const effectiveTranslate = translate ?? t;
@@ -112,8 +114,8 @@ export function SecretMintBody({ schema, screen, translate }: SecretMintBodyProp
   const handleCancel = useMemo<(() => void) | undefined>(() => {
     const target = screen.cancelTarget ?? screen.redirect;
     if (target === undefined || target === false) return undefined;
-    return () => nav.navigate({ screenId: lastSegment(target) });
-  }, [nav, screen.redirect, screen.cancelTarget]);
+    return () => nav.navigate(returnTarget ?? { screenId: lastSegment(target) });
+  }, [nav, screen.redirect, screen.cancelTarget, returnTarget]);
 
   // Ends the reveal phase for both paths (the bare acknowledge button, and a
   // successful confirm submit): clears the secret and the carried values, then
@@ -124,11 +126,11 @@ export function SecretMintBody({ schema, screen, translate }: SecretMintBodyProp
     setRevealed(null);
     carriedRef.current = {};
     if (screen.redirect !== undefined) {
-      nav.navigate({ screenId: lastSegment(screen.redirect) });
+      nav.navigate(returnTarget ?? { screenId: lastSegment(screen.redirect) });
     } else {
       setDone(true);
     }
-  }, [nav, screen.redirect]);
+  }, [nav, screen.redirect, returnTarget]);
 
   const handleConfirmSubmitted = useCallback(
     (result: SubmitResult<unknown>) => {