@cosmicdrift/kumiko-renderer 0.328.0 → 0.328.1

package/dist/app/row-actions.js

@@ -0,0 +1,416 @@
+import { evalFieldCondition } from "@cosmicdrift/kumiko-framework/ui-types";
+import { resolveActionIcon } from "@cosmicdrift/kumiko-types/action-icon";
+import { lastSegment } from "./qn.js";
+import { navigateWithReturnTo } from "./return-to.js";
+import { dispatcherErrorText, WriteFailedError } from "./write-failed-error.js";
+// 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, idColumn = "id") {
+    if (editScreen === undefined)
+        return undefined;
+    return {
+        kind: "navigate",
+        id: "edit",
+        label: "kumiko.actions.edit",
+        screen: lastSegment(editScreen.id),
+        entityId: idColumn,
+    };
+}
+export function evalRowExtractor(extractor, row) {
+    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]]));
+}
+export function isWriteHandlerRowAction(action) {
+    return action.kind === "writeHandler" || action.kind === undefined;
+}
+function isPlainObject(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+export function stringifyNavParams(params) {
+    const out = {};
+    for (const [k, v] of Object.entries(params)) {
+        // Structured field values such as money `{amount, currency}` must survive
+        // the URL round-trip as JSON; Date & other class instances stay String().
+        out[k] =
+            v === null || v === undefined
+                ? null
+                : Array.isArray(v) || isPlainObject(v)
+                    ? JSON.stringify(v)
+                    : String(v);
+    }
+    return out;
+}
+export function navigateActionSearchParams(action, values) {
+    const params = action.params !== undefined
+        ? stringifyNavParams(evalRowExtractor(action.params, values))
+        : undefined;
+    if (action.tab === undefined)
+        return params;
+    return { ...params, tab: action.tab };
+}
+export async function refetchAfterWrite(refetch) {
+    await refetch().catch((err) => {
+        // biome-ignore lint/suspicious/noConsole: refetch must not poison the write-action error path
+        console.error("kumiko-screen: refetch after write action failed", err);
+    });
+}
+// Navigate execution for query-driven rows (projectionList, and relatedList
+// — both have no guaranteed "id" field, unlike entityList's rows which back
+// a real entity). No same-entity row["id"] fallback (see EntityListBody's
+// own runNavigate for that variant, which stays separate — entityList's
+// fallback needs `screen.entity`, which neither projectionList nor
+// relatedList has).
+export function runProjectionRowNavigate(nav, action, row, host) {
+    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;
+        const params = navigateActionSearchParams(action, row.values);
+        navigateWithReturnTo(nav, { entity: action.entity, id }, host, params);
+    }
+    else if (action.screen !== undefined) {
+        const entityId = action.entityId !== undefined ? String(row.values[action.entityId] ?? "") : undefined;
+        const target = {
+            screenId: action.screen,
+            ...(entityId !== undefined && entityId !== "" && { entityId }),
+        };
+        const params = navigateActionSearchParams(action, row.values);
+        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, translate, nav, host) {
+    const { visible } = action;
+    const actionIcon = resolveActionIcon(action.id, action.icon);
+    return {
+        id: action.id,
+        label: translate(action.label),
+        ...(action.style !== undefined && { style: action.style }),
+        confirmRequired: false,
+        ...(action.rowClick === true && { rowClick: true }),
+        ...(actionIcon !== undefined && { icon: actionIcon }),
+        onTrigger: (row) => runProjectionRowNavigate(nav, action, row, host),
+        ...(visible !== undefined && {
+            isVisible: (row) => evalFieldCondition(visible, row.values),
+        }),
+    };
+}
+// 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();
+/** @internal test-only */
+export function resetDrawerActionWarningsForTests() {
+    warnedDrawerActionIds.clear();
+}
+function warnDrawerActionDropped(actionKind, actionId) {
+    const key = `${actionKind}:${actionId}`;
+    // skip: already warned for this id — suppresses the repeat, not the warning itself.
+    if (warnedDrawerActionIds.has(key))
+        return;
+    warnedDrawerActionIds.add(key);
+    // biome-ignore lint/suspicious/noConsole: dev-warning for a setup error
+    console.warn(`[kumiko] ${actionKind} "${actionId}" is kind:"drawer", but the host did not wire openDrawer (RelatedListSection: pass onOpenDrawer) — it will not render.`);
+}
+function buildDrawerRowAction(action, translate, openDrawer) {
+    const { visible, params } = action;
+    const actionIcon = resolveActionIcon(action.id, action.icon);
+    return {
+        id: action.id,
+        label: translate(action.label),
+        ...(action.style !== undefined && { style: action.style }),
+        confirmRequired: false,
+        ...(actionIcon !== undefined && { icon: actionIcon }),
+        onTrigger: (row) => {
+            openDrawer(action, params !== undefined ? evalRowExtractor(params, row.values) : undefined);
+        },
+        ...(visible !== undefined && {
+            isVisible: (row) => evalFieldCondition(visible, row.values),
+        }),
+    };
+}
+// Prepends defaultEditRowAction unless a declared action already claims id
+// "edit" — declared wins.
+function mergeDefaultEditAction(rowActions, defaultEditRowAction) {
+    const declaredHasEdit = rowActions?.some((a) => a.id === "edit") === true;
+    return defaultEditRowAction !== undefined && !declaredHasEdit
+        ? [defaultEditRowAction, ...(rowActions ?? [])]
+        : (rowActions ?? []);
+}
+function buildWriteHandlerRowAction(action, translate, refetch, dispatcher) {
+    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) => {
+            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) => 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
+// Dispatcher and refetches `refetch` on success. Single implementation so
+// projectionList's rowActions and a projectionDetail relatedList section's
+// rowActions can't drift apart (fw editable-detail-screens).
+export function buildProjectionRowActions(options) {
+    const { rowActions, translate, dispatcher, nav, refetch, openDrawer, defaultEditRowAction, host, } = options;
+    const effectiveActions = mergeDefaultEditAction(rowActions, defaultEditRowAction);
+    if (effectiveActions.length === 0)
+        return undefined;
+    const out = [];
+    for (const action of effectiveActions) {
+        if (action.kind === "navigate") {
+            out.push(buildNavigateRowAction(action, translate, nav, host));
+            continue;
+        }
+        if (action.kind === "drawer") {
+            if (openDrawer === undefined) {
+                warnDrawerActionDropped("rowAction", action.id);
+                continue;
+            }
+            out.push(buildDrawerRowAction(action, translate, openDrawer));
+            continue;
+        }
+        // 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;
+        out.push(buildWriteHandlerRowAction(action, translate, refetch, dispatcher));
+    }
+    return out.length > 0 ? out : undefined;
+}
+function buildNavigateToolbarAction(action, translate, nav, host, prefill, record) {
+    const actionIcon = resolveActionIcon(action.id);
+    const target = { 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 stringifiedParams = resolvedParams !== undefined ? stringifyNavParams(resolvedParams) : undefined;
+            const params = action.tab === undefined ? stringifiedParams : { ...stringifiedParams, tab: action.tab };
+            navigateWithReturnTo(nav, target, host, params);
+        },
+    };
+}
+function buildDrawerToolbarAction(action, translate, openDrawer) {
+    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, translate, refetch, dispatcher) {
+    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) {
+    const { toolbarActions, translate, dispatcher, nav, refetch, openDrawer, navigatePrefill, record, host, } = options;
+    if (toolbarActions === undefined)
+        return undefined;
+    const out = [];
+    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;
+}
+function buildNavigateRecordAction(action, options) {
+    const { record, translate, nav, host, actionIcon, defaultScreenTargetEntityId, sameEntityScreenId, } = options;
+    if (action.entity !== undefined) {
+        const targetEntity = action.entity;
+        const id = action.entityId !== undefined ? String(record[action.entityId] ?? "") : "";
+        return {
+            id: action.id,
+            label: translate(action.label),
+            ...(action.style !== undefined && { style: action.style }),
+            confirmRequired: false,
+            ...(actionIcon !== undefined && { icon: actionIcon }),
+            onPress: () => {
+                // No entityId on record (id === "") → nothing to navigate to.
+                if (id !== "") {
+                    const params = navigateActionSearchParams(action, record);
+                    navigateWithReturnTo(nav, { entity: targetEntity, id }, host, params);
+                }
+            },
+        };
+    }
+    if (action.screen !== undefined) {
+        const explicit = action.entityId !== undefined ? String(record[action.entityId] ?? "") : undefined;
+        const fallback = sameEntityScreenId?.(action.screen) ?? defaultScreenTargetEntityId;
+        const navEntityId = explicit ?? fallback;
+        const targetScreen = action.screen;
+        return {
+            id: action.id,
+            label: translate(action.label),
+            ...(action.style !== undefined && { style: action.style }),
+            confirmRequired: false,
+            ...(actionIcon !== undefined && { icon: actionIcon }),
+            onPress: () => {
+                const target = {
+                    screenId: targetScreen,
+                    ...(navEntityId !== undefined && navEntityId !== "" && { entityId: navEntityId }),
+                };
+                const params = navigateActionSearchParams(action, record);
+                navigateWithReturnTo(nav, target, host, params);
+            },
+        };
+    }
+    return undefined;
+}
+function buildDrawerRecordAction(action, options) {
+    const { record, translate, actionIcon, openDrawer } = options;
+    return {
+        id: action.id,
+        label: translate(action.label),
+        ...(action.style !== undefined && { style: action.style }),
+        confirmRequired: false,
+        ...(actionIcon !== undefined && { icon: actionIcon }),
+        onPress: () => {
+            const initialValues = action.params !== undefined ? evalRowExtractor(action.params, record) : undefined;
+            openDrawer(action, initialValues);
+        },
+    };
+}
+function buildWriteHandlerRecordAction(action, options) {
+    const { record, translate, actionIcon, dispatcher, onWriteSuccess } = options;
+    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),
+        }),
+        onPress: async () => {
+            const payload = action.payload !== undefined
+                ? evalRowExtractor(action.payload, record)
+                : { id: record["id"] };
+            const result = await dispatcher.write(action.handler, payload);
+            if (!result.isSuccess) {
+                throw new WriteFailedError(result.error, dispatcherErrorText(result.error, translate));
+            }
+            await onWriteSuccess();
+        },
+    };
+}
+// Shared builder for a RowAction[] evaluated against one "record"
+// context (not a specific list row) — a head card's `screen.actions`, an
+// entityEdit's own `screen.actions`, and any section-level
+// `actions`/`emptyState.action` are all this same shape: a RowAction
+// resolved against the record currently being viewed/edited, independent of
+// any table row.
+export function buildRecordActions(options) {
+    const { actions, record, translate, nav, host, dispatcher, openDrawer, onWriteSuccess, defaultScreenTargetEntityId, sameEntityScreenId, } = options;
+    const out = [];
+    for (const action of actions) {
+        if (action.visible !== undefined && !evalFieldCondition(action.visible, record))
+            continue;
+        const actionIcon = resolveActionIcon(action.id, action.icon);
+        if (action.kind === "navigate") {
+            const built = buildNavigateRecordAction(action, {
+                record,
+                translate,
+                nav,
+                host,
+                actionIcon,
+                defaultScreenTargetEntityId,
+                sameEntityScreenId,
+            });
+            if (built !== undefined)
+                out.push(built);
+            continue;
+        }
+        if (action.kind === "drawer") {
+            out.push(buildDrawerRecordAction(action, { record, translate, actionIcon, openDrawer }));
+            continue;
+        }
+        // writeHandler — skip without a dispatcher instead of crashing.
+        if (dispatcher === undefined)
+            continue;
+        out.push(buildWriteHandlerRecordAction(action, {
+            record,
+            translate,
+            actionIcon,
+            dispatcher,
+            onWriteSuccess,
+        }));
+    }
+    return out.length > 0 ? out : undefined;
+}

