@cosmicdrift/kumiko-renderer 0.192.0 → 0.193.0

package/package.json

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

package/src/app/__tests__/entity-edit-jsonb-embedded-submit.test.tsx

@@ -0,0 +1,239 @@
+// Finding: render-field-unsupported-types.test.tsx only proves jsonb/embedded
+// (no embeddedListCells) fields render read-only (Banner, no Input wired up).
+// It never proves the actual claim that matters: saving the form after
+// editing an UNRELATED field does not corrupt or overwrite those fields'
+// real data. Because RenderField never wires an onChange for them, their
+// value in the form controller stays reference-identical to the record it
+// was seeded from — the update payload's `changes` diff (reference-equality
+// based, see form-controller.ts valuesDiff) must therefore omit them
+// entirely, never re-include them as e.g. a stringified copy.
+//
+// This renders the real update path (KumikoScreen → EntityEditScreen →
+// EntityEditUpdateBody → RenderEdit → RenderField) under a stub dispatcher
+// and inspects the actual write() payload, not just the render tree.
+
+import { describe, expect, test } from "bun:test";
+import type {
+  EntityDefinition,
+  EntityEditScreenDefinition,
+} from "@cosmicdrift/kumiko-framework/ui-types";
+import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
+import { act, render, waitFor } from "@testing-library/react";
+import type { ComponentType, FormEvent, ReactNode } from "react";
+import { DispatcherProvider } from "../../context/dispatcher-context";
+import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
+import { kumikoDefaultTranslations } from "../../i18n-defaults";
+import {
+  type CorePrimitives,
+  type FormProps,
+  type InputProps,
+  PrimitivesProvider,
+} from "../../primitives";
+import type { FeatureSchema } from "../feature-schema";
+import { KumikoScreen } from "../kumiko-screen";
+import { NavProvider } from "../nav";
+
+const capturedInputs: Record<string, InputProps | undefined> = {};
+const captureInput: ComponentType<InputProps> = (props) => {
+  capturedInputs[props.name] = props;
+  return null;
+};
+let capturedFormSubmit: ((e?: FormEvent) => void) | undefined;
+const captureForm: ComponentType<FormProps> = (props) => {
+  capturedFormSubmit = props.onSubmit;
+  return <>{props.children}</>;
+};
+const noop = (): ReactNode => null;
+const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
+
+const testPrimitives: CorePrimitives = {
+  Button: noop,
+  Banner: passChildren,
+  Field: passChildren,
+  Input: captureInput,
+  DataTable: noop,
+  Form: captureForm,
+  Section: passChildren,
+  Card: passChildren,
+  Grid: passChildren,
+  GridCell: passChildren,
+  Text: passChildren,
+  Heading: noop,
+  Dialog: noop,
+  Modal: noop,
+  Lightbox: noop,
+  ConfigSourceBadge: noop,
+  ConfigCascadeView: noop,
+  Link: noop,
+};
+
+let lastWrite: { type: string; payload: unknown } | undefined;
+
+// The annotation resets TS's flow-narrowing, which only tracks the
+// straight-line `lastWrite = undefined` reset, not the reassignment inside the dispatcher closure.
+function requireLastWrite(): { type: string; payload: unknown } {
+  const write: { type: string; payload: unknown } | undefined = lastWrite;
+  if (!write) throw new Error("expected a write() call");
+  return write;
+}
+
+function stubDispatcher(record: Readonly<Record<string, unknown>>): Dispatcher {
+  return {
+    write: (async (type: string, payload: unknown) => {
+      lastWrite = { type, payload };
+      return { isSuccess: true, data: {} };
+    }) as unknown as Dispatcher["write"],
+    query: (async () => ({ isSuccess: true, data: record })) as unknown as Dispatcher["query"],
+    batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
+    statusStore: {
+      getState: () => "online",
+      subscribe: () => () => {},
+    } as unknown as Dispatcher["statusStore"],
+    async *stream() {},
+    pendingWrites: () => [],
+    pendingFiles: () => [],
+  };
+}
+
+function buildSchema(): FeatureSchema {
+  const entity: EntityDefinition = {
+    fields: {
+      name: { type: "text", maxLength: 200, required: false, searchable: false, sortable: false },
+      extra: { type: "jsonb" },
+      meta: {
+        type: "embedded",
+        schema: { note: { type: "text" } },
+      },
+    },
+  };
+  const screen: EntityEditScreenDefinition = {
+    id: "widget-edit",
+    type: "entityEdit",
+    entity: "widget",
+    layout: { sections: [{ columns: 1, fields: ["name", "extra", "meta"] }] },
+  };
+  return {
+    featureName: "widgets",
+    entities: { widget: entity },
+    screens: [screen],
+  } as FeatureSchema;
+}
+
+describe("EntityEditUpdateForm — untouched jsonb/embedded fields survive submit", () => {
+  test("changing an unrelated field and submitting keeps jsonb/embedded fields out of the diff (not stringified, not overwritten)", async () => {
+    lastWrite = undefined;
+    capturedFormSubmit = undefined;
+    for (const key of Object.keys(capturedInputs)) delete capturedInputs[key];
+
+    const record = {
+      id: "w1",
+      version: 3,
+      name: "Old name",
+      extra: { a: 1 },
+      meta: { note: "keep me" },
+    };
+
+    render(
+      <LocaleProvider
+        resolver={createStaticLocaleResolver({ locale: "de-DE" })}
+        fallbackBundles={[kumikoDefaultTranslations]}
+      >
+        <DispatcherProvider dispatcher={stubDispatcher(record)}>
+          <NavProvider
+            value={{
+              route: { screenId: "widgets:widget-edit" },
+              navigate: () => {},
+              replace: () => {},
+              hrefFor: () => "",
+              searchParams: {},
+              setSearchParams: () => {},
+            }}
+          >
+            <PrimitivesProvider value={testPrimitives}>
+              <KumikoScreen schema={buildSchema()} qn="widgets:screen:widget-edit" entityId="w1" />
+            </PrimitivesProvider>
+          </NavProvider>
+        </DispatcherProvider>
+      </LocaleProvider>,
+    );
+
+    await waitFor(() => {
+      expect(capturedInputs["name"]).toBeDefined();
+    });
+
+    const nameInput = capturedInputs["name"];
+    if (nameInput?.kind !== "text") throw new Error("expected a text input for the name field");
+    act(() => nameInput.onChange("New name"));
+
+    await waitFor(() => {
+      expect(capturedFormSubmit).toBeDefined();
+    });
+    act(() => capturedFormSubmit?.());
+
+    await waitFor(() => {
+      expect(lastWrite).toBeDefined();
+    });
+
+    const payload = requireLastWrite().payload as { changes: Record<string, unknown> };
+    expect(payload.changes["name"]).toBe("New name");
+    // The untouched jsonb/embedded fields must never resurface in the diff —
+    // if they did (the pre-fix bug this guards against), it would mean the
+    // update overwrites them, and the old code path could send a corrupted
+    // (e.g. stringified) copy instead of the real object.
+    expect(Object.hasOwn(payload.changes, "extra")).toBe(false);
+    expect(Object.hasOwn(payload.changes, "meta")).toBe(false);
+  });
+
+  test("touching the jsonb field itself keeps it a real object in the diff, never a string", async () => {
+    lastWrite = undefined;
+    capturedFormSubmit = undefined;
+    for (const key of Object.keys(capturedInputs)) delete capturedInputs[key];
+
+    const record = {
+      id: "w1",
+      version: 3,
+      name: "Old name",
+      extra: { a: 1 },
+      meta: { note: "keep me" },
+    };
+
+    render(
+      <LocaleProvider
+        resolver={createStaticLocaleResolver({ locale: "de-DE" })}
+        fallbackBundles={[kumikoDefaultTranslations]}
+      >
+        <DispatcherProvider dispatcher={stubDispatcher(record)}>
+          <NavProvider
+            value={{
+              route: { screenId: "widgets:widget-edit" },
+              navigate: () => {},
+              replace: () => {},
+              hrefFor: () => "",
+              searchParams: {},
+              setSearchParams: () => {},
+            }}
+          >
+            <PrimitivesProvider value={testPrimitives}>
+              <KumikoScreen schema={buildSchema()} qn="widgets:screen:widget-edit" entityId="w1" />
+            </PrimitivesProvider>
+          </NavProvider>
+        </DispatcherProvider>
+      </LocaleProvider>,
+    );
+
+    await waitFor(() => {
+      expect(capturedFormSubmit).toBeDefined();
+    });
+    act(() => capturedFormSubmit?.());
+
+    await waitFor(() => {
+      expect(lastWrite).toBeDefined();
+    });
+
+    const payload = requireLastWrite().payload as { changes: Record<string, unknown> };
+    // Nothing was touched at all — the diff must be empty, and specifically
+    // must not contain a stringified copy of extra/meta.
+    expect(Object.hasOwn(payload.changes, "extra")).toBe(false);
+    expect(Object.hasOwn(payload.changes, "meta")).toBe(false);
+  });
+});

