@cosmicdrift/kumiko-renderer 0.327.0 → 0.328.1

package/dist/app/action-form-shim.d.ts

@@ -0,0 +1,14 @@
+import type { ActionFormScreenDefinition, EntityDefinition, EntityEditScreenDefinition, FieldDefinition, SecretMintConfirmStep, SecretMintScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+/** Baut eine minimale EntityDefinition aus den Inline-Fields eines
+ *  ActionForm- oder SecretMint-Screens. RenderEdit + computeEditViewModel
+ *  iterieren über entity.fields zur Render-Zeit; alle weiteren
+ *  EntityDefinition-Felder bleiben undefined. */
+export declare function synthesizeActionFormEntity(fields: Readonly<Record<string, FieldDefinition>>): EntityDefinition;
+/** Wandelt ein ActionFormScreenDefinition oder SecretMintScreenDefinition in
+ *  die EntityEditScreen-Shape die RenderEdit erwartet. type wird auf
+ *  "entityEdit" gesetzt damit der Type-Constraint hält; entity wird auf den
+ *  Pseudo-Namen gepinnt — RenderEdit liest das Feld nicht. */
+export declare function synthesizeActionFormScreen(screen: ActionFormScreenDefinition | SecretMintScreenDefinition): EntityEditScreenDefinition;
+/** Separate id (`${screen.id}:confirm`) keeps this confirm-form screen from
+ *  colliding with the mint-form screen's draft key. */
+export declare function synthesizeSecretMintConfirmScreen(screen: SecretMintScreenDefinition, confirm: SecretMintConfirmStep): EntityEditScreenDefinition;

package/{src/app/action-form-shim.ts → dist/app/action-form-shim.js}

@@ -14,61 +14,43 @@
 // RenderActionForm-Komponente, die `fields` direkt als Input nimmt.
 // Der Boot-Validator kennt actionForm bereits eigenständig (kein
 // entity-Lookup), also ist der Server-Pfad davon nicht betroffen.
-
-import type {
-  ActionFormScreenDefinition,
-  EntityDefinition,
-  EntityEditScreenDefinition,
-  FieldDefinition,
-  SecretMintConfirmStep,
-  SecretMintScreenDefinition,
-} from "@cosmicdrift/kumiko-framework/ui-types";
-
 const ACTION_FORM_PSEUDO_ENTITY = "__action-form__";
-
 /** Baut eine minimale EntityDefinition aus den Inline-Fields eines
  *  ActionForm- oder SecretMint-Screens. RenderEdit + computeEditViewModel
  *  iterieren über entity.fields zur Render-Zeit; alle weiteren
  *  EntityDefinition-Felder bleiben undefined. */
-export function synthesizeActionFormEntity(
-  fields: Readonly<Record<string, FieldDefinition>>,
-): EntityDefinition {
-  return { fields } as EntityDefinition;
+export function synthesizeActionFormEntity(fields) {
+    return { fields };
 }
-
 /** Wandelt ein ActionFormScreenDefinition oder SecretMintScreenDefinition in
  *  die EntityEditScreen-Shape die RenderEdit erwartet. type wird auf
  *  "entityEdit" gesetzt damit der Type-Constraint hält; entity wird auf den
  *  Pseudo-Namen gepinnt — RenderEdit liest das Feld nicht. */
-export function synthesizeActionFormScreen(
-  screen: ActionFormScreenDefinition | SecretMintScreenDefinition,
-): EntityEditScreenDefinition {
-  return {
-    id: screen.id,
-    type: "entityEdit",
-    entity: ACTION_FORM_PSEUDO_ENTITY,
-    layout: screen.layout,
-    ...(screen.description !== undefined && { description: screen.description }),
-    ...(screen.access !== undefined && { access: screen.access }),
-    // Only ActionFormScreenDefinition carries slots/fieldLabels; `in` narrows
-    // without a cast since SecretMintScreenDefinition has neither.
-    ...("slots" in screen && screen.slots !== undefined && { slots: screen.slots }),
-    ...("fieldLabels" in screen &&
-      screen.fieldLabels !== undefined && { fieldLabels: screen.fieldLabels }),
-  };
+export function synthesizeActionFormScreen(screen) {
+    return {
+        id: screen.id,
+        type: "entityEdit",
+        entity: ACTION_FORM_PSEUDO_ENTITY,
+        layout: screen.layout,
+        ...(screen.description !== undefined && { description: screen.description }),
+        ...(screen.access !== undefined && { access: screen.access }),
+        // Only ActionFormScreenDefinition carries slots/fieldLabels; `in` narrows
+        // without a cast since SecretMintScreenDefinition has neither.
+        ...("slots" in screen && screen.slots !== undefined && { slots: screen.slots }),
+        ...("fillHeight" in screen &&
+            screen.fillHeight !== undefined && { fillHeight: screen.fillHeight }),
+        ...("fieldLabels" in screen &&
+            screen.fieldLabels !== undefined && { fieldLabels: screen.fieldLabels }),
+    };
 }
-
 /** Separate id (`${screen.id}:confirm`) keeps this confirm-form screen from
  *  colliding with the mint-form screen's draft key. */
-export function synthesizeSecretMintConfirmScreen(
-  screen: SecretMintScreenDefinition,
-  confirm: SecretMintConfirmStep,
-): EntityEditScreenDefinition {
-  return {
-    id: `${screen.id}:confirm`,
-    type: "entityEdit",
-    entity: ACTION_FORM_PSEUDO_ENTITY,
-    layout: confirm.layout,
-    ...(screen.access !== undefined && { access: screen.access }),
-  };
+export function synthesizeSecretMintConfirmScreen(screen, confirm) {
+    return {
+        id: `${screen.id}:confirm`,
+        type: "entityEdit",
+        entity: ACTION_FORM_PSEUDO_ENTITY,
+        layout: confirm.layout,
+        ...(screen.access !== undefined && { access: screen.access }),
+    };
 }

package/dist/app/app-features-context.d.ts

@@ -0,0 +1,8 @@
+import { type ReactNode } from "react";
+import type { FeatureSchema } from "./feature-schema.js";
+export type AppFeaturesProviderProps = {
+    readonly features: readonly FeatureSchema[];
+    readonly children: ReactNode;
+};
+export declare function AppFeaturesProvider({ features, children }: AppFeaturesProviderProps): ReactNode;
+export declare function useAppFeatures(): readonly FeatureSchema[];

package/dist/app/app-features-context.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Cross-feature schema access for components that need to resolve a
+// screen owned by a DIFFERENT feature than the one they're rendering
+// under — e.g. a reference field opening the target entity's create
+// screen (kumiko-framework#1681). `createKumikoApp` provides the full
+// `app.features` list; components elsewhere in the render tree default
+// to an empty list (no cross-feature schema known, e.g. outside
+// createKumikoApp or in isolated tests).
+import { createContext, useContext } from "react";
+const AppFeaturesContext = createContext([]);
+export function AppFeaturesProvider({ features, children }) {
+    return _jsx(AppFeaturesContext.Provider, { value: features, children: children });
+}
+export function useAppFeatures() {
+    return useContext(AppFeaturesContext);
+}

package/dist/app/column-renderers.d.ts

@@ -0,0 +1,30 @@
+import { type ComponentType, type ReactNode } from "react";
+export type ColumnRendererProps = {
+    readonly value: unknown;
+    readonly row: Readonly<Record<string, unknown>>;
+    readonly column: {
+        readonly field: string;
+    };
+    /** Set only when the caller (DataTable's `onCellChange`) wired an
+     *  editable path for this cell — undefined means read-only. A renderer
+     *  can branch its own markup (input vs. plain text) on presence alone. */
+    readonly onChange?: (value: unknown) => void;
+};
+export type ColumnRendererComponent = ComponentType<ColumnRendererProps>;
+export type ColumnRenderersMap = Readonly<Record<string, ColumnRendererComponent>>;
+export type ColumnRenderersProviderProps = {
+    readonly children: ReactNode;
+    readonly value: ColumnRenderersMap;
+};
+export declare function ColumnRenderersProvider({ children, value, }: ColumnRenderersProviderProps): ReactNode;
+/** Schaut die Component für einen Renderer-Key nach. Returnt undefined
+ *  wenn `name` leer/undefined ist (Caller hat keinen __component-Renderer)
+ *  oder weder Provider gemounted noch der Key in der Map ist. Der Caller
+ *  (DataTable.renderCell) loggt dann eine Warnung und fällt auf den
+ *  Default-Type-Renderer zurück.
+ *
+ *  `name` ist optional damit Caller den Hook unkonditional aufrufen
+ *  können — Rules-of-Hooks verbieten einen Function-Branch der den Hook
+ *  überspringt. So bleibt der Aufruf eine einzige Zeile, ohne dass der
+ *  Caller einen Stub-Key wie `""` reichen muss. */
+export declare function useColumnRenderer(name?: string): ColumnRendererComponent | undefined;

package/dist/app/column-renderers.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Column-Renderer-Map: client-side Lookup für ListColumn-Spalten die im
+// Schema einen PlatformComponent-Renderer (`{ react: { __component: "Name" } }`)
+// statt einer String-Funktion angeben. createKumikoApp im renderer-web sammelt
+// alle clientFeatures.columnRenderers und mountet den Provider; der DataTable-
+// Cell-Renderer schlägt den Component über `useColumnRenderer(name)` nach.
+//
+// Analog zu CustomScreensProvider — der Renderer-Web-Bootstrap mounted beide
+// Provider an derselben Stelle. Schemas selbst bleiben serializable: der
+// Component wird nur per String-Key referenziert, die Map liegt allein
+// client-seitig.
+import { createContext, useContext } from "react";
+const ColumnRenderersContext = createContext(undefined);
+export function ColumnRenderersProvider({ children, value, }) {
+    return (_jsx(ColumnRenderersContext.Provider, { value: value, children: children }));
+}
+/** Schaut die Component für einen Renderer-Key nach. Returnt undefined
+ *  wenn `name` leer/undefined ist (Caller hat keinen __component-Renderer)
+ *  oder weder Provider gemounted noch der Key in der Map ist. Der Caller
+ *  (DataTable.renderCell) loggt dann eine Warnung und fällt auf den
+ *  Default-Type-Renderer zurück.
+ *
+ *  `name` ist optional damit Caller den Hook unkonditional aufrufen
+ *  können — Rules-of-Hooks verbieten einen Function-Branch der den Hook
+ *  überspringt. So bleibt der Aufruf eine einzige Zeile, ohne dass der
+ *  Caller einen Stub-Key wie `""` reichen muss. */
+export function useColumnRenderer(name) {
+    const map = useContext(ColumnRenderersContext);
+    if (name === undefined || name === "")
+        return undefined;
+    if (map === undefined)
+        return undefined;
+    return map[name];
+}

package/dist/app/config-edit-shim.d.ts

@@ -0,0 +1,11 @@
+import type { ConfigEditScreenDefinition, EntityDefinition, EntityEditScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+/** Baut eine minimale EntityDefinition aus den Inline-Fields des
+ *  ConfigEdit-Screens. RenderEdit + computeEditViewModel iterieren
+ *  über entity.fields zur Render-Zeit; alle weiteren EntityDefinition-
+ *  Felder bleiben undefined. */
+export declare function synthesizeConfigEditEntity(fields: ConfigEditScreenDefinition["fields"]): EntityDefinition;
+/** Wandelt ein ConfigEditScreenDefinition in die EntityEditScreen-
+ *  Shape die RenderEdit erwartet. type wird auf "entityEdit" gesetzt
+ *  damit der Type-Constraint hält; entity wird auf den Pseudo-Namen
+ *  gepinnt — RenderEdit liest das Feld nicht. */
+export declare function synthesizeConfigEditScreen(screen: ConfigEditScreenDefinition): EntityEditScreenDefinition;

package/{src/app/config-edit-shim.ts → dist/app/config-edit-shim.js}

@@ -12,39 +12,26 @@
 // zukünftiger Boot-Validator die schema.entities-Map cross-referenziert,
 // brechen die Type-Lies hier silent. Dann ist Zeit für eine echte
 // RenderConfigEdit-Komponente die direkt fields nimmt.
-
-import type {
-  ConfigEditScreenDefinition,
-  EntityDefinition,
-  EntityEditScreenDefinition,
-} from "@cosmicdrift/kumiko-framework/ui-types";
-
 const CONFIG_EDIT_PSEUDO_ENTITY = "__config-edit__";
-
 /** Baut eine minimale EntityDefinition aus den Inline-Fields des
  *  ConfigEdit-Screens. RenderEdit + computeEditViewModel iterieren
  *  über entity.fields zur Render-Zeit; alle weiteren EntityDefinition-
  *  Felder bleiben undefined. */
-export function synthesizeConfigEditEntity(
-  fields: ConfigEditScreenDefinition["fields"],
-): EntityDefinition {
-  return { fields } as EntityDefinition;
+export function synthesizeConfigEditEntity(fields) {
+    return { fields };
 }
-
 /** Wandelt ein ConfigEditScreenDefinition in die EntityEditScreen-
  *  Shape die RenderEdit erwartet. type wird auf "entityEdit" gesetzt
  *  damit der Type-Constraint hält; entity wird auf den Pseudo-Namen
  *  gepinnt — RenderEdit liest das Feld nicht. */
-export function synthesizeConfigEditScreen(
-  screen: ConfigEditScreenDefinition,
-): EntityEditScreenDefinition {
-  return {
-    id: screen.id,
-    type: "entityEdit",
-    entity: CONFIG_EDIT_PSEUDO_ENTITY,
-    layout: screen.layout,
-    ...(screen.description !== undefined && { description: screen.description }),
-    ...(screen.fieldLabels !== undefined && { fieldLabels: screen.fieldLabels }),
-    ...(screen.access !== undefined && { access: screen.access }),
-  };
+export function synthesizeConfigEditScreen(screen) {
+    return {
+        id: screen.id,
+        type: "entityEdit",
+        entity: CONFIG_EDIT_PSEUDO_ENTITY,
+        layout: screen.layout,
+        ...(screen.description !== undefined && { description: screen.description }),
+        ...(screen.fieldLabels !== undefined && { fieldLabels: screen.fieldLabels }),
+        ...(screen.access !== undefined && { access: screen.access }),
+    };
 }

package/dist/app/content-editors.d.ts

@@ -0,0 +1,38 @@
+import type { ContentEditorFormat } from "@cosmicdrift/kumiko-types/nav";
+import { type ComponentType, type ReactNode } from "react";
+export type ContentEditorProps = {
+    /** DOM id every registered editor must render onto its own focusable
+     *  root element. Callers that wrap an editor in a `Field` (label +
+     *  htmlFor) pass a stable id here so the label stays associated with
+     *  whatever element actually renders — a fixed constant would break as
+     *  soon as a registered editor swaps in for the textarea fallback. */
+    readonly id: string;
+    readonly value: string;
+    readonly onChange: (value: string) => void;
+    /** Variable names insertable as chips (from the collection's
+     *  variableSchema). Empty until the variable-chip step wires it up —
+     *  editors must accept it now, that's the point of fixing the signature
+     *  here. */
+    readonly variables: readonly string[];
+    readonly readOnly: boolean;
+};
+export type ContentEditorComponent = ComponentType<ContentEditorProps>;
+/** Default id value for callers that don't generate their own (e.g. a
+ *  standalone TextareaContentEditor render outside a multi-editor page).
+ *  Registered editors don't apply this automatically — every caller passes
+ *  its own id via ContentEditorProps.id. */
+export declare const CONTENT_EDITOR_ELEMENT_ID = "content-editor-textarea";
+export type ContentEditorsMap = Partial<Record<ContentEditorFormat, ContentEditorComponent>>;
+export type ContentEditorsProviderProps = {
+    readonly children: ReactNode;
+    readonly value: ContentEditorsMap;
+};
+export declare function ContentEditorsProvider({ children, value, }: ContentEditorsProviderProps): ReactNode;
+/** Plain-textarea fallback for a contentFormat with no registered editor.
+ *  Uses the primitives Input like every other form field, so it renders on
+ *  every platform without requiring the platform's DOM/native equivalent. */
+export declare function TextareaContentEditor({ id, value, onChange, readOnly, }: ContentEditorProps): ReactNode;
+/** Resolves the editor for a contentFormat, falling back to the plain
+ *  textarea when no clientFeature registered one. `contentFormat`
+ *  undefined (collection didn't declare one) behaves like "plain". */
+export declare function useContentEditor(contentFormat?: ContentEditorFormat): ContentEditorComponent;

package/dist/app/content-editors.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+import { usePrimitives } from "../primitives.js";
+/** Default id value for callers that don't generate their own (e.g. a
+ *  standalone TextareaContentEditor render outside a multi-editor page).
+ *  Registered editors don't apply this automatically — every caller passes
+ *  its own id via ContentEditorProps.id. */
+export const CONTENT_EDITOR_ELEMENT_ID = "content-editor-textarea";
+const ContentEditorsContext = createContext({});
+export function ContentEditorsProvider({ children, value, }) {
+    return _jsx(ContentEditorsContext.Provider, { value: value, children: children });
+}
+/** Plain-textarea fallback for a contentFormat with no registered editor.
+ *  Uses the primitives Input like every other form field, so it renders on
+ *  every platform without requiring the platform's DOM/native equivalent. */
+export function TextareaContentEditor({ id, value, onChange, readOnly, }) {
+    const { Input } = usePrimitives();
+    return (_jsx(Input, { kind: "textarea", id: id, name: CONTENT_EDITOR_ELEMENT_ID, value: value, onChange: onChange, readOnly: readOnly, rows: 14 }));
+}
+/** Resolves the editor for a contentFormat, falling back to the plain
+ *  textarea when no clientFeature registered one. `contentFormat`
+ *  undefined (collection didn't declare one) behaves like "plain". */
+export function useContentEditor(contentFormat) {
+    const map = useContext(ContentEditorsContext);
+    return map[contentFormat ?? "plain"] ?? TextareaContentEditor;
+}

package/dist/app/content-preview.d.ts

@@ -0,0 +1,11 @@
+import type { ContentEditorFormat } from "@cosmicdrift/kumiko-types/nav";
+import { type ReactNode } from "react";
+/** A name with no example value (or not in the schema at all) stays as the
+ *  literal `{{name}}` placeholder — there is nothing else to show for it. */
+export declare function substituteVariables(content: string, variables: Readonly<Record<string, string>>): string;
+export type ContentPreviewProps = {
+    readonly content: string;
+    readonly variables: Readonly<Record<string, string>>;
+    readonly contentFormat?: ContentEditorFormat;
+};
+export declare function ContentPreview({ content, variables, contentFormat, }: ContentPreviewProps): ReactNode;

package/dist/app/content-preview.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useId } from "react";
+import { useContentEditor } from "./content-editors.js";
+const VARIABLE_PATTERN = /\{\{\s*(\w+)\s*\}\}/g;
+const noop = () => { };
+/** A name with no example value (or not in the schema at all) stays as the
+ *  literal `{{name}}` placeholder — there is nothing else to show for it. */
+export function substituteVariables(content, variables) {
+    return content.replace(VARIABLE_PATTERN, (match, name) => Object.hasOwn(variables, name) ? (variables[name] ?? match) : match);
+}
+function escapeHtml(value) {
+    return value
+        .replace(/&/g, "&")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
+export function ContentPreview({ content, variables, contentFormat, }) {
+    const Editor = useContentEditor(contentFormat);
+    const id = useId();
+    // "rich" content is HTML (see ContentCollectionDefinition.contentFormat) —
+    // an example value substituted in raw could break the markup (`<`) or
+    // render as an unescaped entity (`&`). "plain"/"markdown" content is text,
+    // no escaping wanted there.
+    const safeVariables = contentFormat === "rich"
+        ? Object.fromEntries(Object.entries(variables).map(([name, value]) => [name, escapeHtml(value)]))
+        : variables;
+    return (_jsx(Editor, { id: id, value: substituteVariables(content, safeVariables), onChange: noop, variables: [], readOnly: true }));
+}

package/dist/app/custom-screens.d.ts

@@ -0,0 +1,11 @@
+import { type ComponentType, type ReactNode } from "react";
+export type CustomScreensMap = Readonly<Record<string, ComponentType>>;
+export type CustomScreensProviderProps = {
+    readonly children: ReactNode;
+    readonly value: CustomScreensMap;
+};
+export declare function CustomScreensProvider({ children, value }: CustomScreensProviderProps): ReactNode;
+/** Schaut die Component für ein Custom-Screen nach. Returnt undefined
+ *  wenn weder Provider gemounted noch screenId in der Map ist — der
+ *  Caller (KumikoScreen) zeigt dann seinen Placeholder-Banner. */
+export declare function useCustomScreenComponent(screenId: string): ComponentType | undefined;

package/dist/app/custom-screens.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Custom-Screen-Components-Map: client-side Lookup für Screens vom Typ
+// `custom`. KumikoScreen schaut hier nach `screen.id` (oder qn) und
+// rendert die passende Component. createKumikoApp im renderer-web sammelt
+// alle clientFeatures.components und mountet den Provider; Tests die
+// einzelne Custom-Screens prüfen wollen, mounten den Provider direkt.
+import { createContext, useContext } from "react";
+const CustomScreensContext = createContext(undefined);
+export function CustomScreensProvider({ children, value }) {
+    return _jsx(CustomScreensContext.Provider, { value: value, children: children });
+}
+/** Schaut die Component für ein Custom-Screen nach. Returnt undefined
+ *  wenn weder Provider gemounted noch screenId in der Map ist — der
+ *  Caller (KumikoScreen) zeigt dann seinen Placeholder-Banner. */
+export function useCustomScreenComponent(screenId) {
+    const map = useContext(CustomScreensContext);
+    if (map === undefined)
+        return undefined;
+    return map[screenId];
+}

package/dist/app/dashboard-body.d.ts

@@ -0,0 +1,16 @@
+import type { DashboardScreenDefinition } from "@cosmicdrift/kumiko-framework/ui-types";
+import type { Translate } from "@cosmicdrift/kumiko-headless";
+import { type ComponentType, type ReactNode } from "react";
+export type DashboardBodyProps = {
+    readonly featureName: string;
+    readonly screen: DashboardScreenDefinition;
+    readonly translate?: Translate;
+};
+export type DashboardBodyProviderProps = {
+    readonly children: ReactNode;
+    readonly value: ComponentType<DashboardBodyProps>;
+};
+export declare function DashboardBodyProvider({ children, value }: DashboardBodyProviderProps): ReactNode;
+/** Undefined wenn kein Platform-Package einen Dashboard-Body registriert
+ *  hat — KumikoScreen zeigt dann seinen Placeholder-Banner. */
+export declare function useDashboardBody(): ComponentType<DashboardBodyProps> | undefined;

package/dist/app/dashboard-body.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const DashboardBodyContext = createContext(undefined);
+export function DashboardBodyProvider({ children, value }) {
+    return _jsx(DashboardBodyContext.Provider, { value: value, children: children });
+}
+/** Undefined wenn kein Platform-Package einen Dashboard-Body registriert
+ *  hat — KumikoScreen zeigt dann seinen Placeholder-Banner. */
+export function useDashboardBody() {
+    return useContext(DashboardBodyContext);
+}

package/dist/app/extension-form-submit.d.ts

@@ -0,0 +1,32 @@
+export type ExtensionSubmitContext = {
+    readonly entityId: string;
+};
+export type ExtensionSubmitResult = {
+    readonly isSuccess: boolean;
+    /** i18n-Key für die Fehlermeldung, die die Form als Banner zeigt. */
+    readonly errorKey?: string;
+};
+export type ExtensionFormSubmitHandler = (ctx: ExtensionSubmitContext) => Promise<ExtensionSubmitResult>;
+type Registration = {
+    readonly key: string;
+    readonly dirty: boolean;
+    readonly handler: ExtensionFormSubmitHandler;
+};
+export type ExtensionFormRegistry = {
+    readonly upsert: (reg: Registration) => void;
+    readonly remove: (key: string) => void;
+};
+export declare const ExtensionFormRegistryProvider: import("react").Provider<ExtensionFormRegistry | null>;
+export type ExtensionFormHostStatus = {
+    readonly anyDirty: boolean;
+    readonly hasRegistrations: boolean;
+};
+export declare function useExtensionFormHost(onStatusChange: (status: ExtensionFormHostStatus) => void): {
+    readonly registry: ExtensionFormRegistry;
+    readonly runAll: (ctx: ExtensionSubmitContext) => Promise<readonly ExtensionSubmitResult[]>;
+};
+export declare function useExtensionFormSubmit(opts: {
+    readonly dirty: boolean;
+    readonly onSubmit: ExtensionFormSubmitHandler;
+}): boolean;
+export {};

package/dist/app/extension-form-submit.js

@@ -0,0 +1,73 @@
+// @runtime client
+// Extension-Form-Submit-Registry — erlaubt einer Extension-Section (z.B.
+// Custom-Fields), beim Submit des umgebenden entityEdit-Forms mitzuschreiben,
+// statt einen eigenen Save-Button zu führen ("composed form, ein Save",
+// Bug-Bash 3 #1). Die Section meldet (a) einen Submit-Handler und (b) ihren
+// dirty-State an die Form; die Form aktiviert ihren Save-Button auch wenn nur
+// eine Section dirty ist und ruft nach dem Entity-Write alle Section-Handler
+// mit der entityId.
+//
+// Ohne umgebende Form (Context === null) fällt die Section auf ihren eigenen
+// Save-Button zurück (Standalone-Backward-Compat).
+import { createContext, useContext, useEffect, useId, useMemo, useRef } from "react";
+const ExtensionFormRegistryContext = createContext(null);
+export const ExtensionFormRegistryProvider = ExtensionFormRegistryContext.Provider;
+export function useExtensionFormHost(onStatusChange) {
+    const regsRef = useRef(new Map());
+    const onStatusRef = useRef(onStatusChange);
+    onStatusRef.current = onStatusChange;
+    const registry = useMemo(() => {
+        const emitDirty = () => {
+            let any = false;
+            for (const r of regsRef.current.values()) {
+                if (r.dirty) {
+                    any = true;
+                    break;
+                }
+            }
+            onStatusRef.current({ anyDirty: any, hasRegistrations: regsRef.current.size > 0 });
+        };
+        return {
+            upsert: (reg) => {
+                regsRef.current.set(reg.key, reg);
+                emitDirty();
+            },
+            remove: (key) => {
+                regsRef.current.delete(key);
+                emitDirty();
+            },
+        };
+    }, []);
+    const runAll = useMemo(() => async (ctx) => {
+        const results = [];
+        // Insertion-Order (Map) = Section-Reihenfolge im Form.
+        for (const reg of regsRef.current.values()) {
+            results.push(await reg.handler(ctx));
+        }
+        return results;
+    }, []);
+    return { registry, runAll };
+}
+// Section-Seite: meldet Handler + dirty an die umgebende Form. Returnt true
+// wenn eine composed-Form vorhanden ist (Section blendet dann ihren eigenen
+// Save-Button aus); false = standalone (eigener Save-Button bleibt).
+export function useExtensionFormSubmit(opts) {
+    const registry = useContext(ExtensionFormRegistryContext);
+    const key = useId();
+    // Handler über ref, damit das Re-Registrieren NICHT an jeder Handler-
+    // Identity hängt (nur an dirty); der Handler liest immer den frischen
+    // Closure-State (pending) zur Aufruf-Zeit.
+    const handlerRef = useRef(opts.onSubmit);
+    handlerRef.current = opts.onSubmit;
+    useEffect(() => {
+        if (registry === null)
+            return;
+        registry.upsert({
+            key,
+            dirty: opts.dirty,
+            handler: (ctx) => handlerRef.current(ctx),
+        });
+        return () => registry.remove(key);
+    }, [registry, key, opts.dirty]);
+    return registry !== null;
+}

package/dist/app/extension-sections.d.ts

@@ -0,0 +1,72 @@
+import type { PlatformComponent } from "@cosmicdrift/kumiko-framework/ui-types";
+import { type ComponentType, type ReactNode } from "react";
+/** Extrahiert den `__component`-Namen aus einer PlatformComponent. Liest
+ *  react- und native-Branch (die App-Author registriert beide unter dem
+ *  gleichen Namen); returnt den ersten gefundenen string. Pure narrowing
+ *  via `in` — kein cast, kein assertion. */
+export declare function extensionSectionName(component: PlatformComponent): string | undefined;
+export type ExtensionSectionProps = {
+    readonly entityName: string;
+    readonly entityId: string | null;
+    /** Bereits gespeicherte Extension-Werte der Entity (aus der geladenen
+     *  detail-row durchgereicht). `undefined` im Create-Mode oder wenn der
+     *  Host-Screen keine Werte liefert. Erlaubt der Section, den Bestand
+     *  beim Edit anzuzeigen statt write-only zu sein. */
+    readonly initialValues?: Readonly<Record<string, unknown>>;
+    /** Nur im List-Header-Slot gesetzt (entityId ist dort null): die screen.id
+     *  der Liste, damit ein Header-Control den per-Screen URL-Filter-State
+     *  (useListUrlState) ansprechen kann — z.B. ein Tag-Filter der die Liste auf
+     *  eine id-Menge narrowed. In entityEdit-Sections undefined. */
+    readonly screenId?: string;
+    /** Nur im Dashboard-`custom`-Panel gesetzt: der aktuell gewählte Wert des
+     *  Screen-Filters (siehe DashboardFilterDefinition), gemerged wie bei jeder
+     *  anderen Panel-Query. In allen anderen Mount-Orten undefined. Dashboard-
+     *  Panels haben keine Entity — entityName/entityId tragen dort die
+     *  screen.id bzw. null, siehe CustomPanelBody in dashboard-body.tsx. */
+    readonly filterParams?: Readonly<Record<string, unknown>>;
+    /** Current form values of the host RenderEdit (controlled mode,
+     *  issue #1887/#1888) — same snapshot reference as
+     *  `RenderEditChangeState.values`. Lets the section read the host
+     *  form's live state (e.g. for a review step). Only set in
+     *  entityEdit sections; undefined in list-header and dashboard
+     *  mounts, where no host form exists. */
+    readonly values?: Readonly<Record<string, unknown>>;
+    /** Sets host RenderEdit form values from outside (e.g. a VIN-decode
+     *  roundtrip that fills other fields) — same function as
+     *  `RenderEditControls.patch`, merges only the given keys. `patch` must
+     *  converge: `setValues` is a no-op only when the merged result is
+     *  reference-equal to the current values, so an unconditional
+     *  `patch(...)` from a `values`-dependent effect loops. Undefined outside
+     *  entityEdit sections. */
+    readonly patch?: (partial: Readonly<Record<string, unknown>>) => void;
+    /** Validates the host form without writing — same function as
+     *  `RenderEditControls.validate`; field errors land in
+     *  `snapshot.errors` on the field instead of a collective message.
+     *  Undefined outside entityEdit sections. */
+    readonly validate?: () => boolean;
+    /** Whether the host form has unsaved changes. Only set in the entityEdit
+     *  footer slot (`screen.slots.footer`); undefined in all other mounts. */
+    readonly hasUnsavedChanges?: boolean;
+    /** Current wizard step, only set for `layout.mode === "wizard"` forms.
+     *  Only set in the entityEdit footer slot (`screen.slots.footer`);
+     *  undefined in all other mounts, and undefined there too for a
+     *  non-wizard form. */
+    readonly wizardStep?: {
+        readonly index: number;
+        readonly isLast: boolean;
+    };
+};
+export type ExtensionSectionComponent = ComponentType<ExtensionSectionProps>;
+export type ExtensionSectionsMap = Readonly<Record<string, ExtensionSectionComponent>>;
+export type ExtensionSectionsProviderProps = {
+    readonly children: ReactNode;
+    readonly value: ExtensionSectionsMap;
+};
+export declare function ExtensionSectionsProvider({ children, value, }: ExtensionSectionsProviderProps): ReactNode;
+/** Schaut die Component für einen extension-section-Namen nach. Returnt
+ *  undefined wenn weder Provider gemounted noch der Name in der Map
+ *  registriert ist — der Caller (RenderEdit) zeigt dann seinen
+ *  Placeholder-Banner. `name` ist optional damit Caller den Hook
+ *  unkonditional aufrufen können (Rules-of-Hooks), ohne einen Stub-Key
+ *  wie `""` reichen zu müssen — analog `useColumnRenderer`. */
+export declare function useExtensionSectionComponent(name?: string): ExtensionSectionComponent | undefined;