@cosmicdrift/kumiko-renderer 0.399.0 → 0.400.0

package/dist/app/entity-edit-prefill.js

@@ -14,6 +14,12 @@ export function versionOf(record) {
     const version = record["version"];
     return typeof version === "number" ? version : 1;
 }
+// An untouched amount carries only its currency (the input needs it for display), so a typed 0
+// stays distinguishable from the seed; required-ness is enforced on the typed amount, and the
+// submit drops a currency-only value.
+function moneySeed(currency) {
+    return { currency };
+}
 export function buildInitialValues(fields, defaultCurrency, moneyCurrencyOverrides) {
     const out = {};
     for (const [name, def] of Object.entries(fields)) {
@@ -35,7 +41,7 @@ export function buildInitialValues(fields, defaultCurrency, moneyCurrencyOverrid
         if (type === "money") {
             const currency = moneyCurrencyOverrides?.[name] ?? defaultCurrency;
             if (currency !== undefined) {
-                out[name] = { amount: 0, currency };
+                out[name] = moneySeed(currency);
                 continue;
             }
         }

package/dist/app/form-schema.js

@@ -1,4 +1,4 @@
-import { evalFieldCondition, findUnavailableSelectOptions, isUnchangedValue, NO_WIDGET_FIELD_TYPES, } from "@cosmicdrift/kumiko-framework/ui-types";
+import { evalFieldCondition, findMissingConditionalRequirements, findUnavailableSelectOptions, isFieldRequired, isUnchangedValue, NO_WIDGET_FIELD_TYPES, } from "@cosmicdrift/kumiko-framework/ui-types";
 import * as z from "zod";
 import { I18N_KEY_PARAM } from "../headless/index.js";
 import { layoutEditFields } from "./layout-fields.js";
@@ -9,6 +9,9 @@ export function isPresent(value) {
         return false;
     if (Array.isArray(value) && value.length === 0)
         return false;
+    // A money field seeded with its currency only has no amount yet.
+    if (typeof value === "object" && "currency" in value && !("amount" in value))
+        return false;
     return true;
 }
 function isEmbeddedListField(field) {
@@ -21,8 +24,9 @@ function isRequiredValueMissing(spec, field, record, unchangedFrom) {
     // Screen-spec `required` overrides the entity default, mirroring
     // `view-model/edit.ts` — the rendered form is the reference, and a
     // presence check stricter than the form blocks the user for nothing.
-    const entityRequired = "required" in field && field.required === true;
-    const isRequired = spec.required === undefined ? entityRequired : evalFieldCondition(spec.required, record);
+    const isRequired = spec.required === undefined
+        ? isFieldRequired(field, record)
+        : evalFieldCondition(spec.required, record);
     if (!isRequired)
         return false;
     // Embedded LIST fields get their own EmbeddedListField grid widget
@@ -36,6 +40,39 @@ function isRequiredValueMissing(spec, field, record, unchangedFrom) {
         return false;
     return !(unchangedFrom !== undefined && isUnchangedValue(record[spec.field], unchangedFrom[spec.field]));
 }
+// Embedded sub-field `requiredWhen` (e.g. checkpoints.0.finding) — the top-level
+// conditions are already covered by isRequiredValueMissing.
+function addEmbeddedRequirementIssues(ctx, entity, record, unchangedFrom, checkedFields) {
+    for (const path of findMissingConditionalRequirements(entity.fields, record, unchangedFrom)) {
+        const segments = path.split(".");
+        const root = segments[0];
+        if (segments.length < 2 || root === undefined || !Object.hasOwn(checkedFields, root)) {
+            continue;
+        }
+        ctx.addIssue({
+            code: "custom",
+            path: segments.map((segment) => (/^\d+$/.test(segment) ? Number(segment) : segment)),
+            message: `"${path}" is required.`,
+            params: { [I18N_KEY_PARAM]: REQUIRED_FIELD_I18N_KEY },
+        });
+    }
+}
+function addUnavailableOptionIssues(ctx, record, unchangedFrom, lockedSelectFields, selectFieldsToCheck) {
+    // Against `unchangedFrom` the helper still checks a stored value whose
+    // discriminator changed — the server validates the merged row.
+    for (const issue of findUnavailableSelectOptions({ ...lockedSelectFields, ...selectFieldsToCheck }, record, unchangedFrom)) {
+        const lockedDef = lockedSelectFields[issue.field];
+        const blamedField = lockedDef !== undefined && lockedDef.type === "select"
+            ? (lockedDef.conditionalOptions?.find((rule) => rule.options.includes(issue.value) && !evalFieldCondition(rule.when, record))?.when.field ?? issue.field)
+            : issue.field;
+        ctx.addIssue({
+            code: "custom",
+            path: [blamedField],
+            message: `"${blamedField}" is not available for the current selection.`,
+            params: { [I18N_KEY_PARAM]: OPTION_NOT_AVAILABLE_I18N_KEY, allowed: issue.allowed },
+        });
+    }
+}
 // Client-side presence validation for the auto-wired entityEdit path —
 // checks that every rendered required field HAS a value, not that the
 // value has the right shape. Format/range/type validation stays server-
@@ -107,19 +144,7 @@ export function buildFormSchema(entity, screen, verb, unchangedFrom) {
                 params: { [I18N_KEY_PARAM]: REQUIRED_FIELD_I18N_KEY },
             });
         }
-        // Against `unchangedFrom` the helper still checks a stored value whose
-        // discriminator changed — the server validates the merged row.
-        for (const issue of findUnavailableSelectOptions({ ...lockedSelectFields, ...selectFieldsToCheck }, record, unchangedFrom)) {
-            const lockedDef = lockedSelectFields[issue.field];
-            const blamedField = lockedDef !== undefined && lockedDef.type === "select"
-                ? (lockedDef.conditionalOptions?.find((rule) => rule.options.includes(issue.value) && !evalFieldCondition(rule.when, record))?.when.field ?? issue.field)
-                : issue.field;
-            ctx.addIssue({
-                code: "custom",
-                path: [blamedField],
-                message: `"${blamedField}" is not available for the current selection.`,
-                params: { [I18N_KEY_PARAM]: OPTION_NOT_AVAILABLE_I18N_KEY, allowed: issue.allowed },
-            });
-        }
+        addEmbeddedRequirementIssues(ctx, entity, record, unchangedFrom, selectFieldsToCheck);
+        addUnavailableOptionIssues(ctx, record, unchangedFrom, lockedSelectFields, selectFieldsToCheck);
     });
 }