package/src/app/__tests__/entity-list-create-singleton.test.tsx

@@ -0,0 +1,128 @@
+// Guard-evasion-adjacent bug: useNavigateToCreateFor picked the first
+// entityEdit screen with allowCreate !== false as the "+ Neu" target,
+// without excluding singleton:true screens. A singleton screen opened
+// without an entityId resolves the existing record (EntityEditSingletonBody)
+// instead of a blank create form — so "+ Neu" silently opened a prefilled
+// update form. This test renders the real list path (KumikoScreen →
+// EntityListScreen → EntityListBody → RenderList) for an entity whose only
+// registered entityEdit screen is a singleton, and asserts no create button
+// renders — not just the hook in isolation.
+import { describe, expect, test } from "bun:test";
+import type {
+  EntityDefinition,
+  EntityEditScreenDefinition,
+  EntityListScreenDefinition,
+} from "@cosmicdrift/kumiko-framework/ui-types";
+import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
+import { render } from "@testing-library/react";
+import type { ComponentType, ReactNode } from "react";
+import { DispatcherProvider } from "../../context/dispatcher-context";
+import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
+import { type ButtonProps, type CorePrimitives, PrimitivesProvider } from "../../primitives";
+import type { FeatureSchema } from "../feature-schema";
+import { KumikoScreen } from "../kumiko-screen";
+import { NavProvider } from "../nav";
+
+const capturedButtonTestIds: string[] = [];
+const captureButton: ComponentType<ButtonProps> = (props) => {
+  if (props.testId !== undefined) capturedButtonTestIds.push(props.testId);
+  return null;
+};
+const noop = (): ReactNode => null;
+const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
+
+const testPrimitives: CorePrimitives = {
+  Button: captureButton,
+  Banner: passChildren,
+  Field: passChildren,
+  Input: noop,
+  DataTable: noop,
+  Form: passChildren,
+  Section: passChildren,
+  Card: passChildren,
+  Grid: passChildren,
+  GridCell: passChildren,
+  Text: passChildren,
+  Heading: noop,
+  Dialog: noop,
+  Modal: noop,
+  Lightbox: noop,
+  ConfigSourceBadge: noop,
+  ConfigCascadeView: noop,
+  Link: noop,
+};
+
+function stubDispatcher(): Dispatcher {
+  return {
+    write: (async () => ({ isSuccess: true, data: {} })) as unknown as Dispatcher["write"],
+    query: (async () => ({
+      isSuccess: true,
+      data: { rows: [], total: 0 },
+    })) as unknown as Dispatcher["query"],
+    batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
+    statusStore: {
+      getState: () => "online",
+      subscribe: () => () => {},
+    } as unknown as Dispatcher["statusStore"],
+    async *stream() {},
+    pendingWrites: () => [],
+    pendingFiles: () => [],
+  };
+}
+
+function buildSchema(): FeatureSchema {
+  const entity: EntityDefinition = {
+    fields: {
+      name: { type: "text", maxLength: 200, required: false, searchable: false, sortable: false },
+    },
+  };
+  const listScreen: EntityListScreenDefinition = {
+    id: "org-list",
+    type: "entityList",
+    entity: "org",
+    columns: ["name"],
+  };
+  // The only entityEdit screen for "org" is a singleton — there is
+  // deliberately no separate non-singleton entityEdit screen.
+  const editScreen: EntityEditScreenDefinition = {
+    id: "org-edit",
+    type: "entityEdit",
+    entity: "org",
+    singleton: true,
+    layout: { sections: [{ columns: 1, fields: ["name"] }] },
+  };
+  return {
+    featureName: "orgs",
+    entities: { org: entity },
+    screens: [listScreen, editScreen],
+  } as FeatureSchema;
+}
+
+describe("entityList '+ Neu' target excludes singleton entityEdit screens", () => {
+  test("no create button renders when the only entityEdit screen is singleton:true", () => {
+    capturedButtonTestIds.length = 0;
+    render(
+      <LocaleProvider resolver={createStaticLocaleResolver({ locale: "de-DE" })}>
+        <DispatcherProvider dispatcher={stubDispatcher()}>
+          <NavProvider
+            value={{
+              route: { screenId: "orgs:org-list" },
+              navigate: () => {},
+              replace: () => {},
+              hrefFor: () => "",
+              searchParams: {},
+              setSearchParams: () => {},
+            }}
+          >
+            <PrimitivesProvider value={testPrimitives}>
+              <KumikoScreen schema={buildSchema()} qn="orgs:screen:org-list" />
+            </PrimitivesProvider>
+          </NavProvider>
+        </DispatcherProvider>
+      </LocaleProvider>,
+    );
+
+    expect(capturedButtonTestIds).not.toContain("render-list-create");
+    expect(capturedButtonTestIds).not.toContain("render-list-empty-create");
+  });
+});

