@cosmicdrift/kumiko-renderer 0.373.0 → 0.377.0

package/dist/web/app/app-schema-boot.js

@@ -0,0 +1,124 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { toAppSchema, usePrimitives, useSessionEndedSignal, useTranslation } from "../../index.js";
+// Mirrors framework's api-constants Routes.schema, same pattern as
+// dispatcher-live's PATH_* constants — the one place that spells out the
+// wire path both sides agree on.
+export const APP_SCHEMA_API_PATH = "/api/schema";
+function isFeatureSchemaPayload(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    if (!("featureName" in value) || typeof value.featureName !== "string")
+        return false;
+    return "screens" in value && Array.isArray(value.screens);
+}
+export function isAppSchemaPayload(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    if (!("features" in value) || !Array.isArray(value.features))
+        return false;
+    return value.features.every((feature) => isFeatureSchemaPayload(feature));
+}
+function isAbortError(err) {
+    return err instanceof DOMException && err.name === "AbortError";
+}
+// Mirrors createLiveDispatcher: a cross-origin API (absolute baseUrl) needs
+// credentials "include" for the session cookie to travel; same-origin stays
+// "same-origin" so a relative path never widens.
+function schemaFetchCredentials(schemaUrl) {
+    try {
+        return new URL(schemaUrl, window.location.href).origin === window.location.origin
+            ? "same-origin"
+            : "include";
+    }
+    catch {
+        return "same-origin";
+    }
+}
+// Rejects only on abort (caller-cancelled) — every other failure mode
+// (network error, non-2xx, unparseable/invalid body) resolves to
+// `{ kind: "failed" }` so callers get one uniform result shape to branch
+// on instead of a mix of thrown errors and resolved results.
+export async function fetchAppSchema(signal, schemaUrl = APP_SCHEMA_API_PATH) {
+    let res;
+    try {
+        res = await fetch(schemaUrl, {
+            credentials: schemaFetchCredentials(schemaUrl),
+            headers: { Accept: "application/json" },
+            signal,
+        });
+    }
+    catch (err) {
+        if (isAbortError(err))
+            throw err;
+        return { kind: "failed" };
+    }
+    if (res.status === 401)
+        return { kind: "session-ended" };
+    if (res.status === 403)
+        return { kind: "unauthorized" };
+    if (!res.ok)
+        return { kind: "failed" };
+    let payload;
+    try {
+        payload = await res.json();
+    }
+    catch {
+        return { kind: "failed" };
+    }
+    if (!isAppSchemaPayload(payload))
+        return { kind: "failed" };
+    return { kind: "loaded", app: toAppSchema(payload) };
+}
+// Boots the app once the caller (AppSchemaBoundary, itself inside the
+// clientFeature gates) decides to mount it — a login gate renders its own
+// placeholder instead of children, so this component (and its fetch) never
+// mounts until the user is authenticated.
+export function AppSchemaFetchBoot({ onLoaded, schemaUrl, }) {
+    const t = useTranslation();
+    const { Banner, Button } = usePrimitives();
+    const [status, setStatus] = useState("loading");
+    const sessionEndedSignal = useSessionEndedSignal();
+    const [attempt, setAttempt] = useState(0);
+    // Ref instead of an effect dependency: onLoaded is a fresh closure on
+    // every KumikoAppRoot render (it captures setApp) — depending on it
+    // directly would refetch on every unrelated re-render.
+    const onLoadedRef = useRef(onLoaded);
+    onLoadedRef.current = onLoaded;
+    // biome-ignore lint/correctness/useExhaustiveDependencies: attempt is the retry trigger, never read in the body — bumping it is how the Retry button re-fires this effect.
+    useEffect(() => {
+        const controller = new AbortController();
+        setStatus("loading");
+        fetchAppSchema(controller.signal, schemaUrl)
+            .then((result) => {
+            if (controller.signal.aborted)
+                return;
+            if (result.kind === "loaded") {
+                onLoadedRef.current(result.app);
+                return;
+            }
+            setStatus(result.kind);
+        })
+            .catch((err) => {
+            if (!isAbortError(err))
+                setStatus("failed");
+        });
+        return () => controller.abort();
+    }, [attempt, schemaUrl]);
+    useEffect(() => {
+        if (status === "session-ended")
+            sessionEndedSignal?.notify();
+    }, [status, sessionEndedSignal]);
+    if (status === "loading") {
+        return (_jsx("div", { role: "status", "aria-busy": "true", children: t("kumiko.app-boot.loading") }));
+    }
+    if (status === "unauthorized" || status === "session-ended") {
+        // No auto-retry/reload here on purpose — a signed-out user retrying
+        // the same request just gets the same 401 again; the login gate that
+        // wraps this component is the actual way out. For session-ended the
+        // notify above normally swaps this banner for the login screen; the
+        // banner stays as fallback when no session provider is mounted.
+        return (_jsx(Banner, { variant: "error", padded: true, children: t("kumiko.app-boot.unauthorized") }));
+    }
+    return (_jsx(Banner, { variant: "error", padded: true, actions: _jsx(Button, { variant: "secondary", onClick: () => setAttempt((n) => n + 1), children: t("kumiko.actions.reload") }), children: t("kumiko.app-boot.failed") }));
+}

