@cosmicdrift/kumiko-headless 0.328.0 → 0.328.1

package/dist/view-model/list.js

@@ -0,0 +1,201 @@
+import { LIST_ROW_META_COLUMNS, LIST_ROW_META_REFERENCES, normalizeListColumn, parseRefTarget, } from "@cosmicdrift/kumiko-framework/ui-types";
+// Pure transform: takes the declared screen + entity + incoming rows, spits
+// out the flat shape the renderer draws. No conditions, no access-checks —
+// those are list-level decisions that the caller makes BEFORE calling
+// here (e.g. filtering rows by ownership on the server / before query).
+// Field-level read-access (Level 3 of UI-architecture.md §Permission) is a
+// follow-up; this v1 assumes the caller passed a row-filter that drops any
+// field the user may not see.
+export function computeListViewModel(input) {
+    const { screen, entity, rows, translate, featureName } = input;
+    const columns = [];
+    for (const spec of screen.columns) {
+        const normalized = normalizeListColumn(spec);
+        if (normalized.refEntity !== undefined) {
+            // Declared reference metadata (ListColumnSpec.refEntity) — for
+            // projectionList/relatedList columns, which have no EntityDefinition
+            // field to carry a real "reference" type. Checked before the
+            // entity.fields lookup below so it also fires against the pseudo-
+            // entities that hardcode every field as "text" (projection-list-shim,
+            // related-list-section) — those never reach the reference branch
+            // further down since fieldDef.type is always "text" there.
+            const refTarget = parseRefTarget(normalized.refEntity, featureName);
+            columns.push({
+                field: normalized.field,
+                label: translate(normalized.label ?? fieldLabelKey(featureName, screen.entity, normalized.field)),
+                type: "reference",
+                // The declared value is the referenced id, not the resolved label —
+                // there is no column to server-sort by, same as row-meta references.
+                sortable: false,
+                refEntity: refTarget.entityName,
+                refFeature: refTarget.featureName,
+                refLabelField: normalized.refLabelField ?? "id",
+                ...(normalized.renderer !== undefined && { renderer: normalized.renderer }),
+            });
+            continue;
+        }
+        const fieldDef = entity.fields[normalized.field];
+        if (!fieldDef) {
+            // Not a stored field — may be a read-time derived field (value appended
+            // by the list-query handler). Render it as its display valueType; derived
+            // columns carry no reference/select metadata and never server-sort.
+            const derivedDef = entity.derivedFields?.[normalized.field];
+            if (!derivedDef) {
+                // Row-meta column (id/tenantId/version/insertedAt/modifiedAt/...) —
+                // a real base-table column that's never a declared entity field, e.g.
+                // a SystemAdmin cross-tenant list exposing tenantId. Unlike the
+                // derivedFields branch above, these are actual DB columns, so
+                // server-side ORDER BY works — sortable stays true, except for the
+                // ID columns in LIST_ROW_META_REFERENCES (see their reference branch).
+                const rowMetaType = LIST_ROW_META_COLUMNS[normalized.field];
+                if (rowMetaType !== undefined) {
+                    const rowMetaRef = LIST_ROW_META_REFERENCES[normalized.field];
+                    columns.push({
+                        field: normalized.field,
+                        label: translate(normalized.label ?? fieldLabelKey(featureName, screen.entity, normalized.field)),
+                        type: rowMetaRef !== undefined ? "reference" : rowMetaType,
+                        // The DB column holds the GUID, not the resolved label — server-side
+                        // ORDER BY would sort by GUID while the cell shows the name.
+                        sortable: rowMetaRef === undefined,
+                        ...(normalized.renderer !== undefined && { renderer: normalized.renderer }),
+                        ...(rowMetaRef !== undefined && {
+                            refEntity: rowMetaRef.refEntity,
+                            refFeature: rowMetaRef.refFeature,
+                            refLabelField: rowMetaRef.refLabelField,
+                        }),
+                    });
+                    continue;
+                }
+                // A virtual presentational column — drawn entirely by a columnRenderer
+                // component from the row (e.g. tag chips); value is undefined and it
+                // never server-sorts. `field` is just the column key. It needs BOTH a
+                // label AND a renderer — renderer is what actually draws it; a label
+                // alone with no renderer would push an empty, unrendered column into
+                // the view model. Missing either is an author typo (or a stale
+                // field-rename) → fail loud instead of silently drawing nothing.
+                if (normalized.label !== undefined && normalized.renderer !== undefined) {
+                    columns.push({
+                        field: normalized.field,
+                        label: translate(normalized.label),
+                        type: "text",
+                        sortable: false,
+                        renderer: normalized.renderer,
+                    });
+                    continue;
+                }
+                throw new Error(`computeListViewModel: screen "${screen.id}" references unknown field "${normalized.field}" on entity "${screen.entity}"`);
+            }
+            columns.push({
+                field: normalized.field,
+                label: translate(normalized.label ?? fieldLabelKey(featureName, screen.entity, normalized.field)),
+                type: derivedDef.valueType,
+                // Display-only: a header sort would round-trip to the server, which has
+                // no column to sort by (see DerivedFieldDef). Never offer the affordance.
+                sortable: false,
+                ...(normalized.renderer !== undefined && { renderer: normalized.renderer }),
+            });
+            continue;
+        }
+        const label = translate(normalized.label ?? fieldLabelKey(featureName, screen.entity, normalized.field));
+        // Tier 2.7e-3 + Cross-Feature: Reference-Field — entity-String
+        // kann same-feature ("user") oder cross-feature ("users:user")
+        // sein. parseRefTarget gibt (featureName, entityName), der
+        // Renderer baut die Lookup-QN als
+        // `<refFeature>:query:<refEntity>:list`.
+        const refRaw = fieldDef.type === "reference"
+            ? fieldDef.entity
+            : undefined;
+        const refTarget = refRaw !== undefined ? parseRefTarget(refRaw, featureName) : undefined;
+        const refEntity = refTarget?.entityName;
+        const refFeature = refTarget?.featureName;
+        const refLabelField = fieldDef.type === "reference"
+            ? (fieldDef.labelField ?? "id")
+            : undefined;
+        // For select and multiSelect fields: bake in translated option labels.
+        // Convention matches the form path → one translation source for list +
+        // form. A missing key returns the key itself per convention; the
+        // renderer then falls back to humanizeSlug.
+        const optionLabels = fieldDef.type === "select" || fieldDef.type === "multiSelect"
+            ? buildOptionLabels(translate, (value) => fieldOptionLabelKey(featureName, screen.entity, normalized.field, value), fieldDef.options ?? [])
+            : undefined;
+        const optionTones = fieldDef.type === "select" ? fieldDef.optionTones : undefined;
+        const grouping = fieldDef.type === "number" ? fieldDef.grouping : undefined;
+        const column = {
+            field: normalized.field,
+            label,
+            type: fieldDef.type,
+            sortable: fieldIsSortable(fieldDef),
+            ...(normalized.renderer !== undefined && { renderer: normalized.renderer }),
+            ...(optionLabels !== undefined && { optionLabels }),
+            ...(optionTones !== undefined && { optionTones }),
+            ...(refEntity !== undefined && { refEntity }),
+            ...(refFeature !== undefined && { refFeature }),
+            ...(refLabelField !== undefined && { refLabelField }),
+            ...(grouping !== undefined && { grouping }),
+            ...(normalized.hideOnNarrow === true && { hideOnNarrow: true }),
+        };
+        columns.push(column);
+    }
+    const listRows = rows.map((row) => ({
+        id: String(row["id"] ?? ""),
+        values: row,
+    }));
+    return {
+        screenId: screen.id,
+        entityName: screen.entity,
+        columns,
+        rows: listRows,
+        ...(screen.slots && { slots: screen.slots }),
+        isEmpty: listRows.length === 0,
+    };
+}
+// Field-i18n-key convention matches what features register translations
+// under (see packages/framework/src/i18n/ for the pattern). Duplicated
+// here as a plain function — the ui-core boundary forbids depending on
+// the i18n module directly.
+export function fieldLabelKey(featureName, entityName, fieldName) {
+    return `${featureName}:entity:${entityName}:field:${fieldName}`;
+}
+export function fieldOptionLabelKeyPrefix(featureName, entityName, fieldName) {
+    return `${fieldLabelKey(featureName, entityName, fieldName)}:option:`;
+}
+export function fieldOptionLabelKey(featureName, entityName, fieldName, value) {
+    return `${fieldOptionLabelKeyPrefix(featureName, entityName, fieldName)}${value}`;
+}
+// Embedded-list cell label key — one level deeper than fieldLabelKey,
+// keyed by the sub-field name inside an embedded-LIST field's `schema`
+// (invoice-positions-style tables built via createEmbeddedListField()).
+export function embeddedCellLabelKey(featureName, entityName, fieldName, subFieldName) {
+    return `${featureName}:entity:${entityName}:field:${fieldName}:cell:${subFieldName}`;
+}
+export function embeddedCellOptionLabelKey(featureName, entityName, fieldName, subFieldName, value) {
+    return `${featureName}:entity:${entityName}:field:${fieldName}:cell:${subFieldName}:option:${value}`;
+}
+// Build a value→label map for a select-field's options. Convention:
+// translate() returns the input key when the lookup misses (i18next
+// default + LocaleResolver convention) — we surface the *raw value* in
+// that case so the renderer's humanizeSlug fallback can take over.
+// Without that fallback, an unlabeled option would render as the full
+// `feature:entity:field:option:value`-key.
+//
+// `keyFor` carries whichever key convention the caller needs (top-level
+// field via fieldOptionLabelKey, embedded-list cell via
+// embeddedCellOptionLabelKey) — shared between list-VM, edit-VM, and
+// embedded-list cells so all three produce identical option-translations.
+export function buildOptionLabels(translate, keyFor, options) {
+    const out = {};
+    for (const value of options) {
+        const key = keyFor(value);
+        const translated = translate(key);
+        out[value] = translated === key ? value : translated;
+    }
+    return out;
+}
+// A field can declare `sortable: true` on the FieldDefinition. This is
+// framework-level metadata used both by the server's list-query builder
+// (ORDER BY safety) and by the UI (column header click indicator). All
+// field types can bear the flag; it's off by default.
+function fieldIsSortable(field) {
+    const flag = field.sortable;
+    return flag === true;
+}