package/src/app/kumiko-screen.tsx

@@ -289,10 +289,15 @@ function useNavigateToCreateFor(
   const nav = useNav();
   const editScreenId = useMemo(() => {
     // allowCreate:false = update-only Edit-Screen (Create läuft über einen
-    // Lifecycle-Write) — der zählt nicht als „+ Neu"-Ziel.
+    // Lifecycle-Write) — der zählt nicht als „+ Neu"-Ziel. singleton:true
+    // öffnet ohne entityId den vorhandenen Record (EntityEditSingletonBody)
+    // statt eines leeren Create-Forms — zählt aus demselben Grund nicht.
     const edit = schema.screens.find(
       (s: ScreenDefinition) =>
-        s.type === "entityEdit" && s.entity === entityName && s.allowCreate !== false,
+        s.type === "entityEdit" &&
+        s.entity === entityName &&
+        s.allowCreate !== false &&
+        s.singleton !== true,
     );
     return edit !== undefined ? lastSegment(edit.id) : undefined;
   }, [schema.screens, entityName]);

package/src/components/__tests__/embedded-list-field.test.tsx

@@ -166,6 +166,68 @@ describe("EmbeddedListField — cell change recomputes derived", () => {
       { product: "p1", unit: "pcs", quantity: 2.5, unitPrice: 923, amount: 2308 },
     ]);
   });
