@cosmicdrift/kumiko-renderer 0.328.0 → 0.328.1

package/src/app/__tests__/secret-mint-body.test.tsx

@@ -1,404 +0,0 @@
-// fw#2548: secretMint mints a one-time secret from a write-handler's own
-// success payload. This renders the real path (KumikoScreen → SecretMintBody
-// → RenderEdit) under a stub dispatcher, proving: (1) the secret is absent
-// before submit, (2) only the whitelisted reveal.fields survive the submit —
-// a stray "id" in the payload never leaks, (3) confirming clears the reveal
-// from the DOM, (4) no query call ever runs that could reload the secret.
-
-import { describe, expect, test } from "bun:test";
-import type {
-  SecretMintScreenDefinition,
-  TextFieldDef,
-} from "@cosmicdrift/kumiko-framework/ui-types";
-import type { Dispatcher } from "@cosmicdrift/kumiko-headless";
-import { fireEvent, render, screen as rtlScreen, waitFor } from "@testing-library/react";
-import type { ComponentType, ReactNode } from "react";
-import { DispatcherProvider } from "../../context/dispatcher-context";
-import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
-import { kumikoDefaultTranslations } from "../../i18n-defaults";
-import {
-  type BannerProps,
-  type CorePrimitives,
-  PrimitivesProvider,
-  type SecretRevealProps,
-  type SectionProps,
-  type TextProps,
-} from "../../primitives";
-import type { FeatureSchema } from "../feature-schema";
-import { KumikoScreen } from "../kumiko-screen";
-import { NavProvider, type NavTarget } from "../nav";
-
-const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
-const noop = () => null;
-
-const testButton: ComponentType<{
-  children?: ReactNode;
-  onClick?: () => void;
-  testId?: string;
-  type?: "button" | "submit";
-  disabled?: boolean;
-}> = ({ children, onClick, testId, type, disabled }) => (
-  <button type={type ?? "button"} data-testid={testId} onClick={onClick} disabled={disabled}>
-    {children}
-  </button>
-);
-
-const testForm: ComponentType<{
-  children?: ReactNode;
-  actions?: ReactNode;
-  secondaryActions?: ReactNode;
-  onSubmit?: () => void;
-}> = ({ children, actions, secondaryActions, onSubmit }) => (
-  <form
-    onSubmit={(e) => {
-      e.preventDefault();
-      onSubmit?.();
-    }}
-  >
-    {children}
-    {secondaryActions}
-    {actions}
-  </form>
-);
-
-const testInput: ComponentType<{
-  name?: string;
-  value?: unknown;
-  onChange?: (v: unknown) => void;
-}> = ({ name = "field", value, onChange }) => (
-  <input
-    aria-label={name}
-    data-testid={`input-${name}`}
-    value={typeof value === "string" ? value : ""}
-    onChange={(e) => onChange?.(e.target.value)}
-  />
-);
-
-const testSection: ComponentType<SectionProps> = ({ testId, children }) => (
-  <div data-testid={testId}>{children}</div>
-);
-const testBanner: ComponentType<BannerProps> = ({ children, testId }) => (
-  <div data-testid={testId}>{children}</div>
-);
-const testText: ComponentType<TextProps> = ({ children, testId }) => (
-  <span data-testid={testId}>{children}</span>
-);
-// Renders every value's raw text plus a `data-qr` marker — lets tests assert
-// both DOM-leak absence (no query needed to find rendered text) and that
-// display: "qr" reaches the primitive as `qr: true`.
-const testSecretReveal: ComponentType<SecretRevealProps> = ({ values, testId }) => (
-  <div data-testid={testId}>
-    {values.map((v) => (
-      <div key={v.label} data-testid={`secret-value-${v.label}`} data-qr={String(v.qr === true)}>
-        {v.value}
-      </div>
-    ))}
-  </div>
-);
-
-const testPrimitives: CorePrimitives = {
-  Button: testButton,
-  Banner: testBanner,
-  Field: passChildren,
-  Input: testInput,
-  DataTable: noop,
-  Form: testForm,
-  Section: testSection,
-  Card: passChildren,
-  Grid: passChildren,
-  GridCell: passChildren,
-  Text: testText,
-  Heading: passChildren,
-  Dialog: noop,
-  Modal: noop,
-  Lightbox: noop,
-  ConfigSourceBadge: noop,
-  ConfigCascadeView: noop,
-  Link: noop,
-  SecretReveal: testSecretReveal,
-} as unknown as CorePrimitives;
-
-const mintScreen: SecretMintScreenDefinition = {
-  id: "mint-token",
-  type: "secretMint",
-  handler: "shop:write:token:mint",
-  fields: { label: { type: "text" } as TextFieldDef },
-  layout: { sections: [{ title: "Mint", fields: ["label"] }] },
-  reveal: { fields: [{ field: "token", label: "Token" }] },
-};
-
-function buildSchema(screen: SecretMintScreenDefinition): FeatureSchema {
-  return {
-    featureName: "shop",
-    entities: {},
-    screens: [screen],
-  } as FeatureSchema;
-}
-
-function stubDispatcher(writeData: unknown): {
-  dispatcher: Dispatcher;
-  queryCalls: unknown[];
-} {
-  const queryCalls: unknown[] = [];
-  const dispatcher: Dispatcher = {
-    write: (async () => ({ isSuccess: true, data: writeData })) as unknown as Dispatcher["write"],
-    query: (async (type: string, payload: unknown) => {
-      queryCalls.push({ type, payload });
-      return { isSuccess: true, data: {} };
-    }) as unknown as Dispatcher["query"],
-    batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
-    statusStore: {
-      getState: () => "online",
-      subscribe: () => () => {},
-    } as unknown as Dispatcher["statusStore"],
-    async *stream() {},
-    pendingWrites: () => [],
-    pendingFiles: () => [],
-  };
-  return { dispatcher, queryCalls };
-}
-
-// Keyed stub — one write-response per handler QN, and every write call
-// recorded with its full payload — for scenarios with more than one
-// write-handler in play (mint + confirm).
-function stubMultiWriteDispatcher(responses: Readonly<Record<string, unknown>>): {
-  dispatcher: Dispatcher;
-  writeCalls: Array<{ readonly command: string; readonly payload: unknown }>;
-} {
-  const writeCalls: Array<{ readonly command: string; readonly payload: unknown }> = [];
-  const dispatcher: Dispatcher = {
-    write: (async (command: string, payload: unknown) => {
-      writeCalls.push({ command, payload });
-      return { isSuccess: true, data: responses[command] ?? {} };
-    }) as unknown as Dispatcher["write"],
-    query: (async () => ({ isSuccess: true, data: {} })) as unknown as Dispatcher["query"],
-    batch: (async () => ({ isSuccess: true, results: [] })) as unknown as Dispatcher["batch"],
-    statusStore: {
-      getState: () => "online",
-      subscribe: () => () => {},
-    } as unknown as Dispatcher["statusStore"],
-    async *stream() {},
-    pendingWrites: () => [],
-    pendingFiles: () => [],
-  };
-  return { dispatcher, writeCalls };
-}
-
-function renderMintScreen(
-  dispatcher: Dispatcher,
-  screen: SecretMintScreenDefinition = mintScreen,
-  navigate: (target: NavTarget) => void = () => {},
-) {
-  const qn = `shop:screen:${screen.id}`;
-  return render(
-    <LocaleProvider
-      resolver={createStaticLocaleResolver({ locale: "en-US" })}
-      fallbackBundles={[kumikoDefaultTranslations]}
-    >
-      <DispatcherProvider dispatcher={dispatcher}>
-        <NavProvider
-          value={{
-            route: { screenId: qn },
-            navigate,
-            replace: () => {},
-            hrefFor: () => "",
-            searchParams: {},
-            setSearchParams: () => {},
-          }}
-        >
-          <PrimitivesProvider value={testPrimitives}>
-            <KumikoScreen schema={buildSchema(screen)} qn={qn} />
-          </PrimitivesProvider>
-        </NavProvider>
-      </DispatcherProvider>
-    </LocaleProvider>,
-  );
-}
-
-describe("SecretMintBody (fw#2548)", () => {
-  test("before submit: the secret is not in the DOM", () => {
-    const { dispatcher } = stubDispatcher({ token: "kpat_secret", id: "x" });
-    renderMintScreen(dispatcher);
-    expect(rtlScreen.queryByText("kpat_secret")).toBeNull();
-  });
-
-  test("after a successful submit: only the whitelisted reveal field appears — not the payload's other fields", async () => {
-    const { dispatcher } = stubDispatcher({ token: "kpat_secret", id: "x" });
-    renderMintScreen(dispatcher);
-
-    fireEvent.change(rtlScreen.getByLabelText(/label/i), { target: { value: "My token" } });
-    fireEvent.click(rtlScreen.getByTestId("render-edit-submit"));
-
-    await waitFor(() => expect(rtlScreen.queryByText("kpat_secret")).not.toBeNull());
-    expect(rtlScreen.queryByText("x")).toBeNull();
-  });
-
-  test("confirming the reveal clears the secret from the DOM", async () => {
-    const { dispatcher } = stubDispatcher({ token: "kpat_secret", id: "x" });
-    renderMintScreen(dispatcher);
-
-    fireEvent.change(rtlScreen.getByLabelText(/label/i), { target: { value: "My token" } });
-    fireEvent.click(rtlScreen.getByTestId("render-edit-submit"));
-    await waitFor(() => expect(rtlScreen.queryByText("kpat_secret")).not.toBeNull());
-
-    fireEvent.click(rtlScreen.getByTestId("kumiko-screen-secret-mint-confirm"));
-    await waitFor(() => expect(rtlScreen.queryByText("kpat_secret")).toBeNull());
-  });
-
-  test("the secret is never fetched via a query — it only ever comes from the write result", async () => {
-    const { dispatcher, queryCalls } = stubDispatcher({ token: "kpat_secret", id: "x" });
-    renderMintScreen(dispatcher);
-
-    fireEvent.change(rtlScreen.getByLabelText(/label/i), { target: { value: "My token" } });
-    fireEvent.click(rtlScreen.getByTestId("render-edit-submit"));
-    await waitFor(() => expect(rtlScreen.queryByText("kpat_secret")).not.toBeNull());
-
-    expect(queryCalls.length).toBe(0);
-  });
-
-  test("acknowledging without a confirm step and without a redirect shows the done banner", async () => {
-    const { dispatcher } = stubDispatcher({ token: "kpat_secret", id: "x" });
-    renderMintScreen(dispatcher);
-
-    fireEvent.change(rtlScreen.getByLabelText(/label/i), { target: { value: "My token" } });
-    fireEvent.click(rtlScreen.getByTestId("render-edit-submit"));
-    await waitFor(() => expect(rtlScreen.queryByText("kpat_secret")).not.toBeNull());
-
-    fireEvent.click(rtlScreen.getByTestId("kumiko-screen-secret-mint-confirm"));
-    await waitFor(() =>
-      expect(rtlScreen.queryByTestId("kumiko-screen-secret-mint-done")).not.toBeNull(),
-    );
-  });
-
-  test("acknowledging with a redirect navigates instead of showing the done banner", async () => {
-    const { dispatcher } = stubDispatcher({ token: "kpat_secret", id: "x" });
-    const navigateCalls: NavTarget[] = [];
-    renderMintScreen(dispatcher, { ...mintScreen, redirect: "after-mint" }, (target) =>
-      navigateCalls.push(target),
-    );
-
-    fireEvent.change(rtlScreen.getByLabelText(/label/i), { target: { value: "My token" } });
-    fireEvent.click(rtlScreen.getByTestId("render-edit-submit"));
-    await waitFor(() => expect(rtlScreen.queryByText("kpat_secret")).not.toBeNull());
-
-    fireEvent.click(rtlScreen.getByTestId("kumiko-screen-secret-mint-confirm"));
-    await waitFor(() => expect(navigateCalls.length).toBe(1));
-    expect(navigateCalls[0]).toEqual({ screenId: "after-mint" });
-    expect(rtlScreen.queryByTestId("kumiko-screen-secret-mint-done")).toBeNull();
-  });
-
-  test("a reveal field with display 'qr' reaches the SecretReveal primitive with qr: true", async () => {
-    const qrScreen: SecretMintScreenDefinition = {
-      ...mintScreen,
-      reveal: { fields: [{ field: "token", label: "Token", display: "qr" }] },
-    };
-    const { dispatcher } = stubDispatcher({ token: "otpauth://totp/x?secret=ABC", id: "x" });
-    renderMintScreen(dispatcher, qrScreen);
-
-    fireEvent.change(rtlScreen.getByLabelText(/label/i), { target: { value: "My token" } });
-    fireEvent.click(rtlScreen.getByTestId("render-edit-submit"));
-
-    await waitFor(() =>
-      expect(rtlScreen.getByTestId("secret-value-Token").getAttribute("data-qr")).toBe("true"),
-    );
-  });
-
-  test("an input-less secretMint (no fields) has an active submit button and dispatches the mint handler on click", async () => {
-    const inputLessScreen: SecretMintScreenDefinition = {
-      id: "mint-token",
-      type: "secretMint",
-      handler: "shop:write:token:mint",
-      fields: {},
-      layout: { sections: [] },
-      reveal: { fields: [{ field: "token", label: "Token" }] },
-    };
-    const { dispatcher, writeCalls } = stubMultiWriteDispatcher({
-      "shop:write:token:mint": { token: "kpat_secret" },
-    });
-    renderMintScreen(dispatcher, inputLessScreen);
-
-    const submit = rtlScreen.getByTestId("render-edit-submit") as HTMLButtonElement;
-    expect(submit.disabled).toBe(false);
-    fireEvent.click(submit);
-
-    await waitFor(() => expect(rtlScreen.queryByText("kpat_secret")).not.toBeNull());
-    expect(writeCalls.map((c) => c.command)).toEqual(["shop:write:token:mint"]);
-  });
-});
-
-describe("SecretMintBody confirm step (fw#2838)", () => {
-  const mintScreenWithConfirm: SecretMintScreenDefinition = {
-    ...mintScreen,
-    confirm: {
-      handler: "shop:write:token:confirm",
-      fields: { code: { type: "text" } as TextFieldDef },
-      layout: { sections: [{ title: "Confirm", fields: ["code"] }] },
-      carry: ["setupToken"],
-    },
-  };
-
-  // The confirm form mounts from an async post-mint update, so its form-store subscription can
-  // still be pending when the change fires — clicking before that subscription re-renders hits a disabled submit.
-  async function enterConfirmCodeAndSubmit(code: string): Promise<void> {
-    fireEvent.change(rtlScreen.getByLabelText(/code/i), { target: { value: code } });
-    await waitFor(() =>
-      expect(rtlScreen.getByTestId<HTMLButtonElement>("render-edit-submit").disabled).toBe(false),
-    );
-    fireEvent.click(rtlScreen.getByTestId("render-edit-submit"));
-  }
-
-  test("renders the confirm form instead of the acknowledge button, and submits the confirm form's own values merged with the carried mint-payload field", async () => {
-    const { dispatcher, writeCalls } = stubMultiWriteDispatcher({
-      "shop:write:token:mint": { token: "kpat_secret", id: "x", setupToken: "stok_123" },
-      "shop:write:token:confirm": {},
-    });
-    renderMintScreen(dispatcher, mintScreenWithConfirm);
-
-    fireEvent.change(rtlScreen.getByLabelText(/label/i), { target: { value: "My token" } });
-    fireEvent.click(rtlScreen.getByTestId("render-edit-submit"));
-    await waitFor(() => expect(rtlScreen.queryByText("kpat_secret")).not.toBeNull());
-
-    // No bare acknowledge button — the confirm form takes its place.
-    expect(rtlScreen.queryByTestId("kumiko-screen-secret-mint-confirm")).toBeNull();
-
-    await enterConfirmCodeAndSubmit("123456");
-
-    await waitFor(() =>
-      expect(writeCalls.some((c) => c.command === "shop:write:token:confirm")).toBe(true),
-    );
-    const confirmCall = writeCalls.find((c) => c.command === "shop:write:token:confirm");
-    expect(confirmCall?.payload).toEqual({ code: "123456", setupToken: "stok_123" });
-  });
-
-  test("a carried field that is not in reveal.fields never appears in the DOM", async () => {
-    const { dispatcher } = stubMultiWriteDispatcher({
-      "shop:write:token:mint": { token: "kpat_secret", id: "x", setupToken: "stok_123" },
-    });
-    renderMintScreen(dispatcher, mintScreenWithConfirm);
-
-    fireEvent.change(rtlScreen.getByLabelText(/label/i), { target: { value: "My token" } });
-    fireEvent.click(rtlScreen.getByTestId("render-edit-submit"));
-    await waitFor(() => expect(rtlScreen.queryByText("kpat_secret")).not.toBeNull());
-
-    expect(rtlScreen.queryByText("stok_123")).toBeNull();
-  });
-
-  test("without a redirect, a successful confirm shows the done banner", async () => {
-    const { dispatcher } = stubMultiWriteDispatcher({
-      "shop:write:token:mint": { token: "kpat_secret", id: "x", setupToken: "stok_123" },
-      "shop:write:token:confirm": {},
-    });
-    renderMintScreen(dispatcher, mintScreenWithConfirm);
-
-    fireEvent.change(rtlScreen.getByLabelText(/label/i), { target: { value: "My token" } });
-    fireEvent.click(rtlScreen.getByTestId("render-edit-submit"));
-    await waitFor(() => expect(rtlScreen.queryByText("kpat_secret")).not.toBeNull());
-
-    await enterConfirmCodeAndSubmit("123456");
-
-    await waitFor(() =>
-      expect(rtlScreen.queryByTestId("kumiko-screen-secret-mint-done")).not.toBeNull(),
-    );
-    expect(rtlScreen.queryByText("kpat_secret")).toBeNull();
-  });
-});

