@cosmicdrift/kumiko-renderer 0.373.0 → 0.377.0

package/dist/web/app/dashboard-refresh.d.ts

@@ -0,0 +1,6 @@
+import type { DashboardRefresh } from "@cosmicdrift/kumiko-framework/ui-types";
+/** Polling interval of a dashboard in ms; undefined means no polling. A record
+ *  field that is missing, not a positive number or not loaded yet disables it
+ *  until a valid value arrives. The result never drops below
+ *  DASHBOARD_MIN_REFRESH_SECONDS, whatever the record says. */
+export declare function resolveRefreshIntervalMs(refresh: DashboardRefresh | undefined, record: Readonly<Record<string, unknown>> | null): number | undefined;

package/dist/web/app/dashboard-refresh.js

@@ -0,0 +1,15 @@
+import { DASHBOARD_MIN_REFRESH_SECONDS } from "@cosmicdrift/kumiko-types/screen";
+// setInterval treats anything above a signed 32-bit int as 0 ms and would fire in a tight loop.
+const MAX_TIMER_MS = 2_147_483_647;
+/** Polling interval of a dashboard in ms; undefined means no polling. A record
+ *  field that is missing, not a positive number or not loaded yet disables it
+ *  until a valid value arrives. The result never drops below
+ *  DASHBOARD_MIN_REFRESH_SECONDS, whatever the record says. */
+export function resolveRefreshIntervalMs(refresh, record) {
+    if (refresh === undefined)
+        return undefined;
+    const seconds = "seconds" in refresh ? refresh.seconds : record?.[refresh.field];
+    if (typeof seconds !== "number" || !Number.isFinite(seconds) || seconds <= 0)
+        return undefined;
+    return Math.min(Math.max(seconds, DASHBOARD_MIN_REFRESH_SECONDS) * 1000, MAX_TIMER_MS);
+}

package/dist/web/app/document-lang-sync.d.ts

@@ -0,0 +1,4 @@
+import type { LocaleResolver } from "../../headless/index.ts";
+export declare function DocumentLangSync({ resolver }: {
+    readonly resolver: LocaleResolver;
+}): null;

package/dist/web/app/document-lang-sync.js

@@ -0,0 +1,27 @@
+// Keeps document.documentElement.lang (+ dataset.kumikoLocale) in sync with
+// the active locale. Screen readers and the browser's built-in translate
+// offer read lang; dispatcher-live reads dataset.kumikoLocale for X-Locale
+// (see dispatcher-live/src/locale.ts) so a static <html lang> cannot spoof
+// the active UI language.
+//
+// Lives here, not in @cosmicdrift/kumiko-renderer: that package is DOM-free
+// by design (Renderer-Boundaries Guard enforces it — web/native both
+// consume it). createApp/createPublicSurface are the two places every web
+// app already goes through, so mounting this here covers every app with
+// zero app-side wiring, same as createBrowserLocaleResolver.
+import { useEffect } from "react";
+function syncDocumentLocale(locale) {
+    document.documentElement.lang = locale;
+    // Dedicated marker for dispatcher-live — static <html lang> must not
+    // look like an active UI locale (kumiko-framework#2334).
+    document.documentElement.dataset["kumikoLocale"] = locale;
+}
+export function DocumentLangSync({ resolver }) {
+    useEffect(() => {
+        syncDocumentLocale(resolver.locale());
+        return resolver.subscribe(() => {
+            syncDocumentLocale(resolver.locale());
+        });
+    }, [resolver]);
+    return null;
+}

package/dist/web/app/draft-storage.d.ts

@@ -0,0 +1,11 @@
+import type { DraftStorage } from "../../index.ts";
+export type CreateBrowserDraftStorageOptions = {
+    /** sessionStorage-key prefix, one entry per screenId gets appended.
+     *  Default: `"kumiko:draft-id:"`. */
+    readonly storagePrefix?: string;
+};
+/** Default DraftStorage when createKumikoApp boots without one. Guards every
+ *  sessionStorage call — Safari private mode and storage-disabled browsers
+ *  throw on access, and a lost draftId just falls back to the `list` resume
+ *  path (same UX as a genuinely cleared storage), not a broken form. */
+export declare function createBrowserDraftStorage(options?: CreateBrowserDraftStorageOptions): DraftStorage;