package/dist/web/app/browser-locale.d.ts

@@ -0,0 +1,22 @@
+import { type LocaleResolver } from "../../headless/index.ts";
+export type CreateBrowserLocaleResolverOptions = {
+    /** localStorage-Key unter dem die aktive Locale persistiert wird.
+     *  Default: `"kumiko:locale"`. Apps die mehrere Kumiko-Instanzen auf
+     *  derselben Origin mounten (selten), setzen verschiedene Keys. */
+    readonly storageKey?: string;
+    /** Fallback wenn weder localStorage noch navigator.language liefern.
+     *  Default: `"en"`. */
+    readonly defaultLocale?: string;
+    /** Maps a stored or browser-reported tag onto one of the app's locales;
+     *  `undefined` rejects it (a stored tag then falls through to
+     *  navigator.language, the browser tag to `defaultLocale`). Only applied to
+     *  the initial detection, not to `setLocale`. */
+    readonly normalizeLocale?: (tag: string) => string | undefined;
+};
+export declare const BROWSER_LOCALE_STORAGE_KEY = "kumiko:locale";
+/** Default-Resolver wenn createKumikoApp ohne `locale`-Option gebootet
+ *  wird. Stateful: setLocale() persistiert in localStorage und ruft
+ *  subscribed listeners. Apps die eine vollwertige i18n-Schicht haben
+ *  (i18next, FormatJS, eigener Store), reichen stattdessen ihre eigene
+ *  Resolver-Impl via `createKumikoApp({ locale })`. */
+export declare function createBrowserLocaleResolver(options?: CreateBrowserLocaleResolverOptions): LocaleResolver;

package/dist/web/app/browser-locale.js

