@cosmicdrift/kumiko-renderer 0.187.0 → 0.189.0

package/src/app/kumiko-screen.tsx

@@ -15,11 +15,7 @@ import type {
   ScreenDefinition,
   ToolbarAction,
 } from "@cosmicdrift/kumiko-framework/ui-types";
-import {
-  evalFieldCondition,
-  isExtensionEditSection,
-  normalizeEditField,
-} from "@cosmicdrift/kumiko-framework/ui-types";
+import { evalFieldCondition } from "@cosmicdrift/kumiko-framework/ui-types";
 import type {
   Command,
   FormSnapshot,
@@ -43,6 +39,8 @@ import { synthesizeConfigEditEntity, synthesizeConfigEditScreen } from "./config
 import { useCustomScreenComponent } from "./custom-screens";
 import { useDashboardBody } from "./dashboard-body";
 import type { FeatureSchema } from "./feature-schema";
+import { buildFormSchema } from "./form-schema";
+import { layoutFieldNames } from "./layout-fields";
 import { useNav } from "./nav";
 import {
   synthesizeProjectionDetailEntity,
@@ -310,8 +308,15 @@ function useNavigateToCreateFor(
 // with a `default: true`/`default: 5` would show the form in a state
 // the entity didn't ask for — subtle and easy to miss until a user
 // submits and is surprised.
+// `defaultCurrency` is only passed by entityEdit call sites — the money
+// payload shape it enables (`{amount, currency}`) matches the entity's
+// write schema (schema-builder.ts, kumiko-framework#1923). Callers outside
+// that path (config-edit, action-form) synthesize their own entity and use
+// money as a plain number against a different write contract, so they
+// deliberately keep the old bare-`0` default by omitting the argument.
 export function buildInitialValues(
   fields: Readonly<Record<string, unknown>>,
+  defaultCurrency?: string,
 ): Readonly<Record<string, unknown>> {
   const out: Record<string, unknown> = {};
   for (const [name, def] of Object.entries(fields)) {
@@ -320,33 +325,23 @@ export function buildInitialValues(
       out[name] = shape.default;
       continue;
     }
+    if (shape.type === "money" && defaultCurrency !== undefined) {
+      out[name] = { amount: 0, currency: defaultCurrency };
+      continue;
+    }
     out[name] =
       shape.type === "boolean" ? false : shape.type === "number" || shape.type === "money" ? 0 : "";
   }
   return out;
 }
 
-// Field names actually rendered by the screen's layout — a search-param
-// merge must not set fields the form never shows the user (#1708:
-// unrendered fields get no client-side validation and no chance to
-// review/correct the injected value).
-function layoutFieldNames(screen: EntityEditScreenDefinition): ReadonlySet<string> {
-  const names = new Set<string>();
-  for (const section of screen.layout.sections) {
-    if (isExtensionEditSection(section)) continue;
-    for (const spec of section.fields) {
-      names.add(normalizeEditField(spec).field);
-    }
-  }
-  return names;
-}
-
 export function mergeSearchParamsIntoInitial(
   fields: Readonly<Record<string, unknown>>,
   searchParams: Readonly<Record<string, string>>,
   renderableFields?: ReadonlySet<string>,
+  defaultCurrency?: string,
 ): Record<string, unknown> {
-  const defaults = buildInitialValues(fields) as Record<string, unknown>;
+  const defaults = buildInitialValues(fields, defaultCurrency) as Record<string, unknown>;
   const merged: Record<string, unknown> = { ...defaults };
   for (const [name, fieldDef] of Object.entries(fields)) {
     if (renderableFields !== undefined && !renderableFields.has(name)) continue;
@@ -354,9 +349,16 @@ export function mergeSearchParamsIntoInitial(
     if (shape.sensitive === true) continue;
     const raw = searchParams[name];
     if (raw === undefined) continue;
-    if (shape.type === "number" || shape.type === "money") {
+    if (shape.type === "number") {
       const parsed = Number(raw);
       merged[name] = Number.isNaN(parsed) ? defaults[name] : parsed;
+    } else if (shape.type === "money") {
+      const parsed = Number(raw);
+      merged[name] = Number.isNaN(parsed)
+        ? defaults[name]
+        : defaultCurrency !== undefined
+          ? { amount: parsed, currency: defaultCurrency }
+          : parsed;
     } else if (shape.type === "boolean") {
       merged[name] = raw === "true";
     } else {
@@ -404,19 +406,19 @@ function EntityEditScreen({
       />
     );
   }
-  if (screen.allowCreate === false) {
-    // Update-only Screen ohne entityId (Direkt-URL / verirrte Navigation):
-    // ein Create-Form würde gegen den nicht registrierten
-    // `<entity>:create`-Handler submitten — Fehler statt Falle.
+  if (screen.singleton === true) {
     return (
-      <Banner padded variant="error" testId="kumiko-screen-create-disabled">
-        Screen <Text variant="code">{screen.id}</Text> is update-only (allowCreate: false) — open it
-        from a row action with an entity id.
-      </Banner>
+      <EntityEditSingletonBody
+        schema={schema}
+        screen={screen}
+        entity={entity}
+        {...(translate !== undefined && { translate })}
+        {...(onCopyLink !== undefined && { onCopyLink })}
+      />
     );
   }
   return (
-    <EntityEditCreateBody
+    <EntityEditCreateOrDisabled
       schema={schema}
       screen={screen}
       entity={entity}
@@ -443,16 +445,23 @@ function EntityEditCreateBody({
         entity.fields,
         nav.searchParams,
         layoutFieldNames(screen),
+        entity.defaultCurrency ?? "EUR",
       ) as FormValues,
-    [entity.fields, nav.searchParams, screen],
+    [entity.fields, nav.searchParams, screen, entity.defaultCurrency],
   );
+  const formSchema = useMemo(() => buildFormSchema(entity, screen), [entity, screen]);
   const writeCommand = entityWriteCommand(schema.featureName, screen.entity, "create");
   const navigateToList = useNavigateToListAfter(schema, screen.entity);
   const handleSubmitted = useCallback(
     (result: SubmitResult<unknown>) => {
-      if (result.isSuccess) navigateToList();
+      if (!result.isSuccess) return;
+      if (screen.redirect !== undefined) {
+        nav.navigate({ screenId: lastSegment(screen.redirect) });
+        return;
+      }
+      navigateToList();
     },
-    [navigateToList],
+    [nav, screen.redirect, navigateToList],
   );
   return (
     <RenderEdit
@@ -460,6 +469,7 @@ function EntityEditCreateBody({
       entity={entity}
       featureName={schema.featureName}
       initial={initial}
+      schema={formSchema}
       writeCommand={writeCommand}
       onSubmit={handleSubmitted}
       onCancel={navigateToList}
@@ -566,11 +576,15 @@ function EntityEditUpdateForm({
   const recordVersion = (record as { version?: number }).version ?? 1;
   const initial = useMemo(() => {
     const out: Record<string, unknown> = {};
+    const defaultCurrency = entity.defaultCurrency ?? "EUR";
     for (const name of Object.keys(entity.fields)) {
-      out[name] = record[name] ?? buildInitialValues({ [name]: entity.fields[name] })[name];
+      out[name] =
+        record[name] ?? buildInitialValues({ [name]: entity.fields[name] }, defaultCurrency)[name];
     }
     return out as FormValues;
-  }, [entity.fields, record]);
+  }, [entity.fields, entity.defaultCurrency, record]);
+
+  const formSchema = useMemo(() => buildFormSchema(entity, screen), [entity, screen]);
 
   // Extension-Werte (z.B. customFields-jsonb) an extension-sections geben,
   // damit sie beim Edit den Bestand zeigen statt write-only zu sein.
@@ -593,13 +607,19 @@ function EntityEditUpdateForm({
     [entityId, recordVersion],
   );
 
+  const nav = useNav();
   const dispatcher = useDispatcher();
   const navigateToList = useNavigateToListAfter(schema, screen.entity);
   const handleSubmitted = useCallback(
     (result: SubmitResult<unknown>) => {
-      if (result.isSuccess) navigateToList();
+      if (!result.isSuccess) return;
+      if (screen.redirect !== undefined) {
+        nav.navigate({ screenId: lastSegment(screen.redirect) });
+        return;
+      }
+      navigateToList();
     },
-    [navigateToList],
+    [nav, screen.redirect, navigateToList],
   );
   const handleDelete = useCallback(async () => {
     const res = await dispatcher.write(deleteCommand, { id: entityId });
@@ -619,6 +639,7 @@ function EntityEditUpdateForm({
       // customFields-Bestand an die extension-section, damit sie beim Edit
       // die gespeicherten Werte zeigt (nicht write-only).
       extensionInitialValues={extensionInitialValues}
+      schema={formSchema}
       writeCommand={writeCommand}
       payloadMode="changes"
       buildPayload={buildPayload}
@@ -636,6 +657,100 @@ function EntityEditUpdateForm({
   );
 }
 
+// Singleton entities (`singleton: true`, exactly one record per tenant):
+// EntityEditScreen reaches here only without an entityId. Resolve the
+// existing record via list(limit:1) before deciding create vs update —
+// otherwise every visit without an id would create another record.
+function EntityEditSingletonBody({
+  schema,
+  screen,
+  entity,
+  translate,
+  onCopyLink,
+}: {
+  readonly schema: FeatureSchema;
+  readonly screen: EntityEditScreenDefinition;
+  readonly entity: EntityDefinition;
+  readonly translate?: Translate;
+  readonly onCopyLink?: () => Promise<void> | void;
+}): ReactNode {
+  const { Banner } = usePrimitives();
+  const t = useTranslation();
+  const effectiveTranslate = translate ?? t;
+  const listQn = entityQueryCommand(schema.featureName, screen.entity, "list");
+  const listQuery = useQuery<PagedRows>(listQn, { limit: 1 });
+
+  if (listQuery.loading && listQuery.data === null) {
+    return (
+      <Banner padded variant="loading" testId="kumiko-screen-loading">
+        Loading…
+      </Banner>
+    );
+  }
+  if (listQuery.error) {
+    return (
+      <Banner padded variant="error" testId="kumiko-screen-error">
+        {dispatcherErrorText(listQuery.error, effectiveTranslate)}
+      </Banner>
+    );
+  }
+  const existingId = listQuery.data?.rows[0]?.["id"] as string | undefined;
+  if (existingId !== undefined) {
+    return (
+      <EntityEditUpdateBody
+        schema={schema}
+        screen={screen}
+        entity={entity}
+        entityId={existingId}
+        {...(translate !== undefined && { translate })}
+        {...(onCopyLink !== undefined && { onCopyLink })}
+      />
+    );
+  }
+  return (
+    <EntityEditCreateOrDisabled
+      schema={schema}
+      screen={screen}
+      entity={entity}
+      {...(translate !== undefined && { translate })}
+    />
+  );
+}
+
+// Shared no-entityId tail for both the plain create path and the
+// singleton path's empty-table fallback: `allowCreate: false` blocks
+// both the same way, since a create submit there would hit an
+// unregistered `<entity>:create` handler.
+function EntityEditCreateOrDisabled({
+  schema,
+  screen,
+  entity,
+  translate,
+}: {
+  readonly schema: FeatureSchema;
+  readonly screen: EntityEditScreenDefinition;
+  readonly entity: EntityDefinition;
+  readonly translate?: Translate;
+}): ReactNode {
+  const { Banner, Text } = usePrimitives();
+  if (screen.allowCreate === false) {
+    return (
+      <Banner padded variant="error" testId="kumiko-screen-create-disabled">
+        Screen <Text variant="code">{screen.id}</Text> is update-only (allowCreate: false) — open it
+        from a row action with an entity id.
+      </Banner>
+    );
+  }
+  return (
+    <EntityEditCreateBody
+      schema={schema}
+      screen={screen}
+      entity={entity}
+      {...(translate !== undefined && { translate })}
+    />
+  );
+}
+
 // ---- entity-list ----
 
 function entityQueryCommand(featureName: string, entity: string, verb: "list"): string {
@@ -1456,7 +1571,7 @@ function ActionFormBody({
       // Author entscheidet bewusst ob "stay on form" (default) oder
       // "back to list" (typisch bei Create-style Aktionen).
       if (result.isSuccess && screen.redirect !== undefined) {
-        nav.navigate({ screenId: screen.redirect });
+        nav.navigate({ screenId: lastSegment(screen.redirect) });
       }
     },
     [nav, screen.redirect],
@@ -1468,7 +1583,7 @@ function ActionFormBody({
   const handleCancel = useMemo<(() => void) | undefined>(() => {
     const target = screen.cancelTarget ?? screen.redirect;
     if (target === undefined || target === false) return undefined;
-    return () => nav.navigate({ screenId: target });
+    return () => nav.navigate({ screenId: lastSegment(target) });
   }, [nav, screen.redirect, screen.cancelTarget]);
   return (
     <RenderEdit
@@ -1513,6 +1628,19 @@ type ConfigValueResponse = Readonly<
   Record<string, { value: string | number | boolean | undefined; scope: string; source: string }>
 >;
 
+// A money-typed config-edit field renders through RenderField's entityEdit
+// `{amount, currency}` payload shape (render-field.tsx, #1923), but
+// `ConfigKeyType` (write-helpers.ts validateType) only ever knows
+// number/boolean/text/select — a config value is always a bare scalar.
+// Unwrap back to the amount before it hits config:write:set.
+function unwrapMoneyValue(value: unknown): unknown {
+  if (typeof value === "object" && value !== null && "amount" in value) {
+    const amount = (value as { amount?: unknown }).amount;
+    if (typeof amount === "number") return amount;
+  }
+  return value;
+}
+
 function ConfigEditBody({
   schema,
   screen,
@@ -1604,9 +1732,14 @@ function ConfigEditBody({
       for (const [shortName, value] of Object.entries(snapshot.changes)) {
         const qualified = screen.configKeys[shortName];
         if (qualified === undefined) continue;
+        const ftype = (screen.fields[shortName] as { type?: string } | undefined)?.type;
         commands.push({
           type: "config:write:set",
-          payload: { key: qualified, value, scope: screen.scope },
+          payload: {
+            key: qualified,
+            value: ftype === "money" ? unwrapMoneyValue(value) : value,
+            scope: screen.scope,
+          },
         });
       }
       if (commands.length === 0) {
@@ -1623,7 +1756,14 @@ function ConfigEditBody({
       await Promise.allSettled([valuesQuery.refetch?.(), cascadeQuery.refetch?.()]);
       return { validationBlocked: false, isSuccess: true, data: undefined };
     },
-    [dispatcher, screen.configKeys, screen.scope, valuesQuery.refetch, cascadeQuery.refetch],
+    [
+      dispatcher,
+      screen.configKeys,
+      screen.fields,
+      screen.scope,
+      valuesQuery.refetch,
+      cascadeQuery.refetch,
+    ],
   );
 
   // Cascade-Disclosure (#429): Trigger sitzt in der Label-Row, das Panel

package/src/app/layout-fields.ts

@@ -0,0 +1,27 @@
+import type {
+  EditFieldSpec,
+  EntityEditScreenDefinition,
+} from "@cosmicdrift/kumiko-framework/ui-types";
+import { isExtensionEditSection, normalizeEditField } from "@cosmicdrift/kumiko-framework/ui-types";
+
+// Normalized field specs actually rendered by the screen's layout, extension
+// sections skipped. Both this and `layoutFieldNames` key off "rendered by
+// the layout" for the same reason: a field the user never sees gets no
+// chance to review/correct a value nor to fix a presence error
+// (search-param merge, #1708; presence schema in form-schema.ts).
+export function layoutEditFields(
+  screen: EntityEditScreenDefinition,
+): readonly Exclude<EditFieldSpec, string>[] {
+  const specs: Exclude<EditFieldSpec, string>[] = [];
+  for (const section of screen.layout.sections) {
+    if (isExtensionEditSection(section)) continue;
+    for (const spec of section.fields) {
+      specs.push(normalizeEditField(spec));
+    }
+  }
+  return specs;
+}
+
+export function layoutFieldNames(screen: EntityEditScreenDefinition): ReadonlySet<string> {
+  return new Set(layoutEditFields(screen).map((spec) => spec.field));
+}

package/src/components/__tests__/render-edit-logic.test.ts

@@ -6,6 +6,7 @@ import type {
   SubmitResult,
 } from "@cosmicdrift/kumiko-headless";
 import {
+  filterEditSections,
   hasEditableSection,
   resolveExtensionEntityId,
   shouldNotifyCaller,
@@ -177,3 +178,50 @@ describe("hasEditableSection", () => {
     expect(hasEditableSection([section])).toBe(false);
   });
 });
+
+const namedField = (name: string): EditFieldViewModel => ({
+  field: name,
+  label: name,
+  type: "text",
+  value: "",
+  visible: true,
+  readOnly: false,
+  required: false,
+});
+const namedFieldsSection = (...names: string[]): EditSectionViewModel => ({
+  kind: "fields",
+  columns: 1,
+  visible: true,
+  fields: names.map(namedField),
+});
+
+describe("filterEditSections", () => {
+  test("fieldsFilter undefined → returns the same array reference (unchanged behavior)", () => {
+    const sections = [namedFieldsSection("a", "b")];
+    expect(filterEditSections(sections, undefined)).toBe(sections);
+  });
+
+  test("mixed section → only the filtered-in fields remain in section.fields", () => {
+    const sections = [namedFieldsSection("a", "b", "c")];
+    const result = filterEditSections(sections, ["a", "c"]);
+    expect(result).toHaveLength(1);
+    expect(result[0]?.kind).toBe("fields");
+    expect(result[0]?.kind === "fields" ? result[0].fields.map((f) => f.field) : []).toEqual([
+      "a",
+      "c",
+    ]);
+  });
+
+  test("section whose filtered field list becomes empty is dropped entirely, not rendered empty", () => {
+    const sections = [namedFieldsSection("a", "b"), namedFieldsSection("c")];
+    const result = filterEditSections(sections, ["c"]);
+    expect(result).toHaveLength(1);
+    expect(result[0]?.kind === "fields" ? result[0].fields.map((f) => f.field) : []).toEqual(["c"]);
+  });
+
+  test("extension section always survives the filter regardless of its content", () => {
+    const sections = [extensionSection, namedFieldsSection("a")];
+    const result = filterEditSections(sections, ["zzz"]);
+    expect(result).toEqual([extensionSection]);
+  });
+});

package/src/components/__tests__/render-field-money-roundtrip.test.tsx

@@ -0,0 +1,189 @@
+// kumiko-framework#1923: money didn't round-trip on the auto-wired
+// entityEdit path — create sent a bare number against the server's
+// `{amount, currency}` schema, update rendered the rehydrated read value as
+// NaN, and a naive fix would have been 100x off (minor vs. major units).
+//
+// This test walks the whole chain with real functions, no mocks:
+// computeEditViewModel (headless) → RenderField → simulated widget
+// onChange → buildInsertSchema/buildUpdateSchema (framework/engine). The
+// widget's own minor-units math (MoneyInput) is pinned separately in
+// packages/renderer-web/src/primitives/__tests__/money-input.test.tsx —
+// this test starts one step in, at the value RenderField hands to/from the
+// widget contract (`number | ""` minor units).
+
+import { describe, expect, test } from "bun:test";
+import { rehydrateMoney } from "@cosmicdrift/kumiko-framework/db";
+import { buildInsertSchema, buildUpdateSchema } from "@cosmicdrift/kumiko-framework/engine";
+import type {
+  EntityDefinition,
+  EntityEditScreenDefinition,
+} from "@cosmicdrift/kumiko-framework/ui-types";
+import { computeEditViewModel, type EditFieldViewModel } from "@cosmicdrift/kumiko-headless";
+import { render } from "@testing-library/react";
+import type { ComponentType, ReactNode } from "react";
+import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
+import { type CorePrimitives, type InputProps, PrimitivesProvider } from "../../primitives";
+import { RenderField } from "../render-field";
+
+let captured: InputProps | undefined;
+const captureInput: ComponentType<InputProps> = (props) => {
+  captured = props;
+  return null;
+};
+const noop = (): ReactNode => null;
+const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
+
+const testPrimitives: CorePrimitives = {
+  Button: noop,
+  Banner: noop,
+  Field: passChildren,
+  Input: captureInput,
+  DataTable: noop,
+  Form: noop,
+  Section: noop,
+  Card: noop,
+  Grid: noop,
+  GridCell: noop,
+  Text: noop,
+  Heading: noop,
+  Dialog: noop,
+  Modal: noop,
+  Lightbox: noop,
+  ConfigSourceBadge: noop,
+  ConfigCascadeView: noop,
+  Link: noop,
+};
+
+function buildEntity(defaultCurrency: string): EntityDefinition {
+  return {
+    fields: {
+      price: { type: "money", required: true },
+    },
+    defaultCurrency,
+  } as EntityDefinition;
+}
+
+function buildScreen(): EntityEditScreenDefinition {
+  return {
+    id: "product-edit",
+    type: "entityEdit",
+    entity: "product",
+    layout: { sections: [{ columns: 1, fields: ["price"] }] },
+  } as EntityEditScreenDefinition;
+}
+
+function priceField(entity: EntityDefinition, values: Record<string, unknown>): EditFieldViewModel {
+  const vm = computeEditViewModel({
+    screen: buildScreen(),
+    entity,
+    values,
+    translate: (key) => key,
+    featureName: "shop",
+  });
+  const section = vm.sections[0];
+  if (section === undefined || section.kind !== "fields") {
+    throw new Error("expected a fields section");
+  }
+  const field = section.fields[0];
+  if (field === undefined) throw new Error("expected a price field");
+  return field;
+}
+
+function renderMoneyField(
+  entity: EntityDefinition,
+  values: Record<string, unknown>,
+  onChange: (v: unknown) => void,
+): InputProps {
+  captured = undefined;
+  render(
+    <LocaleProvider resolver={createStaticLocaleResolver({ locale: "de-DE" })}>
+      <PrimitivesProvider value={testPrimitives}>
+        <RenderField field={priceField(entity, values)} onChange={onChange} />
+      </PrimitivesProvider>
+    </LocaleProvider>,
+  );
+  if (captured === undefined) throw new Error("money field did not render an Input");
+  return captured;
+}
+
+describe("RenderField money round-trip (kumiko-framework#1923)", () => {
+  test("create: untouched required field, buildInitialValues default validates against buildInsertSchema", () => {
+    const entity = buildEntity("USD");
+    // Same default shape kumiko-screen.tsx's buildInitialValues produces
+    // for a money field once a defaultCurrency is threaded through.
+    const initialPrice = { amount: 0, currency: "USD" };
+    const result = buildInsertSchema(entity).safeParse({ price: initialPrice });
+    expect(result.success).toBe(true);
+  });
+
+  test("create: user-entered amount becomes a payload that validates against buildInsertSchema", () => {
+    const entity = buildEntity("USD");
+    let payload: unknown;
+    const field = renderMoneyField(entity, {}, (v) => {
+      payload = v;
+    });
+    expect(field.kind).toBe("money");
+    if (field.kind !== "money") return;
+    expect(field.value).toBe(""); // untouched — empty widget state, not NaN/0
+    field.onChange(1299); // widget emits minor units: 12.99 USD
+    expect(payload).toEqual({ amount: 12.99, currency: "USD" });
+    const result = buildInsertSchema(entity).safeParse({ price: payload });
+    expect(result.success).toBe(true);
+  });
+
+  test("update: server-rehydrated value renders as a real number, not NaN (regression)", () => {
+    const entity = buildEntity("USD");
+    const row = { price: 1299, priceCurrency: "USD" };
+    const record = rehydrateMoney(row, entity);
+    const field = renderMoneyField(entity, record, () => {});
+    expect(field.kind).toBe("money");
+    if (field.kind !== "money") return;
+    expect(field.value).toBe(1299);
+    expect(Number.isNaN(field.value)).toBe(false);
+  });
+
+  test("update: edited amount becomes a payload that validates against buildUpdateSchema", () => {
+    const entity = buildEntity("USD");
+    const row = { price: 1299, priceCurrency: "USD" };
+    const record = rehydrateMoney(row, entity);
+    let payload: unknown;
+    const field = renderMoneyField(entity, record, (v) => {
+      payload = v;
+    });
+    if (field.kind !== "money") throw new Error("expected money kind");
+    field.onChange(1500); // user edits to 15.00
+    expect(payload).toEqual({ amount: 15, currency: "USD" });
+    const result = buildUpdateSchema(entity).safeParse({ price: payload });
+    expect(result.success).toBe(true);
+  });
+
+  test("JPY (zero-decimal currency): amountMinor is not read, so the widget value is not 100x off", () => {
+    const entity = buildEntity("JPY");
+    // DB stores minor units at the framework's flat MINOR_UNIT_SCALE=100,
+    // so ¥500 is row-stored as 50000 — rehydrateMoney's amountMinor mirrors
+    // that scale, which disagrees with JPY's real 0 decimal places. Reading
+    // amountMinor here would render 50000 instead of 500.
+    const row = { price: 50000, priceCurrency: "JPY" };
+    const record = rehydrateMoney(row, entity);
+    let payload: unknown;
+    const field = renderMoneyField(entity, record, (v) => {
+      payload = v;
+    });
+    if (field.kind !== "money") throw new Error("expected money kind");
+    expect(field.value).toBe(500);
+    field.onChange(500); // user submits the same amount unchanged
+    expect(payload).toEqual({ amount: 500, currency: "JPY" });
+    const result = buildInsertSchema(entity).safeParse({ price: payload });
+    expect(result.success).toBe(true);
+    expect(result.data?.["price"]).toEqual({ amount: 500, currency: "JPY" });
+  });
+
+  test("server schema strips an unexpected amountMinor key instead of rejecting the payload", () => {
+    const entity = buildEntity("USD");
+    const result = buildUpdateSchema(entity).safeParse({
+      price: { amount: 12.99, currency: "USD", amountMinor: 1299 },
+    });
+    expect(result.success).toBe(true);
+    expect(result.data?.["price"]).toEqual({ amount: 12.99, currency: "USD" });
+  });
+});