@cosmicdrift/kumiko-renderer 0.328.0 → 0.329.0

package/dist/app/layout-fields.d.ts

@@ -0,0 +1,3 @@
+import type { EditFieldSpec, EntityEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+export declare function layoutEditFields(screen: EntityEditScreenDefinition): readonly Exclude<EditFieldSpec, string>[];
+export declare function layoutFieldNames(screen: EntityEditScreenDefinition): ReadonlySet<string>;

package/dist/app/layout-fields.js

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

package/dist/app/list-facets.d.ts

@@ -0,0 +1,48 @@
+import type { ListFacetSpec } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { Translate } from "@cosmicdrift/kumiko-headless";
+import type { DataTableFacet } from "../primitives.js";
+export type ResolvedFacetSpec = {
+    readonly field: string;
+    readonly type: "select" | "boolean" | "reference";
+    readonly label: string;
+    /** Empty for a "reference" facet until `ReferenceFacetBridges` resolves it
+     *  at render time, unlike select/boolean's author-declared options. */
+    readonly options: readonly {
+        readonly value: string;
+        readonly label: string;
+    }[];
+    /** Present only for a "reference" facet — the resolved lookup target
+     *  `ReferenceFacetBridges` needs to fetch its options. */
+    readonly reference?: {
+        readonly refEntity: string;
+        readonly refFeature: string;
+        readonly labelField: string;
+    };
+};
+export declare function mergeReferenceFacetOptions(specs: readonly ResolvedFacetSpec[], optionsByField: Readonly<Record<string, readonly {
+    readonly value: string;
+    readonly label: string;
+}[]>>): ResolvedFacetSpec[];
+export declare function buildFilterFacets(specs: readonly ResolvedFacetSpec[]): DataTableFacet[];
+export declare function buildFilterPayload(urlFilters: Readonly<Record<string, readonly string[]>>, typeOf: (field: string) => string | undefined): {
+    field: string;
+    op: "in";
+    value: unknown;
+}[];
+export declare function resolveProjectionFacetSpecs(facets: readonly ListFacetSpec[] | undefined, translate: Translate, featureName: string): ResolvedFacetSpec[];
+export type ResolvedDateRangeFacet = {
+    readonly field: string;
+    readonly label: string;
+    readonly fromParam: string;
+    readonly toParam: string;
+};
+export type DateRangeBound = "from" | "to";
+export type DateRangeValue = {
+    readonly from: string;
+    readonly to: string;
+};
+export declare function resolveDateRangeFacets(facets: readonly ListFacetSpec[] | undefined, translate: Translate): ResolvedDateRangeFacet[];
+export declare function dateRangeUrlField(field: string, bound: DateRangeBound): string;
+export declare function readDateRange(urlFilters: Readonly<Record<string, readonly string[]>>, field: string): DateRangeValue;
+export declare function clampDateRange(current: DateRangeValue, bound: DateRangeBound, value: string): DateRangeValue;
+export declare function buildDateRangePayload(specs: readonly ResolvedDateRangeFacet[], urlFilters: Readonly<Record<string, readonly string[]>>, timeZone: string): Record<string, string>;

package/dist/app/list-facets.js

@@ -0,0 +1,185 @@
+// Split from kumiko-screen.tsx: related-list-section.tsx renders through
+// kumiko-screen.tsx, so importing this back from there would be a require cycle.
+import { parseRefTarget } from "@cosmicdrift/kumiko-framework/ui-types";
+import { Temporal } from "temporal-polyfill";
+// Fills in a "reference" spec's initially-empty `options` from the
+// field-keyed options ReferenceFacetBridges resolved, shared by every caller.
+export function mergeReferenceFacetOptions(specs, optionsByField) {
+    return specs.map((spec) => spec.reference !== undefined
+        ? { ...spec, options: optionsByField[spec.field] ?? spec.options }
+        : spec);
+}
+export function buildFilterFacets(specs) {
+    return specs.map((spec) => ({ field: spec.field, label: spec.label, options: spec.options }));
+}
+// User-selected faceted filters from URL-state → payload.filters. Boolean
+// fields coerce "true"/"false" strings to real booleans (DB column is
+// boolean); everything else stays string[] under op:"in" (multi-select
+// semantics). `typeOf` resolves a field to its known type string —
+// undefined means "unknown field", so it's dropped (typo-safe: a stale/
+// hand-crafted URL param for an undeclared field never reaches the
+// server). Deliberately NOT gated on the field being a *facet* — entityList
+// passes through any field present in entity.fields, matching its
+// pre-fw#2224 behavior; only the boolean-coercion branch cares about type.
+function isFacetI18nKey(label) {
+    return !/\s/.test(label) && (label.includes(".") || label.includes(":"));
+}
+export function buildFilterPayload(urlFilters, typeOf) {
+    const out = [];
+    for (const [field, values] of Object.entries(urlFilters)) {
+        if (values.length === 0)
+            continue;
+        // `id` is a base column (not a declared facet), allowed as an id-set
+        // filter so a header-slot control — e.g. the tags TagFilter — can narrow
+        // ANY list to a resolved set of row ids without the host declaring a facet.
+        if (field === "id") {
+            out.push({ field, op: "in", value: values });
+            continue;
+        }
+        const type = typeOf(field);
+        if (type === undefined)
+            continue;
+        const value = type === "boolean" ? values.map((v) => v === "true") : values;
+        out.push({ field, op: "in", value });
+    }
+    return out;
+}
+// projectionList/relatedList adapter — neither has an entity/i18n convention
+// to derive labels from, so ListFacetSpec carries every label explicitly
+// (fw#2224). Labels may be raw display strings or i18n keys; run them
+// through translate like entity facets (passthrough when the key is missing).
+// `featureName` resolves a reference facet's `entity` target the same way
+// ListColumnSpec.refEntity does (same-feature short name, or "feature:entity").
+export function resolveProjectionFacetSpecs(facets, translate, featureName) {
+    if (facets === undefined)
+        return [];
+    const tr = (label) => (isFacetI18nKey(label) ? translate(label) : label);
+    // dateRange carries no option list and no `filters` entry — it resolves
+    // through resolveDateRangeFacets into its own toolbar control instead.
+    return facets.flatMap((facet) => {
+        if (facet.type === "dateRange")
+            return [];
+        if (facet.type === "select") {
+            return [
+                {
+                    field: facet.field,
+                    type: "select",
+                    label: tr(facet.label),
+                    options: facet.options.map((opt) => ({
+                        value: opt.value,
+                        label: tr(opt.label),
+                    })),
+                },
+            ];
+        }
+        if (facet.type === "boolean") {
+            return [
+                {
+                    field: facet.field,
+                    type: "boolean",
+                    label: tr(facet.label),
+                    options: [
+                        { value: "true", label: tr(facet.trueLabel) },
+                        { value: "false", label: tr(facet.falseLabel) },
+                    ],
+                },
+            ];
+        }
+        const target = parseRefTarget(facet.entity, featureName);
+        return [
+            {
+                field: facet.field,
+                type: "reference",
+                label: tr(facet.label),
+                options: [],
+                reference: {
+                    refEntity: target.entityName,
+                    refFeature: target.featureName,
+                    labelField: facet.labelField ?? "id",
+                },
+            },
+        ];
+    });
+}
+export function resolveDateRangeFacets(facets, translate) {
+    if (facets === undefined)
+        return [];
+    return facets.flatMap((facet) => facet.type === "dateRange"
+        ? [
+            {
+                field: facet.field,
+                label: isFacetI18nKey(facet.label) ? translate(facet.label) : facet.label,
+                fromParam: facet.params.from,
+                toParam: facet.params.to,
+            },
+        ]
+        : []);
+}
+// The bounds live in the same `<screenId>.f.<key>` URL namespace the option
+// facets use, so setFilter's page-reset and clearFilters cover them for free.
+// buildFilterPayload drops them again: a dotted key resolves to no facet
+// type, which is its "unknown field" case.
+export function dateRangeUrlField(field, bound) {
+    return `${field}.${bound}`;
+}
+export function readDateRange(urlFilters, field) {
+    return {
+        from: urlFilters[dateRangeUrlField(field, "from")]?.[0] ?? "",
+        to: urlFilters[dateRangeUrlField(field, "to")]?.[0] ?? "",
+    };
+}
+// Keeps from <= to by pushing the opposite bound along, so an inverted range
+// can't reach the server and trip a handler's `from <= to` refine (a 422 the
+// user would see as a broken list, not as a correction).
+export function clampDateRange(current, bound, value) {
+    if (bound === "from") {
+        const to = current.to !== "" && value !== "" && value > current.to ? value : current.to;
+        return { from: value, to };
+    }
+    const from = current.from !== "" && value !== "" && value < current.from ? value : current.from;
+    return { from, to: value };
+}
+// A calendar date covers a whole day in the viewer's zone: "from the 14th"
+// starts at that day's first instant, "to the 14th" includes everything up to
+// its last. Going through the next day's start keeps both ends right across a
+// DST boundary, where the day is not 24h long.
+function dayBoundInstant(date, bound, timeZone) {
+    let plainDate;
+    try {
+        plainDate = Temporal.PlainDate.from(date);
+    }
+    catch {
+        // Half-typed or hand-crafted URL value — drop the bound rather than send
+        // something the handler's ISO-datetime schema would reject.
+        return null;
+    }
+    const start = plainDate.toZonedDateTime(timeZone).toInstant();
+    return bound === "from"
+        ? start.toString()
+        : plainDate
+            .add({ days: 1 })
+            .toZonedDateTime(timeZone)
+            .toInstant()
+            .subtract({
+            nanoseconds: 1,
+        })
+            .toString();
+}
+export function buildDateRangePayload(specs, urlFilters, timeZone) {
+    const out = {};
+    for (const spec of specs) {
+        const range = readDateRange(urlFilters, spec.field);
+        for (const [bound, param] of [
+            ["from", spec.fromParam],
+            ["to", spec.toParam],
+        ]) {
+            const value = range[bound];
+            if (value === "")
+                continue;
+            const instant = dayBoundInstant(value, bound, timeZone);
+            if (instant !== null)
+                out[param] = instant;
+        }
+    }
+    return out;
+}

package/dist/app/nav.d.ts

@@ -0,0 +1,61 @@
+import { type ReactNode } from "react";
+import type { FeatureSchema } from "./feature-schema.js";
+export type NavRoute = {
+    readonly workspaceId?: string;
+    readonly screenId: string;
+    readonly entityId?: string;
+};
+export type ScreenTarget = {
+    readonly workspaceId?: string;
+    readonly screenId: string;
+    readonly entityId?: string;
+};
+export type ObjectTarget = {
+    readonly workspaceId?: string;
+    readonly entity: string;
+    readonly id: string;
+};
+export type NavTarget = ScreenTarget | ObjectTarget;
+export type NavApi = {
+    /** Current route — `undefined` when the URL is at the root / there's
+     *  no route selected. Caller's initial fallback kicks in then. */
+    readonly route: NavRoute | undefined;
+    /** Push a new route. Platform-specific Impl writes to
+     *  history/stack and notifies subscribers. */
+    readonly navigate: (target: NavTarget) => void;
+    /** Replace the current route in place. Same effect as navigate from
+     *  the user's perspective, but doesn't add a history entry — used for
+     *  mount-time URL fills (e.g. WorkspaceShell defaulting to `/admin/x`
+     *  when the user typed `/`). Browser Back must take the user out of
+     *  the app, not back to the original empty path. */
+    readonly replace: (target: NavTarget) => void;
+    /** Build the href a click on {target} would produce. Used by
+     *  platform-specific Link-Komponenten (Web: `<a href>`; Native
+     *  typically doesn't need this). */
+    readonly hrefFor: (target: NavTarget) => string;
+    /** Lese-Snapshot der aktuellen Search-Params (Browser: ?key=value-
+     *  Pairs nach dem Pfad). Native-Impls die kein URL-Konzept haben
+     *  liefern ein leeres Object. Wert ist ein Plain-Record (kein Map)
+     *  damit React-Subscribers shallow-compare können. */
+    readonly searchParams: Readonly<Record<string, string>>;
+    /** Mergt Updates in die aktuellen Search-Params. Wert `null` löscht
+     *  den Key. Ändert NICHT den Pfad. Plattform-Impls nutzen
+     *  history.replaceState (kein Push) — Sort/Filter-Toggles sollen
+     *  nicht die Back-Navigation fluten. Native-Impls können no-op'en
+     *  wenn das Konzept nicht existiert. */
+    readonly setSearchParams: (updates: Readonly<Record<string, string | null>>) => void;
+};
+export declare function parsePath(pathname: string, hasWorkspaces?: boolean): NavRoute | undefined;
+export declare function formatPath(target: ScreenTarget): string;
+/** Non-throwing existence check for findDetailForScreen — lets a caller pick
+ *  a different default (fw#2164's row-click fallback) instead of resolving. */
+export declare function hasDetailScreen(features: readonly FeatureSchema[], entity: string): boolean;
+export declare function resolveTarget(features: readonly FeatureSchema[], target: NavTarget): ScreenTarget;
+export type NavProviderProps = {
+    readonly children: ReactNode;
+    readonly value: NavApi;
+};
+export declare function NavProvider({ children, value }: NavProviderProps): ReactNode;
+export declare function useNavigateWithInitialValues(): (target: ScreenTarget, initialValues: Readonly<Record<string, unknown>>) => void;
+export declare function useInitialValuesHandoff(screenId: string): Readonly<Record<string, unknown>> | undefined;
+export declare function useNav(): NavApi;

package/dist/app/nav.js

@@ -0,0 +1,139 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useState } from "react";
+import { lastSegment } from "./qn.js";
+// Pfad-Format:
+//   ohne workspaces: `/task-list`, `/task-edit/abc-123`, `/` → undefined
+//   mit workspaces:  `/admin/task-list`, `/admin/task-edit/abc`,
+//                    `/admin` → workspace-only (no screen yet),
+//                    `/` → undefined.
+// Alles nach den ersten 2/3 Segmenten wird ignoriert — kumikos
+// Navigation-Grammatik nested nicht weiter. Nested-Routes wäre eine
+// Spec-Änderung, nicht ein URL-Shape-Unfall.
+export function parsePath(pathname, hasWorkspaces) {
+    const parts = pathname.split("/").filter((p) => p !== "");
+    if (hasWorkspaces === true) {
+        const [workspaceId, screenId, entityId] = parts;
+        if (workspaceId === undefined || workspaceId === "")
+            return undefined;
+        if (screenId === undefined || screenId === "") {
+            // Workspace-only URL ("/admin") — caller resolves the default screen
+            // for that workspace. We carry workspaceId WITHOUT a screen so the
+            // shell can branch instead of making something up.
+            return { workspaceId, screenId: "" };
+        }
+        return {
+            workspaceId,
+            screenId,
+            ...(entityId !== undefined && { entityId }),
+        };
+    }
+    const [screenId, entityId] = parts;
+    if (screenId === undefined || screenId === "")
+        return undefined;
+    return { screenId, ...(entityId !== undefined && { entityId }) };
+}
+export function formatPath(target) {
+    // Workspace-Mode: prefix the workspace short id. Order matters —
+    // workspace before screen mirrors parsePath's segment order.
+    const segments = [];
+    if (target.workspaceId !== undefined)
+        segments.push(target.workspaceId);
+    segments.push(target.screenId);
+    if (target.entityId !== undefined)
+        segments.push(target.entityId);
+    return `/${segments.join("/")}`;
+}
+// Shared entity→detailFor-screen lookup — resolveTarget's ObjectTarget
+// branch and hasDetailScreen (create-app's row-click default, fw#2164) both
+// need "is there a detail screen for this entity", one to resolve it, the
+// other to just check before falling back to a different default.
+function findDetailForScreen(features, entity) {
+    for (const feature of features) {
+        for (const screen of feature.screens) {
+            if (screen.detailFor === entity)
+                return { featureName: feature.featureName, screenId: screen.id };
+        }
+    }
+    return undefined;
+}
+/** Non-throwing existence check for findDetailForScreen — lets a caller pick
+ *  a different default (fw#2164's row-click fallback) instead of resolving. */
+export function hasDetailScreen(features, entity) {
+    return findDetailForScreen(features, entity) !== undefined;
+}
+// Resolves a NavTarget to the ScreenTarget form navigate/replace/hrefFor
+// operate on. Pure — no context, no I/O — so callers can use it outside
+// React too (see resolve-at-NavApi-build alternative in renderer-web).
+export function resolveTarget(features, target) {
+    if ("screenId" in target)
+        return target;
+    const found = findDetailForScreen(features, target.entity);
+    if (found !== undefined) {
+        // Short form (globally unique per validateScreenShortIdCollisions) —
+        // ScreenTarget.screenId round-trips through formatPath/parsePath as a
+        // short id; qualifying it here double-qualifies at RoutedScreen.
+        return {
+            ...(target.workspaceId !== undefined && { workspaceId: target.workspaceId }),
+            screenId: found.screenId,
+            entityId: target.id,
+        };
+    }
+    throw new Error(`resolveTarget: no detail screen for entity "${target.entity}". Add detailFor: "${target.entity}" to the screen that shows it.`);
+}
+// Context + Hook. Default ist `undefined` damit fehlender Provider
+// laut kracht statt ein silent-no-op NavApi mit toten navigate()
+// Aufrufen anzubieten.
+const NavContext = createContext(undefined);
+const InitialValuesHandoffContext = createContext(undefined);
+export function NavProvider({ children, value }) {
+    const [handoffSlot] = useState(() => ({ current: undefined }));
+    const routeScreenId = value.route?.screenId;
+    // An offer whose form never mounted (e.g. already on that screen) must not
+    // resurface on a later, unrelated visit — drop it once the route moves elsewhere.
+    useEffect(() => {
+        const pending = handoffSlot.current;
+        if (pending === undefined || routeScreenId === undefined)
+            return;
+        if (lastSegment(routeScreenId) !== pending.screenId)
+            handoffSlot.current = undefined;
+    }, [handoffSlot, routeScreenId]);
+    return (_jsx(NavContext.Provider, { value: value, children: _jsx(InitialValuesHandoffContext.Provider, { value: handoffSlot, children: children }) }));
+}
+// Navigates to a form screen (actionForm, secretMint, entityEdit-create) with
+// initial values carried in memory — never in the URL, so a link cannot
+// forge them and they are not limited to the screen's urlPrefillFields.
+// sensitive and password fields are still never prefilled.
+export function useNavigateWithInitialValues() {
+    const nav = useNav();
+    const handoffSlot = useContext(InitialValuesHandoffContext);
+    return useCallback((target, initialValues) => {
+        if (handoffSlot !== undefined) {
+            handoffSlot.current = { screenId: lastSegment(target.screenId), values: initialValues };
+        }
+        nav.navigate(target);
+    }, [nav, handoffSlot]);
+}
+export function useInitialValuesHandoff(screenId) {
+    const handoffSlot = useContext(InitialValuesHandoffContext);
+    const [values] = useState(() => {
+        const pending = handoffSlot?.current;
+        return pending !== undefined && pending.screenId === lastSegment(screenId)
+            ? pending.values
+            : undefined;
+    });
+    useEffect(() => {
+        if (handoffSlot !== undefined &&
+            values !== undefined &&
+            handoffSlot.current?.values === values) {
+            handoffSlot.current = undefined;
+        }
+    }, [handoffSlot, values]);
+    return values;
+}
+export function useNav() {
+    const api = useContext(NavContext);
+    if (api === undefined) {
+        throw new Error("useNav: no <NavProvider> mounted above this component. Plattform-Packages (z.B. @cosmicdrift/kumiko-renderer-web) liefern eine Default-Impl über createKumikoApp.");
+    }
+    return api;
+}

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