package/dist/app/screen-access.d.ts

@@ -0,0 +1,8 @@
+import type { EntityEditScreenDefinition, FeatureSchema } from "@cosmicdrift/kumiko-framework/ui-types";
+import { isUiAccessGranted } from "@cosmicdrift/kumiko-framework/ui-types";
+export { isUiAccessGranted as screenAccessAllows };
+export declare function navigateTargetAllows(navigate: {
+    readonly screen?: string;
+    readonly entity?: string;
+}, appFeatures: readonly FeatureSchema[], userRoles: readonly string[] | undefined): boolean;
+export declare function findEditScreenFor(entity: string, appFeatures: readonly FeatureSchema[], userRoles: readonly string[] | undefined): EntityEditScreenDefinition | undefined;

package/dist/app/screen-access.js

@@ -0,0 +1,48 @@
+import { isUiAccessGranted } from "@cosmicdrift/kumiko-framework/ui-types";
+import { lastSegment } from "./qn.js";
+// Shared UI-visibility predicate for the screen-render path (#1203 — nav
+// filtering via filterByAccess in workspace-shell.tsx hid role-gated
+// screens from the menu, but a direct URL/screenQn hit reached
+// KumikoScreen unchecked). Public name kept as an alias of the shared
+// predicate that headless/nav and workspace-shell use as well.
+export { isUiAccessGranted as screenAccessAllows };
+// A navigate target (metric click) declares no access rule of its own — the
+// destination screen already does, so the jump is offered exactly when the
+// user may open where it lands (solon#424). No second copy of the rule to
+// drift from the screen's own.
+export function navigateTargetAllows(navigate, appFeatures, userRoles) {
+    const { screen, entity } = navigate;
+    // Neither set — stays on the current screen (tab switch), already allowed.
+    if (screen === undefined && entity === undefined)
+        return true;
+    // KumikoScreen rendered outside createKumikoApp has no screen registry to
+    // resolve against; gating on an empty one would hide every jump, not the
+    // forbidden ones.
+    if (appFeatures.length === 0)
+        return true;
+    for (const feature of appFeatures) {
+        for (const candidate of feature.screens) {
+            const isTarget = entity !== undefined
+                ? candidate.detailFor === entity
+                : lastSegment(candidate.id) === screen;
+            // First match IS the destination: short ids are globally unique
+            // (validateScreenShortIdCollisions) and both the router and
+            // resolveTarget take the first hit.
+            if (isTarget)
+                return isUiAccessGranted(candidate.access, userRoles);
+        }
+    }
+    // Unresolvable target — the boot-validator doesn't check metric navigate
+    // targets, so this is a typo'd dead jump. Don't offer it.
+    return false;
+}
+// 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, appFeatures, userRoles) {
+    for (const feature of appFeatures) {
+        const match = feature.screens.find((s) => s.type === "entityEdit" && s.entity === entity && isUiAccessGranted(s.access, userRoles));
+        if (match !== undefined)
+            return match;
+    }
+    return undefined;
+}