package/dist/web/app/draft-storage.js

@@ -0,0 +1,53 @@
+// Browser-backed DraftStorage default for createKumikoApp (issue #1913).
+//
+// Persists a create-mode draftId per screen in `sessionStorage` — same-tab
+// scope only (deliberately, unlike browser-locale.ts's localStorage): the
+// draft row itself already survives a new tab / cleared storage via
+// RenderEdit's `form-draft:query:list` mount-time fallback, so this is only
+// about not losing the draftId on an accidental same-tab reload.
+function keyFor(prefix, screenId) {
+    return `${prefix}${screenId}`;
+}
+/** Default DraftStorage when createKumikoApp boots without one. Guards every
+ *  sessionStorage call — Safari private mode and storage-disabled browsers
+ *  throw on access, and a lost draftId just falls back to the `list` resume
+ *  path (same UX as a genuinely cleared storage), not a broken form. */
+export function createBrowserDraftStorage(options = {}) {
+    const prefix = options.storagePrefix ?? "kumiko:draft-id:";
+    return {
+        getDraftId: (screenId) => {
+            if (typeof sessionStorage === "undefined")
+                return null;
+            try {
+                return sessionStorage.getItem(keyFor(prefix, screenId));
+            }
+            catch {
+                return null;
+            }
+        },
+        setDraftId: (screenId, draftId) => {
+            // skip: no sessionStorage in this environment (SSR, disabled) — the
+            // draftId just stays in-memory-only for this render.
+            if (typeof sessionStorage === "undefined")
+                return;
+            try {
+                sessionStorage.setItem(keyFor(prefix, screenId), draftId);
+            }
+            catch {
+                // Persistence failure isn't fatal — the draft stays usable in the
+                // current tab, only a reload would lose the draftId.
+            }
+        },
+        clearDraftId: (screenId) => {
+            // skip: no sessionStorage in this environment — nothing to clear.
+            if (typeof sessionStorage === "undefined")
+                return;
+            try {
+                sessionStorage.removeItem(keyFor(prefix, screenId));
+            }
+            catch {
+                // skip: nothing to clean up if storage is unreachable.
+            }
+        },
+    };
+}

package/dist/web/app/nav-providers-context.d.ts

@@ -0,0 +1,13 @@
+import type { TreeChildrenSubscribe } from "@cosmicdrift/kumiko-framework/engine";
+import { type ReactNode } from "react";
+export type NavProvidersProviderProps = {
+    readonly value: ReadonlyMap<string, TreeChildrenSubscribe>;
+    readonly entities?: ReadonlyMap<string, readonly string[]>;
+    readonly children: ReactNode;
+};
+export declare function NavProvidersProvider({ value, entities, children, }: NavProvidersProviderProps): ReactNode;
+/** Provider-Map keyed auf Nav-QN. Empty-Map-Default → kein Crash ohne
+ *  registrierte Provider. */
+export declare function useNavProviders(): ReadonlyMap<string, TreeChildrenSubscribe>;
+/** SSE-Entity-Liste pro Provider-QN für Live-Refresh. Empty-Map-Default. */
+export declare function useNavEntities(): ReadonlyMap<string, readonly string[]>;

package/dist/web/app/nav-providers-context.js

@@ -0,0 +1,18 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const EMPTY_PROVIDERS = new Map();
+const EMPTY_ENTITIES = new Map();
+const NavProvidersContext = createContext(EMPTY_PROVIDERS);
+const NavEntitiesContext = createContext(EMPTY_ENTITIES);
+export function NavProvidersProvider({ value, entities, children, }) {
+    return (_jsx(NavProvidersContext.Provider, { value: value, children: _jsx(NavEntitiesContext.Provider, { value: entities ?? EMPTY_ENTITIES, children: children }) }));
+}
+/** Provider-Map keyed auf Nav-QN. Empty-Map-Default → kein Crash ohne
+ *  registrierte Provider. */
+export function useNavProviders() {
+    return useContext(NavProvidersContext);
+}
+/** SSE-Entity-Liste pro Provider-QN für Live-Refresh. Empty-Map-Default. */
+export function useNavEntities() {
+    return useContext(NavEntitiesContext);
+}

package/dist/web/app/nav.d.ts