package/dist/view-model/types.d.ts

@@ -0,0 +1,300 @@
+import type { EditFieldSpec, EditSectionSpec, FieldIconKey, FieldRenderer, IconKey, ListColumnSpec, ListFacetSpec, ListSortSpec, PlatformComponent, RelatedListToolbarAction, RowAction, ScreenSlots, SelectOptionTone } from "@cosmicdrift/kumiko-framework/ui-types";
+export type RuntimeRenderer = (value: unknown, row?: Readonly<Record<string, unknown>>) => string;
+export type ListColumnViewModel = {
+    readonly field: string;
+    readonly label: string;
+    readonly type: string;
+    readonly renderer?: FieldRenderer | RuntimeRenderer;
+    readonly sortable: boolean;
+    /** Only for `type: "select"` or `type: "multiSelect"` — translated option
+     *  labels keyed by raw value. The renderer renders `optionLabels[value]`
+     *  instead of humanizeSlug when present. Convention key:
+     *  `<feature>:entity:<entity>:field:<field>:option:<value>`. */
+    readonly optionLabels?: Readonly<Record<string, string>>;
+    /** Only for `type: "select"` — declared tone per raw option value. */
+    readonly optionTones?: Readonly<Partial<Record<string, SelectOptionTone>>>;
+    /** Nur bei `type: "reference"` — referenced Entity-Name für Bulk-
+     *  Lookup im Renderer (`<refFeature>:query:<refEntity>:list`). */
+    readonly refEntity?: string;
+    /** Nur bei `type: "reference"` — Feature-Name in dem die referenced
+     *  Entity wohnt. Default = current feature. Cross-Feature über
+     *  qualifizierte Form ("feature:entity") am ReferenceFieldDef. */
+    readonly refFeature?: string;
+    /** Nur bei `type: "reference"` — Welches Feld der referenced Entity
+     *  als Display-Wert in der Cell erscheint (Default "id"). */
+    readonly refLabelField?: string;
+    /** Set by the caller at runtime (not schema-derived) to emphasize one
+     *  column — e.g. the currently selected base-year column in a
+     *  multi-year statement grid. DataTable renders it with a distinct
+     *  header/cell background. */
+    readonly highlighted?: boolean;
+    /** Mirrors `ListColumnSpec.hideOnNarrow`: card layout skips the column. */
+    readonly hideOnNarrow?: boolean;
+    /** Only for `type: "number"` — mirrors `NumberFieldDef.grouping` (default
+     *  `true`). `false` renders without thousands-separators (e.g. a model
+     *  year). */
+    readonly grouping?: boolean;
+};
+export type ListRowViewModel = {
+    readonly id: string;
+    readonly values: Readonly<Record<string, unknown>>;
+};
+export type ListViewModel = {
+    readonly screenId: string;
+    readonly entityName: string;
+    readonly columns: readonly ListColumnViewModel[];
+    readonly rows: readonly ListRowViewModel[];
+    readonly slots?: ScreenSlots;
+    readonly isEmpty: boolean;
+};
+export type EmbeddedListCellViewModel = {
+    readonly field: string;
+    readonly label: string;
+    readonly type: "text" | "number" | "boolean" | "date" | "money" | "decimal" | "select" | "reference" | "timestamp";
+    readonly required: boolean;
+    /** Only for `type: "select"`. */
+    readonly options?: readonly string[];
+    readonly optionLabels?: Readonly<Record<string, string>>;
+    /** Only for `type: "reference"`. */
+    readonly refEntity?: string;
+    readonly refFeature?: string;
+    readonly refLabelField?: string;
+    readonly refOptionsQuery?: string;
+    /** Only for `type: "decimal"`. */
+    readonly scale?: number;
+};
+export type EditFieldViewModel = {
+    readonly field: string;
+    readonly label: string;
+    readonly type: string;
+    readonly value: unknown;
+    readonly visible: boolean;
+    readonly readOnly: boolean;
+    readonly required: boolean;
+    readonly span?: number;
+    readonly renderer?: FieldRenderer;
+    /** Set for `type: "select"` and `type: "multiSelect"` — the allowed
+     *  values. The renderer uses these as dropdown/combobox options.
+     *  Source is SelectFieldDef.options / MultiSelectFieldDef.options on
+     *  the EntityDefinition. */
+    readonly options?: readonly string[];
+    /** Set for `type: "select"` and `type: "multiSelect"` — translated
+     *  labels per option, keyed by raw value. The renderer shows
+     *  `optionLabels[value]` as the dropdown/combobox label instead of the
+     *  raw value. Convention key:
+     *  `<feature>:entity:<entity>:field:<field>:option:<value>`. */
+    readonly optionLabels?: Readonly<Record<string, string>>;
+    /** Set for `type: "multiSelect"` when MultiSelectFieldDef.display is
+     *  "checkboxes" — the renderer shows a checkbox grid with a select-all
+     *  toggle instead of the default combobox dropdown. Set for
+     *  `type: "select"` when SelectFieldDef.display is "radio" or "dropdown" —
+     *  the renderer then skips its own radio-vs-dropdown heuristic. */
+    readonly display?: "checkboxes" | "dropdown" | "radio";
+    /** Set for `type: "multiSelect"` when MultiSelectFieldDef.columns is
+     *  defined — column count for the checkbox grid at the widest breakpoint.
+     *  Ignored unless `display` is "checkboxes". */
+    readonly columns?: 1 | 2 | 3 | 4;
+    /** Set for `type: "multiSelect"` when MultiSelectFieldDef.maxRows is
+     *  defined — grid rows visible before the checkbox grid becomes
+     *  scrollable. Ignored unless `display` is "checkboxes". */
+    readonly maxRows?: number;
+    /** For `type: "text"`, set when TextFieldDef.multiline is true — the
+     *  renderer then renders a textarea instead of a single-line input.
+     *  `type: "longText"` always renders a textarea regardless of this
+     *  value; here it only carries an optional `{ rows }` override.
+     *  `true` = default rows, `{ rows }` = explicit height. */
+    readonly multiline?: boolean | {
+        readonly rows?: number;
+    };
+    /** From TextFieldDef.format — `password` makes the renderer mask the input. */
+    readonly format?: "email" | "url" | "phone" | "password";
+    /** Nur bei `type: "timestamp"` gesetzt wenn TimestampFieldDef.locatedBy
+     *  existiert — Wall-Clock-Zeit ohne Offset. Der Renderer emittiert
+     *  dann lokale Zeit ohne `Z` statt eines UTC-Instants. */
+    readonly wallClock?: boolean;
+    /** Nur bei `type: "date" | "timestamp"` — Datumsgrenzen (ISO) und
+     *  Format/Locale-Override aus der FieldDefinition. Der Renderer begrenzt
+     *  damit den Picker; die Write-Validierung läuft separat über Zod. */
+    readonly min?: string;
+    readonly max?: string;
+    readonly dateLocale?: string;
+    /** Only for `type: "number"` — mirrors `NumberFieldDef.grouping` (default
+     *  `true`). `false` renders without thousands-separators (e.g. a model
+     *  year). */
+    readonly grouping?: boolean;
+    /** Nur bei `type: "reference"` gesetzt — Tier 2.7e-3.
+     *  Die referenced Entity (kurz, ohne feature-prefix). Der Renderer
+     *  baut die Query-QN als `<refFeature>:query:<refEntity>:list`. */
+    readonly refEntity?: string;
+    /** Nur bei `type: "reference"` gesetzt — Feature-Name in dem die
+     *  referenced Entity wohnt. Same-feature default = aktuelles
+     *  Feature. Cross-Feature wird über "feature:entity" am
+     *  ReferenceFieldDef.entity erkannt. */
+    readonly refFeature?: string;
+    /** Nur bei `type: "reference"` gesetzt — Welches Feld der referenced
+     *  Entity als Display-Label im Dropdown erscheint. Default: "id". */
+    readonly refLabelField?: string;
+    /** Only for `type: "reference"` — query handler QN the picker sources its
+     *  options from (fw#2780), replacing the referenced entity's list handler.
+     *  Rows carry `{ id, label }`; `refLabelField` is then unused for the
+     *  picker but still drives list cells. */
+    readonly refOptionsQuery?: string;
+    /** Nur bei `type: "reference"` — Multi-Mode (Tier 2.7e-Multi):
+     *  Wert ist UUID-Array, Renderer mountet Multi-Combobox mit Tags. */
+    readonly refMultiple?: boolean;
+    /** Nur bei `type: "file" | "image"` — erlaubte Extensions/MIME (z.B.
+     *  ["jpg","png"]) + Max-Größe ("5mb"). Der Renderer setzt das `accept`-
+     *  Attribut + zeigt die Grenze; die Validierung läuft serverseitig im
+     *  Upload-Endpoint gegen die Field-Def. */
+    readonly accept?: readonly string[];
+    readonly maxSize?: string;
+    /** Nur bei `type: "file" | "image"` — Entity-Name + Field-Name für den
+     *  Upload-POST (`/api/files`), damit der Endpoint maxSize/accept gegen
+     *  die richtige Field-Def prüfen kann. */
+    readonly entityType?: string;
+    readonly fieldName?: string;
+    /** Only for `type: "image"` — the variant name the preview requests
+     *  (`/api/files/:id/variant/:name`) instead of the original. The FIRST
+     *  variant declared on the field def wins; a spec may legitimately carry
+     *  neither `size` nor `maxEdge` (format-/blur-only), so "the smallest one"
+     *  is not a rule that always has an answer. Absent when the field declares
+     *  no variants — the preview then loads the original. */
+    readonly imageVariant?: string;
+    /** Only for `type: "image"` — forwarded to the file input's `capture`
+     *  attribute so a phone opens the camera instead of the file picker. */
+    readonly capture?: "environment" | "user";
+    /** Closed FieldIconKey from EditFieldSpec.icon (FIELD_ICONS registry). */
+    readonly icon?: FieldIconKey;
+    /** Only set for an embedded-LIST field (`multiple: true`) — the per-cell
+     *  metadata the renderer needs to draw each column/cell. Absent for a
+     *  plain (non-list) embedded field. */
+    readonly embeddedListCells?: readonly EmbeddedListCellViewModel[];
+    /** Minimum row count for the embedded list. From EmbeddedFieldDef.minItems. */
+    readonly embeddedListMinItems?: number;
+    /** Maximum row count for the embedded list. From EmbeddedFieldDef.maxItems. */
+    readonly embeddedListMaxItems?: number;
+    /** Sub-field name → how to compute its cell from other sub-fields of the
+     *  same row. From EmbeddedFieldDef.derived. */
+    readonly embeddedListDerived?: Readonly<Record<string, {
+        readonly op: "multiply" | "sum" | "subtract";
+        readonly from: readonly string[];
+    }>>;
+    /** Numeric sub-field names to sum in a totals row. From EmbeddedFieldDef.totals. */
+    readonly embeddedListTotals?: readonly string[];
+    /** Currency for the whole embedded list's money cells and totals row —
+     *  currency lives on the head aggregate (EntityDefinition.defaultCurrency),
+     *  not per row. Falls back to "EUR" when the entity has no defaultCurrency. */
+    readonly embeddedListCurrency?: string;
+    /** Only set for a plain (non-list, non-embedded) `type: "money"` field —
+     *  same source as embeddedListCurrency (EntityDefinition.defaultCurrency,
+     *  falls back to "EUR"). The renderer needs this to build the payload's
+     *  `{amount, currency}` shape (kumiko-framework#1923). */
+    readonly currency?: string;
+    /** Only set for `type: "number"` when NumberFieldDef.unit is set — a static
+     *  suffix string, or a sibling-field reference the renderer resolves against
+     *  the live row values. Display-only, never converts the stored number. */
+    readonly unit?: string | {
+        readonly field: string;
+    };
+};
+export type EditSectionViewModel = EditFieldsSectionViewModel | EditExtensionSectionViewModel | EditRelatedListSectionViewModel | EditWriteFormSectionViewModel;
+export type EditFieldsSectionViewModel = {
+    readonly kind: "fields";
+    /** From `EditFieldsSection.id`. The boot-validator makes it mandatory under
+     *  `layout.mode: "tabs"` so the tab strip has a stable key per tab; other
+     *  layouts leave it unset. */
+    readonly id?: string;
+    /** False when the section has fields but none of them is visible.
+     *  The renderer then draws nothing, but the section stays in the array
+     *  (key stability). */
+    readonly visible: boolean;
+    /** Optional — eine titellose Section rendert nur ihre Felder (flache Form). */
+    readonly title?: string;
+    /** Translated help text under the block heading, from
+     *  `EditFieldsSection.description`. Renders even without `title`. */
+    readonly description?: string;
+    readonly columns: number;
+    readonly fields: readonly EditFieldViewModel[];
+    /** From `EditFieldsSection.groups` — each entry's `fields` are the same
+     *  view-model objects as `fields` above, re-grouped (not recomputed). */
+    readonly groups?: readonly {
+        readonly title: string;
+        readonly columns: number;
+        readonly fields: readonly EditFieldViewModel[];
+    }[];
+    /** From `EditFieldsSection.icon` — closed IconKey vocabulary, renders
+     *  left of the title. No effect without `title`. */
+    readonly icon?: IconKey;
+    /** From `EditFieldsSection.actions` — rendered in the Section's
+     *  title row, same slot as the projectionDetail head card's actions. */
+    readonly actions?: readonly RowAction[];
+};
+export type EditExtensionSectionViewModel = {
+    readonly kind: "extension";
+    /** From `EditExtensionSection.id` — same tab-strip role as on a "fields"
+     *  section, see EditFieldsSectionViewModel.id. */
+    readonly id?: string;
+    readonly title: string;
+    readonly component: PlatformComponent;
+    readonly contributesToFormSubmit: boolean;
+    /** Section-declared override — see `EditExtensionSection.entityName`. */
+    readonly entityName?: string;
+    /** From `EditExtensionSection.actions`. */
+    readonly actions?: readonly RowAction[];
+};
+export type EditRelatedListSectionViewModel = {
+    readonly kind: "relatedList";
+    readonly title: string;
+    readonly query: string;
+    readonly parentParam?: string;
+    readonly parentFilter?: {
+        readonly field: string;
+    };
+    readonly columns: readonly ListColumnSpec[];
+    readonly description?: string;
+    /** Untranslated plural-forms key, resolved with the row count by the list footer. */
+    readonly itemNoun?: string;
+    readonly pageSize?: number;
+    readonly defaultSort?: ListSortSpec;
+    readonly searchable?: boolean;
+    readonly facets?: readonly ListFacetSpec[];
+    readonly rowClick?: {
+        readonly entity: string;
+        readonly idColumn?: string;
+    };
+    readonly rowActions?: readonly RowAction[];
+    readonly toolbarActions?: readonly RelatedListToolbarAction[];
+    /** From `EditRelatedListSection.actions` — rendered in the
+     *  Section's title row, distinct from `toolbarActions` (which render
+     *  above the table itself). */
+    readonly actions?: readonly RowAction[];
+    /** From `EditRelatedListSection.emptyState` — forwarded to the
+     *  DataTable's `emptyState` prop when the section has zero rows. */
+    readonly emptyState?: {
+        readonly title: string;
+        readonly description?: string;
+        readonly action?: RowAction;
+    };
+};
+export type EditWriteFormSectionViewModel = {
+    readonly kind: "writeForm";
+    readonly title?: string;
+    readonly description?: string;
+    readonly columns: number;
+    readonly fields: readonly EditFieldViewModel[];
+    readonly icon?: IconKey;
+    readonly handler: string;
+    readonly submitLabel?: string;
+    /** From `EditWriteFormSection.actions`. */
+    readonly actions?: readonly RowAction[];
+};
+export type EditViewModel = {
+    readonly screenId: string;
+    readonly entityName: string;
+    readonly id: string | null;
+    readonly sections: readonly EditSectionViewModel[];
+    readonly slots?: ScreenSlots;
+};
+export type Translate = (key: string, params?: Readonly<Record<string, unknown>>) => string;
+export type FieldConditionCtx = unknown;
+export type { EditFieldSpec, EditSectionSpec, FieldRenderer, ListColumnSpec, ScreenSlots };

