@cosmicdrift/kumiko-renderer 0.384.0 → 0.385.0

package/dist/app/screen-shared.js

@@ -0,0 +1,325 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { parseRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
+import { propertyOf } from "@cosmicdrift/kumiko-types/type-guards";
+import { useCallback, useEffect, useMemo } from "react";
+import { extractIdField } from "../components/reference-create-dialog.js";
+import { rendererWarn } from "../dev-console.js";
+import { applyFormatSpec } from "../headless/index.js";
+import { REFERENCE_LIST_LOOKUP_LIMIT } from "../hooks/reference-limits.js";
+import { PAGE_SIZE_OPTIONS } from "../hooks/use-list-url-state.js";
+import { referenceLookupSource } from "../hooks/use-reference-lookup.js";
+import { useTranslation } from "../i18n.js";
+import { usePrimitives } from "../primitives.js";
+import { ISO_DATE_PATTERN, isMoneyValue } from "./entity-edit-prefill.js";
+import { useNav } from "./nav.js";
+import { lastSegment, toKebab } from "./qn.js";
+import { featureNameFromQualifiedScreenId } from "./qualify-screen-id.js";
+import { navigateToReturn, navigateWithReturnTo, useReturnHost } from "./return-to.js";
+function ScreenMissingHomeButton({ homeScreenId, testId, }) {
+    const { Button } = usePrimitives();
+    const t = useTranslation();
+    const nav = useNav();
+    return (_jsx(Button, { variant: "secondary", onClick: () => nav.navigate({ screenId: homeScreenId }), testId: testId, children: t("kumiko.screen-missing.home") }));
+}
+/** Empty state for a screen QN that is not in the schema (feature disabled for
+ *  the tenant, stale link, miswired screen). The QN only goes to the console. */
+export function ScreenMissingState({ screenQn, homeScreenId, testId = "kumiko-screen-not-found", }) {
+    const { Card, Text } = usePrimitives();
+    const t = useTranslation();
+    useEffect(() => {
+        rendererWarn(`[kumiko] screen "${screenQn}" is not in the schema (feature disabled, stale link or miswired screen).`);
+    }, [screenQn]);
+    return (_jsx(Card, { options: { padded: true }, slots: {
+            title: _jsx(Text, { testId: `${testId}-title`, children: t("kumiko.screen-missing.title") }),
+            subtitle: _jsx(Text, { variant: "muted", children: t("kumiko.screen-missing.hint") }),
+        }, testId: testId, children: homeScreenId !== undefined ? (_jsx(ScreenMissingHomeButton, { homeScreenId: homeScreenId, testId: `${testId}-home` })) : null }));
+}
+export function ScreenAccessDeniedBanner({ screenQn, testId, }) {
+    const { Banner } = usePrimitives();
+    const t = useTranslation();
+    useEffect(() => {
+        rendererWarn(`[kumiko] access to screen "${screenQn}" denied for the current roles.`);
+    }, [screenQn]);
+    return (_jsx(Banner, { padded: true, variant: "error", testId: testId, children: t("kumiko.screen-access-denied.title") }));
+}
+// ---- entity-edit ----
+// Derives `<feature>:write:<entity>:<verb>` from the screen's entity
+// and the schema's feature name. Matches qualifyEntityName / toKebab in
+// packages/framework/src/engine/qualified-name.ts so camelCase entity
+// ids (e.g. driverModel) resolve to server QNs (driver-model:create).
+export function entityWriteCommand(featureName, entity, verb) {
+    return `${toKebab(featureName)}:write:${toKebab(entity)}:${verb}`;
+}
+// Default "success -> back to the list" navigation. Finds the first
+// entityList screen for the entity and navigates there. Create, update and
+// delete all use it: each of them ends with "done editing, leave" as the
+// sensible default.
+export function findEntityListScreen(schema, entityName) {
+    return schema.screens.find((s) => s.type === "entityList" && s.entity === entityName);
+}
+// Unknown or deleted record id: a localized empty state with a way back
+// instead of a bare error banner. Composed from shared primitives so web and
+// native render it alike.
+export function RecordNotFoundState({ translate, onBack, }) {
+    const { Card, Text, Button } = usePrimitives();
+    return (_jsxs(Card, { options: { padded: true }, testId: "kumiko-screen-record-missing", children: [_jsx(Text, { testId: "kumiko-screen-record-missing-title", children: translate("kumiko.record.not-found.title") }), _jsx(Text, { variant: "muted", children: translate("kumiko.record.not-found.hint") }), onBack !== undefined && (_jsx(Button, { variant: "secondary", onClick: onBack, testId: "kumiko-screen-record-missing-back", children: translate("kumiko.record.not-found.back") }))] }));
+}
+export function useNavigateToListAfter(schema, entityName) {
+    const nav = useNav();
+    return useCallback(() => {
+        const list = findEntityListScreen(schema, entityName);
+        if (!list)
+            return;
+        // schema.screens.id is in QN form (registry-stamped); nav.navigate
+        // expects the short form. Otherwise the URL ends up double-qualified.
+        nav.navigate({ screenId: lastSegment(list.id) });
+    }, [nav, schema, entityName]);
+}
+// Default "+ New" navigation for the list toolbar: finds the first
+// entityEdit screen without an entityId attachment and navigates there.
+// Returns undefined when no edit screen is registered, so RenderList
+// renders no "+ New" button.
+//
+// Schema screens come from the registry with qualified ids
+// ("publicstatus:screen:component-edit"); lastSegment strips the prefix
+// for nav.navigate (see ./qn.ts).
+export function pageSizeOptionsFor(currentLimit) {
+    return PAGE_SIZE_OPTIONS.includes(currentLimit)
+        ? PAGE_SIZE_OPTIONS
+        : [...PAGE_SIZE_OPTIONS, currentLimit].sort((a, b) => a - b);
+}
+export function useNavigateToCreateFor(schema, entityName, createScreen, createUnavailable) {
+    const nav = useNav();
+    const host = useReturnHost();
+    const editScreenId = useMemo(() => {
+        if (createScreen !== undefined)
+            return createScreen;
+        // The role may not open the declared create target; falling back to the
+        // entity's edit form would bypass the flow the app prescribes (e.g. a wizard).
+        if (createUnavailable === true)
+            return undefined;
+        // allowCreate:false = update-only edit screen (create runs through a
+        // lifecycle write), so it is not a "+ New" target. singleton:true opens
+        // the existing record without an entityId (EntityEditSingletonBody)
+        // instead of an empty create form, so it does not count for the same reason.
+        const edit = schema.screens.find((s) => s.type === "entityEdit" &&
+            s.entity === entityName &&
+            s.allowCreate !== false &&
+            s.singleton !== true);
+        return edit !== undefined ? lastSegment(edit.id) : undefined;
+    }, [schema.screens, entityName, createScreen, createUnavailable]);
+    const navigate = useCallback(() => {
+        if (editScreenId !== undefined)
+            navigateWithReturnTo(nav, { screenId: editScreenId }, host);
+    }, [nav, editScreenId, host]);
+    return editScreenId !== undefined ? navigate : undefined;
+}
+function formatSummaryValue(value, locale) {
+    if (isMoneyValue(value)) {
+        return new Intl.NumberFormat(locale, { style: "currency", currency: value.currency }).format(value.amount);
+    }
+    if (typeof value === "number")
+        return applyFormatSpec({ format: "number", locale }, value);
+    if (typeof value === "string" && ISO_DATE_PATTERN.test(value)) {
+        return applyFormatSpec({ format: "date", locale }, value);
+    }
+    return value === null || value === undefined ? "" : String(value);
+}
+export function formatSummaryParams(prefill, locale) {
+    return Object.fromEntries(Object.entries(prefill ?? {}).map(([name, value]) => [name, formatSummaryValue(value, locale)]));
+}
+// Placeholders of `successMessage`: formatted submitted values, with a
+// reference field resolved to the chosen record's label. A lookup that fails or
+// misses the row (the lookup list is capped) falls back to the raw id.
+export async function resolveSuccessMessageParams(screen, featureName, values, dispatcher, locale) {
+    const params = formatSummaryParams(values, locale);
+    await Promise.all(Object.entries(screen.fields).map(async ([name, def]) => {
+        const raw = values[name];
+        if (def.type !== "reference" || typeof raw !== "string" || raw === "")
+            return;
+        const target = parseRefTarget(def.entity, featureName);
+        const { queryQn, labelKey } = referenceLookupSource(target.featureName, target.entityName, def.labelField ?? "id");
+        const lookup = await dispatcher.query(queryQn, { limit: REFERENCE_LIST_LOOKUP_LIMIT });
+        if (!lookup.isSuccess)
+            return;
+        const row = lookup.data.rows.find((candidate) => candidate["id"] === raw);
+        const label = row?.[labelKey];
+        if (label !== undefined && label !== null)
+            params[name] = String(label);
+    }));
+    return params;
+}
+export function resolveActionFormSummary(summary, prefill, translate, locale) {
+    if (summary === undefined)
+        return undefined;
+    const params = formatSummaryParams(prefill, locale);
+    return {
+        title: translate(summary.title, params),
+        ...(summary.subtitle !== undefined && { subtitle: translate(summary.subtitle, params) }),
+    };
+}
+// ---- entity-list ----
+export function entityQueryCommand(featureName, entity, verb) {
+    return `${toKebab(featureName)}:query:${toKebab(entity)}:${verb}`;
+}
+// Payload for the server-side list query handler (LIST_PAYLOAD_SCHEMA):
+// search/sort/sortDirection/limit + offset/totalCount for pager mode OR
+// cursor for infinite scroll. Shared by EntityListBody and
+// ProjectionListBody so the two branches can't drift on this shape
+// (fw#2165) — entity-only additions (screen.filter, faceted filters) are
+// layered on top by the caller instead of living in here.
+export function buildListQueryPayload(state) {
+    const payload = { limit: state.limit };
+    if (state.search !== "")
+        payload["search"] = state.search;
+    if (state.sort !== null) {
+        payload["sort"] = state.sort.field;
+        payload["sortDirection"] = state.sort.dir;
+    }
+    if (state.usePager) {
+        // page=1 → offset=0, page=2 → offset=limit, etc. Server clamps itself
+        // when offset >= total.
+        const offset = (state.page - 1) * state.limit;
+        if (offset > 0)
+            payload["offset"] = offset;
+        // totalCount: extra COUNT(*) so the pager can render "Page X of Y".
+        payload["totalCount"] = true;
+    }
+    else if (state.useInfinite && state.cursor !== undefined) {
+        payload["cursor"] = state.cursor;
+    }
+    return payload;
+}
+export function redirectScreenTarget(redirect) {
+    return typeof redirect === "string" ? redirect : redirect.screen;
+}
+// Same-entity detection for navigate defaults: only an entityEdit screen of the
+// SAME entity may receive the current record's id (it opens in UPDATE mode, which
+// is what the boot validator assumes). Searched across all features.
+export function isEntityEditScreenOfEntity(entity, targetScreen, schema, appFeatures) {
+    if (entity === undefined)
+        return false;
+    return [schema, ...appFeatures].some((feature) => feature.screens.some((s) => s.type === "entityEdit" && s.entity === entity && lastSegment(s.id) === targetScreen));
+}
+// Record-scoped targets (actionForm, secretMint) take the shown record's id; an
+// entityEdit of ANOTHER entity must not, or it would open that entity's UPDATE
+// mode on the wrong id instead of create.
+export function isEntityEditScreenOfOtherEntity(entity, targetScreen, schema, appFeatures) {
+    return [schema, ...appFeatures].some((feature) => feature.screens.some((s) => s.type === "entityEdit" && s.entity !== entity && lastSegment(s.id) === targetScreen));
+}
+// A qualified redirect names its feature, so the search space is THAT feature
+// only — the current schema's own screens must not shadow it with a same
+// short-id screen of another type. An unqualified redirect searches this
+// schema first (own screen wins), then every mounted feature. A named feature
+// that isn't mounted (no provider / isolated test) falls back to this schema.
+function findRedirectTargetScreen(redirect, schema, appFeatures) {
+    const redirectScreen = redirectScreenTarget(redirect);
+    const targetId = lastSegment(redirectScreen);
+    const targetFeatureName = featureNameFromQualifiedScreenId(redirectScreen);
+    const targetFeature = targetFeatureName !== undefined
+        ? appFeatures.find((f) => f.featureName === targetFeatureName)
+        : undefined;
+    const searchSpace = targetFeature !== undefined
+        ? targetFeature.screens
+        : targetFeatureName === undefined
+            ? [...schema.screens, ...appFeatures.flatMap((f) => f.screens)]
+            : schema.screens;
+    return searchSpace.find((s) => lastSegment(s.id) === targetId);
+}
+// A redirect to a record screen ("show the result") is a deliberate forward
+// navigation and keeps precedence over returnTo.
+function redirectTargetsRecord(redirect, schema, appFeatures) {
+    const target = findRedirectTargetScreen(redirect, schema, appFeatures);
+    return (target !== undefined && (target.type === "entityEdit" || target.type === "projectionDetail"));
+}
+// Type-guard form narrows `returnTarget` for the caller's subsequent
+// navigateToReturn(nav, returnTarget) call.
+export function returnToWinsOverRedirect(returnTarget, redirect, schema, appFeatures) {
+    return returnTarget !== undefined && !redirectTargetsRecord(redirect, schema, appFeatures);
+}
+// 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.
+// `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, or the create path's just-submitted
+// form values — both of which carry fields (e.g. a parent FK) the CRUD
+// write executor's success payload doesn't flatly expose.
+export function resolveRedirectTarget(redirect, submittedData, schema, appFeatures, fallbackRecord) {
+    const redirectScreen = redirectScreenTarget(redirect);
+    const idField = typeof redirect === "string" ? "id" : (redirect.idFrom ?? "id");
+    const targetId = lastSegment(redirectScreen);
+    const target = findRedirectTargetScreen(redirect, schema, appFeatures);
+    const carriesId = target !== undefined && (target.type === "entityEdit" || target.type === "projectionDetail");
+    if (!carriesId)
+        return { screenId: targetId, entityId: undefined, tab: undefined };
+    const entityId = extractIdField(submittedData, idField) ??
+        (fallbackRecord !== undefined ? extractIdField(fallbackRecord, idField) : undefined);
+    return {
+        screenId: targetId,
+        entityId,
+        tab: typeof redirect === "string" ? undefined : redirect.tab,
+    };
+}
+export function navigateToRedirectTarget(nav, target) {
+    const navTarget = {
+        screenId: target.screenId,
+        ...(target.entityId !== undefined && { entityId: target.entityId }),
+    };
+    if (target.tab === undefined)
+        nav.navigate(navTarget);
+    else
+        nav.navigate(navTarget, { searchParams: { tab: target.tab } });
+}
+// Links of the success box. Targets resolve like `redirect`; a link whose target
+// needs a record id (entityEdit, projectionDetail) but whose payload field holds
+// no string id is dropped instead of navigating to an id-less record screen.
+// A link without idFrom to a non-record screen always navigates id-less.
+export function resolveSuccessLinks(links, data, schema, appFeatures, nav, translate) {
+    const resolved = [];
+    (links ?? []).forEach((link, index) => {
+        const target = resolveRedirectTarget(link, data, schema, appFeatures);
+        if (target.entityId === undefined && redirectTargetsRecord(link, schema, appFeatures))
+            return;
+        const navTarget = {
+            screenId: target.screenId,
+            ...(target.entityId !== undefined && { entityId: target.entityId }),
+        };
+        const options = target.tab === undefined ? undefined : { searchParams: { tab: target.tab } };
+        resolved.push({
+            key: String(index),
+            label: translate(link.label),
+            href: nav.hrefFor(navTarget, options),
+            onPress: () => nav.navigate(navTarget, options),
+        });
+    });
+    return resolved;
+}
+// Success navigation for a configured redirect — shared by entityEdit's
+// save and writeHandler record actions. The string form navigates without an
+// entityId; the object form resolves like actionForm's, with `record` as the
+// fallback id source.
+export function navigateAfterRedirect(options) {
+    const { nav, schema, appFeatures, returnTarget, redirect, resultData, record } = options;
+    if (returnToWinsOverRedirect(returnTarget, redirect, schema, appFeatures)) {
+        navigateToReturn(nav, returnTarget);
+        return;
+    }
+    if (typeof redirect === "string") {
+        nav.navigate({ screenId: lastSegment(redirect) });
+        return;
+    }
+    navigateToRedirectTarget(nav, resolveRedirectTarget(redirect, resultData, schema, appFeatures, record));
+}
+// The update payload nests the saved projection under `data`; a changed
+// parent FK lives there, not in the pre-edit `record`.
+export function overlayUpdatedProjection(record, resultData) {
+    if (typeof resultData !== "object" || resultData === null)
+        return record;
+    const projection = propertyOf(resultData, "data");
+    if (typeof projection !== "object" || projection === null)
+        return record;
+    return { ...record, ...projection };
+}

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

@@ -2,10 +2,11 @@ import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-run
 import { propertyOf } from "@cosmicdrift/kumiko-types/type-guards";
 import { useCallback, useMemo, useRef, useState } from "react";
 import { RenderEdit } from "../components/render-edit.js";
+import { rendererError } from "../dev-console.js";
 import { useTranslation } from "../i18n.js";
 import { usePrimitives } from "../primitives.js";
 import { synthesizeActionFormEntity, synthesizeActionFormScreen, synthesizeSecretMintConfirmScreen, } from "./action-form-shim.js";
-import { buildInitialValues, mergeSearchParamsIntoInitial, tenantCurrencyMoneyFieldNames, useMoneyCurrencyOverrides, } from "./kumiko-screen.js";
+import { buildInitialValues, mergeSearchParamsIntoInitial, tenantCurrencyMoneyFieldNames, useMoneyCurrencyOverrides, } from "./entity-edit-prefill.js";
 import { hiddenRequiredFieldsFilled, layoutFieldNames } from "./layout-fields.js";
 import { useInitialValuesHandoff, useNav } from "./nav.js";
 import { lastSegment } from "./qn.js";
@@ -104,8 +105,7 @@ export function SecretMintBody({ schema, screen, translate }) {
             values[revealField.field] = value;
         }
         if (Object.values(values).every(isBlank)) {
-            // biome-ignore lint/suspicious/noConsole: the user-facing banner carries no detail; this names the screen and fields for the developer
-            console.error(`secretMint "${screen.id}": write result carried no value for reveal fields [${screen.reveal.fields
+            rendererError(`secretMint "${screen.id}": write result carried no value for reveal fields [${screen.reveal.fields
                 .map((revealField) => revealField.field)
                 .join(", ")}]`);
             setRevealMissing(true);

package/dist/components/edit-mounts.d.ts

@@ -0,0 +1,33 @@
+import type { PlatformComponent } from "@cosmicdrift/kumiko-framework/ui-types";
+import { type ReactNode } from "react";
+import type { EditExtensionSectionViewModel } from "../headless/index.ts";
+import { type StickyPrimaryActionMarker } from "../primitives.tsx";
+export declare function ExtensionSectionMount({ section, entityName: hostEntityName, entityId, initialValues, values, patch, validate, markSaved, hideTitle, actions, stepKey, onReportStepComplete, }: {
+    readonly section: EditExtensionSectionViewModel;
+    readonly entityName: string;
+    readonly entityId: string | null;
+    readonly initialValues?: Readonly<Record<string, unknown>>;
+    readonly values?: Readonly<Record<string, unknown>>;
+    readonly patch?: (partial: Readonly<Record<string, unknown>>) => void;
+    readonly validate?: () => boolean;
+    readonly markSaved?: () => void;
+    readonly hideTitle?: boolean;
+    /** section.actions, already resolved into buttons by the caller. */
+    readonly actions?: ReactNode;
+    readonly stepKey?: string;
+    readonly onReportStepComplete?: (stepKey: string, complete: boolean) => void;
+}): ReactNode;
+export declare function EditSlotMount({ slot, slotName, screenId, entityName, entityId, values, markSaved, hasUnsavedChanges, wizardStep, }: {
+    readonly slot: PlatformComponent;
+    readonly slotName: "header" | "titleAction" | "footer";
+    readonly screenId: string;
+    readonly entityName: string;
+    readonly entityId: string | null;
+    readonly values: Readonly<Record<string, unknown>>;
+    readonly markSaved?: () => void;
+    readonly hasUnsavedChanges?: boolean;
+    readonly wizardStep?: {
+        readonly index: number;
+        readonly isLast: boolean;
+    };
+} & StickyPrimaryActionMarker): ReactNode;

package/dist/components/edit-mounts.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect } from "react";
+import { extensionSectionName, useExtensionSectionComponent } from "../app/extension-sections.js";
+import { rendererWarn } from "../dev-console.js";
+import { usePrimitives } from "../primitives.js";
+// Resolves an extension-section's `{ react: { __component: "X" } }` marker
+// to a registered React component via ExtensionSectionsProvider (filled in
+// createKumikoApp from clientFeatures.extensionSectionComponents) and
+// mounts it with the host entity name + id. Hook lives in its own
+// component so we don't call `use*` inside vm.sections.map (rules-of-
+// hooks would punish reordering sections between renders).
+export function ExtensionSectionMount({ section, entityName: hostEntityName, entityId, initialValues, values, patch, validate, markSaved, hideTitle, actions, stepKey, onReportStepComplete, }) {
+    const { Banner, FillContainer, Section, Text } = usePrimitives();
+    const name = extensionSectionName(section.component);
+    const Component = useExtensionSectionComponent(name);
+    const reportStepComplete = useCallback((complete) => {
+        if (stepKey !== undefined)
+            onReportStepComplete?.(stepKey, complete);
+    }, [stepKey, onReportStepComplete]);
+    const testId = `section-extension-${section.title}`;
+    if (Component === undefined) {
+        const placeholder = (_jsx(Banner, { variant: "info", testId: `section-extension-placeholder-${section.title}`, children: _jsxs(Text, { children: ["Extension section component ", _jsx(Text, { variant: "code", children: name ?? "(no __component name)" }), " ", "not registered in clientFeatures.extensionSectionComponents."] }) }));
+        // Tabs mode already frames this in the caller's own Card — a Section
+        // here would add a second, unwanted divider inset (px-6 py-4) on top of
+        // the Card's own padding, misaligning this tab's content against the
+        // fields tab (Grid sits directly in the Card there). FillContainer keeps
+        // the testId without adding chrome (same primitive RelatedListSection
+        // uses for its own hideTitle branch).
+        return hideTitle === true ? (FillContainer !== undefined ? (_jsx(FillContainer, { testId: testId, children: placeholder })) : (placeholder)) : (_jsx(Section, { title: section.title, testId: testId, children: placeholder }, section.title));
+    }
+    const mounted = (_jsx(Component, { entityName: section.entityName ?? hostEntityName, entityId: entityId, initialValues: initialValues, values: values, patch: patch, validate: validate, markSaved: markSaved, ...(onReportStepComplete !== undefined && { reportStepComplete }) }));
+    // Same reasoning as the placeholder branch above: tabs mode's outer Card
+    // is the only frame this content gets, no nested Section divider.
+    return hideTitle === true ? (FillContainer !== undefined ? (_jsx(FillContainer, { testId: testId, children: mounted })) : (mounted)) : (_jsx(Section, { ...(actions !== undefined && { actions }), title: section.title, testId: testId, children: mounted }));
+}
+// 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).
+export function EditSlotMount({ slot, slotName, screenId, entityName, entityId, values, markSaved, hasUnsavedChanges, wizardStep, }) {
+    const name = extensionSectionName(slot);
+    const Component = useExtensionSectionComponent(name);
+    useEffect(() => {
+        if (name !== undefined && Component === undefined) {
+            rendererWarn(`[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 (_jsx(Component, { entityName: entityName, entityId: entityId, values: values, ...(markSaved !== undefined && { markSaved }), ...(hasUnsavedChanges !== undefined && { hasUnsavedChanges }), ...(wizardStep !== undefined && { wizardStep }) }));
+}

package/dist/components/error-boundary.js

@@ -1,5 +1,6 @@
 import { ERROR_BOUNDARY_LOG_MARKER } from "@cosmicdrift/kumiko-types/error-boundary";
 import { Component } from "react";
+import { rendererError } from "../dev-console.js";
 import { createErrorId } from "./error-id.js";
 function toError(thrown) {
     return thrown instanceof Error ? thrown : new Error(String(thrown));
@@ -22,8 +23,7 @@ export class ErrorBoundary extends Component {
         }
     }
     logCaught(error, detail) {
-        // biome-ignore lint/suspicious/noConsole: the client has no logger and the boundary must not swallow the error; the e2e fixture detects boundary failures via this exact console.error line
-        console.error(`[kumiko] ${this.props.scope} ${ERROR_BOUNDARY_LOG_MARKER}:`, error, detail);
+        rendererError(`[kumiko] ${this.props.scope} ${ERROR_BOUNDARY_LOG_MARKER}:`, error, detail);
     }
     reset = () => {
         this.setState({ caught: undefined });

package/dist/components/reference-create-dialog.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { propertyOf } from "@cosmicdrift/kumiko-types/type-guards";
 import { useMemo } from "react";
-import { buildInitialValues, tenantCurrencyMoneyFieldNames, useMoneyCurrencyOverrides, } from "../app/kumiko-screen.js";
+import { buildInitialValues, tenantCurrencyMoneyFieldNames, useMoneyCurrencyOverrides, } from "../app/entity-edit-prefill.js";
 import { toKebab } from "../app/qn.js";
 import { useTranslation } from "../i18n.js";
 import { usePrimitives } from "../primitives.js";

package/dist/components/related-list-section.js

@@ -13,6 +13,7 @@ import { findEditScreenFor } from "../app/screen-access.js";
 import { dispatcherErrorText } from "../app/write-failed-error.js";
 import { useOptionalDispatcher } from "../context/dispatcher-context.js";
 import { useUserRoles } from "../context/user-roles-context.js";
+import { rendererWarn } from "../dev-console.js";
 import { useQuery } from "../hooks/use-query.js";
 import { useOptionalLocale, useTranslation } from "../i18n.js";
 import { PageHeaderSlotAvailableProvider } from "../page-header-slot.js";
@@ -46,8 +47,7 @@ function synthesizeRelatedListEntity(columns, sourceEntity) {
 // onOpenDrawer wired is dropped (not rendered) with a dev warning, same as a
 // drawer-kind rowAction/toolbarAction without one.
 function warnRelatedListEmptyStateDrawerDropped(actionId) {
-    // biome-ignore lint/suspicious/noConsole: dev-time warning, same pattern as row-actions.ts
-    console.warn(`[kumiko] relatedList emptyState.action "${actionId}" is kind: "drawer" but no onOpenDrawer was supplied — dropped.`);
+    rendererWarn(`[kumiko] relatedList emptyState.action "${actionId}" is kind: "drawer" but no onOpenDrawer was supplied — dropped.`);
 }
 function buildRowGrouping(groupBy, translate, locale) {
     return {

package/dist/components/render-edit-helpers.d.ts

@@ -0,0 +1,29 @@
+import type { EntityEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type * as z from "zod";
+import type { EditSectionViewModel, FieldConditions, FormValues, Translate } from "../headless/index.ts";
+import { relevantFieldIssues, zodErrorToFieldIssues } from "../headless/index.ts";
+export declare function tabIdAt(section: EditSectionViewModel | undefined, index: number): string;
+export declare function deriveFormFields<TValues extends FormValues, TCtx>(screen: EntityEditScreenDefinition): Record<string, FieldConditions<TValues, TCtx>>;
+type FieldsSectionViewModel = Extract<EditSectionViewModel, {
+    readonly kind: "fields";
+}>;
+type DryRunSnapshot = {
+    readonly values: unknown;
+    readonly fields: Readonly<Record<string, {
+        readonly visible: boolean;
+    }>>;
+};
+type DryRunParse = {
+    readonly issues: ReturnType<typeof zodErrorToFieldIssues>;
+    readonly hiddenFields: ReadonlySet<string>;
+};
+export declare function dryRunParse(schema: z.ZodType, snapshot: DryRunSnapshot): DryRunParse | undefined;
+export declare function dryRunFieldIssues(schema: z.ZodType, snapshot: DryRunSnapshot, scope: readonly string[] | undefined, includeRoot: boolean): ReturnType<typeof relevantFieldIssues>;
+export declare function wizardStepKey(section: EditSectionViewModel, index: number): string;
+export declare function isFieldsStepFilled(section: FieldsSectionViewModel, parse: DryRunParse | undefined): boolean;
+export type FormErrorSource = "submit" | "delete";
+export declare function formSectionDomId(sectionIndex: number): string;
+/** A record title is a non-blank string; anything else leaves the screen title alone. */
+export declare function resolveRecordTitle(value: unknown): string | undefined;
+export declare function resolveTitleTemplate(template: string | undefined, values: FormValues, translate: Translate, fallback: string): string;
+export {};

package/dist/components/render-edit-helpers.js

@@ -0,0 +1,121 @@
+import { evalFieldCondition, isFieldsEditSection, normalizeEditField, sectionFieldSpecs, } from "@cosmicdrift/kumiko-framework/ui-types";
+import { relevantFieldIssues, zodErrorToFieldIssues } from "../headless/index.js";
+// End-to-end renderer for an entityEdit screen. Renders exclusively
+// through primitives, no raw HTML. A native renderer that fills the same
+// primitives registry gets the form without further changes.
+function toConditionValue(cond) {
+    if (typeof cond === "boolean")
+        return cond;
+    // @cast-boundary form-values: TValues is structurally a record.
+    return (values) => evalFieldCondition(cond, values);
+}
+// Tab-strip key. The boot-validator makes `id` mandatory on a tabs layout and
+// entityEdit only ever has "fields"/"extension" sections (relatedList and
+// writeForm are rejected outright), so the positional fallback is unreachable
+// for a tabs screen — it only keeps this total for other layouts.
+export function tabIdAt(section, index) {
+    const declared = section?.kind === "fields" || section?.kind === "extension" ? section.id : undefined;
+    return declared ?? `section-${index}`;
+}
+export function deriveFormFields(screen) {
+    const out = {};
+    for (const section of screen.layout.sections) {
+        // relatedList carries no `fields` for the form-condition map either.
+        if (!isFieldsEditSection(section))
+            continue;
+        for (const spec of sectionFieldSpecs(section)) {
+            const normalized = normalizeEditField(spec);
+            out[normalized.field] = {
+                ...(normalized.visible !== undefined && {
+                    visible: toConditionValue(normalized.visible),
+                }),
+                ...(normalized.readOnly !== undefined && {
+                    readonly: toConditionValue(normalized.readOnly),
+                }),
+                ...(normalized.required !== undefined && {
+                    required: toConditionValue(normalized.required),
+                }),
+            };
+        }
+    }
+    return out;
+}
+// Dry-run parse against `schema` — NOT controller.validate(), which writes
+// field errors into the snapshot. Undefined when the values parse cleanly.
+// Parse once, then narrow per scope with scopedDryRunIssues: the wizard step
+// check would otherwise re-parse the whole form per section on every keystroke.
+export function dryRunParse(schema, snapshot) {
+    const parsed = schema.safeParse(snapshot.values);
+    if (parsed.success)
+        return undefined;
+    const hiddenFields = new Set(Object.entries(snapshot.fields)
+        .filter(([, state]) => !state.visible)
+        .map(([fieldKey]) => fieldKey));
+    return { issues: zodErrorToFieldIssues(parsed.error), hiddenFields };
+}
+// Issues are filtered exactly like the controller's validate(): hidden
+// fields never count, `scope` narrows.
+function scopedDryRunIssues(parse, scope, includeRoot) {
+    if (parse === undefined)
+        return [];
+    return relevantFieldIssues(parse.issues, {
+        hiddenFields: parse.hiddenFields,
+        ...(scope !== undefined && { scope }),
+        includeRoot,
+    });
+}
+export function dryRunFieldIssues(schema, snapshot, scope, includeRoot) {
+    return scopedDryRunIssues(dryRunParse(schema, snapshot), scope, includeRoot);
+}
+// Index-independent: indices shift when a fields section hides.
+export function wizardStepKey(section, index) {
+    const declaredId = section.kind === "fields" || section.kind === "extension" ? section.id : undefined;
+    return declaredId ?? section.title ?? `step-${index}`;
+}
+function isMoneyValue(value) {
+    return typeof value === "object" && value !== null && "amount" in value;
+}
+// The seeds buildInitialValues writes for NULL columns of an existing record.
+function isEmptyFormValue(value) {
+    if (value === null || value === undefined || value === "" || value === 0 || value === false) {
+        return true;
+    }
+    if (Array.isArray(value))
+        return value.length === 0;
+    return isMoneyValue(value) && value.amount === 0;
+}
+// select/boolean are excluded from the "holds user data" check: they are
+// often pre-filled (defaults, server-set values), so they say nothing about
+// whether the step was filled in. They still count through the validation.
+export function isFieldsStepFilled(section, parse) {
+    const fieldNames = section.fields.map((f) => f.field);
+    if (scopedDryRunIssues(parse, fieldNames, false).length > 0)
+        return false;
+    return section.fields.some((f) => f.visible &&
+        !f.readOnly &&
+        f.type !== "boolean" &&
+        f.type !== "select" &&
+        !isEmptyFormValue(f.value));
+}
+export function formSectionDomId(sectionIndex) {
+    return `form-section-${sectionIndex}`;
+}
+/** A record title is a non-blank string; anything else leaves the screen title alone. */
+export function resolveRecordTitle(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+const TITLE_PLACEHOLDER_PATTERN = /\{(\w+)\}/g;
+// Falls back to the plain title while any placeholder value is still empty,
+// so the header never shows "Add  " mid-typing.
+export function resolveTitleTemplate(template, values, translate, fallback) {
+    if (template === undefined)
+        return fallback;
+    const placeholders = [...translate(template).matchAll(TITLE_PLACEHOLDER_PATTERN)].map((match) => match[1] ?? "");
+    const isFilled = (name) => {
+        const value = values[name];
+        return value !== undefined && value !== null && String(value).trim() !== "";
+    };
+    if (!placeholders.every(isFilled))
+        return fallback;
+    return translate(template, values);
+}

package/dist/components/render-edit.d.ts

@@ -1,8 +1,5 @@
+import { type ReactNode } from "react";
 import type { FormValues } from "../headless/index.ts";
 import type { RenderEditProps } from "./render-edit-types.ts";
 export type { RenderEditAction, RenderEditChangeState, RenderEditControls, RenderEditProps, } from "./render-edit-types.ts";
-import { type ReactNode } from "react";
-export declare const PATCH_DRAFT_SAVE_DEBOUNCE_MS = 500;
-/** A record title is a non-blank string; anything else leaves the screen title alone. */
-export declare function resolveRecordTitle(value: unknown): string | undefined;
 export declare function RenderEdit<TValues extends FormValues, TCtx = unknown>(props: RenderEditProps<TValues, TCtx>): ReactNode;