@@ -0,0 +1,40 @@
+import { type AnchorHTMLAttributes, type ReactNode } from "react";
+import { type FeatureSchema, type NavApi, type NavTarget } from "../../index.ts";
+/** React-Hook der eine NavApi aus der Browser-History baut. Sollte
+ *  einmal im App-Root aufgerufen und als value an den shared
+ *  `<NavProvider>` durchgereicht werden — createKumikoApp tut das.
+ *
+ *  hasWorkspaces aus dem Schema (schema.workspaces non-empty) entscheidet,
+ *  ob das erste URL-Segment als Workspace-id parsed wird. Pure Pass-
+ *  through an parsePath; formatPath checkt selbst auf target.workspaceId.
+ *
+ *  basePath mounted die App unter einem URL-Prefix (z.B. "/admin"). Read-
+ *  Pfad strippt vor parsePath, Write-Pfad prepend'd vor pushState/href.
+ *  URLs außerhalb des basePath liefern route=undefined, ohne Auto-Redirect.
+ *
+ *  Achtung — Ambiguität bei route=undefined mit basePath:
+ *  Sowohl die App-Root (URL === basePath, z.B. "/admin") als auch URLs
+ *  außerhalb des basePath (z.B. "/marketing") liefern route=undefined. Eine
+ *  App die zwischen "render Default-Screen" und "render Not-Found"
+ *  unterscheiden muss, muss zusätzlich `window.location.pathname` prüfen:
+ *
+ *    if (window.location.pathname.startsWith("/admin")) {
+ *      // in-app, aber an der Root → Default-Screen
+ *    } else {
+ *      // out-of-app → Not-Found / Marketing-Layer
+ *    }
+ *
+ *  Im non-basePath-Modus ergibt sich diese Ambiguität nicht — out-of-app
+ *  ist dort kein Konzept. */
+export declare function useBrowserNavApi(options?: {
+    readonly hasWorkspaces?: boolean;
+    readonly basePath?: string;
+    /** Feature list ObjectTarget resolution needs (resolveTarget). Omit when
+     *  the caller never passes an ObjectTarget — a ScreenTarget resolves
+     *  without looking at the feature list at all. */
+    readonly features?: readonly FeatureSchema[];
+}): NavApi;
+export type KumikoLinkProps = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> & {
+    readonly to: NavTarget;
+};
+export declare function KumikoLink({ to, onClick, children, ...rest }: KumikoLinkProps): ReactNode;

package/dist/web/app/nav.js