package/dist/view-model/types.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cosmicdrift/kumiko-headless",
-  "version": "0.328.0",
+  "version": "0.328.1",
   "description": "Headless UI logic for Kumiko — Dispatcher contract, Form-Controller, View-Model, Nav-Resolver. Plattform- und React-frei; jeder Renderer (renderer, renderer-web, renderer-native, …) komponiert darauf.",
   "license": "BUSL-1.1",
   "author": "Marc Frost <marc@cosmicdriftgamestudio.com>",
@@ -19,33 +19,52 @@
   },
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "default": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
     },
     "./dispatcher": {
-      "types": "./src/dispatcher/index.ts",
-      "default": "./src/dispatcher/index.ts"
+      "types": "./dist/dispatcher/index.d.ts",
+      "default": "./dist/dispatcher/index.js"
     },
     "./apex": {
-      "types": "./src/apex/index.ts",
-      "default": "./src/apex/index.ts"
+      "types": "./dist/apex/index.d.ts",
+      "default": "./dist/apex/index.js"
     },
     "./locale-routing": {
-      "types": "./src/locale-routing/index.ts",
-      "default": "./src/locale-routing/index.ts"
+      "types": "./dist/locale-routing/index.d.ts",
+      "default": "./dist/locale-routing/index.js"
     }
   },
   "dependencies": {
-    "@cosmicdrift/kumiko-framework": "0.328.0",
+    "@cosmicdrift/kumiko-framework": "0.328.1",
     "temporal-polyfill": "^0.3.2",
     "zod": "^4.4.3"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org",
-    "access": "public"
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "./dispatcher": {
+        "types": "./dist/dispatcher/index.d.ts",
+        "default": "./dist/dispatcher/index.js"
+      },
+      "./apex": {
+        "types": "./dist/apex/index.d.ts",
+        "default": "./dist/apex/index.js"
+      },
+      "./locale-routing": {
+        "types": "./dist/locale-routing/index.d.ts",
+        "default": "./dist/locale-routing/index.js"
+      }
+    }
   },
   "files": [
-    "src",
+    "dist",
+    "src/changes.json",
     "README.md",
     "LICENSE"
   ]