package/src/app/__tests__/variable-chips.test.tsx

@@ -1,70 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { fireEvent, render, screen } from "@testing-library/react";
-import type { ComponentType, ReactNode } from "react";
-import { createStaticLocaleResolver, LocaleProvider } from "../../i18n";
-import { type ButtonProps, type CorePrimitives, PrimitivesProvider } from "../../primitives";
-import { VariableChips } from "../variable-chips";
-
-const captureButton: ComponentType<ButtonProps> = ({ children, onClick, ariaLabel, disabled }) => (
-  <button type="button" aria-label={ariaLabel} onClick={() => void onClick?.()} disabled={disabled}>
-    {children}
-  </button>
-);
-
-const noop = (): ReactNode => null;
-const passChildren = ({ children }: { readonly children?: ReactNode }): ReactNode => children;
-
-const testPrimitives: CorePrimitives = {
-  Button: captureButton,
-  Banner: passChildren,
-  Field: passChildren,
-  Input: noop,
-  DataTable: noop,
-  Form: passChildren,
-  Section: passChildren,
-  Card: passChildren,
-  Grid: passChildren,
-  GridCell: passChildren,
-  Text: passChildren,
-  Heading: noop,
-  Dialog: noop,
-  Modal: noop,
-  Lightbox: noop,
-  ConfigSourceBadge: noop,
-  ConfigCascadeView: noop,
-  Link: noop,
-};
-
-function Wrapper({ children }: { readonly children: ReactNode }): ReactNode {
-  return (
-    <LocaleProvider resolver={createStaticLocaleResolver({ locale: "en" })}>
-      <PrimitivesProvider value={testPrimitives}>{children}</PrimitivesProvider>
-    </LocaleProvider>
-  );
-}
-
-describe("VariableChips", () => {
-  test("renders no chips when there are no variables", () => {
-    render(<VariableChips variables={[]} onInsert={() => {}} />, { wrapper: Wrapper });
-    expect(screen.queryAllByRole("button")).toHaveLength(0);
-  });
-
-  test("renders one chip per variable and reports a click by name", () => {
-    const inserted: string[] = [];
-    render(
-      <VariableChips
-        variables={["customerName", "orderId"]}
-        onInsert={(name) => inserted.push(name)}
-      />,
-      { wrapper: Wrapper },
-    );
-    expect(screen.getAllByRole("button")).toHaveLength(2);
-    fireEvent.click(screen.getByText("{{orderId}}"));
-    expect(inserted).toEqual(["orderId"]);
-  });
-
-  test("disabled propagates to every chip", () => {
-    render(<VariableChips variables={["a"]} onInsert={() => {}} disabled />, { wrapper: Wrapper });
-    expect((screen.getByRole("button") as HTMLButtonElement).disabled).toBe(true);
-  });
-});

