@cosmicdrift/kumiko-renderer 0.398.0 → 0.400.0

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

@@ -8,7 +8,7 @@ import { useListBulk } from "../app/list-bulk-actions.js";
 import { buildFilterFacets, buildFilterPayload, mergeReferenceFacetOptions, resolveProjectionFacetSpecs, } from "../app/list-facets.js";
 import { useNav } from "../app/nav.js";
 import { SYNTHESIZED_FIELD_PII_REASON } from "../app/projection-list-shim.js";
-import { ReferenceFacetBridges, } from "../app/reference-facet-bridge.js";
+import { ReferenceFacetBridges, withReferenceFacetState, } from "../app/reference-facet-bridge.js";
 import { navigateWithReturnTo, useReturnHost } from "../app/return-to.js";
 import { buildDefaultEditRowAction, buildProjectionRowActions, buildProjectionToolbarActions, buildRecordActions, findRowClickAction, runDrawerRowAction, runProjectionRowNavigate, } from "../app/row-actions.js";
 import { findEditScreenFor } from "../app/screen-access.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";
@@ -142,19 +143,14 @@ export function RelatedListSection({ section, parentId, record, featureName, tra
     const { search, filters, sort, setSearch, setFilters, setSort, listTable, groupField } = useRelatedListState(section, nav.route?.screenId);
     const facetSpecs = useMemo(() => resolveProjectionFacetSpecs(section.facets, effectiveTranslate, featureName), [section.facets, effectiveTranslate, featureName]);
     const [referenceFacetOptions, setReferenceFacetOptions] = useState({});
-    const handleFacetOptions = useCallback((field, options) => setReferenceFacetOptions((prev) => prev[field] === options ? prev : { ...prev, [field]: options }), []);
+    const handleFacetOptions = useCallback((field, state) => setReferenceFacetOptions((prev) => withReferenceFacetState(prev, field, state)), []);
     const resolvedFacetSpecs = useMemo(() => mergeReferenceFacetOptions(facetSpecs, referenceFacetOptions), [facetSpecs, referenceFacetOptions]);
     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
@@ -332,7 +328,7 @@ export function RelatedListSection({ section, parentId, record, featureName, tra
     // `renderer` stays DOM-free. Stacked (non-tabs) sections keep their own
     // Section card and document-flow height since they render a visible title
     // and aren't confined to a tab panel.
-    const bridges = _jsx(ReferenceFacetBridges, { specs: facetSpecs, onOptions: handleFacetOptions });
+    const bridges = (_jsx(ReferenceFacetBridges, { specs: facetSpecs, selected: filters, onState: handleFacetOptions }));
     if (embedded === true) {
         const countSuffix = listRows.hasData
             ? ` · ${aggregates.serverGroups?.totalCount ?? listRows.rows.length}`

package/dist/components/render-edit-fields-section.js

@@ -10,7 +10,7 @@ function renderTabbedGroupsSection(rc, section, sectionKey) {
     // group cards (Card-in-Card) — the boot-validator rejects that
     // combination in tabs mode, so `sectionActionsEl` is always
     // undefined here at runtime.
-    return rc.wrapWizardStep(sectionKey, _jsx(Card, { options: { framed: false }, children: groupsGrid }, sectionKey));
+    return rc.wrapWizardStep(sectionKey, _jsx(Card, { options: { framed: false }, ...(section.description !== undefined && { slots: { subtitle: section.description } }), children: groupsGrid }, sectionKey));
 }
 function renderTabbedFieldsSection(rc, section, sectionKey) {
     if (section.groups !== undefined)

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

@@ -73,7 +73,7 @@ export function wizardStepKey(section, index) {
     return declaredId ?? section.title ?? `step-${index}`;
 }
 function isMoneyValue(value) {
-    return typeof value === "object" && value !== null && "amount" in value;
+    return typeof value === "object" && value !== null && ("amount" in value || "currency" in value);
 }
 // The seeds buildInitialValues writes for NULL columns of an existing record.
 function isEmptyFormValue(value) {
@@ -82,7 +82,7 @@ function isEmptyFormValue(value) {
     }
     if (Array.isArray(value))
         return value.length === 0;
-    return isMoneyValue(value) && value.amount === 0;
+    return isMoneyValue(value) && (value.amount === 0 || value.amount === undefined);
 }
 // select/boolean are excluded from the "holds user data" check: they are
 // often pre-filled (defaults, server-set values), so they say nothing about

package/dist/components/render-field-choice-inputs.js

@@ -25,7 +25,7 @@ export function renderSelectInput({ field, Input, onChange }, { common }) {
     // `display` is shared with multiSelect's "checkboxes", which is not a
     // select presentation — narrow to the two a select field can request.
     const display = field.display === "radio" || field.display === "dropdown" ? field.display : undefined;
-    return (_jsx(Input, { kind: "select", ...common, value: stringValue(field.value), onChange: (v) => onChange(v), options: selectOptions, ...(display !== undefined && { display }) }));
+    return (_jsx(Input, { kind: "select", ...common, value: stringValue(field.value), onChange: (v) => onChange(v), options: selectOptions, ...(display !== undefined && { display }), ...(field.optionTones !== undefined && { optionTones: field.optionTones }) }));
 }
 export function renderFileInput({ field, Input, onChange }, { common }) {
     const kind = field.type === "image" ? "image" : "file";

package/dist/data-table-facet-types.d.ts

@@ -16,6 +16,11 @@ export type DataTableFacet = {
     readonly showCounts?: boolean;
     /** Chips only: hide chips whose `count` is 0 (unless pressed). */
     readonly hideEmpty?: boolean;
+    /** Present: the options come from a server-side search (reference facets), so the dropdown
+     *  shows a search field and reports the typed term instead of filtering `options` itself. */
+    readonly onSearchChange?: (query: string) => void;
+    /** The search is loading; the option list may still show the previous term's rows. */
+    readonly searching?: boolean;
 };
 export type DataTableFacetChip = {
     readonly id: string;

package/dist/embedded-list-types.d.ts

@@ -0,0 +1,117 @@
+import type { SelectOptionTone } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { FieldIssue } from "./headless/index.ts";
+/** Cell type for one column of an embedded-list field. Mirrors
+ *  EmbeddedListCellViewModel["type"] from `@cosmicdrift/kumiko-renderer/headless`. */
+export type EmbeddedListCellType = "text" | "number" | "boolean" | "date" | "money" | "decimal" | "select" | "reference" | "timestamp" | "images" | "files";
+/** One column of an embedded-list table (one entry per key of the source
+ *  EmbeddedFieldDef's `schema`). */
+export type EmbeddedListColumn = {
+    readonly field: string;
+    readonly label: string;
+    readonly type: EmbeddedListCellType;
+    readonly required: boolean;
+    /** Read-only, value supplied by the caller (already computed from
+     *  sibling cells) — not directly user-editable. */
+    readonly derived: boolean;
+    /** Shown but not editable by the user; unlike `derived` it is not computed. */
+    readonly readOnly?: boolean;
+    /** Phone cards skip this column; the table still shows it. */
+    readonly hiddenInCard?: boolean;
+    /** Phone cards show the row's min/max (sub-field names) as a hint under this column's control. */
+    readonly cardLimits?: {
+        readonly min: string;
+        readonly max: string;
+    };
+    /** Phone cards render this column unlabeled beside the named column's control. */
+    readonly cardAttachedTo?: string;
+    /** Only for `type: "select"`. */
+    readonly options?: readonly string[];
+    readonly optionLabels?: Readonly<Record<string, string>>;
+    /** Only for `type: "select"`; `"radio"` renders segmented buttons, the
+     *  default is a dropdown. */
+    readonly display?: "radio" | "dropdown";
+    /** Only for `type: "reference"` — pre-fetched by the caller, ONE query
+     *  per column shared across every row (not one query per cell). */
+    readonly referenceOptions?: readonly {
+        readonly value: string;
+        readonly label: string;
+    }[];
+    readonly referenceLoading?: boolean;
+    /** Only for `type: "select"`; tone per option (selected segment, derived badge). */
+    readonly optionTones?: Readonly<Partial<Record<string, SelectOptionTone>>>;
+    /** Only for `type: "images" | "files"`. */
+    readonly capture?: "user" | "environment";
+    readonly maxCount?: number;
+    readonly accept?: readonly string[];
+    /** Per-row state, evaluated by the caller (conditions are engine logic the primitive must not import).
+     *  A hidden cell keeps its value but shows no control. */
+    readonly isHiddenInRow?: (row: Readonly<Record<string, unknown>>) => boolean;
+    readonly isRequiredInRow?: (row: Readonly<Record<string, unknown>>) => boolean;
+    /** Overrides `derived` per row: a conditional derived cell is editable on rows where it does not apply. */
+    readonly isDerivedInRow?: (row: Readonly<Record<string, unknown>>) => boolean;
+};
+/** One entry of an embedded-list totals row (e.g. an invoice's total
+ *  amount, summed across all rows by the caller). */
+export type EmbeddedListTotal = {
+    readonly field: string;
+    readonly label: string;
+    readonly value: number;
+    /** Set for labelled multi-column totals, which have no single column to
+     *  read the money type from. */
+    readonly money?: boolean;
+};
+/** Row-array + totals table for a `createEmbeddedListField` (invoice-
+ *  positions-style) field — structurally too different from `Input`'s
+ *  value/onChange union to fit there, so it's its own primitive, same as
+ *  `DataTable`. Controlled: the caller (the eventual form-field wrapper)
+ *  computes rows/derived values/issue groups and wires every callback;
+ *  this primitive only renders and reports interaction. */
+export type EmbeddedListInputProps = {
+    readonly id: string;
+    readonly columns: readonly EmbeddedListColumn[];
+    readonly rows: readonly Readonly<Record<string, unknown>>[];
+    readonly totals?: readonly EmbeddedListTotal[];
+    /** Currency for money cells and the totals row — one value for the whole
+     *  list (currency lives on the head aggregate, not the row). Web impl
+     *  falls back to "EUR" when absent. */
+    readonly currency?: string;
+    /** Whole-list read-only (e.g. a released invoice) — hides row-mutation
+     *  affordances and disables every cell. */
+    readonly disabled?: boolean;
+    /** Rows are fixed: no add, remove, duplicate or move; cells stay editable. */
+    readonly fixedRows?: boolean;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    /** Upload target of file cells: `entityType`/`entityId`/`fieldName` of the list, the column name is the `subField`. */
+    readonly uploadTarget?: {
+        readonly entityType: string;
+        readonly fieldName: string;
+        readonly entityId?: string;
+    };
+    /** Shown under the whole list (e.g. under the totals row). */
+    readonly listIssues?: readonly FieldIssue[];
+    /** Keyed by row index. */
+    readonly rowIssues?: Readonly<Record<number, readonly FieldIssue[]>>;
+    /** Keyed `${rowIndex}.${field}`. */
+    readonly cellIssues?: Readonly<Record<string, readonly FieldIssue[]>>;
+    readonly onCellChange: (rowIndex: number, field: string, value: unknown) => void;
+    readonly onAddRow: () => void;
+    readonly onRemoveRow: (rowIndex: number) => void;
+    readonly onDuplicateRow: (rowIndex: number) => void;
+    readonly onMoveRow: (fromIndex: number, toIndex: number) => void;
+    /** Tab/newline-delimited clipboard paste starting at (rowIndex,
+     *  columnIndex) — parsed to a 2D string grid by the Web impl (paste
+     *  events are a browser-only concept); undefined caller = no paste
+     *  handling wired up. */
+    readonly onPasteCells?: (rowIndex: number, columnIndex: number, grid: readonly (readonly string[])[]) => void;
+    readonly addLabel: string;
+    /** Accessible name of the (otherwise headerless) row-actions column. */
+    readonly actionsLabel: string;
+    readonly removeLabel: string;
+    readonly duplicateLabel: string;
+    readonly moveUpLabel: string;
+    readonly moveDownLabel: string;
+    readonly emptyLabel: string;
+    readonly emptyCtaLabel: string;
+    readonly testId?: string;
+};

package/dist/embedded-list-types.js

@@ -0,0 +1 @@
+export {};

package/dist/headless/form/form-controller.js

@@ -62,6 +62,13 @@ function valuesDiff(current, initial) {
 // of being omitted — no validation error surfaces it, unlike the "" case.
 // Fixing that needs real per-field seed-tracking (which value was actually
 // user-set vs. defaulted), not just a wider strip predicate here.
+// The seed of an untouched optional money field (buildInitialValues); never a valid payload value.
+function isCurrencyOnlyMoney(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "currency" in value &&
+        !("amount" in value && value.amount !== undefined));
+}
 function stripUntouchedEmptyStrings(values, initial, forceIncludeEmpty) {
     const v = values; // @cast-boundary form-values
     const ini = initial; // @cast-boundary form-values
@@ -69,7 +76,8 @@ function stripUntouchedEmptyStrings(values, initial, forceIncludeEmpty) {
     for (const key of Object.keys(v)) {
         // Value-based seed strip, except keys previously submitted as "" after a
         // real clear — those must survive post-rebase submits.
-        if (!forceIncludeEmpty.has(key) && v[key] === "" && ini[key] === "") {
+        const untouchedEmptyString = !forceIncludeEmpty.has(key) && v[key] === "" && ini[key] === "";
+        if (untouchedEmptyString || isCurrencyOnlyMoney(v[key])) {
             out ??= { ...v };
             delete out[key];
         }

package/dist/headless/index.d.ts

@@ -12,4 +12,4 @@ export { pluralKey } from "./plural-key.ts";
 export type { Store, WritableStore } from "./store/index.ts";
 export { createStore, shallowEqual } from "./store/index.ts";
 export type { CellLink, CellLinkItem, ComputeEditViewModelInput, ComputeListViewModelInput, DerivedCellRoundingTarget, EditExtensionSectionViewModel, EditFieldSpec, EditFieldsSectionViewModel, EditFieldViewModel, EditFormMode, EditRelatedListSectionViewModel, EditSectionSpec, EditSectionViewModel, EditViewModel, EditWriteFormSectionViewModel, EmbeddedDerivedOp, EmbeddedListCellViewModel, EmbeddedListIssueGroups, FieldConditionCtx, FieldRenderer, ListColumnFileDisplay, ListColumnSpec, ListColumnViewModel, ListRowViewModel, ListViewModel, RuntimeCellLink, RuntimeCellLinkItems, RuntimeRenderer, ScreenSlots, Translate, } from "./view-model/index.ts";
-export { buildOptionLabels, computeDerivedCellValue, computeEditViewModel, computeListViewModel, computeRelatedListSectionViewModel, embeddedCellLabelKey, embeddedCellOptionLabelKey, fieldLabelKey, fieldOptionLabelKey, fieldOptionLabelKeyPrefix, groupEmbeddedListIssues, roundDerivedCellValue, sumEmbeddedListColumn, } from "./view-model/index.ts";
+export { buildOptionLabels, computeDerivedCellValue, computeEditViewModel, computeListViewModel, computeRelatedListSectionViewModel, embeddedCellLabelKey, embeddedCellOptionLabelKey, fieldLabelKey, fieldOptionLabelKey, fieldOptionLabelKeyPrefix, groupEmbeddedListIssues, roundDerivedCellValue, sumEmbeddedListColumn, withDerivedCells, } from "./view-model/index.ts";

package/dist/headless/index.js

@@ -7,4 +7,4 @@ export { applyFormatSpec, currencyDecimals, DOCUMENT_FALLBACK_CURRENCY, EMPTY_VA
 export { resolveNavigation } from "./nav/index.js";
 export { pluralKey } from "./plural-key.js";
 export { createStore, shallowEqual } from "./store/index.js";
-export { buildOptionLabels, computeDerivedCellValue, computeEditViewModel, computeListViewModel, computeRelatedListSectionViewModel, embeddedCellLabelKey, embeddedCellOptionLabelKey, fieldLabelKey, fieldOptionLabelKey, fieldOptionLabelKeyPrefix, groupEmbeddedListIssues, roundDerivedCellValue, sumEmbeddedListColumn, } from "./view-model/index.js";
+export { buildOptionLabels, computeDerivedCellValue, computeEditViewModel, computeListViewModel, computeRelatedListSectionViewModel, embeddedCellLabelKey, embeddedCellOptionLabelKey, fieldLabelKey, fieldOptionLabelKey, fieldOptionLabelKeyPrefix, groupEmbeddedListIssues, roundDerivedCellValue, sumEmbeddedListColumn, withDerivedCells, } from "./view-model/index.js";