@@ -0,0 +1,78 @@
+// Browser-spezifischer LocaleResolver-Default für createKumikoApp.
+//
+// Stateful: hält die aktuelle Locale in localStorage, bricht subscribe-
+// listener bei setLocale(). Initial-wert kommt aus localStorage wenn
+// gespeichert, sonst aus navigator.language, sonst aus defaultLocale.
+//
+// App-Code setzt die Locale programmatisch via resolver.setLocale() —
+// der LanguageSwitcher-Component macht genau das. Persistenz über
+// localStorage heißt: nach Page-Reload gleiche Sprache, ohne Server-
+// Roundtrip. Für device-übergreifende Persistenz würde ein
+// user:write:update auf user.locale zusätzlich gesetzt (separater
+// App-Code, nicht im Resolver).
+import { createStore } from "../../headless/index.js";
+export const BROWSER_LOCALE_STORAGE_KEY = "kumiko:locale";
+function detectInitialLocale(storageKey, fallback, normalizeLocale) {
+    if (typeof localStorage !== "undefined") {
+        try {
+            const stored = localStorage.getItem(storageKey);
+            if (stored !== null && stored.length > 0) {
+                const normalized = normalizeLocale(stored);
+                if (normalized !== undefined)
+                    return normalized;
+            }
+        }
+        catch {
+            // localStorage kann throwen (safari private mode, disabled) —
+            // leise auf navigator zurückfallen.
+        }
+    }
+    if (typeof navigator !== "undefined" && navigator.language) {
+        return normalizeLocale(navigator.language) ?? fallback;
+    }
+    return fallback;
+}
+function detectTimeZone() {
+    if (typeof Intl === "undefined")
+        return "UTC";
+    try {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone ?? "UTC";
+    }
+    catch {
+        return "UTC";
+    }
+}
+/** Default-Resolver wenn createKumikoApp ohne `locale`-Option gebootet
+ *  wird. Stateful: setLocale() persistiert in localStorage und ruft
+ *  subscribed listeners. Apps die eine vollwertige i18n-Schicht haben
+ *  (i18next, FormatJS, eigener Store), reichen stattdessen ihre eigene
+ *  Resolver-Impl via `createKumikoApp({ locale })`. */
+export function createBrowserLocaleResolver(options = {}) {
+    const storageKey = options.storageKey ?? BROWSER_LOCALE_STORAGE_KEY;
+    const fallback = options.defaultLocale ?? "en";
+    const store = createStore(detectInitialLocale(storageKey, fallback, options.normalizeLocale ?? ((tag) => tag)));
+    const timeZone = detectTimeZone();
+    return {
+        translate: (key) => key,
+        locale: () => store.getSnapshot(), // @wrapper-known semantic-alias
+        timeZone: () => timeZone,
+        subscribe: store.subscribe,
+        setLocale: (next) => {
+            // skip: locale unchanged, avoid redundant localStorage write
+            // own Object.is-Gate would already block listener notification,
+            // but the persistence side-effect lives outside the store.
+            if (next === store.getSnapshot())
+                return;
+            store.setState(next);
+            if (typeof localStorage !== "undefined") {
+                try {
+                    localStorage.setItem(storageKey, next);
+                }
+                catch {
+                    // Persistenz fehlgeschlagen ist nicht fatal — die Session-Locale
+                    // bleibt trotzdem gesetzt, nur der nächste Reload verliert sie.
+                }
+            }
+        },
+    };
+}

package/dist/web/app/client-plugin.d.ts