+
+  // Regression: withRecomputedDerived used to read source values from
+  // `result` (mutated in-place during the loop), so a chained derived cell
+  // (gross depends on net, net depends on raw qty/price) got the FRESH net
+  // when "net" happened to iterate before "gross" in embeddedListDerived's
+  // key order, but the STALE pre-edit net otherwise — the client preview
+  // drifted from the server (withDerivedCells always reads the untouched
+  // source row) purely based on object-key order. Fixed by reading from a
+  // frozen `source` snapshot, same as the server. Two field configs with
+  // "net"/"gross" declared in opposite key order must therefore produce the
+  // identical, order-independent result.
+  test("chained derived cells (gross depends on net) recompute the same value regardless of the derived-map's key order", () => {
+    const cells: EditFieldViewModel["embeddedListCells"] = [
+      { field: "qty", label: "Qty", type: "number", required: true },
+      { field: "price", label: "Price", type: "number", required: true },
+      { field: "tax", label: "Tax", type: "number", required: true },
+      { field: "net", label: "Net", type: "number", required: false },
+      { field: "gross", label: "Gross", type: "number", required: false },
+    ];
+    // Pre-edit, already-settled row: net = 2*3 = 6, gross = 6+1 = 7.
+    const rows = [{ qty: 2, price: 3, tax: 1, net: 6, gross: 7 }];
+    // A fixed reference calculation for "qty changes from 2 to 4": net
+    // recomputes from the fresh raw inputs (qty=4, price=3) to 12; gross
+    // reads net from the row as it was BEFORE this edit (still 6, same as
+    // the server would), giving 6+1=7 — not 12+1=13.
+    const expected = { qty: 4, price: 3, tax: 1, net: 12, gross: 7 };
+
+    let netFirstResult: unknown;
+    renderEmbeddedListField(
+      {
+        ...invoiceLinesField({ value: rows }),
+        embeddedListCells: cells,
+        embeddedListDerived: {
+          net: { op: "multiply", from: ["qty", "price"] },
+          gross: { op: "sum", from: ["net", "tax"] },
+        },
+      },
+      (v) => {
+        netFirstResult = v;
+      },
+    );
+    captured?.onCellChange(0, "qty", 4);
+
+    let grossFirstResult: unknown;
+    renderEmbeddedListField(
+      {
+        ...invoiceLinesField({ value: rows }),
+        embeddedListCells: cells,
+        embeddedListDerived: {
+          gross: { op: "sum", from: ["net", "tax"] },
+          net: { op: "multiply", from: ["qty", "price"] },
+        },
+      },
+      (v) => {
+        grossFirstResult = v;
+      },
+    );
+    captured?.onCellChange(0, "qty", 4);
+
+    expect(netFirstResult).toEqual([expected]);
+    expect(grossFirstResult).toEqual([expected]);
+  });
 });
 
 describe("EmbeddedListField — row operations", () => {

package/src/components/embedded-list-field.tsx

@@ -33,10 +33,15 @@ function withRecomputedDerived(
   cells: readonly EmbeddedListCellViewModel[],
 ): EmbeddedRow {
   if (derived === undefined) return row;
+  // Read sources from an unchanged snapshot, never from `result` (which this
+  // loop mutates) — mirrors withDerivedCells server-side so chained derived
+  // cells (e.g. net=qty*price, then gross=sum(net,tax)) can't drift between
+  // client preview and server depending on Object.entries(derived) order.
+  const source = { ...row };
   const result: Record<string, unknown> = { ...row };
   for (const [derivedField, def] of Object.entries(derived)) {
     const values = def.from.map((src) => {
-      const v = result[src];
+      const v = source[src];
       return typeof v === "number" ? v : undefined;
     });
     const computed = computeDerivedCellValue(def.op, values);

package/src/components/render-edit.tsx

@@ -177,6 +177,12 @@ export type RenderEditProps<TValues extends FormValues, TCtx = unknown> = {
    *  no way to force-disable an arbitrary registered component. Omitting
    *  this prop keeps unchanged behavior. */
   readonly disabled?: boolean;
+  /** Renders the fields without RenderEdit's own action bar (save, cancel,
+   *  delete, copy-link). For hosts that put those controls into their own
+   *  chrome — a drawer footer, a wizard shell — and drive the write through
+   *  `onControlsReady`'s `submit`. Omitting this prop keeps unchanged
+   *  behavior. */
+  readonly hideActions?: boolean;
 };
 
 export type RenderEditChangeState<TValues extends FormValues> = {
@@ -190,6 +196,12 @@ export type RenderEditControls<TValues extends FormValues> = {
   readonly patch: (partial: Partial<TValues>) => void;
   readonly validate: () => boolean;
   readonly getValues: () => TValues;
+  /** Runs the same pipeline the built-in save button runs: validation,
+   *  `customSubmit`/`writeCommand`, extension-section persistence, draft
+   *  discard, state rebase. Unlike the button it carries no unchanged-form
+   *  guard — a host showing a pre-filled proposal must be able to accept it
+   *  untouched. */
+  readonly submit: () => Promise<void>;
 };
 
 function toConditionValue<TValues extends FormValues, TCtx>(
@@ -238,6 +250,7 @@ function ExtensionSectionMount({
   values,
   patch,
   validate,
+  hidden,
 }: {
   readonly section: EditExtensionSectionViewModel;
   readonly entityName: string;
@@ -246,6 +259,7 @@ function ExtensionSectionMount({
   readonly values?: Readonly<Record<string, unknown>>;
   readonly patch?: (partial: Readonly<Record<string, unknown>>) => void;
   readonly validate?: () => boolean;
+  readonly hidden?: boolean;
 }): ReactNode {
   const { Banner, Section, Text } = usePrimitives();
   const name = extensionSectionName(section.component);
@@ -256,6 +270,7 @@ function ExtensionSectionMount({
         key={section.title}
         title={section.title}
         testId={`section-extension-${section.title}`}
+        hidden={hidden}
       >
         <Banner variant="info" testId={`section-extension-placeholder-${section.title}`}>
           <Text>
@@ -268,7 +283,7 @@ function ExtensionSectionMount({
     );
   }
   return (
-    <Section title={section.title} testId={`section-extension-${section.title}`}>
+    <Section title={section.title} testId={`section-extension-${section.title}`} hidden={hidden}>
       <Component
         entityName={entityName}
         entityId={entityId}
@@ -309,6 +324,7 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
     onControlsReady,
     fields: fieldsFilter,
     disabled = false,
+    hideActions,
   } = props;
   const { customSubmit } = props;
   // Translate-Fallback: wenn der Caller keine Translate-Fn übergibt,
@@ -432,6 +448,13 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
   // re-subscribes with a "new" onChange → refires.
   const onChangeRef = useRef(onChange);
   onChangeRef.current = onChange;
+  // `schema` is typically an inline caller prop (`schema={z.object({...})}`)
+  // with unstable identity across renders — as an effect dep it would refire
+  // on every parent render, not just on a snapshot change, risking a loop if
+  // the caller's onChange triggers a parent re-render. Held in a ref like
+  // onChangeRef so only a real snapshot mutation retriggers this effect.
+  const schemaRef = useRef(schema);
+  schemaRef.current = schema;
   useEffect(() => {
     const cb = onChangeRef.current;
     if (cb === undefined) return;
@@ -441,9 +464,11 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
     // typing. `valid` can therefore legitimately diverge from what's
     // currently rendered under the fields (the last *mutating* validate()
     // call, e.g. from controls.validate() or submit()).
-    const valid = schema === undefined ? true : schema.safeParse(snapshot.values).success;
+    const currentSchema = schemaRef.current;
+    const valid =
+      currentSchema === undefined ? true : currentSchema.safeParse(snapshot.values).success;
     cb({ values: snapshot.values, changes: snapshot.changes, dirty: snapshot.isDirty, valid });
-  }, [snapshot, schema]);
+  }, [snapshot]);
 
   const onControlsReadyRef = useRef(onControlsReady);
   onControlsReadyRef.current = onControlsReady;
@@ -463,6 +488,10 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
   // is defined — kept fresh where `currentStep` is computed below.
   const saveDraftRef = useRef(saveDraft);
   saveDraftRef.current = saveDraft;
+  // `handleSubmit` (defined below) is a fresh closure over this render's
+  // snapshot/extensionDirty, while the onControlsReady effect fires once per
+  // mount — the ref lets controls.submit() always reach the current one.
+  const handleSubmitRef = useRef<() => Promise<void>>(async () => {});
   const currentStepRef = useRef(0);
   const draftSaveTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
   useEffect(() => {
@@ -495,6 +524,7 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
       patch: patchAndScheduleDraftSave,
       validate: scopedValidate,
       getValues: () => controller.getSnapshot().values,
+      submit: () => handleSubmitRef.current(),
     });
     // controller is mount-lifetime-stable (see useForm's comment on its own
     // useMemo), same for patchAndScheduleDraftSave/scopedValidate (both
@@ -539,11 +569,14 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
   }, [draftEnabled, draftKey, draftId, dispatcher, controller]);
 
   // Mount-time fallback (issue #1913) for create-mode when no draftId
-  // survived in storage (new tab, cleared storage): ask the server for
-  // this screen's open drafts. Exactly one → adopt it silently (same
-  // effect as if storage had it). Multiple → render a simple picker
-  // (below) and let the user choose. Zero → stay null, saveDraft mints a
-  // fresh draftId on the first step change same as any other fresh create.
+  // survived in storage (new tab, cleared storage): ask the server for this
+  // screen's open drafts and let the user choose via a picker (below) —
+  // even for exactly one candidate. Auto-adopting a lone candidate would
+  // silently hand this tab someone else's in-progress draft from a parallel
+  // session on the same screen (cross-tab hijack); the picker's "start new"
+  // action covers the common case (it really was this tab's own draft) with
+  // one extra click. Zero candidates → stay null, saveDraft mints a fresh
+  // draftId on the first step change same as any other fresh create.
   useEffect(() => {
     // skip: this screen does not persist a draft, this is edit-mode, a
     // draftId is already known (from storage or an earlier adoption), or
@@ -566,19 +599,12 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
       // skip: no open drafts for this screen — stay null, saveDraft mints a
       // fresh draftId on the first step change same as any other create.
       if (candidates.length === 0) return;
-      const [only] = candidates;
-      if (candidates.length === 1 && only !== undefined) {
-        const adoptedId = only.draftKey.slice(prefix.length);
-        draftStorage.setDraftId(screen.id, adoptedId);
-        setDraftId(adoptedId);
-        return;
-      }
       setDraftCandidates(candidates);
     })();
     return () => {
       cancelled = true;
     };
-  }, [draftEnabled, isCreateMode, draftId, dispatcher, screen.id, draftStorage]);
+  }, [draftEnabled, isCreateMode, draftId, dispatcher, screen.id]);
 
   // User picked one of several open drafts from the mount-time picker
   // (see draftCandidates below) — adopt it the same way a single
@@ -675,11 +701,20 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
   // have no field scope here (they validate via the controlled-mode
   // controls.validate() API), so no call, no clearing of unrelated errors.
   function handleWizardNext(): void {
+    const next = Math.min(currentStep + 1, lastStepIndex);
+    // Locked state (#1896): `disabled` means "no input/no write", not "no
+    // navigation" — a disabled wizard must still be steppable so Back/Next
+    // reach every step. But neither validate() (would block on an empty
+    // required field nobody can fill in) nor saveDraft() (would mint a
+    // draftId / dispatch a write — exactly what `disabled` forbids) may run.
+    if (disabled) {
+      setRawStep(next);
+      return;
+    }
     const section = filteredSections[currentStep];
     const fieldNames = section?.kind === "fields" ? section.fields.map((f) => f.field) : [];
     // skip: the current step has field errors — no transition, no draft save.
     if (fieldNames.length > 0 && !controller.validate(fieldNames)) return;
-    const next = Math.min(currentStep + 1, lastStepIndex);
     setRawStep(next);
     saveDraft(next);
   }
@@ -702,7 +737,17 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
     // skip: create-mode, no step change happened yet — no draftId was ever
     // minted, so no row exists to discard.
     if (draftKey === undefined) return;
-    await dispatcher.write(FORM_DRAFT_DISCARD, { draftKey });
+    // Best-effort: a rejected write (e.g. network error) must not propagate
+    // out of handleSubmit AFTER the entity write already succeeded — that
+    // would break onSubmit/navigation/toast and risk a duplicate submit on
+    // retry. An orphaned draft row is swept later by cleanup.job.ts. Local
+    // cleanup below still runs on failure so this instance doesn't try to
+    // resume a draft it already considers submitted.
+    try {
+      await dispatcher.write(FORM_DRAFT_DISCARD, { draftKey });
+    } catch {
+      // best-effort, see comment above.
+    }
     // A successful submit ends this draftId's life — a subsequent create on
     // the same screen (new mount) must mint its own, not resume this one.
     if (isCreateMode) {
@@ -712,18 +757,37 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
     }
   }
 
+  // Wizard mode: locates the first step whose "fields" section contains one
+  // of the given field paths — matched on the path's first segment, since
+  // `FieldIssue.path`/`snapshot.errors` keys can be dotted (embedded-list
+  // rows, e.g. `tasks.2.title`) while a section's field name is always the
+  // plain top-level name. Returns undefined for a root-level issue (path
+  // `"(root)"`, see zod-bridge.ts) or one that matches no rendered field —
+  // callers must NOT suppress the error banner in that case, there is
+  // nowhere to jump the user to.
+  function findFirstErroringStep(fieldPaths: readonly string[]): number | undefined {
+    const erroredFields = new Set(fieldPaths.map((p) => p.split(".")[0]));
+    const idx = filteredSections.findIndex(
+      (s) => s.kind === "fields" && s.fields.some((f) => erroredFields.has(f.field)),
+    );
+    return idx === -1 ? undefined : idx;
+  }
+
   async function handleSubmit(): Promise<void> {
-    // Locked state (#1896): the submit button is visibly disabled, but a
-    // native form submit (Enter key) reaches this handler regardless of the
-    // button's disabled attribute — block it here too, not just in the UI.
-    if (disabled) return;
     // Enter in the active step triggers the native form submit (Next is
     // type="submit" for Enter support) — on intermediate steps that means
-    // "Next", not "Save".
+    // "Next", not "Save". Checked BEFORE the `disabled` guard below:
+    // `disabled` means "no input/no write", not "no navigation" — a
+    // disabled wizard must still be steppable (handleWizardNext itself
+    // blocks validate()/saveDraft() while disabled).
     if (isWizard && !isLastWizardStep) {
       handleWizardNext();
       return;
     }
+    // Locked state (#1896): the submit button is visibly disabled, but a
+    // native form submit (Enter key) reaches this handler regardless of the
+    // button's disabled attribute — block it here too, not just in the UI.
+    if (disabled) return;
     setIsSubmitting(true);
     setExtensionErrorKey(null);
     try {
@@ -781,9 +845,36 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
         // the draft behind after a successful submit.
         await discardDraft();
         extensionsPersisted = await persistExtensions();
-      } else if (!result.validationBlocked) {
+      } else if (result.validationBlocked) {
+        // Root-level `.refine()`/cross-field issues from controller.validate()
+        // — same "jump to the erroring step" treatment as a server field
+        // error below, sourced from the freshly-validated snapshot.
+        if (isWizard) {
+          const step = findFirstErroringStep(Object.keys(controller.getSnapshot().errors));
+          if (step !== undefined) setRawStep(step);
+        }
+      } else {
         const fieldIssues = result.error.details?.fields ?? [];
-        setFormError(fieldIssues.length === 0 ? result.error : null);
+        // A server field error on a step the wizard isn't currently showing
+        // is otherwise invisible — jump to the first step that contains one
+        // of the errored fields. Non-wizard forms render every field at
+        // once, so the original suppress-when-field-issues-exist rule still
+        // applies there (the field itself already shows the error inline).
+        if (isWizard) {
+          const step = findFirstErroringStep(fieldIssues.map((i) => i.path));
+          if (step !== undefined) {
+            setRawStep(step);
+            setFormError(null);
+          } else {
+            // No rendered step contains any of the errored fields (a
+            // root-level issue, or a field outside every step) — nothing
+            // will show this error inline, so the banner must not be
+            // suppressed.
+            setFormError(result.error);
+          }
+        } else {
+          setFormError(fieldIssues.length === 0 ? result.error : null);
+        }
       }
       // skip: on entity-success-but-extension-failure the extension-error
       // banner is showing — don't notify (the caller navigates away on success
@@ -793,6 +884,7 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
       setIsSubmitting(false);
     }
   }
+  handleSubmitRef.current = handleSubmit;
 
   // Sticky-top Action-Bar: Delete (links, destructive) + Cancel +
   // Save. Delete sitzt links abgesetzt damit die Click-Distanz zu
@@ -844,12 +936,7 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
         </Button>
       )}
       {isWizard && !isLastWizardStep && (
-        <Button
-          type="submit"
-          disabled={disabled}
-          variant="primary"
-          testId="render-edit-wizard-next"
-        >
+        <Button type="submit" variant="primary" testId="render-edit-wizard-next">
           {translate("kumiko.actions.next")}
         </Button>
       )}