package/dist/app/projection-detail-body.js

@@ -19,6 +19,7 @@ import { useReturnHost, useReturnTarget } from "./return-to.js";
 import { useProjectionDetailActions } from "./use-projection-detail-actions.js";
 import { useProjectionDetailData } from "./use-projection-detail-data.js";
 import { useProjectionDetailLayout } from "./use-projection-detail-layout.js";
+import { useRelatedListTabCounts } from "./use-related-list-tab-counts.js";
 // Projection detail body: read-only single-row inspector over an explicit
 // query instead of an entity (see projection-detail-shim.ts for the debt
 // doc). Fetches itself via `screen.query` + `idParam` (like
@@ -75,6 +76,11 @@ export function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
         reloadDetail,
     });
     const { hasMetrics, headerActionsList, hasHeaderActions, hasHeaderCard, renderedDetailScreen } = useProjectionDetailLayout({ screen, headerActions, hasTabs, detailScreen });
+    const recordId = detailQuery.data?.["id"];
+    const tabCounts = useRelatedListTabCounts({
+        sections: hasTabs ? screen.layout.sections : [],
+        parentId: effectiveEntityId ?? (typeof recordId === "string" ? recordId : undefined),
+    });
     if (effectiveEntityId === undefined && screen.singleton !== true) {
         return renderMissingIdBanner(primitives, screen);
     }
@@ -110,6 +116,7 @@ export function ProjectionDetailBody({ schema, screen, translate, entityId, }) {
         hasMetrics,
         hasHeaderCard,
         hasTabs,
+        tabCounts,
         activeSection,
     };
     const regionPieces = deriveDetailRegionPieces(regionModel);

package/dist/app/projection-detail-header-model.d.ts

@@ -9,4 +9,4 @@ export type DetailTabItem = {
     readonly label: string;
     readonly count?: number;
 };
-export declare function buildDetailTabItems(sections: ProjectionDetailScreenDefinition["layout"]["sections"], record: Readonly<Record<string, unknown>>, translate: Translate): DetailTabItem[];
+export declare function buildDetailTabItems(sections: ProjectionDetailScreenDefinition["layout"]["sections"], record: Readonly<Record<string, unknown>>, translate: Translate, queryCounts?: Readonly<Record<string, number>>): DetailTabItem[];

package/dist/app/projection-detail-header-model.js