package/src/apex/__tests__/lightbox.test.ts

@@ -1,20 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { createHash } from "node:crypto";
-import { APEX_LIGHTBOX_SCRIPT, APEX_LIGHTBOX_SCRIPT_CSP_HASH } from "../index";
-
-function scriptBody(html: string): string {
-  const match = html.match(/^<script>(?<body>[\s\S]*)<\/script>$/);
-  const body = match?.groups?.["body"];
-  if (body === undefined) {
-    throw new Error("APEX_LIGHTBOX_SCRIPT isn't a single <script>...</script> string");
-  }
-  return body;
-}
-
-describe("APEX_LIGHTBOX_SCRIPT_CSP_HASH", () => {
-  test("matches the actual script content byte-for-byte", () => {
-    const body = scriptBody(APEX_LIGHTBOX_SCRIPT);
-    const hash = `sha256-${createHash("sha256").update(body).digest("base64")}`;
-    expect(hash).toBe(APEX_LIGHTBOX_SCRIPT_CSP_HASH);
-  });
-});

package/src/apex/__tests__/page-head.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { injectPageHead, resolveAndInjectPageHead } from "../index";
-
-describe("injectPageHead", () => {
-  const TAGS = '<title>New Title</title>\n<meta name="description" content="d">';
-
-  test("replaces an existing <title> instead of duplicating it", () => {
-    const html = "<html><head><title>Old</title></head><body></body></html>";
-    const out = injectPageHead(html, TAGS);
-    expect(out).not.toContain("<title>Old</title>");
-    expect((out.match(/<title>/g) ?? []).length).toBe(1);
-    expect(out).toContain("<title>New Title</title>");
-  });
-
-  test("applying twice does not duplicate the head-tags block", () => {
-    const html = "<html><head><title>Old</title></head><body></body></html>";
-    const once = injectPageHead(html, TAGS);
-    const twice = injectPageHead(once, TAGS);
-    expect(twice).toBe(once);
-    expect((twice.match(/kumiko-page-head/g) ?? []).length).toBe(1);
-  });
-
-  test("HTML without </head> is returned unchanged", () => {
-    const html = "<html><body><title>Old</title></body></html>";
-    expect(injectPageHead(html, TAGS)).toBe(html);
-  });
-});
-
-describe("resolveAndInjectPageHead", () => {
-  const HTML = "<!doctype html><html><head><title>Shell</title></head><body>shell</body></html>";
-  const input = { path: "/", host: "t", systemQuery: async () => ({}) };
-
-  test("resolved meta is injected as head tags", async () => {
-    const out = await resolveAndInjectPageHead(
-      HTML,
-      async () => ({ title: "Vehicle X", description: "A car", ogImage: "https://x/i.png" }),
-      input,
-    );
-    expect(out).toContain("<title>Vehicle X</title>");
-    expect(out).toContain('<meta property="og:image" content="https://x/i.png" />');
-  });
-
-  test("resolver throws → unchanged html, not a rejection", async () => {
-    const out = await resolveAndInjectPageHead(
-      HTML,
-      async () => {
-        throw new Error("boom");
-      },
-      input,
-    );
-    expect(out).toBe(HTML);
-  });
-
-  test("resolver returns null → unchanged html", async () => {
-    const out = await resolveAndInjectPageHead(HTML, async () => null, input);
-    expect(out).toBe(HTML);
-  });
-
-  test("resolver never resolves → unchanged html after the shared timeout", async () => {
-    const out = await resolveAndInjectPageHead(HTML, () => new Promise(() => {}), input);
-    expect(out).toBe(HTML);
-  }, 2000);
-});