@@ -895,7 +982,7 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
         onSubmit={() => void handleSubmit()}
         title={formTitle}
         {...(formSubtitle !== undefined && { subtitle: formSubtitle })}
-        actions={formActions}
+        {...(hideActions !== true && { actions: formActions })}
         testId="render-edit-form"
         stickyActions={isWizard}
         {...(screen.layout.width !== undefined && { width: screen.layout.width })}
@@ -904,17 +991,28 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
           <Banner
             variant="info"
             testId="render-edit-draft-picker"
-            actions={draftCandidates.map((candidate) => (
+            actions={[
+              ...draftCandidates.map((candidate) => (
+                <Button
+                  key={candidate.id}
+                  type="button"
+                  variant="link"
+                  onClick={() => adoptDraft(candidate)}
+                  testId={`render-edit-draft-pick-${candidate.id}`}
+                >
+                  {formatWhen(candidate.savedAt)}
+                </Button>
+              )),
               <Button
-                key={candidate.id}
+                key="start-new"
                 type="button"
                 variant="link"
-                onClick={() => adoptDraft(candidate)}
-                testId={`render-edit-draft-pick-${candidate.id}`}
+                onClick={() => setDraftCandidates(null)}
+                testId="render-edit-draft-start-new"
               >
-                {formatWhen(candidate.savedAt)}
-              </Button>
-            ))}
+                {translate("kumiko.form.draft.start-new")}
+              </Button>,
+            ]}
           >
             <Text>{translate("kumiko.form.draft.resume-multiple")}</Text>
           </Banner>