@@ -50,10 +50,10 @@ export function resolveSubtitleHref(header, record) {
     const value = record[header.subtitleHref];
     return typeof value === "string" && isAbsoluteHttpUrl(value) ? value : undefined;
 }
-export function buildDetailTabItems(sections, record, translate) {
+export function buildDetailTabItems(sections, record, translate, queryCounts = {}) {
     return sections.map((section) => {
         const countField = isWriteFormEditSection(section) ? undefined : section.countField;
-        const countValue = countField !== undefined ? record[countField] : undefined;
+        const countValue = countField !== undefined ? record[countField] : queryCounts[section.id ?? ""];
         const count = typeof countValue === "number" && Number.isFinite(countValue) ? countValue : undefined;
         return {
             id: section.id ?? "",

package/dist/app/projection-detail-header-region.d.ts

@@ -10,6 +10,7 @@ export type DetailRegionModel = DetailHeaderModel & {
     readonly hasMetrics: boolean;
     readonly hasHeaderCard: boolean;
     readonly hasTabs: boolean;
+    readonly tabCounts: Readonly<Record<string, number>>;
     readonly activeSection: ProjectionDetailScreenDefinition["layout"]["sections"][number] | undefined;
 };
 export type DetailRegionPieces = {

package/dist/app/projection-detail-header-region.js

@@ -68,7 +68,7 @@ function renderHeaderCardBranch(model, pieces, headerSlot) {
 }
 function renderDetailTabs(model, activeSection, Tabs) {
     const { screen, record, effectiveTranslate, nav } = model;
-    return (_jsx(Tabs, { testId: "kumiko-screen-projection-detail-tabs", items: buildDetailTabItems(screen.layout.sections, record, effectiveTranslate), activeId: activeSection.id ?? "", onSelect: (id) => requestLeave(() => nav.setSearchParams({ tab: id })) }));
+    return (_jsx(Tabs, { testId: "kumiko-screen-projection-detail-tabs", items: buildDetailTabItems(screen.layout.sections, record, effectiveTranslate, model.tabCounts), activeId: activeSection.id ?? "", onSelect: (id) => requestLeave(() => nav.setSearchParams({ tab: id })) }));
 }
 export function renderDetailHeaderContent(model, pieces, headerSlot) {
     const { hasTabs, activeSection } = model;

package/dist/app/projection-detail-header.js

@@ -3,7 +3,7 @@ import { Fragment } from "react";
 import { ErrorReference } from "./error-reference.js";
 import { HeaderActionsBar } from "./header-actions-bar.js";
 import { headerStatusTone, resolveHeaderStatusText, resolveSubtitleHref, } from "./projection-detail-header-model.js";
-import { buildSubtitleParts, runMetricNavigate } from "./projection-detail-navigation.js";
+import { buildSubtitleParts, metricNavigateResolves, runMetricNavigate, } from "./projection-detail-navigation.js";
 import { navigateTargetAllows } from "./screen-access.js";
 export function renderHeaderActionsContent(model) {
     const { screen, primitives, headerActionsList, setActionError } = model;
@@ -58,7 +58,9 @@ export function buildMetricItems(model) {
         const tone = rawValue === 0 ? undefined : metric.tone;
         const testId = `kumiko-screen-projection-detail-metric-${field}`;
         const navigate = metric.navigate;
-        const onPress = navigate !== undefined && navigateTargetAllows(navigate, appFeatures, userRoles)
+        const onPress = navigate !== undefined &&
+            metricNavigateResolves(navigate, record) &&
+            navigateTargetAllows(navigate, appFeatures, userRoles)
             ? () => runMetricNavigate(nav, navigate, record, host)
             : undefined;
         return Metric !== undefined ? (_jsx(Metric, { label: label, value: value, testId: testId, ...(onPress !== undefined && { onPress }), ...(tiles && { tile: true }), ...(tone !== undefined && { tone }), ...(metric.icon !== undefined && { icon: metric.icon }) }, field)) : (_jsxs(GridCell, { children: [_jsx(Text, { variant: "small", testId: `${testId}-label`, children: label }), _jsx(Text, { testId: `${testId}-value`, children: value })] }, field));

package/dist/app/projection-detail-navigation.d.ts

@@ -10,4 +10,5 @@ export type SubtitlePartView = {
     readonly href?: string;
     readonly onPress?: () => void;
 };
+export declare function metricNavigateResolves(navigate: MetricNavigate, record: Readonly<Record<string, unknown>>): boolean;
 export declare function buildSubtitleParts(parts: readonly RecordHeaderSubtitlePart[], record: Readonly<Record<string, unknown>>, nav: NavApi, appFeatures: readonly FeatureSchema[], userRoles: readonly string[] | undefined, host: ReturnHost | undefined): SubtitlePartView[];

package/dist/app/projection-detail-navigation.js

@@ -47,12 +47,20 @@ export function runMetricNavigate(nav, navigate, record, host) {
 export function isAbsoluteHttpUrl(value) {
     return /^https?:\/\//i.test(value) && isSafeHref(value);
 }
+function recordEntityId(navigate, record) {
+    return navigate.entityId !== undefined ? String(record[navigate.entityId] ?? "") : undefined;
+}
+// A metric whose declared entityId field is empty on this record has nowhere to go, so it must
+// not look clickable. Tab-only navigation always resolves.
+export function metricNavigateResolves(navigate, record) {
+    return recordEntityId(navigate, record) !== "";
+}
 // hrefFor throws for an entity without a detailFor screen; outside
 // createKumikoApp the feature list is empty, so navigateTargetAllows can't
 // rule that out beforehand. The NavApi owns target resolution, so asking it
 // and falling back to plain text covers both cases.
 function hrefForNavigate(nav, navigate, record) {
-    const entityId = navigate.entityId !== undefined ? String(record[navigate.entityId] ?? "") : undefined;
+    const entityId = recordEntityId(navigate, record);
     try {
         if (navigate.entity !== undefined) {
             return entityId === undefined || entityId === ""

package/dist/app/use-related-list-tab-counts.d.ts

@@ -0,0 +1,5 @@
+import type { EditSectionSpec } from "@cosmicdrift/kumiko-framework/ui-types";
+export declare function useRelatedListTabCounts(args: {
+    readonly sections: readonly EditSectionSpec[];
+    readonly parentId: string | undefined;
+}): Readonly<Record<string, number>>;

package/dist/app/use-related-list-tab-counts.js

@@ -0,0 +1,68 @@
+import { useEffect, useMemo, useState } from "react";
+import { useOptionalDispatcher } from "../context/dispatcher-context.js";
+import { liveEntitiesForQuery, subscribeToEntities } from "../hooks/live-query-entities.js";
+import { createLiveRefetchScheduler } from "../hooks/live-refetch-scheduler.js";
+import { buildRelatedListParentPayload } from "../hooks/related-list-parent-payload.js";
+import { useLiveEvents } from "../sse/live-events.js";
+import { useAppFeatures } from "./app-features-context.js";
+// Tab badges come from each section's own query (`limit: 1, totalCount: true` → `total`), so
+// they match the tab's rows and refresh on the same live events.
+export function useRelatedListTabCounts(args) {
+    const { sections, parentId } = args;
+    const dispatcher = useOptionalDispatcher();
+    const features = useAppFeatures();
+    const subscribeLive = useLiveEvents();
+    const [counts, setCounts] = useState({});
+    const requests = useMemo(() => {
+        if (parentId === undefined)
+            return [];
+        const out = [];
+        for (const section of sections) {
+            if (section.kind !== "relatedList" || section.count !== true || section.id === undefined) {
+                continue;
+            }
+            out.push({
+                sectionId: section.id,
+                query: section.query,
+                payload: {
+                    ...buildRelatedListParentPayload(section, parentId),
+                    limit: 1,
+                    totalCount: true,
+                },
+            });
+        }
+        return out;
+    }, [sections, parentId]);
+    useEffect(() => {
+        // skip: nothing to count, or no dispatcher mounted
+        if (requests.length === 0 || dispatcher === undefined)
+            return;
+        const ctrl = new AbortController();
+        const load = async () => {
+            const results = await Promise.all(requests.map((request) => dispatcher.query(request.query, request.payload, {
+                signal: ctrl.signal,
+            })));
+            // skip: unmounted or superseded while the queries were in flight
+            if (ctrl.signal.aborted)
+                return;
+            const next = {};
+            results.forEach((result, index) => {
+                const total = result.isSuccess ? result.data?.total : undefined;
+                const request = requests[index];
+                if (request !== undefined && typeof total === "number")
+                    next[request.sectionId] = total;
+            });
+            setCounts(next);
+        };
+        void load();
+        const scheduler = createLiveRefetchScheduler(load);
+        const entities = [...new Set(requests.flatMap((r) => liveEntitiesForQuery(r.query, features)))];
+        const unsubscribe = subscribeToEntities(subscribeLive, entities, scheduler.trigger);
+        return () => {
+            ctrl.abort();
+            unsubscribe();
+            scheduler.dispose();
+        };
+    }, [requests, dispatcher, features, subscribeLive]);
+    return counts;
+}

package/dist/components/embedded-list-field.js

@@ -1,12 +1,65 @@
 import { jsx as _jsx } from "react/jsx-runtime";
+import { evalFieldCondition, isFieldRequired } from "@cosmicdrift/kumiko-framework/ui-types";
+import { isPlainObject } from "@cosmicdrift/kumiko-types/type-guards";
 import { useState } from "react";
-import { computeDerivedCellValue, currencyDecimals, groupEmbeddedListIssues, roundDerivedCellValue, sumEmbeddedListColumn, } from "../headless/index.js";
+import { groupEmbeddedListIssues, sumEmbeddedListColumn, withDerivedCells, } from "../headless/index.js";
 import { pluralKey } from "../headless/plural-key.js";
 import { REFERENCE_COMBOBOX_LIMIT } from "../hooks/reference-limits.js";
 import { useQuery } from "../hooks/use-query.js";
 import { referenceOptionSource, storedReferenceRowsPayload, withUnlistedSelectedRows, } from "../hooks/use-reference-lookup.js";
 import { useTranslation } from "../i18n.js";
 import { usePrimitives } from "../primitives.js";
+import { coerceCellValue } from "./embedded-list-paste.js";
+// The primitive never imports condition logic, so the per-row state is evaluated here.
+function rowStateCallbacks(cell, derivedDef) {
+    const { visibleWhen, requiredWhen } = cell;
+    const derivedWhen = derivedDef?.when;
+    return {
+        ...(visibleWhen !== undefined && {
+            isHiddenInRow: (row) => !evalFieldCondition(visibleWhen, row),
+        }),
+        ...((visibleWhen !== undefined || requiredWhen !== undefined) && {
+            isRequiredInRow: (row) => isFieldRequired({ required: cell.required, visibleWhen, requiredWhen }, row),
+        }),
+        ...(derivedDef !== undefined &&
+            derivedWhen !== undefined && {
+            isDerivedInRow: (row) => evalFieldCondition(derivedWhen, row),
+        }),
+    };
+}
+// An inRange derived cell (value, min, max → result) reads as one measurement on a phone card:
+// the limits become a hint under the value and the result sits beside it. Editable limits stay
+// their own rows: hiding them would leave phone users no way to fill them.
+function cardPlacementByField(derived, cells) {
+    const placement = new Map();
+    const isNotEditable = (field) => {
+        const cell = cells.find((c) => c.field === field);
+        return cell !== undefined && (cell.readOnly === true || derived?.[field] !== undefined);
+    };
+    for (const [target, def] of Object.entries(derived ?? {})) {
+        if (def.op !== "inRange")
+            continue;
+        const [value, min, max] = def.from;
+        if (value === undefined || min === undefined || max === undefined)
+            continue;
+        if (isNotEditable(min) && isNotEditable(max)) {
+            placement.set(value, { cardLimits: { min, max } });
+            placement.set(min, { hiddenInCard: true });
+            placement.set(max, { hiddenInCard: true });
+        }
+        placement.set(target, { cardAttachedTo: value });
+    }
+    return placement;
+}
+function cardColumnProps(cell, placement) {
+    const fromDerived = placement.get(cell.field);
+    return {
+        ...fromDerived,
+        ...((cell.hiddenInCard === true || fromDerived?.hiddenInCard === true) && {
+            hiddenInCard: true,
+        }),
+    };
+}
 function storedCellIds(rows, cellField) {
     const ids = new Set();
     for (const row of rows) {
@@ -19,95 +72,9 @@ function storedCellIds(rows, cellField) {
 function withRecomputedDerived(row, derived, cells) {
     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 = { ...row };
-    for (const [derivedField, def] of Object.entries(derived)) {
-        const values = def.from.map((src) => {
-            const v = source[src];
-            return typeof v === "number" ? v : undefined;
-        });
-        const computed = computeDerivedCellValue(def.op, values);
-        const target = cells.find((c) => c.field === derivedField);
-        result[derivedField] =
-            computed !== undefined && target !== undefined
-                ? roundDerivedCellValue(computed, target)
-                : computed;
-    }
-    return result;
-}
-// Locale-aware decimal parse for pasted text: strips space/NBSP thousands
-// separators outright, then treats whichever of "," or "." appears LAST in
-// the string as the decimal separator and strips the other one — handles
-// both "1.234,56" (de) and "1,234.56" (en-US) pastes. Returns undefined for
-// anything that still doesn't parse as a finite number.
-function parseLocaleAwareDecimal(raw) {
-    const stripped = raw.replace(/[\s ]/g, "");
-    if (stripped === "")
-        return undefined;
-    const lastComma = stripped.lastIndexOf(",");
-    const lastDot = stripped.lastIndexOf(".");
-    const decimalIndex = Math.max(lastComma, lastDot);
-    if (decimalIndex === -1) {
-        const n = Number(stripped);
-        return Number.isFinite(n) ? n : undefined;
-    }
-    const integerPart = stripped.slice(0, decimalIndex).replace(/[.,]/g, "");
-    const fractionPart = stripped.slice(decimalIndex + 1);
-    if (!/^\d*$/.test(integerPart) || !/^\d*$/.test(fractionPart))
-        return undefined;
-    const n = Number(`${integerPart === "" ? "0" : integerPart}.${fractionPart === "" ? "0" : fractionPart}`);
-    return Number.isFinite(n) ? n : undefined;
-}
-function coerceCellValue(column, text, currency) {
-    switch (column.type) {
-        case "text":
-            return text;
-        case "number":
-        case "decimal": {
-            if (text.trim() === "")
-                return undefined;
-            const n = Number(text);
-            return Number.isFinite(n) ? n : undefined;
-        }
-        case "money": {
-            // Money cells are minor-unit integers (cents) in storage — paste
-            // arrives as a major-unit decimal string ("12,99"/"12.99"), so scale
-            // by the currency's decimal places. Must agree with the typed-in path
-            // (renderCellControl's MoneyInput, which scales by the same
-            // currencyDecimals) — a hardcoded ×100 here diverged for zero-/three-
-            // decimal currencies (JPY, BHD, ...), landing a pasted value 100x off
-            // from the same value typed by hand.
-            // parseLocaleAwareDecimal handles both "1.234,56" (de) and
-            // "1,234.56" (en-US) thousands/decimal conventions — a naive
-            // `replace(",", ".")` mangled German-locale pastes with thousands
-            // separators into NaN.
-            if (text.trim() === "")
-                return undefined;
-            const n = parseLocaleAwareDecimal(text);
-            return n === undefined ? undefined : Math.round(n * 10 ** currencyDecimals(currency));
-        }
-        case "boolean":
-            return ["true", "1", "yes", "y", "ja"].includes(text.trim().toLowerCase());
-        case "date":
-        case "timestamp":
-            return text.trim();
-        case "select": {
-            const match = (column.options ?? []).find((opt) => opt === text || column.optionLabels?.[opt] === text);
-            return match;
-        }
-        case "reference": {
-            const match = (column.referenceOptions ?? []).find((o) => o.label === text || o.value === text);
-            return match?.value;
-        }
-        default: {
-            const exhaustiveCheck = column.type;
-            return exhaustiveCheck;
-        }
-    }
+    const targets = Object.fromEntries(cells.map((cell) => [cell.field, cell]));
+    const recomputed = withDerivedCells(row, derived, targets);
+    return isPlainObject(recomputed) ? recomputed : row;
 }
 // The reference-column queries are hooks called in a loop, so their count must
 // stay fixed per mount. Keying on the reference cells remounts when that set
@@ -141,6 +108,7 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
     });
     if (EmbeddedListInput === undefined)
         return null;
+    const cardPlacement = cardPlacementByField(derived, cells);
     const columns = cells.map((cell) => {
         const isDerived = derived?.[cell.field] !== undefined;
         if (cell.type === "reference") {
@@ -157,7 +125,9 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
                 type: cell.type,
                 required: cell.required,
                 derived: isDerived,
+                ...rowStateCallbacks(cell, derived?.[cell.field]),
                 ...(cell.readOnly === true && { readOnly: true }),
+                ...cardColumnProps(cell, cardPlacement),
                 referenceOptions,
                 referenceLoading: query?.loading ?? false,
             };
@@ -168,10 +138,16 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
             type: cell.type,
             required: cell.required,
             derived: isDerived,
+            ...rowStateCallbacks(cell, derived?.[cell.field]),
             ...(cell.readOnly === true && { readOnly: true }),
+            ...cardColumnProps(cell, cardPlacement),
             ...(cell.options !== undefined && { options: cell.options }),
             ...(cell.optionLabels !== undefined && { optionLabels: cell.optionLabels }),
             ...(cell.display !== undefined && { display: cell.display }),
+            ...(cell.optionTones !== undefined && { optionTones: cell.optionTones }),
+            ...(cell.capture !== undefined && { capture: cell.capture }),
+            ...(cell.maxCount !== undefined && { maxCount: cell.maxCount }),
+            ...(cell.accept !== undefined && { accept: cell.accept }),
         };
     });
     const totals = (field.embeddedListTotals ?? []).map((entry) => {
@@ -271,6 +247,8 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
                 const column = columns[columnIndex + gridColOffset];
                 if (column === undefined || column.readOnly === true)
                     return;
+                if (column.type === "images" || column.type === "files")
+                    return;
                 const coerced = coerceCellValue(column, text, field.embeddedListCurrency ?? "EUR");
                 // Also covers an unparseable money paste (e.g. mangled thousands
                 // separators) — the cell must stay unchanged instead of silently
@@ -291,5 +269,5 @@ function EmbeddedListFieldInner({ field, id, onChange, allIssues, featureName, }
         const recomputed = nextRows.map((row, i) => touchedIndices.has(i) ? withRecomputedDerived(row, derived, cells) : row);
         onChange(recomputed);
     }
-    return (_jsx(EmbeddedListInput, { id: id, columns: columns, rows: rows, totals: totals, currency: field.embeddedListCurrency, disabled: field.readOnly, fixedRows: field.embeddedListFixedRows, minItems: field.embeddedListMinItems, maxItems: field.embeddedListMaxItems, listIssues: combinedListIssues, rowIssues: rowIssues, cellIssues: cellIssues, onCellChange: handleCellChange, onAddRow: handleAddRow, onRemoveRow: handleRemoveRow, onDuplicateRow: handleDuplicateRow, onMoveRow: handleMoveRow, onPasteCells: handlePasteCells, addLabel: t("kumiko.field.embedded-list.add-row"), actionsLabel: t("kumiko.field.embedded-list.actions"), removeLabel: t("kumiko.field.embedded-list.remove-row"), duplicateLabel: t("kumiko.field.embedded-list.duplicate-row"), moveUpLabel: t("kumiko.field.embedded-list.move-up"), moveDownLabel: t("kumiko.field.embedded-list.move-down"), emptyLabel: t("kumiko.field.embedded-list.empty"), emptyCtaLabel: t("kumiko.field.embedded-list.empty-cta"), testId: id }));
+    return (_jsx(EmbeddedListInput, { id: id, columns: columns, rows: rows, totals: totals, currency: field.embeddedListCurrency, disabled: field.readOnly, fixedRows: field.embeddedListFixedRows, minItems: field.embeddedListMinItems, maxItems: field.embeddedListMaxItems, uploadTarget: field.embeddedListUploadTarget, listIssues: combinedListIssues, rowIssues: rowIssues, cellIssues: cellIssues, onCellChange: handleCellChange, onAddRow: handleAddRow, onRemoveRow: handleRemoveRow, onDuplicateRow: handleDuplicateRow, onMoveRow: handleMoveRow, onPasteCells: handlePasteCells, addLabel: t("kumiko.field.embedded-list.add-row"), actionsLabel: t("kumiko.field.embedded-list.actions"), removeLabel: t("kumiko.field.embedded-list.remove-row"), duplicateLabel: t("kumiko.field.embedded-list.duplicate-row"), moveUpLabel: t("kumiko.field.embedded-list.move-up"), moveDownLabel: t("kumiko.field.embedded-list.move-down"), emptyLabel: t("kumiko.field.embedded-list.empty"), emptyCtaLabel: t("kumiko.field.embedded-list.empty-cta"), testId: id }));
 }

package/dist/components/embedded-list-paste.d.ts

@@ -0,0 +1,2 @@
+import type { EmbeddedListColumn } from "../primitives.tsx";
+export declare function coerceCellValue(column: EmbeddedListColumn, text: string, currency: string): unknown;

package/dist/components/embedded-list-paste.js

@@ -0,0 +1,73 @@
+import { currencyDecimals } from "../headless/index.js";
+// Locale-aware decimal parse for pasted text: strips space/NBSP thousands
+// separators outright, then treats whichever of "," or "." appears LAST in
+// the string as the decimal separator and strips the other one — handles
+// both "1.234,56" (de) and "1,234.56" (en-US) pastes. Returns undefined for
+// anything that still doesn't parse as a finite number.
+function parseLocaleAwareDecimal(raw) {
+    const stripped = raw.replace(/[\s\u00a0]/g, "");
+    if (stripped === "")
+        return undefined;
+    const lastComma = stripped.lastIndexOf(",");
+    const lastDot = stripped.lastIndexOf(".");
+    const decimalIndex = Math.max(lastComma, lastDot);
+    if (decimalIndex === -1) {
+        const n = Number(stripped);
+        return Number.isFinite(n) ? n : undefined;
+    }
+    const integerPart = stripped.slice(0, decimalIndex).replace(/[.,]/g, "");
+    const fractionPart = stripped.slice(decimalIndex + 1);
+    if (!/^\d*$/.test(integerPart) || !/^\d*$/.test(fractionPart))
+        return undefined;
+    const n = Number(`${integerPart === "" ? "0" : integerPart}.${fractionPart === "" ? "0" : fractionPart}`);
+    return Number.isFinite(n) ? n : undefined;
+}
+function coerceNumber(text) {
+    if (text.trim() === "")
+        return undefined;
+    const n = Number(text);
+    return Number.isFinite(n) ? n : undefined;
+}
+// Money cells are minor-unit integers (cents) in storage — paste arrives as a major-unit decimal
+// string ("12,99"/"12.99"), so scale by the currency's decimal places. Must agree with the
+// typed-in path (MoneyInput, which scales by the same currencyDecimals) — a hardcoded ×100
+// diverged for zero-/three-decimal currencies (JPY, BHD, ...).
+function coerceMoney(text, currency) {
+    if (text.trim() === "")
+        return undefined;
+    const n = parseLocaleAwareDecimal(text);
+    return n === undefined ? undefined : Math.round(n * 10 ** currencyDecimals(currency));
+}
+function coerceSelect(column, text) {
+    return (column.options ?? []).find((opt) => opt === text || column.optionLabels?.[opt] === text);
+}
+function coerceReference(column, text) {
+    return (column.referenceOptions ?? []).find((o) => o.label === text || o.value === text)?.value;
+}
+export function coerceCellValue(column, text, currency) {
+    switch (column.type) {
+        case "text":
+            return text;
+        case "number":
+        case "decimal":
+            return coerceNumber(text);
+        case "money":
+            return coerceMoney(text, currency);
+        case "boolean":
+            return ["true", "1", "yes", "y", "ja"].includes(text.trim().toLowerCase());
+        case "date":
+        case "timestamp":
+            return text.trim();
+        case "select":
+            return coerceSelect(column, text);
+        case "reference":
+            return coerceReference(column, text);
+        case "images":
+        case "files":
+            return undefined;
+        default: {
+            const exhaustiveCheck = column.type;
+            return exhaustiveCheck;
+        }
+    }
+}

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

@@ -16,6 +16,7 @@ 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 { buildRelatedListParentPayload } from "../hooks/related-list-parent-payload.js";
 import { useRelatedListRows } from "../hooks/use-related-list-rows.js";
 import { useRelatedListState } from "../hooks/use-related-list-state.js";
 import { useOptionalLocale, useTranslation } from "../i18n.js";
@@ -147,14 +148,9 @@ export function RelatedListSection({ section, parentId, record, featureName, tra
     const filterPayload = useMemo(() => buildFilterPayload(filters, (field) => resolvedFacetSpecs.find((spec) => spec.field === field)?.type), [filters, resolvedFacetSpecs]);
     const filterFacets = useMemo(() => buildFilterFacets(resolvedFacetSpecs), [resolvedFacetSpecs]);
     const payload = useMemo(() => ({
-        // `parentFilter` sends the parent id as a server-side `filter` clause
-        // instead of a bespoke top-level key — the generic `<entity>:list`
-        // query understands `filter`, not an arbitrary `parentParam` key. Kept
-        // separate from `filterPayload` (user facets) below so a facet
-        // selection can never clear or overwrite it.
-        ...(section.parentFilter !== undefined
-            ? { filter: { field: section.parentFilter.field, op: "eq", value: parentId } }
-            : { [section.parentParam ?? "id"]: parentId }),
+        // Kept separate from `filterPayload` (user facets) below so a facet selection can never
+        // clear or overwrite the parent pin.
+        ...buildRelatedListParentPayload({ parentFilter: section.parentFilter, parentParam: section.parentParam }, parentId),
         ...(section.pageSize !== undefined && { limit: section.pageSize }),
         // Gated on the declared capability, not just on state carrying a value —
         // same rule as ProjectionListBody: a param the bound query's Zod schema