package/dist/app/secret-mint-body.d.ts

@@ -0,0 +1,10 @@
+import type { SecretMintScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { Translate } from "@cosmicdrift/kumiko-headless";
+import { type ReactNode } from "react";
+import type { FeatureSchema } from "./feature-schema.js";
+export type SecretMintBodyProps = {
+    readonly schema: FeatureSchema;
+    readonly screen: SecretMintScreenDefinition;
+    readonly translate?: Translate;
+};
+export declare function SecretMintBody({ schema, screen, translate }: SecretMintBodyProps): ReactNode;

package/dist/app/secret-mint-body.js

@@ -0,0 +1,140 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useMemo, useRef, useState } from "react";
+import { RenderEdit } from "../components/render-edit.js";
+import { useTranslation } from "../i18n.js";
+import { usePrimitives } from "../primitives.js";
+import { synthesizeActionFormEntity, synthesizeActionFormScreen, synthesizeSecretMintConfirmScreen, } from "./action-form-shim.js";
+import { buildInitialValues, literalCurrencyOverrides, mergeSearchParamsIntoInitial, } from "./kumiko-screen.js";
+import { layoutFieldNames } from "./layout-fields.js";
+import { useInitialValuesHandoff, useNav } from "./nav.js";
+import { lastSegment } from "./qn.js";
+import { navigateToReturnOr, useReturnTarget } from "./return-to.js";
+function extractRevealValue(data, field) {
+    if (typeof data !== "object" || data === null)
+        return undefined;
+    if (!Object.hasOwn(data, field))
+        return undefined;
+    return data[field];
+}
+function extractCarriedValues(data, carry) {
+    const carried = {};
+    for (const field of carry) {
+        const value = extractRevealValue(data, field);
+        if (value === undefined)
+            continue;
+        carried[field] = value;
+    }
+    return carried;
+}
+function isBlank(value) {
+    if (value === undefined || value === null || value === "")
+        return true;
+    return Array.isArray(value) && value.length === 0;
+}
+// Mint form → one-time reveal → optional confirm → done. The revealed values
+// live ONLY in this component's `revealed` state — never in the URL, a query
+// cache, or nav — the write-handler's success payload is the only place the
+// secret ever exists (fw#2548). onSubmit copies exclusively the fields
+// declared in `screen.reveal.fields` out of that payload (a whitelist, never
+// the payload as a whole) so an unrelated field (e.g. an internal "id") can
+// never leak into the reveal. `screen.confirm` (fw#2838, e.g. TOTP enroll:
+// scan the code, then enter one) works the same way for its own carried
+// mint-payload fields — those live only in `carriedRef`, never in React state
+// that gets rendered, never in the confirm form's own values.
+export function SecretMintBody({ schema, screen, translate }) {
+    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;
+    const synthEntity = useMemo(() => synthesizeActionFormEntity(screen.fields), [screen.fields]);
+    const synthScreen = useMemo(() => synthesizeActionFormScreen(screen), [screen]);
+    const handoffValues = useInitialValuesHandoff(screen.id);
+    const initial = useMemo(() => mergeSearchParamsIntoInitial(screen.fields, {
+        searchParams: nav.searchParams,
+        urlPrefillFields: screen.urlPrefillFields,
+        renderableFields: layoutFieldNames(synthScreen),
+        // A mint form has no entity either, so its money fields name their own
+        // currency source (fw#2839). Only the literal form is resolved here:
+        // `{ kind: "tenant" }` would need the config query this screen never
+        // runs, and a one-time secret mint has no money use case to justify it.
+        moneyCurrencyOverrides: literalCurrencyOverrides(screen.fields),
+        ...(handoffValues !== undefined && { handoffValues }),
+    }), [screen.fields, screen.urlPrefillFields, nav.searchParams, synthScreen, handoffValues]);
+    const [revealed, setRevealed] = useState(null);
+    const [done, setDone] = useState(false);
+    // Never rendered, never merged into `revealed` or the confirm form's
+    // initial values — read only from `buildPayload` at confirm-submit time.
+    const carriedRef = useRef({});
+    const confirm = screen.confirm;
+    const confirmEntity = useMemo(() => (confirm !== undefined ? synthesizeActionFormEntity(confirm.fields) : undefined), [confirm]);
+    const confirmScreen = useMemo(() => (confirm !== undefined ? synthesizeSecretMintConfirmScreen(screen, confirm) : undefined), [screen, confirm]);
+    const confirmInitial = useMemo(() => confirm !== undefined
+        ? buildInitialValues(confirm.fields, undefined, literalCurrencyOverrides(confirm.fields))
+        : undefined, [confirm]);
+    const handleSubmitted = useCallback((result) => {
+        if (!result.isSuccess)
+            return;
+        const values = {};
+        for (const revealField of screen.reveal.fields) {
+            const value = extractRevealValue(result.data, revealField.field);
+            if (value === undefined)
+                continue;
+            values[revealField.field] = value;
+        }
+        setRevealed(values);
+        carriedRef.current =
+            confirm?.carry !== undefined ? extractCarriedValues(result.data, confirm.carry) : {};
+    }, [screen.reveal.fields, confirm?.carry]);
+    const handleCancel = useMemo(() => {
+        const target = screen.cancelTarget ?? screen.redirect;
+        if (target === undefined || target === false)
+            return undefined;
+        return () => navigateToReturnOr(nav, returnTarget, () => nav.navigate({ 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
+    // either navigates (screen.redirect) or shows a done-state — never falls
+    // back to re-rendering the mint form, which would let a stray click mint
+    // (and invalidate) the secret again.
+    const finishMint = useCallback(() => {
+        setRevealed(null);
+        carriedRef.current = {};
+        const redirect = screen.redirect;
+        if (redirect !== undefined) {
+            navigateToReturnOr(nav, returnTarget, () => nav.navigate({ screenId: lastSegment(redirect) }));
+        }
+        else {
+            setDone(true);
+        }
+    }, [nav, screen.redirect, returnTarget]);
+    const handleConfirmSubmitted = useCallback((result) => {
+        if (result.isSuccess)
+            finishMint();
+    }, [finishMint]);
+    if (done) {
+        return (_jsx(Card, { children: _jsx(Banner, { variant: "info", testId: "kumiko-screen-secret-mint-done", children: effectiveTranslate(confirm?.doneMessage ?? "kumiko.secretMint.done") }) }));
+    }
+    if (revealed !== null) {
+        const values = screen.reveal.fields.flatMap((revealField) => {
+            const raw = revealed[revealField.field];
+            if (isBlank(raw))
+                return [];
+            const display = revealField.display ?? "code";
+            const value = display === "list" && Array.isArray(raw)
+                ? raw.map((v) => String(v)).join("\n")
+                : String(raw);
+            return [
+                {
+                    label: effectiveTranslate(revealField.label),
+                    value,
+                    copyable: revealField.copyable ?? true,
+                    multiline: display === "list",
+                    ...(display === "qr" && { qr: true }),
+                },
+            ];
+        });
+        return (_jsxs(Card, { testId: "kumiko-screen-secret-mint-card", children: [_jsx(Heading, { variant: "page", children: effectiveTranslate(screen.reveal.title ?? "kumiko.secretMint.title") }), _jsx(Banner, { variant: "warning", testId: "kumiko-screen-secret-mint-warning", children: effectiveTranslate(screen.reveal.warning ?? "kumiko.secretMint.warning") }), SecretReveal !== undefined ? (_jsx(SecretReveal, { values: values, copyLabel: effectiveTranslate("kumiko.secretMint.copy"), copiedLabel: effectiveTranslate("kumiko.secretMint.copied"), testId: "kumiko-screen-secret-mint-reveal" })) : (_jsx(Grid, { columns: 1, testId: "kumiko-screen-secret-mint-reveal", children: values.map((v) => (_jsxs(GridCell, { children: [_jsx(Text, { children: v.label }), _jsx(Text, { variant: "code", children: v.value })] }, v.label))) })), confirm !== undefined && confirmEntity !== undefined && confirmScreen !== undefined ? (_jsx(RenderEdit, { screen: confirmScreen, entity: confirmEntity, featureName: schema.featureName, initial: confirmInitial ?? {}, writeCommand: confirm.handler, payloadMode: "values", buildPayload: (snapshot) => ({ ...snapshot.values, ...carriedRef.current }), onSubmit: handleConfirmSubmitted, ...(handleCancel !== undefined && { onCancel: handleCancel }), ...(translate !== undefined && { translate }), ...(confirm.submitLabel !== undefined && { submitLabel: confirm.submitLabel }) })) : (_jsx(Button, { type: "button", variant: "primary", onClick: finishMint, testId: "kumiko-screen-secret-mint-confirm", children: effectiveTranslate(screen.reveal.confirmLabel ?? "kumiko.secretMint.confirm") }))] }));
+    }
+    return (_jsx(RenderEdit, { screen: synthScreen, entity: synthEntity, featureName: schema.featureName, initial: initial, extensionInitialValues: initial, writeCommand: screen.handler, payloadMode: "values", onSubmit: handleSubmitted, ...(handleCancel !== undefined && { onCancel: handleCancel }), ...(translate !== undefined && { translate }), ...(screen.submitLabel !== undefined && { submitLabel: screen.submitLabel }) }));
+}

package/dist/app/secrets-edit-body.d.ts

@@ -0,0 +1,8 @@
+import type { SecretsEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { Translate } from "@cosmicdrift/kumiko-headless";
+import { type ReactNode } from "react";
+export type SecretsEditBodyProps = {
+    readonly screen: SecretsEditScreenDefinition;
+    readonly translate?: Translate;
+};
+export declare function SecretsEditBody({ screen, translate }: SecretsEditBodyProps): ReactNode;