@@ -0,0 +1,231 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// Browser-Impl der Navigation: HTML5-History + popstate subscribe.
+// Types + Context + useNav leben im shared `@cosmicdrift/kumiko-renderer`; dieser
+// File liefert nur die Web-spezifische NavApi-Instanz und die
+// `<KumikoLink>` Anchor-Komponente.
+//
+// Bewusst KEIN createStore: Source-of-truth ist `window.location.pathname`
+// (extern, kann via replaceState außerhalb unserer Kontrolle wechseln).
+// Ein Store wäre entweder eine zweite Wahrheit (Drift-Risiko) oder ein
+// reiner Tick-Counter (Anti-Pattern — createStore ist State-Holder, kein
+// Event-Bus). Hand-rolled Listener-Set ist hier idiomatisch: zwei
+// Notify-Trigger (eigenes pushPath, popstate-Event), nicht generalisierbar.
+import { useCallback, useMemo, useSyncExternalStore, } from "react";
+import { formatPath, parsePath, resolveTarget, useNav, } from "../../index.js";
+// basePath erlaubt es, die App unter einem URL-Prefix zu mounten
+// (z.B. `/admin`). Read-Pfad strippt den Prefix vor dem parsePath,
+// Write-Pfad prepend'd ihn vor dem pushState/replaceState/href.
+//
+// Wenn die URL nicht im basePath liegt (z.B. /marketing/foo bei
+// basePath="/admin"), liefert stripBasePath `undefined` — useBrowserNavApi
+// gibt dann route=undefined zurück, die App rendert ihren "outside"-State
+// (Not-Found, Marketing-Layer, Server-Routing-Pickup, …). Es gibt KEIN
+// Auto-Redirect zur App-Root — die Host-App entscheidet selbst.
+function normalizeBasePath(raw) {
+    if (raw === undefined || raw === "" || raw === "/")
+        return "";
+    const withLeading = raw.startsWith("/") ? raw : `/${raw}`;
+    return withLeading.endsWith("/") ? withLeading.slice(0, -1) : withLeading;
+}
+// Returns the in-app path (basePath-relativ) wenn `path` im basePath liegt,
+// sonst `undefined`. Strict-segment-Boundary: "/administrator" matcht
+// nicht "/admin" — sonst würde der Prefix-Check auf String-Ebene falsche
+// Treffer liefern.
+function stripBasePath(path, basePath) {
+    if (basePath === "")
+        return path;
+    if (path === basePath)
+        return "/";
+    if (path.startsWith(`${basePath}/`))
+        return path.slice(basePath.length);
+    return undefined;
+}
+function prependBasePath(path, basePath) {
+    if (basePath === "")
+        return path;
+    // formatPath liefert immer absoluten in-app-Pfad: "/" oder "/screen-id"
+    // oder "/screen-id/entity-id". "/" → einfach basePath, sonst concat.
+    if (path === "/" || path === "")
+        return basePath;
+    return `${basePath}${path}`;
+}
+// pushState feuert keinen popstate — wir halten einen eigenen
+// Listener-Set, den navigate() notifiziert. popstate (Back/Forward)
+// läuft über einen window-Listener, den wir einmalig verdrahten.
+const listeners = new Set();
+let popstateWired = false;
+// Stable identity for the omitted-features case — `?? []` would create a
+// fresh array every render, busting the useMemo below on every render for
+// every existing useBrowserNavApi() call site (none of which pass features).
+const NO_FEATURES = [];
+function ensurePopstateWired() {
+    if (popstateWired)
+        return;
+    if (typeof window === "undefined")
+        return;
+    window.addEventListener("popstate", () => {
+        for (const l of listeners)
+            l();
+    });
+    popstateWired = true;
+}
+function subscribe(listener) {
+    ensurePopstateWired();
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+function readPath() {
+    return typeof window !== "undefined" ? window.location.pathname : "/";
+}
+// Read der aktuellen ?key=value-Pairs als Plain-Record. URLSearchParams-
+// Iterator gibt String/String — wir kollabieren auf "letzter Wert
+// gewinnt" wenn ein Key mehrfach im Query auftaucht (`?a=1&a=2` → "2").
+// Multi-Value-Lists sind kein Use-Case in Kumiko-Filter-State; explizit
+// dokumentieren statt unspezifizierten Behavior zu liefern.
+function readSearch() {
+    return typeof window !== "undefined" ? window.location.search : "";
+}
+function parseSearchParams(search) {
+    const out = {};
+    if (search === "")
+        return out;
+    const params = new URLSearchParams(search);
+    for (const [k, v] of params.entries())
+        out[k] = v;
+    return out;
+}
+// Mergt updates in den aktuellen ?-String. `null` löscht, sonst
+// überschreibt. Verwendet replaceState (KEIN push) — Sort/Filter-Toggles
+// flutten sonst die Back-Navigation und User clicked sich durch
+// dutzende Zwischen-States um zur vorherigen Seite zu kommen.
+function applySearchParamUpdates(updates) {
+    if (typeof window === "undefined")
+        return;
+    const params = new URLSearchParams(window.location.search);
+    for (const [key, value] of Object.entries(updates)) {
+        if (value === null) {
+            params.delete(key);
+        }
+        else {
+            params.set(key, value);
+        }
+    }
+    const next = params.toString();
+    const nextSearch = next === "" ? "" : `?${next}`;
+    if (nextSearch === window.location.search)
+        return;
+    const url = `${window.location.pathname}${nextSearch}${window.location.hash}`;
+    window.history.replaceState(null, "", url);
+    for (const l of listeners)
+        l();
+}
+// undefined = the caller passed no search params; "" = an explicitly empty query.
+function formatSearch(options) {
+    if (options?.searchParams === undefined)
+        return undefined;
+    const query = new URLSearchParams(options.searchParams).toString();
+    return query === "" ? "" : `?${query}`;
+}
+function pushPath(path, search) {
+    if (typeof window === "undefined")
+        return;
+    // Repeated navigate() calls to the same URL must not flood the history.
+    // Without explicit search params the current query counts as unchanged.
+    const unchanged = window.location.pathname === path &&
+        (search === undefined || window.location.search === search);
+    if (unchanged)
+        return;
+    window.history.pushState(null, "", `${path}${search ?? ""}`);
+    for (const l of listeners)
+        l();
+}
+function replacePath(path, search) {
+    if (typeof window === "undefined")
+        return;
+    // No path-change short-circuit here: callers explicitly chose replace
+    // to avoid creating a history entry, even when the URL is identical.
+    // (pushPath skips no-op pushes; replacePath honors the call so the
+    // entry-stack semantics stay predictable.)
+    window.history.replaceState(null, "", `${path}${search ?? ""}`);
+    for (const l of listeners)
+        l();
+}
+/** React-Hook der eine NavApi aus der Browser-History baut. Sollte
+ *  einmal im App-Root aufgerufen und als value an den shared
+ *  `<NavProvider>` durchgereicht werden — createKumikoApp tut das.
+ *
+ *  hasWorkspaces aus dem Schema (schema.workspaces non-empty) entscheidet,
+ *  ob das erste URL-Segment als Workspace-id parsed wird. Pure Pass-
+ *  through an parsePath; formatPath checkt selbst auf target.workspaceId.
+ *
+ *  basePath mounted die App unter einem URL-Prefix (z.B. "/admin"). Read-
+ *  Pfad strippt vor parsePath, Write-Pfad prepend'd vor pushState/href.
+ *  URLs außerhalb des basePath liefern route=undefined, ohne Auto-Redirect.
+ *
+ *  Achtung — Ambiguität bei route=undefined mit basePath:
+ *  Sowohl die App-Root (URL === basePath, z.B. "/admin") als auch URLs
+ *  außerhalb des basePath (z.B. "/marketing") liefern route=undefined. Eine
+ *  App die zwischen "render Default-Screen" und "render Not-Found"
+ *  unterscheiden muss, muss zusätzlich `window.location.pathname` prüfen:
+ *
+ *    if (window.location.pathname.startsWith("/admin")) {
+ *      // in-app, aber an der Root → Default-Screen
+ *    } else {
+ *      // out-of-app → Not-Found / Marketing-Layer
+ *    }
+ *
+ *  Im non-basePath-Modus ergibt sich diese Ambiguität nicht — out-of-app
+ *  ist dort kein Konzept. */
+export function useBrowserNavApi(options) {
+    const path = useSyncExternalStore(subscribe, readPath, () => "/");
+    // Search wird über denselben Listener-Set notifiziert (popstate +
+    // unsere replaceState-Calls), also reichen wir denselben subscribe
+    // durch. Beide Snapshots werden zusammen recomputed — kein Drift
+    // zwischen Pfad und Query.
+    const search = useSyncExternalStore(subscribe, readSearch, () => "");
+    const hasWorkspaces = options?.hasWorkspaces === true;
+    const basePath = useMemo(() => normalizeBasePath(options?.basePath), [options?.basePath]);
+    const searchParams = useMemo(() => parseSearchParams(search), [search]);
+    const inAppPath = useMemo(() => stripBasePath(path, basePath), [path, basePath]);
+    const features = options?.features ?? NO_FEATURES;
+    return useMemo(() => {
+        const route = inAppPath === undefined ? undefined : parsePath(inAppPath, hasWorkspaces);
+        // NavTarget-Contract: workspaceId weglassen = aktueller Workspace
+        // bleibt. formatPath kennt die aktuelle Route nicht — ohne Injection
+        // landet `/screen-id` in parsePath(hasWorkspaces) als workspaceId,
+        // WorkspaceShell sieht einen unbekannten Workspace und revertet
+        // sofort auf den Default-Screen ("Klick tut nichts"-Prod-Bug).
+        const inCurrentWorkspace = (target) => hasWorkspaces && target.workspaceId === undefined && route?.workspaceId !== undefined
+            ? { ...target, workspaceId: route.workspaceId }
+            : target;
+        // resolveTarget runs first so an ObjectTarget never reaches formatPath —
+        // everything downstream (workspace-injection, path-building) only ever
+        // sees the ScreenTarget shape it already knew about.
+        const toPath = (target) => prependBasePath(formatPath(inCurrentWorkspace(resolveTarget(features, target))), basePath);
+        return {
+            route,
+            navigate: (target, navigateOptions) => pushPath(toPath(target), formatSearch(navigateOptions)),
+            replace: (target, navigateOptions) => replacePath(toPath(target), formatSearch(navigateOptions)),
+            hrefFor: (target, navigateOptions) => `${toPath(target)}${formatSearch(navigateOptions) ?? ""}`,
+            searchParams,
+            setSearchParams: applySearchParamUpdates,
+        };
+    }, [inAppPath, hasWorkspaces, basePath, searchParams, features]);
+}
+export function KumikoLink({ to, onClick, children, ...rest }) {
+    const nav = useNav();
+    const handleClick = useCallback((e) => {
+        onClick?.(e);
+        if (e.defaultPrevented)
+            return;
+        // Standard-Browser-Verhalten für Cmd/Ctrl/Shift/Alt + Middle-Click
+        // erhalten — nur der plain-left-click landet bei navigate().
+        if (e.button !== 0 || e.metaKey || e.ctrlKey || e.shiftKey || e.altKey)
+            return;
+        e.preventDefault();
+        nav.navigate(to);
+    }, [nav, to, onClick]);
+    return (_jsx("a", { href: nav.hrefFor(to), onClick: handleClick, ...rest, children: children }));
+}

package/dist/web/app/plain-content-editor.d.ts

@@ -0,0 +1,3 @@
+import type { ReactNode } from "react";
+import { type ContentEditorProps } from "../../index.ts";
+export declare function PlainContentEditor({ id, value, onChange, variables, readOnly, }: ContentEditorProps): ReactNode;

package/dist/web/app/plain-content-editor.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { TextareaContentEditor, VariableChips } from "../../index.js";
+export function PlainContentEditor({ id, value, onChange, variables, readOnly, }) {
+    const [caret, setCaret] = useState(null);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: keyed on value only — must fire once per committed insert, not on every caret write
+    useEffect(() => {
+        if (caret === null)
+            return;
+        const el = document.getElementById(id);
+        if (el instanceof HTMLTextAreaElement) {
+            el.focus();
+            el.setSelectionRange(caret, caret);
+        }
+        setCaret(null);
+    }, [value]);
+    const insertAtCaret = (name) => {
+        const el = document.getElementById(id);
+        const placeholder = `{{${name}}}`;
+        if (!(el instanceof HTMLTextAreaElement)) {
+            onChange(value + placeholder);
+            return;
+        }
+        const start = el.selectionStart ?? value.length;
+        const end = el.selectionEnd ?? value.length;
+        setCaret(start + placeholder.length);
+        onChange(value.slice(0, start) + placeholder + value.slice(end));
+    };
+    return (_jsxs("div", { className: "rounded-md border border-input bg-transparent", children: [_jsx(TextareaContentEditor, { id: id, value: value, onChange: onChange, variables: variables, readOnly: readOnly }), variables.length > 0 && (_jsx("div", { className: "flex flex-wrap gap-1 border-t border-input p-1", children: _jsx(VariableChips, { variables: variables, onInsert: insertAtCaret, disabled: readOnly }) }))] }));
+}

package/dist/web/app/relative-time.d.ts

@@ -0,0 +1,10 @@
+/** "5 minutes ago" / "in 30 seconds" in the given locale. The unit grows with the
+ *  distance (seconds below a minute, minutes below an hour, hours below a day,
+ *  days beyond); each step is chosen on the already rounded value so 59.6 minutes
+ *  reads "1 hour" instead of "60 minutes". `numeric: "auto"` yields "now" and "yesterday". */
+export declare function formatRelativeTime(atMs: number, nowMs: number, locale: string): string;
+/** Interval at which a relative text at `distanceMs` from now needs a redraw. */
+export declare function relativeTickIntervalMs(distanceMs: number): number;
+/** Returns a formatter for relative times that redraws its component on a timer, but
+ *  only while a render actually called it: no relative output on screen, no timer. */
+export declare function useRelativeTimeFormatter(locale: string): (atMs: number) => string;

package/dist/web/app/relative-time.js

@@ -0,0 +1,56 @@
+import { useEffect, useRef, useState } from "react";
+import { resolveSafeLocale } from "../primitives/locale-number.js";
+const SECONDS_PER_MINUTE = 60;
+const MINUTES_PER_HOUR = 60;
+const HOURS_PER_DAY = 24;
+/** "5 minutes ago" / "in 30 seconds" in the given locale. The unit grows with the
+ *  distance (seconds below a minute, minutes below an hour, hours below a day,
+ *  days beyond); each step is chosen on the already rounded value so 59.6 minutes
+ *  reads "1 hour" instead of "60 minutes". `numeric: "auto"` yields "now" and "yesterday". */
+export function formatRelativeTime(atMs, nowMs, locale) {
+    const formatter = new Intl.RelativeTimeFormat(resolveSafeLocale(locale), { numeric: "auto" });
+    const seconds = Math.round((atMs - nowMs) / 1000);
+    if (Math.abs(seconds) < SECONDS_PER_MINUTE)
+        return formatter.format(seconds, "second");
+    const minutes = Math.round(seconds / SECONDS_PER_MINUTE);
+    if (Math.abs(minutes) < MINUTES_PER_HOUR)
+        return formatter.format(minutes, "minute");
+    const hours = Math.round(minutes / MINUTES_PER_HOUR);
+    if (Math.abs(hours) < HOURS_PER_DAY)
+        return formatter.format(hours, "hour");
+    return formatter.format(Math.round(hours / HOURS_PER_DAY), "day");
+}
+const SECOND_TICK_MS = 1000;
+// Above a minute the text changes at most once per minute; half a minute keeps it
+// at most 30 s late without waking the page every second for a "5 minutes ago".
+const COARSE_TICK_MS = 30_000;
+const SECOND_RESOLUTION_BELOW_MS = SECONDS_PER_MINUTE * 1000;
+/** Interval at which a relative text at `distanceMs` from now needs a redraw. */
+export function relativeTickIntervalMs(distanceMs) {
+    return distanceMs < SECOND_RESOLUTION_BELOW_MS ? SECOND_TICK_MS : COARSE_TICK_MS;
+}
+/** Returns a formatter for relative times that redraws its component on a timer, but
+ *  only while a render actually called it: no relative output on screen, no timer. */
+export function useRelativeTimeFormatter(locale) {
+    const [, setTick] = useState(0);
+    const [intervalMs, setIntervalMs] = useState(null);
+    const nearestDistanceMs = useRef(Number.POSITIVE_INFINITY);
+    nearestDistanceMs.current = Number.POSITIVE_INFINITY;
+    // After every render: the formatter calls of this render decide whether and how fast to tick.
+    useEffect(() => {
+        const distance = nearestDistanceMs.current;
+        setIntervalMs(distance === Number.POSITIVE_INFINITY ? null : relativeTickIntervalMs(distance));
+    });
+    useEffect(() => {
+        // skip: no relative output rendered, nothing to keep current
+        if (intervalMs === null)
+            return;
+        const timer = setInterval(() => setTick((tick) => tick + 1), intervalMs);
+        return () => clearInterval(timer);
+    }, [intervalMs]);
+    return (atMs) => {
+        const nowMs = Date.now();
+        nearestDistanceMs.current = Math.min(nearestDistanceMs.current, Math.abs(atMs - nowMs));
+        return formatRelativeTime(atMs, nowMs, locale);
+    };
+}

package/dist/web/app/resolvers-context.d.ts

@@ -0,0 +1,12 @@
+import type { TargetRef } from "@cosmicdrift/kumiko-framework/engine";
+import type { ComponentType, ReactNode } from "react";
+export type ResolverComponent = ComponentType<{
+    readonly target: TargetRef;
+    readonly onClose: () => void;
+}>;
+export type ResolversProviderProps = {
+    readonly resolvers: ReadonlyMap<string, ResolverComponent>;
+    readonly children: ReactNode;
+};
+export declare function ResolversProvider({ resolvers, children }: ResolversProviderProps): ReactNode;
+export declare function useResolvers(): ReadonlyMap<string, ResolverComponent>;

package/dist/web/app/resolvers-context.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+const ResolversContext = createContext(null);
+export function ResolversProvider({ resolvers, children }) {
+    return _jsx(ResolversContext.Provider, { value: resolvers, children: children });
+}
+export function useResolvers() {
+    const ctx = useContext(ResolversContext);
+    return ctx ?? new Map();
+}

package/dist/web/app/rich-content-editor.d.ts

@@ -0,0 +1,3 @@
+import { type ReactNode } from "react";
+import { type ContentEditorProps } from "../../index.ts";
+export declare function RichContentEditor(props: ContentEditorProps): ReactNode;

package/dist/web/app/rich-content-editor.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// @runtime client
+//
+// "rich" contentFormat editor: WYSIWYG on tiptap. Public contract is the
+// same four props every ContentEditorComponent gets — no tiptap type
+// crosses this boundary. tiptap itself is dynamic-imported (TiptapEditor
+// lives in ./tiptap-editor) so an app that never mounts a "rich" collection
+// never pays for it; the fallback while the chunk loads is the same plain
+// textarea #1794 uses for a missing editor, never a blank panel.
+import { lazy, Suspense } from "react";
+import { TextareaContentEditor } from "../../index.js";
+const TiptapEditor = lazy(() => import("./tiptap-editor.js"));
+export function RichContentEditor(props) {
+    return (_jsx(Suspense, { fallback: _jsx(TextareaContentEditor, { ...props }), children: _jsx(TiptapEditor, { ...props }) }));
+}

package/dist/web/app/root-error-fallback.d.ts

@@ -0,0 +1,2 @@
+import type { ReactNode } from "react";
+export declare function RootErrorFallback(): ReactNode;

package/dist/web/app/root-error-fallback.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ROOT_ERROR_FALLBACK_TEST_ID } from "@cosmicdrift/kumiko-types/error-boundary";
+// Renders outside every provider, so no i18n/theme/primitives: plain DOM + inline text.
+const ROOT_ERROR_TEXTS = {
+    de: { title: "Etwas ist schiefgelaufen.", reload: "Seite neu laden" },
+    en: { title: "Something went wrong.", reload: "Reload page" },
+    es: { title: "Algo salió mal.", reload: "Recargar la página" },
+};
+function rootErrorTexts() {
+    const language = typeof navigator === "undefined" ? "en" : navigator.language;
+    const lower = language.toLowerCase();
+    if (lower.startsWith("de"))
+        return ROOT_ERROR_TEXTS.de;
+    if (lower.startsWith("es"))
+        return ROOT_ERROR_TEXTS.es;
+    return ROOT_ERROR_TEXTS.en;
+}
+export function RootErrorFallback() {
+    const texts = rootErrorTexts();
+    return (_jsxs("div", { role: "alert", "data-testid": ROOT_ERROR_FALLBACK_TEST_ID, children: [_jsx("p", { children: texts.title }), _jsx("button", { type: "button", onClick: () => window.location.reload(), children: texts.reload })] }));
+}