@@ -963,68 +1061,72 @@ export function RenderEdit<TValues extends FormValues, TCtx = unknown>(
             })()}
           </>
         )}
-        {(isWizard ? filteredSections.filter((_, i) => i === currentStep) : filteredSections).map(
-          (section: EditSectionViewModel, sectionIndex: number) => {
-            if (section.kind === "extension") {
-              return (
-                <ExtensionSectionMount
-                  key={section.title}
-                  section={section}
-                  entityName={vm.entityName}
-                  entityId={resolveExtensionEntityId(entityIdProp, vm.id)}
-                  initialValues={extensionInitialValues}
-                  values={snapshot.values}
-                  // @cast-boundary form-values: ExtensionSectionProps is not generic
-                  // over TValues; controller is mount-lifetime-stable, see onControlsReady above.
-                  patch={
-                    patchAndScheduleDraftSave as (
-                      partial: Readonly<Record<string, unknown>>,
-                    ) => void
-                  }
-                  validate={scopedValidate}
-                />
-              );
-            }
-            if (!section.visible) return null;
-            // Section-Header unterdrücken wenn er den Form-Titel der
-            // Action-Bar 1:1 wiederholen würde (typisch bei Single-Section-
-            // ActionForms, deren Section-Label = Screen-Titel ist).
-            const sectionTitle = section.title === formTitle ? undefined : section.title;
-            // Titellose Sections kollidieren sonst auf key/testId — Index-Fallback.
-            const sectionKey = section.title ?? `section-${sectionIndex}`;
+        {filteredSections.map((section: EditSectionViewModel, sectionIndex: number) => {
+          // Wizard steps stay mounted while off-screen (native `hidden`, not
+          // unmounted) so an extension section's submit-registry entry
+          // (useExtensionFormSubmit → registry.remove on unmount) survives
+          // navigating past its step — otherwise Finish only ran the last
+          // mounted step's handler and silently dropped earlier steps' writes.
+          const stepHidden = isWizard && sectionIndex !== currentStep;
+          if (section.kind === "extension") {
             return (
-              <Section
-                key={sectionKey}
-                {...(sectionTitle !== undefined && { title: sectionTitle })}
-                {...(section.description !== undefined && { subtitle: section.description })}
-                testId={`section-${sectionKey}`}
-              >
-                <Grid columns={section.columns}>
-                  {section.fields.map((field: EditFieldViewModel) => (
-                    <GridCellForField
-                      key={field.field}
-                      field={disabled ? { ...field, readOnly: true } : field}
-                      columns={section.columns}
-                      issues={snapshot.errors[field.field]}
-                      onChange={(v) => {
-                        (controller.setField as (k: string, v: unknown) => void)(field.field, v);
-                      }}
-                      GridCell={GridCell}
-                      featureName={featureName}
-                      {...(labelAppendix !== undefined && {
-                        labelAppendix: labelAppendix(field.field),
-                      })}
-                      {...(fieldAppendix !== undefined && {
-                        fieldAppendix: fieldAppendix(field.field),
-                      })}
-                      allIssues={snapshot.errors}
-                    />
-                  ))}
-                </Grid>
-              </Section>
+              <ExtensionSectionMount
+                key={section.title}
+                section={section}
+                entityName={vm.entityName}
+                entityId={resolveExtensionEntityId(entityIdProp, vm.id)}
+                initialValues={extensionInitialValues}
+                values={snapshot.values}
+                // @cast-boundary form-values: ExtensionSectionProps is not generic
+                // over TValues; controller is mount-lifetime-stable, see onControlsReady above.
+                patch={
+                  patchAndScheduleDraftSave as (partial: Readonly<Record<string, unknown>>) => void
+                }
+                validate={scopedValidate}
+                hidden={stepHidden}
+              />
             );
-          },
-        )}
+          }
+          if (!section.visible) return null;
+          // Section-Header unterdrücken wenn er den Form-Titel der
+          // Action-Bar 1:1 wiederholen würde (typisch bei Single-Section-
+          // ActionForms, deren Section-Label = Screen-Titel ist).
+          const sectionTitle = section.title === formTitle ? undefined : section.title;
+          // Titellose Sections kollidieren sonst auf key/testId — Index-Fallback.
+          const sectionKey = section.title ?? `section-${sectionIndex}`;
+          return (
+            <Section
+              key={sectionKey}
+              {...(sectionTitle !== undefined && { title: sectionTitle })}
+              {...(section.description !== undefined && { subtitle: section.description })}
+              testId={`section-${sectionKey}`}
+              hidden={stepHidden}
+            >
+              <Grid columns={section.columns}>
+                {section.fields.map((field: EditFieldViewModel) => (
+                  <GridCellForField
+                    key={field.field}
+                    field={disabled ? { ...field, readOnly: true } : field}
+                    columns={section.columns}
+                    issues={snapshot.errors[field.field]}
+                    onChange={(v) => {
+                      (controller.setField as (k: string, v: unknown) => void)(field.field, v);
+                    }}
+                    GridCell={GridCell}
+                    featureName={featureName}
+                    {...(labelAppendix !== undefined && {
+                      labelAppendix: labelAppendix(field.field),
+                    })}
+                    {...(fieldAppendix !== undefined && {
+                      fieldAppendix: fieldAppendix(field.field),
+                    })}
+                    allIssues={snapshot.errors}
+                  />
+                ))}
+              </Grid>
+            </Section>
+          );
+        })}
         {formError !== null && (
           <Banner
             variant="error"

package/src/components/render-field.tsx

@@ -328,7 +328,6 @@ function renderInput({
     // already emits `number | undefined`, so no extra coercion is needed
     // beyond what "number" already does (#1925).
     case "number":
-    case "decimal":
     case "bigInt":
       return (
         <Input
@@ -339,6 +338,20 @@ function renderInput({
           {...(field.icon !== undefined && { icon: field.icon })}
         />
       );
+    case "decimal":
+      // step="any" disables the native stepMismatch constraint — without it
+      // <input type="number"> defaults to step=1 and blocks form submit on
+      // any fractional value via silent browser-native validation.
+      return (
+        <Input
+          kind="number"
+          {...common}
+          value={numberValue(field.value)}
+          onChange={(v) => onChange(v)}
+          step="any"
+          {...(field.icon !== undefined && { icon: field.icon })}
+        />
+      );
     case "tz":
       return (
         <Input
@@ -532,11 +545,13 @@ function numberValue(v: unknown): number | "" {
 // MINOR_UNIT_SCALE=100 (money.ts), which disagrees with currencyDecimals for
 // zero-decimal currencies like JPY, so it would double-scale JPY amounts.
 // Deriving from `amount * 10**currencyDecimals(currency)` keeps this the
-// exact inverse of moneyPayload below. A bare number is passed through
-// unchanged — legacy/malformed data, already in minor units.
+// exact inverse of moneyPayload below. A bare number (e.g. ConfigEditBody's
+// stored-config coercion) is MAJOR units too — every producer in this repo
+// hands rehydrateMoney's `{amount,…}` shape or a raw major-unit number, never
+// pre-scaled minor units.
 function moneyMinorValue(v: unknown, currency: string): number | "" {
   if (v === undefined || v === null || v === "") return "";
-  if (typeof v === "number") return v;
+  if (typeof v === "number") return Math.round(v * 10 ** currencyDecimals(currency));
   if (typeof v === "object") {
     const amount = (v as { amount?: unknown }).amount;
     if (typeof amount === "number") return Math.round(amount * 10 ** currencyDecimals(currency));

package/src/primitives.tsx

@@ -223,6 +223,9 @@ export type InputProps =
       /** Symbolic icon key (FIELD_ICONS registry, renderer-web) — renders
        *  as a prefix on the input. Unknown key → no icon (no boot-fail). */
       readonly icon?: string;
+      /** `<input step>`. "any" disables the native stepMismatch constraint
+       *  (needed for decimal fields — integer fields leave this unset). */
+      readonly step?: number | "any";
     }
   | {
       readonly kind: "range";
@@ -720,6 +723,11 @@ export type SectionProps = {
    *  Default "default" (normal card border). */
   readonly variant?: "default" | "destructive";
   readonly testId?: string;
+  /** Keeps the section mounted while visually hiding it (native `hidden`
+   *  attribute where supported) — used by wizard mode to keep off-screen
+   *  steps mounted so their state (e.g. an extension section's submit
+   *  registration) survives step navigation instead of unmounting. */
+  readonly hidden?: boolean;
 };
 
 /** Columns-basiertes Layout. Web: CSS grid, Native: Flex-Wrap mit