@@ -0,0 +1,106 @@
+import type { TargetRef, TreeChildrenSubscribe } from "@cosmicdrift/kumiko-framework/engine";
+import type { ContentEditorFormat } from "@cosmicdrift/kumiko-types/nav";
+import type { ComponentType, ReactNode } from "react";
+import type { ClientActionHandler, ColumnRendererComponent, ContentEditorComponent, ExtensionSectionComponent, QualifiedContentCollection, TranslationsByLocale } from "../../index.ts";
+/** What a `navProvidersFromCollections` factory returns: the providers plus
+ *  the entities whose live events should re-fire them. Without `entities` a
+ *  derived tree would sit stale until re-mount — the hand-wired path has the
+ *  SSE refresh and the derived one must not lose it. */
+export type CollectionNavProviders = {
+    readonly providers: Readonly<Record<string, TreeChildrenSubscribe>>;
+    readonly entities?: Readonly<Record<string, readonly string[]>>;
+};
+export type ClientFeatureDefinition = {
+    readonly name: string;
+    /** Context-Provider die um den kompletten Renderer-Tree gewrapped
+     *  werden. Reihenfolge: erstes Element = äußerster Provider. Alle
+     *  Provider stehen VOR allen Gates im Baum, damit jeder Gate und
+     *  jedes Screen-Child darauf Zugriff hat. */
+    readonly providers?: readonly ComponentType<{
+        children: ReactNode;
+    }>[];
+    /** Screen-Decorators die zwischen dem Provider-Stack und dem Shell/
+     *  Screen-Render sitzen. Typisches Muster: AuthGate rendert den
+     *  LoginScreen statt children solange der User nicht eingeloggt ist.
+     *  Reihenfolge: erstes Element = äußerster Gate. */
+    readonly gates?: readonly ComponentType<{
+        children: ReactNode;
+    }>[];
+    /** Default-Translations die das Feature für seine UI-Strings
+     *  mitbringt. Werden in den LocaleProvider als Fallback-Bundle
+     *  eingehängt — der App-Resolver (z.B. i18next) hat Vorrang und kann
+     *  einzelne Keys überschreiben, ohne dass die Feature-Bundles
+     *  komplett ausgetauscht werden müssen. */
+    readonly translations?: TranslationsByLocale;
+    /** Custom-Screen-Components — Map screenId → React-Component. Wenn
+     *  ein Schema-Screen `type: "custom"` hat, schaut KumikoScreen in
+     *  diese Map (gemerged aus allen ClientFeatures) und rendert die
+     *  passende Component. So muss kein Sample mehr im AppShell-Wrapper
+     *  selbst routen. Convention: screenId entspricht dem `id` aus
+     *  `r.screen({ id, type: "custom", ... })` im server-side Feature. */
+    readonly components?: Readonly<Record<string, ComponentType>>;
+    /** Column-Renderer-Components — Map renderer-name → React-Component.
+     *  Schema deklariert eine Column mit
+     *  `renderer: { react: { __component: "ColorSwatch" } }`; client-side
+     *  zieht der DataTable-Cell-Renderer den Component hier raus.
+     *  Schemas bleiben so serializable (nur ein String-Key auf der Wire),
+     *  echte JSX-Renderer leben im Client-Bundle. Last-Wins bei Key-
+     *  Kollision über mehrere Features. */
+    readonly columnRenderers?: Readonly<Record<string, ColumnRendererComponent>>;
+    /** Extension-Section-Components — Map `__component`-name → React-
+     *  Component. Schema deklariert eine entityEdit-Section mit
+     *  `kind: "extension"` + `component: { react: { __component: "X" } }`;
+     *  RenderEdit zieht den Component hier raus und mountet ihn mit
+     *  `{ entityName, entityId }`. Pattern wie columnRenderers — Last-Wins
+     *  bei Key-Kollision über mehrere Features. */
+    readonly extensionSectionComponents?: Readonly<Record<string, ExtensionSectionComponent>>;
+    /** Handlers for RowAction `kind: "clientAction"`, keyed by the action name
+     *  `<feature>:<kebab>`. Last-wins with a warning on key collisions, like
+     *  columnRenderers. */
+    readonly clientActions?: Readonly<Record<string, ClientActionHandler>>;
+    /** Nav-Provider für die EINE Nav (Visual-Tree-Merge): hängt dynamische
+     *  Children an einen statischen `r.nav({ provider: true })`-Knoten. Keyed
+     *  auf die LOKALE nav-id (create-app qualifiziert zu `<feature>:nav:<id>`;
+     *  bereits qualifizierte QNs gehen durch). Anders als `treeProvider` (ein
+     *  Top-Level-Branch pro Feature) attacht ein navProvider an einen konkreten
+     *  Nav-Knoten — der idiomatic Weg seit dem Tree→Nav-Merge. */
+    readonly navProviders?: Readonly<Record<string, TreeChildrenSubscribe>>;
+    /** SSE-Entity-Listen pro nav-id für den Live-Refresh der navProviders
+     *  (analog `treeEntities`). Live-Event für eine Entity → Provider des
+     *  Knotens wird neu aufgerufen → neue Kinder erscheinen live. */
+    readonly navEntities?: Readonly<Record<string, readonly string[]>>;
+    /** Nav providers derived from the app schema — called with every
+     *  `r.contentCollection()` the app declares. A feature that serves any
+     *  number of collections (template-resolver) builds one provider per
+     *  collection this way, without the app writing navId + kind a second time
+     *  and without the renderer having to know bundled-features. Merged with
+     *  `navProviders`; the static map wins on key collision (explicit beats
+     *  derived). */
+    readonly navProvidersFromCollections?: (collections: readonly QualifiedContentCollection[]) => CollectionNavProviders;
+    /** Content editor components — map `contentFormat` ("plain" | "rich" | "markdown" | "document") →
+     *  React component. `r.contentCollection()` declares which format an
+     *  editor edits; the collection's editor UI (template-resolver's
+     *  TextBlockEditor et al.) looks the component up here and falls back to
+     *  a plain textarea when no clientFeature registered one for that
+     *  format. Same last-wins semantics as columnRenderers. Public component
+     *  contract: `{ value, onChange, variables, readOnly }`. */
+    readonly contentEditors?: Partial<Record<ContentEditorFormat, ContentEditorComponent>>;
+    /** Editor-Resolver-Komponenten pro featureId:action-Key. Wenn ein
+     *  TreeNode mit target angeklickt wird, schlägt der EditorPanel das
+     *  Component hier nach und rendert es. Komponenten erhalten target
+     *  (mit args) und eine onClose-Callback. Ohne registrierten Resolver
+     *  zeigt der EditorPanel einen Info-Fallback.
+     *  Siehe visual-tree.md V.1.2. */
+    readonly resolvers?: Readonly<Record<string, ComponentType<{
+        readonly target: TargetRef;
+        readonly onClose: () => void;
+    }>>>;
+};
+/** Wickelt einen ReactNode durch eine Liste von Providern/Gates von
+ *  innen nach außen — erstes Array-Element ist äußerste Hülle.
+ *  Der Key nutzt den Component-Display-Namen (falls gesetzt) plus
+ *  Index, damit Mounts stabil bleiben solange die Wrapper-Liste
+ *  ihre Reihenfolge nicht ändert. */
+export declare function stackWrappers(wrappers: readonly ComponentType<{
+    children: ReactNode;
+}>[], inner: ReactNode): ReactNode;