package/src/app/app-features-context.tsx

@@ -1,25 +0,0 @@
-// 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, type ReactNode, useContext } from "react";
-import type { FeatureSchema } from "./feature-schema";
-
-const AppFeaturesContext = createContext<readonly FeatureSchema[]>([]);
-
-export type AppFeaturesProviderProps = {
-  readonly features: readonly FeatureSchema[];
-  readonly children: ReactNode;
-};
-
-export function AppFeaturesProvider({ features, children }: AppFeaturesProviderProps): ReactNode {
-  return <AppFeaturesContext.Provider value={features}>{children}</AppFeaturesContext.Provider>;
-}
-
-export function useAppFeatures(): readonly FeatureSchema[] {
-  return useContext(AppFeaturesContext);
-}

package/src/app/column-renderers.tsx

@@ -1,68 +0,0 @@
-// 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 { type ComponentType, createContext, type ReactNode, useContext } from "react";
-
-// Props die ein Column-Renderer-Component bekommt. `value` ist der
-// Cell-Value für die Spalte (rohes Field-Value aus der Row), `row` ist
-// die ganze Row als plain object — nice-to-have für Renderer die auf
-// andere Spalten zugreifen wollen (z.B. Status-Badge der den
-// Erstellungs-Zeitpunkt aus der Row mitnimmt). `column.field` ist der
-// Field-Name; hilfreich für generische Renderer (JSON-Pretty-Printer
-// oder Debug-Renderer die den Feldnamen anzeigen).
-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>>;
-
-const ColumnRenderersContext = createContext<ColumnRenderersMap | undefined>(undefined);
-
-export type ColumnRenderersProviderProps = {
-  readonly children: ReactNode;
-  readonly value: ColumnRenderersMap;
-};
-
-export function ColumnRenderersProvider({
-  children,
-  value,
-}: ColumnRenderersProviderProps): ReactNode {
-  return (
-    <ColumnRenderersContext.Provider value={value}>{children}</ColumnRenderersContext.Provider>
-  );
-}
-
-/** 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?: string): ColumnRendererComponent | undefined {
-  const map = useContext(ColumnRenderersContext);
-  if (name === undefined || name === "") return undefined;
-  if (map === undefined) return undefined;
-  return map[name];
-}

package/src/app/content-editors.tsx

@@ -1,85 +0,0 @@
-// Content-Editor-Components-Map: client-side lookup by `contentFormat`
-// ("plain" | "rich" | "markdown") for r.contentCollection() entries. A collection
-// declares its contentFormat in the schema; the client resolves it to a
-// React component here. Same registry shape as columnRenderers/
-// extensionSectionComponents — String-key in the schema, Component in the
-// client bundle, last-wins merge in createKumikoApp.
-//
-// No entry registered for a format → TextareaContentEditor, so a missing
-// editor is never an empty panel.
-
-import type { ContentEditorFormat } from "@cosmicdrift/kumiko-types/nav";
-import { type ComponentType, createContext, type ReactNode, useContext } from "react";
-import { usePrimitives } from "../primitives";
-
-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 const CONTENT_EDITOR_ELEMENT_ID = "content-editor-textarea";
-
-export type ContentEditorsMap = Partial<Record<ContentEditorFormat, ContentEditorComponent>>;
-
-const ContentEditorsContext = createContext<ContentEditorsMap>({});
-
-export type ContentEditorsProviderProps = {
-  readonly children: ReactNode;
-  readonly value: ContentEditorsMap;
-};
-
-export function ContentEditorsProvider({
-  children,
-  value,
-}: ContentEditorsProviderProps): ReactNode {
-  return <ContentEditorsContext.Provider value={value}>{children}</ContentEditorsContext.Provider>;
-}
-
-/** 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,
-}: ContentEditorProps): ReactNode {
-  const { Input } = usePrimitives();
-  return (
-    <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?: ContentEditorFormat): ContentEditorComponent {
-  const map = useContext(ContentEditorsContext);
-  return map[contentFormat ?? "plain"] ?? TextareaContentEditor;
-}