package/dist/web/app/screen-error-fallback.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from "react";
+export declare function ScreenErrorFallback({ screen, error, onReset, }: {
+    readonly screen: string;
+    readonly error: Error;
+    readonly onReset: () => void;
+}): ReactNode;

package/dist/web/app/screen-error-fallback.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { SCREEN_ERROR_FALLBACK_TEST_ID } from "@cosmicdrift/kumiko-types/error-boundary";
+import { usePrimitives, useTranslation } from "../../index.js";
+// Opt-in: a bundle that leaves NODE_ENV unset must not leak error messages to end users.
+function showsErrorDetails() {
+    if (typeof process === "undefined")
+        return false;
+    const nodeEnv = process.env.NODE_ENV;
+    return nodeEnv !== undefined && nodeEnv !== "" && nodeEnv !== "production";
+}
+export function ScreenErrorFallback({ screen, error, onReset, }) {
+    const { Banner, Button } = usePrimitives();
+    const t = useTranslation();
+    return (_jsx(Banner, { variant: "error", padded: true, testId: SCREEN_ERROR_FALLBACK_TEST_ID, title: t("kumiko.screen-error.title"), actions: _jsx(Button, { variant: "secondary", onClick: onReset, testId: `${SCREEN_ERROR_FALLBACK_TEST_ID}-reset`, children: t("kumiko.actions.reload") }), children: showsErrorDetails()
+            ? t("kumiko.screen-error.detail", { screen, message: error.message })
+            : t("kumiko.screen-error.screen", { screen }) }));
+}

package/dist/web/app/tiptap-editor.d.ts

@@ -0,0 +1,3 @@
+import { type ReactNode } from "react";
+import { type ContentEditorProps } from "../../index.ts";
+export default function TiptapEditor({ id, value, onChange, variables, readOnly, }: ContentEditorProps): ReactNode;