package/dist/web/app/client-plugin.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/** Wickelt einen ReactNode durch eine Liste von Providern/Gates von
+ *  innen nach außen — erstes Array-Element ist äußerste Hülle.
+ *  Der Key nutzt den Component-Display-Namen (falls gesetzt) plus
+ *  Index, damit Mounts stabil bleiben solange die Wrapper-Liste
+ *  ihre Reihenfolge nicht ändert. */
+export function stackWrappers(wrappers, inner) {
+    return wrappers.reduceRight((acc, Wrapper, i) => {
+        const key = `${Wrapper.displayName ?? Wrapper.name ?? "wrapper"}-${i}`;
+        return _jsx(Wrapper, { children: acc }, key);
+    }, inner);
+}

package/dist/web/app/create-app.d.ts

@@ -0,0 +1,104 @@
+import type { TreeChildrenSubscribe } from "@cosmicdrift/kumiko-framework/engine";
+import { type ErrorInfo, type ReactNode } from "react";
+import { type Root } from "react-dom/client";
+import type { Dispatcher, ListRowViewModel, LocaleResolver, Translate } from "../../headless/index.ts";
+import { type AppSchema, type ContentEditorComponent, type DraftStorage, type FeatureSchema, type FormWidth, type NavApi, type PrimitivesRegistry, type QualifiedContentCollection } from "../../index.ts";
+import { type ClientFeatureDefinition } from "./client-plugin.tsx";
+export declare function qualifyNavProviderKey(feature: string, id: string): string;
+export declare function buildNavProviderMaps(clientFeatures: readonly ClientFeatureDefinition[], collections: readonly QualifiedContentCollection[]): {
+    readonly navProviders: ReadonlyMap<string, TreeChildrenSubscribe>;
+    readonly navEntities: ReadonlyMap<string, readonly string[]>;
+};
+export type BoundaryErrorHandler = (error: Error, info: ErrorInfo) => void;
+export type CreateKumikoAppOptions = {
+    /** Called when the screen or root error boundary catches an error, after it
+     *  was logged with console.error — attach telemetry here. */
+    readonly onError?: BoundaryErrorHandler;
+    /** App schema. Accepts AppSchema (multi-feature) or the legacy
+     *  FeatureSchema (single-feature) — toAppSchema() normalizes internally.
+     *
+     *  Optional. Resolution order: this option, then
+     *  `window.__KUMIKO_SCHEMA__` (only for explicit/custom builds, e.g. e2e
+     *  fixtures that bake it into the page themselves — the dev-server no
+     *  longer injects it), then a client-side fetch to the authenticated
+     *  `GET /api/schema` once the clientFeature gates (e.g. an auth gate)
+     *  have let rendering through. Without an explicit
+     *  schema, mounting shows a loading/unauthorized/error state until the
+     *  fetch resolves instead of throwing at boot. */
+    readonly schema?: AppSchema | FeatureSchema;
+    readonly rootId?: string;
+    readonly dispatcher?: Dispatcher;
+    /** URL of the authenticated schema endpoint, fetched when no `schema` is
+     *  given. Default `/api/schema` (same origin). Set an absolute URL when the
+     *  API lives on another origin than the SPA (e.g. a `baseUrl` on
+     *  `createLiveDispatcher`); a cross-origin URL is fetched with
+     *  `credentials: "include"`. */
+    readonly schemaUrl?: string;
+    /** RenderEdit's create-mode draftId storage (issue #1913) — where a
+     *  same-tab reload finds which of several parallel create-sessions on a
+     *  screen to resume. Default: `createBrowserDraftStorage()`
+     *  (sessionStorage-backed). Apps that don't want any client-side draftId
+     *  persistence can pass a no-op impl; RenderEdit still resolves via its
+     *  `form-draft:query:list` mount-time fallback either way. */
+    readonly draftStorage?: DraftStorage;
+    readonly screenQn?: string;
+    readonly translate?: Translate;
+    /** Row-click fallback for entities with no declared `detailFor` screen
+     *  (fw#2164) — a `detailFor` screen always wins over this option. */
+    readonly onRowClick?: (row: ListRowViewModel, entityName: string) => void;
+    /** App-Shell. Bekommt das resolved `schema` als Prop — so können
+     *  AppShell-Komponenten an WorkspaceShell/DefaultAppShell durchreichen
+     *  ohne selbst das Schema zu importieren oder auf window-Globals zu
+     *  greifen. */
+    readonly shell?: (props: {
+        readonly children: ReactNode;
+        readonly schema: AppSchema;
+    }) => ReactNode;
+    readonly primitives?: Partial<PrimitivesRegistry>;
+    /** Feature-gelieferte Client-Extensions. Jedes Element bringt
+     *  Provider + Gates mit — siehe ClientFeatureDefinition. Beispiel:
+     *  `clientFeatures: [emailPasswordClient()]` für Session+Login. */
+    readonly clientFeatures?: readonly ClientFeatureDefinition[];
+    /** App-level LocaleResolver. Typischerweise ein Adapter um i18next
+     *  oder eine eigene Store-Impl. Wenn nicht gesetzt → Static-Default
+     *  (`locale: "en"`, `translate: key → key`); Plugin-Translations
+     *  springen dann als Fallback ein. */
+    readonly locale?: LocaleResolver;
+    /** Nav-Adapter — ein React-Hook der eine NavApi-Instanz liefert
+     *  (route + navigate + hrefFor). Default: `useBrowserNavApi`, das
+     *  window.history als Source-of-Truth benutzt. Wer einen anderen
+     *  Router anbinden will (TanStack Router, Expo Linking auf Mobile,
+     *  Memory-Router in Tests) übergibt hier seinen eigenen Hook.
+     *
+     *  Der Hook wird EINMAL im Component-Tree aufgerufen (siehe
+     *  `BrowserNavBoot`), muss also den React-Rules-of-Hooks folgen —
+     *  `useSyncExternalStore` auf der zugrundeliegenden Router-State
+     *  ist das gängige Pattern.
+     *
+     *  Wenn das Schema Workspaces deklariert, wird der Adapter mit
+     *  `{ hasWorkspaces: true }` aufgerufen — der Default-Hook nutzt das
+     *  um das URL-Pattern auf `/<workspace>/<screen>[/<entityId>]`
+     *  umzustellen. Eigene Adapter dürfen die Option ignorieren wenn ihr
+     *  Router das anders löst. `features` ist `app.features` — der
+     *  Default-Hook braucht sie für resolveTarget() (ObjectTarget →
+     *  ScreenTarget); eigene Adapter die nie ein ObjectTarget bekommen,
+     *  dürfen sie ignorieren. */
+    readonly navAdapter?: (options?: {
+        readonly hasWorkspaces?: boolean;
+        readonly features?: readonly FeatureSchema[];
+    }) => NavApi;
+    /** App-wide default width for form/detail screens that don't set their
+     *  own `layout.width` (fw#2656). Default "4xl" (unchanged behavior) — a
+     *  consumer app that wants e.g. bundled-feature screens to match its own
+     *  full-width lists passes `screenWidth: "full"` once here instead of
+     *  forking every screen it doesn't own. Per-screen `layout.width` always
+     *  wins over this default. */
+    readonly screenWidth?: FormWidth;
+};
+export declare function firstOpenScreenQn(features: readonly FeatureSchema[]): string | undefined;
+export declare function firstLandingScreenQnForProjectedSchema(features: readonly FeatureSchema[]): string | undefined;
+export declare function resolveRootScreenQn(features: readonly FeatureSchema[], explicitScreenQn: string | undefined, schemaIsRoleProjected: boolean): string | undefined;
+export declare function mergeContentEditors(clientFeatures: readonly ClientFeatureDefinition[]): Record<string, ContentEditorComponent>;
+export declare function createKumikoApp(options?: CreateKumikoAppOptions): {
+    readonly root: Root;
+};