@@ -0,0 +1,8 @@
+import type { EditLayout, EntityDefinition, EntityEditScreenDefinition, ProjectionDetailScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+/** Minimale EntityDefinition aus den Layout-Feldern: jedes Feld ein Text-
+ *  Feld — computeEditViewModel liest nur `fields[<f>].type`, Text reicht für
+ *  eine reine Anzeige (kein Select/Number-spezifisches Rendering nötig). */
+export declare function synthesizeProjectionDetailEntity(layout: EditLayout): EntityDefinition;
+/** Wandelt ein ProjectionDetailScreenDefinition in die EntityEditScreen-Shape
+ *  die RenderEdit erwartet — mit jedem Feld hart auf readOnly:true erzwungen. */
+export declare function synthesizeProjectionDetailScreen(screen: ProjectionDetailScreenDefinition): EntityEditScreenDefinition;

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

@@ -0,0 +1,71 @@
+// Shim für ProjectionDetail-Renderer (analog zu projection-list-shim.ts /
+// config-edit-shim.ts).
+//
+// RenderEdit verlangt ein `entity: EntityDefinition` + ein
+// `screen: EntityEditScreenDefinition`-Pair, nutzt davon aber nur
+// `entity.fields` (Feld-Typ für den Input-Renderer) und `screen.layout`
+// (welche Felder in welchen Sections). Ein projectionDetail-Screen ist
+// query-getrieben und hat KEINE Entity — die zwei Helper hier shapen den
+// Input ad-hoc um, damit RenderEdit reused werden kann.
+//
+// Der strukturelle Read-Only-Beweis liegt in synthesizeProjectionDetailScreen:
+// JEDES Feld wird hart auf readOnly:true gesetzt (nicht nur was der Author im
+// Layout gesetzt hat) — hasEditableSection() liest genau dieses Flag und
+// blendet den Save-Button aus, wenn kein Feld editierbar ist. Der Author kann
+// diese Garantie nicht versehentlich umgehen.
+//
+// Selbe Schulden-Reservation wie bei den anderen Shims: greift RenderEdit
+// künftig auf weitere EntityDefinition-Felder (transitions, idType) zu, oder
+// cross-referenziert ein Boot-Validator die schema.entities-Map, brechen die
+// Type-Lies hier silent — dann ist Zeit für eine echte RenderProjectionDetail-
+// Komponente.
+import { isFieldsEditSection, normalizeEditField, PROJECTION_DETAIL_ENTITY as PROJECTION_DETAIL_PSEUDO_ENTITY, sectionFieldSpecs, } from "@cosmicdrift/kumiko-framework/ui-types";
+/** Minimale EntityDefinition aus den Layout-Feldern: jedes Feld ein Text-
+ *  Feld — computeEditViewModel liest nur `fields[<f>].type`, Text reicht für
+ *  eine reine Anzeige (kein Select/Number-spezifisches Rendering nötig). */
+export function synthesizeProjectionDetailEntity(layout) {
+    const fields = {};
+    for (const section of layout.sections) {
+        // relatedList and extension sections carry no `fields` to synthesize.
+        if (!isFieldsEditSection(section))
+            continue;
+        for (const spec of sectionFieldSpecs(section)) {
+            fields[normalizeEditField(spec).field] = { type: "text" };
+        }
+    }
+    return { fields };
+}
+/** Wandelt ein ProjectionDetailScreenDefinition in die EntityEditScreen-Shape
+ *  die RenderEdit erwartet — mit jedem Feld hart auf readOnly:true erzwungen. */
+export function synthesizeProjectionDetailScreen(screen) {
+    const forceReadOnly = (spec) => ({ ...normalizeEditField(spec), readOnly: true });
+    const sections = screen.layout.sections.map((section) => {
+        // relatedList and extension sections pass through unchanged.
+        if (!isFieldsEditSection(section))
+            return section;
+        return {
+            ...section,
+            // kumiko-lint-ignore section-fields-raw rewrites both sources in place — the groups branch below does the same for groups[].fields
+            fields: section.fields.map(forceReadOnly),
+            ...(section.groups !== undefined && {
+                groups: section.groups.map((group) => ({
+                    ...group,
+                    fields: group.fields.map(forceReadOnly),
+                })),
+            }),
+        };
+    });
+    return {
+        id: screen.id,
+        type: "entityEdit",
+        entity: PROJECTION_DETAIL_PSEUDO_ENTITY,
+        layout: { sections, ...(screen.layout.width !== undefined && { width: screen.layout.width }) },
+        allowCreate: false,
+        allowDelete: false,
+        ...(screen.description !== undefined && { description: screen.description }),
+        ...(screen.fieldLabels !== undefined && { fieldLabels: screen.fieldLabels }),
+        ...(screen.slots !== undefined && { slots: screen.slots }),
+        ...(screen.access !== undefined && { access: screen.access }),
+        ...(screen.fillHeight !== undefined && { fillHeight: screen.fillHeight }),
+    };
+}

package/dist/app/projection-list-shim.d.ts

@@ -0,0 +1,13 @@
+import type { EntityDefinition, EntityListScreenDefinition, ListColumnSpec, ProjectionListScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+/** Minimal EntityDefinition from the column list: every field is a text
+ *  field. `sortable` applies uniformly to all columns — buildAppSchema
+ *  derives it from the query's Zod schema (`screen.sortable`, fw#2165); the
+ *  query itself has no per-field server-sort guarantee.
+ *  computeListViewModel only reads `fields[<col>].type` — text is enough,
+ *  presentation comes from the column renderer + explicit label. */
+export declare function synthesizeProjectionEntity(columns: readonly ListColumnSpec[], sortable: boolean): EntityDefinition;
+/** Wandelt ein ProjectionListScreenDefinition in die EntityListScreen-Shape die
+ *  RenderList erwartet. `type` = "entityList" + Pseudo-Entity halten den Type-
+ *  Constraint; RenderList branched nicht auf `type` und liest `entity` nur für
+ *  Fehlermeldungen. Die List-Felder werden 1:1 durchgereicht. */
+export declare function synthesizeProjectionScreen(screen: ProjectionListScreenDefinition): EntityListScreenDefinition;

package/{src/app/projection-list-shim.ts → dist/app/projection-list-shim.js}

@@ -13,58 +13,43 @@
 // derivedFields) oder cross-referenziert ein Boot-Validator die schema.entities-
 // Map, brechen die Type-Lies hier silent — dann ist Zeit für eine echte
 // query-native ListView-Komponente.
-
-import type {
-  EntityDefinition,
-  EntityListScreenDefinition,
-  ListColumnSpec,
-  ProjectionListScreenDefinition,
-} from "@cosmicdrift/kumiko-framework/ui-types";
 import { normalizeListColumn } from "@cosmicdrift/kumiko-framework/ui-types";
-
 const PROJECTION_PSEUDO_ENTITY = "__projection__";
-
 /** Minimal EntityDefinition from the column list: every field is a text
  *  field. `sortable` applies uniformly to all columns — buildAppSchema
  *  derives it from the query's Zod schema (`screen.sortable`, fw#2165); the
  *  query itself has no per-field server-sort guarantee.
  *  computeListViewModel only reads `fields[<col>].type` — text is enough,
  *  presentation comes from the column renderer + explicit label. */
-export function synthesizeProjectionEntity(
-  columns: readonly ListColumnSpec[],
-  sortable: boolean,
-): EntityDefinition {
-  const fields: Record<string, { type: "text"; sortable: boolean }> = {};
-  for (const col of columns) {
-    fields[normalizeListColumn(col).field] = { type: "text", sortable };
-  }
-  return { fields } as unknown as EntityDefinition;
+export function synthesizeProjectionEntity(columns, sortable) {
+    const fields = {};
+    for (const col of columns) {
+        fields[normalizeListColumn(col).field] = { type: "text", sortable };
+    }
+    return { fields };
 }
-
 /** Wandelt ein ProjectionListScreenDefinition in die EntityListScreen-Shape die
  *  RenderList erwartet. `type` = "entityList" + Pseudo-Entity halten den Type-
  *  Constraint; RenderList branched nicht auf `type` und liest `entity` nur für
  *  Fehlermeldungen. Die List-Felder werden 1:1 durchgereicht. */
-export function synthesizeProjectionScreen(
-  screen: ProjectionListScreenDefinition,
-): EntityListScreenDefinition {
-  return {
-    id: screen.id,
-    type: "entityList",
-    entity: PROJECTION_PSEUDO_ENTITY,
-    columns: screen.columns,
-    ...(screen.rowRenderer !== undefined && { rowRenderer: screen.rowRenderer }),
-    ...(screen.cardRenderer !== undefined && { cardRenderer: screen.cardRenderer }),
-    ...(screen.rowActions !== undefined && { rowActions: screen.rowActions }),
-    ...(screen.toolbarActions !== undefined && { toolbarActions: screen.toolbarActions }),
-    ...(screen.pagination !== undefined && { pagination: screen.pagination }),
-    ...(screen.pageSize !== undefined && { pageSize: screen.pageSize }),
-    ...(screen.defaultSort !== undefined && { defaultSort: screen.defaultSort }),
-    ...(screen.searchable !== undefined && { searchable: screen.searchable }),
-    ...(screen.createLabel !== undefined && { createLabel: screen.createLabel }),
-    ...(screen.searchPlaceholder !== undefined && { searchPlaceholder: screen.searchPlaceholder }),
-    ...(screen.slots !== undefined && { slots: screen.slots }),
-    ...(screen.access !== undefined && { access: screen.access }),
-    ...(screen.fillHeight !== undefined && { fillHeight: screen.fillHeight }),
-  };
+export function synthesizeProjectionScreen(screen) {
+    return {
+        id: screen.id,
+        type: "entityList",
+        entity: PROJECTION_PSEUDO_ENTITY,
+        columns: screen.columns,
+        ...(screen.rowRenderer !== undefined && { rowRenderer: screen.rowRenderer }),
+        ...(screen.cardRenderer !== undefined && { cardRenderer: screen.cardRenderer }),
+        ...(screen.rowActions !== undefined && { rowActions: screen.rowActions }),
+        ...(screen.toolbarActions !== undefined && { toolbarActions: screen.toolbarActions }),
+        ...(screen.pagination !== undefined && { pagination: screen.pagination }),
+        ...(screen.pageSize !== undefined && { pageSize: screen.pageSize }),
+        ...(screen.defaultSort !== undefined && { defaultSort: screen.defaultSort }),
+        ...(screen.searchable !== undefined && { searchable: screen.searchable }),
+        ...(screen.createLabel !== undefined && { createLabel: screen.createLabel }),
+        ...(screen.searchPlaceholder !== undefined && { searchPlaceholder: screen.searchPlaceholder }),
+        ...(screen.slots !== undefined && { slots: screen.slots }),
+        ...(screen.access !== undefined && { access: screen.access }),
+        ...(screen.fillHeight !== undefined && { fillHeight: screen.fillHeight }),
+    };
 }

package/dist/app/qn.d.ts

@@ -0,0 +1,7 @@
+export declare function lastSegment(qn: string): string;
+/**
+ * Client-safe copy of framework `toKebab` (engine/qualified-name.ts).
+ * Must stay in sync — do NOT import from `@cosmicdrift/kumiko-framework/engine`
+ * here: that barrel pulls server deps into the browser bundle.
+ */
+export declare function toKebab(input: string): string;