@cosmicdrift/kumiko-renderer 1.0.0 → 2.0.0

package/src/hooks/__tests__/use-stream-handler.test.tsx

@@ -0,0 +1,107 @@
+import { describe, expect, test } from "bun:test";
+import type { Dispatcher, DispatcherError } from "@cosmicdrift/kumiko-headless";
+import { act, renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { DispatcherProvider } from "../../context/dispatcher-context";
+import { useStreamHandler } from "../use-stream-handler";
+
+function makeDispatcher(streamImpl: unknown): Dispatcher {
+  return {
+    write: (async () => ({ isSuccess: true, data: {} })) 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"],
+    stream: streamImpl as Dispatcher["stream"],
+    statusStore: {
+      getState: () => "online",
+      subscribe: () => () => {},
+    } as unknown as Dispatcher["statusStore"],
+    pendingWrites: () => [],
+    pendingFiles: () => [],
+  };
+}
+
+function wrapperFor(dispatcher: Dispatcher) {
+  return ({ children }: { readonly children: ReactNode }) => (
+    <DispatcherProvider dispatcher={dispatcher}>{children}</DispatcherProvider>
+  );
+}
+
+describe("useStreamHandler", () => {
+  test("start accumulates chunks then status=done", async () => {
+    const dispatcher = makeDispatcher(async function* () {
+      yield { i: 0 };
+      yield { i: 1 };
+    });
+
+    const { result } = renderHook(() => useStreamHandler<{ i: number }>("f:stream:x:tail"), {
+      wrapper: wrapperFor(dispatcher),
+    });
+
+    await act(async () => {
+      await result.current.start({ count: 2 });
+    });
+
+    await waitFor(() => expect(result.current.status).toBe("done"));
+    expect(result.current.chunks).toEqual([{ i: 0 }, { i: 1 }]);
+    expect(result.current.error).toBeNull();
+  });
+
+  test("stream error sets status=error and error envelope", async () => {
+    const err: DispatcherError = {
+      code: "access_denied",
+      httpStatus: 403,
+      i18nKey: "errors.access",
+      message: "denied",
+    };
+    const dispatcher = makeDispatcher(async function* () {
+      yield* []; // satisfy generator shape; error is the only outcome
+      throw err;
+    });
+
+    const { result } = renderHook(() => useStreamHandler("f:stream:x:tail"), {
+      wrapper: wrapperFor(dispatcher),
+    });
+
+    await act(async () => {
+      await result.current.start();
+    });
+
+    await waitFor(() => expect(result.current.status).toBe("error"));
+    expect(result.current.error?.code).toBe("access_denied");
+  });
+
+  test("abort during stream resets status to idle (no late done)", async () => {
+    let release!: () => void;
+    const gate = new Promise<void>((r) => {
+      release = r;
+    });
+    const dispatcher = makeDispatcher(async function* (
+      _t: string,
+      _p: unknown,
+      opts?: { signal?: AbortSignal },
+    ) {
+      yield { i: 0 };
+      await gate;
+      if (opts?.signal?.aborted) {
+        const e = { code: "aborted", httpStatus: 0, i18nKey: "x", message: "aborted" };
+        throw e;
+      }
+      yield { i: 1 };
+    });
+
+    const { result } = renderHook(() => useStreamHandler<{ i: number }>("f:stream:x:tail"), {
+      wrapper: wrapperFor(dispatcher),
+    });
+
+    let started!: Promise<void>;
+    act(() => {
+      started = result.current.start();
+    });
+    await waitFor(() => expect(result.current.chunks).toEqual([{ i: 0 }]));
+    act(() => result.current.abort());
+    release();
+    await started;
+    expect(result.current.chunks).toEqual([{ i: 0 }]);
+    expect(result.current.status).toBe("idle");
+  });
+});

package/src/hooks/use-ai-text.ts

@@ -0,0 +1,172 @@
+import type { DispatcherError } from "@cosmicdrift/kumiko-headless";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useDispatcher } from "../context/dispatcher-context";
+
+// AiTextField/AiTextArea's client-side surface. Deliberately duplicates the
+// wire-contract shape from kumiko-enterprise's `ai-text` feature instead of
+// importing it — this package is public NPM, ai-text is a private Enterprise
+// package, and the widgets only ever talk HTTP (ai-text-primitive plan doc,
+// Architecture Decision 1). Keep these in lockstep with
+// kumiko-enterprise/packages/ai-text/src/{modes,feature}.ts by hand; there's
+// no compile-time link between the two repos.
+
+export const AI_TEXT_RUN_QN = "ai-text:query:run";
+
+export type AiTextMode = "complete" | "correct" | "translate" | "rewrite";
+export type AiTextRewriteStyle = "formal" | "casual" | "concise" | "expand";
+
+export type AiTextRunPayload =
+  | { readonly mode: "complete"; readonly text: string }
+  | { readonly mode: "correct"; readonly text: string }
+  | { readonly mode: "translate"; readonly text: string; readonly targetLanguage: string }
+  | { readonly mode: "rewrite"; readonly text: string; readonly style?: AiTextRewriteStyle };
+
+export type AiTextUsage = { readonly inputTokens: number; readonly outputTokens: number };
+
+export type AiTextRunResult =
+  | { readonly type: "text"; readonly text: string; readonly usage: AiTextUsage }
+  | { readonly type: "error"; readonly reason: string; readonly usage: AiTextUsage };
+
+// =============================================================================
+// useAiTextAction — one-shot request/response, any mode
+// =============================================================================
+//
+// v1 has no streaming (ai-text-primitive plan doc, sequencing note —
+// SSE-with-auth-reuse needs a framework-core `r.streamHandler` primitive,
+// tracked separately). `complete` goes through this same request/response
+// path as correct/translate/rewrite; `useCompletion` below adds debounce on
+// top for the ghost-text use-case specifically.
+
+export type AiTextActionState =
+  | "idle"
+  | "loading"
+  | "success"
+  | "error"
+  | "cap-exceeded"
+  | "unavailable";
+
+export type UseAiTextActionResult = {
+  readonly run: (payload: AiTextRunPayload) => Promise<AiTextRunResult | null>;
+  readonly state: AiTextActionState;
+  readonly result: AiTextRunResult | null;
+  readonly error: DispatcherError | null;
+  readonly reset: () => void;
+};
+
+function stateForError(error: DispatcherError): AiTextActionState {
+  if (error.code === "cap_exceeded" || error.code === "rate_limited") return "cap-exceeded";
+  if (error.code === "feature_disabled") return "unavailable";
+  return "error";
+}
+
+export function useAiTextAction(): UseAiTextActionResult {
+  const dispatcher = useDispatcher();
+  const [state, setState] = useState<AiTextActionState>("idle");
+  const [result, setResult] = useState<AiTextRunResult | null>(null);
+  const [error, setError] = useState<DispatcherError | null>(null);
+
+  // Track the in-flight call so a newer `run()` cancels an older one, and
+  // unmount doesn't set state after the component is gone — same pattern
+  // as useQuery's activeCtrl.
+  const activeCtrl = useRef<AbortController | null>(null);
+  useEffect(() => {
+    return () => {
+      activeCtrl.current?.abort();
+    };
+  }, []);
+
+  const run = useCallback(
+    async (payload: AiTextRunPayload): Promise<AiTextRunResult | null> => {
+      activeCtrl.current?.abort();
+      const ctrl = new AbortController();
+      activeCtrl.current = ctrl;
+
+      setState("loading");
+      setError(null);
+
+      const res = await dispatcher.query<AiTextRunResult>(AI_TEXT_RUN_QN, payload, {
+        signal: ctrl.signal,
+      });
+      if (ctrl.signal.aborted) return null;
+
+      if (!res.isSuccess) {
+        if (res.error.code === "aborted") return null;
+        setError(res.error);
+        setState(stateForError(res.error));
+        return null;
+      }
+
+      setResult(res.data);
+      setState("success");
+      return res.data;
+    },
+    [dispatcher],
+  );
+
+  const reset = useCallback(() => {
+    activeCtrl.current?.abort();
+    setState("idle");
+    setResult(null);
+    setError(null);
+  }, []);
+
+  return { run, state, result, error, reset };
+}
+
+// =============================================================================
+// useCompletion — debounced ghost-text for AiTextField/AiTextArea
+// =============================================================================
+//
+// Debounce exists to keep the request-rate down against the monthly cap,
+// not for UX polish — every keystroke would otherwise burn a request.
+
+export type UseCompletionResult = {
+  readonly suggestion: string | null;
+  readonly state: AiTextActionState;
+  readonly error: DispatcherError | null;
+  /** Debounced — schedules a completion request `debounceMs` after the
+   *  last call. Calling again before the timer fires replaces it. */
+  readonly requestCompletion: (text: string) => void;
+  /** Cancels any pending/in-flight request and clears the suggestion. */
+  readonly clear: () => void;
+};
+
+const DEFAULT_DEBOUNCE_MS = 500;
+
+export function useCompletion(debounceMs: number = DEFAULT_DEBOUNCE_MS): UseCompletionResult {
+  const { run, state, result, error, reset } = useAiTextAction();
+  const timerRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);
+
+  const clearTimer = useCallback(() => {
+    if (timerRef.current !== undefined) {
+      clearTimeout(timerRef.current);
+      timerRef.current = undefined;
+    }
+  }, []);
+
+  const requestCompletion = useCallback(
+    (text: string) => {
+      clearTimer();
+      if (text.length === 0) {
+        reset();
+        // skip: empty text, state already reset above
+        return;
+      }
+      timerRef.current = setTimeout(() => {
+        void run({ mode: "complete", text });
+      }, debounceMs);
+    },
+    [clearTimer, reset, run, debounceMs],
+  );
+
+  const clear = useCallback(() => {
+    clearTimer();
+    reset();
+  }, [clearTimer, reset]);
+
+  useEffect(() => clearTimer, [clearTimer]);
+
+  const suggestion = result?.type === "text" ? result.text : null;
+
+  return { suggestion, state, error, requestCompletion, clear };
+}

package/src/hooks/use-disclosure.ts

@@ -0,0 +1,20 @@
+import { useCallback, useState } from "react";
+
+// Open/close state for dialogs, sheets and collapsibles — the standard
+// replacement for the hand-rolled `useState(false)` + toggle-callback
+// trio in app screens. All callbacks are referentially stable.
+
+export type UseDisclosureResult = {
+  readonly open: boolean;
+  readonly onOpen: () => void;
+  readonly onClose: () => void;
+  readonly onToggle: () => void;
+};
+
+export function useDisclosure(initialOpen = false): UseDisclosureResult {
+  const [open, setOpen] = useState(initialOpen);
+  const onOpen = useCallback(() => setOpen(true), []);
+  const onClose = useCallback(() => setOpen(false), []);
+  const onToggle = useCallback(() => setOpen((prev) => !prev), []);
+  return { open, onOpen, onClose, onToggle };
+}

package/src/hooks/use-mutation.ts

@@ -0,0 +1,61 @@
+import type { DispatcherError, WriteResult } from "@cosmicdrift/kumiko-headless";
+import { useCallback, useRef, useState } from "react";
+import { useDispatcher } from "../context/dispatcher-context";
+
+// React wrapper around dispatcher.write — the write-side sibling of
+// useQuery. One hook instance per handler-type; `mutate` carries the
+// payload so a single instance serves list-row actions with varying
+// payloads.
+//
+// `mutate` resolves with the raw WriteResult so callers can branch
+// (navigate on success, keep the form open on failure) without waiting
+// for a re-render of `error`/`data`.
+
+export type UseMutationResult<TData> = {
+  readonly mutate: (payload: unknown) => Promise<WriteResult<TData>>;
+  readonly pending: boolean;
+  readonly error: DispatcherError | null;
+  readonly data: TData | null;
+  readonly reset: () => void;
+};
+
+export function useMutation<TData = unknown>(type: string): UseMutationResult<TData> {
+  const dispatcher = useDispatcher();
+  const [pending, setPending] = useState(false);
+  const [error, setError] = useState<DispatcherError | null>(null);
+  const [data, setData] = useState<TData | null>(null);
+  // Sequence guard: `mutate` has no abort (unlike useQuery's GETs, a write
+  // already landed server-side and can't be cancelled). Two overlapping
+  // calls on one instance (e.g. two list-row actions) must not let the
+  // first-to-resolve clobber pending/error/data set by the second — only
+  // the most recently STARTED call's outcome may update shared state.
+  const sequence = useRef(0);
+
+  const mutate = useCallback(
+    async (payload: unknown): Promise<WriteResult<TData>> => {
+      const callSeq = ++sequence.current;
+      setPending(true);
+      setError(null);
+      const result = await dispatcher.write<TData>(type, payload);
+      if (callSeq === sequence.current) {
+        if (result.isSuccess) {
+          setData(result.data);
+        } else {
+          setError(result.error);
+        }
+        setPending(false);
+      }
+      return result;
+    },
+    [dispatcher, type],
+  );
+
+  const reset = useCallback(() => {
+    sequence.current++; // invalidate any in-flight mutate's late update
+    setPending(false);
+    setError(null);
+    setData(null);
+  }, []);
+
+  return { mutate, pending, error, data, reset };
+}

package/src/hooks/use-query.ts

@@ -87,14 +87,14 @@ export function useQuery<TData = unknown>(
 
     setLoading(true);
     const result = await dispatcher.query<TData>(type, payload, { signal: ctrl.signal });
-    // Don't update state if a newer fetch has already taken over.
+    // skip: a newer fetch already superseded this one, don't clobber its state
     if (ctrl.signal.aborted) return;
     if (result.isSuccess) {
       setData(result.data);
       setError(null);
     } else {
       // A cancelled request comes back with code "aborted" from the
-      // dispatcher — skip the state update, another run replaces it.
+      // skip: aborted request, a newer run already replaces this result
       if (result.error.code === "aborted") return;
       setError(result.error);
     }
@@ -104,6 +104,7 @@ export function useQuery<TData = unknown>(
   useEffect(() => {
     if (!enabled) {
       setLoading(false);
+      // skip: query disabled, loading state already cleared above
       return;
     }
     void run();
@@ -117,8 +118,10 @@ export function useQuery<TData = unknown>(
   // Subscription-Lifecycle genau einmal durchwalzt.
   const subscribeLive = useLiveEvents();
   useEffect(() => {
+    // skip: live mode or query disabled, no SSE subscription needed
     if (!live || !enabled) return;
     const entity = entityFromQueryType(type);
+    // skip: query type has no mapped entity, nothing to subscribe to
     if (entity === undefined) return;
     return subscribeLive(entity, () => {
       void run();

package/src/hooks/use-reference-lookup.ts

@@ -18,6 +18,7 @@
 // Entity, Live-Updates kommen via SSE (use-query-live).
 
 import { useMemo } from "react";
+import { toKebab } from "../app/qn";
 import { REFERENCE_LIST_LOOKUP_LIMIT } from "./reference-limits";
 import { useQuery } from "./use-query";
 
@@ -35,7 +36,7 @@ export function useReferenceLookup(
   refEntity: string,
   labelField: string,
 ): { readonly map: ReferenceLookupMap; readonly loading: boolean } {
-  const queryQn = `${featureName}:query:${refEntity}:list`;
+  const queryQn = `${toKebab(featureName)}:query:${toKebab(refEntity)}:list`;
   const result = useQuery<{ rows: ReadonlyArray<Record<string, unknown>> }>(queryQn, {
     limit: REFERENCE_LIST_LOOKUP_LIMIT,
   });

package/src/hooks/use-stream-handler.ts

@@ -0,0 +1,134 @@
+import type { DispatcherError } from "@cosmicdrift/kumiko-headless";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useDispatcher } from "../context/dispatcher-context";
+
+// React wrapper around dispatcher.stream (#1382). Accumulates yielded
+// chunks into `chunks` (unlike useQuery({live:true}), which only
+// invalidates and re-fetches). Each start() owns an AbortController;
+// a newer start() / unmount aborts the previous run so late chunks
+// cannot clobber fresher state.
+
+export type StreamStatus = "idle" | "streaming" | "done" | "error";
+
+export type UseStreamHandlerResult<TChunk> = {
+  readonly chunks: readonly TChunk[];
+  readonly status: StreamStatus;
+  readonly error: DispatcherError | null;
+  readonly start: (payload?: unknown) => Promise<void>;
+  readonly abort: () => void;
+  readonly reset: () => void;
+};
+
+export type UseStreamHandlerOptions = {
+  // When true, start() runs once on mount with the initial payload.
+  // Default false — streams are usually user-triggered (unlike queries).
+  readonly autoStart?: boolean;
+};
+
+export function useStreamHandler<TChunk = unknown>(
+  type: string,
+  payload: unknown = {},
+  options: UseStreamHandlerOptions = {},
+): UseStreamHandlerResult<TChunk> {
+  const dispatcher = useDispatcher();
+  const { autoStart = false } = options;
+
+  const [chunks, setChunks] = useState<readonly TChunk[]>([]);
+  const [status, setStatus] = useState<StreamStatus>("idle");
+  const [error, setError] = useState<DispatcherError | null>(null);
+
+  const activeCtrl = useRef<AbortController | null>(null);
+  const payloadRef = useRef(payload);
+  payloadRef.current = payload;
+
+  const abort = useCallback((): void => {
+    activeCtrl.current?.abort();
+    activeCtrl.current = null;
+    // User cancel — exit streaming so UI can re-enable the start button.
+    setStatus((s) => (s === "streaming" ? "idle" : s));
+  }, []);
+
+  const reset = useCallback((): void => {
+    abort();
+    setChunks([]);
+    setStatus("idle");
+    setError(null);
+  }, [abort]);
+
+  // Shared by every abort-detection branch below: only touch status if this
+  // run is still the active one (or activeCtrl was already cleared by abort()).
+  const settleAborted = useCallback((ctrl: AbortController): void => {
+    if (activeCtrl.current === null || activeCtrl.current === ctrl) setStatus("idle");
+  }, []);
+
+  const start = useCallback(
+    async (overridePayload?: unknown): Promise<void> => {
+      activeCtrl.current?.abort();
+      const ctrl = new AbortController();
+      activeCtrl.current = ctrl;
+
+      setChunks([]);
+      setError(null);
+      setStatus("streaming");
+
+      const body = overridePayload !== undefined ? overridePayload : payloadRef.current;
+      try {
+        for await (const chunk of dispatcher.stream<TChunk>(type, body, { signal: ctrl.signal })) {
+          // skip: a newer start() already superseded this run
+          if (ctrl.signal.aborted) {
+            settleAborted(ctrl);
+            return;
+          }
+          setChunks((prev) => [...prev, chunk]);
+        }
+        // skip: aborted after last chunk, don't mark done
+        if (ctrl.signal.aborted) {
+          settleAborted(ctrl);
+          return;
+        }
+        setStatus("done");
+      } catch (e) {
+        // skip: abort is not an error toast
+        if (ctrl.signal.aborted) {
+          settleAborted(ctrl);
+          return;
+        }
+        const mapped = asDispatcherError(e);
+        // skip: dispatcher-mapped abort (fetch cancelled)
+        if (mapped.code === "aborted") {
+          settleAborted(ctrl);
+          return;
+        }
+        setError(mapped);
+        setStatus("error");
+      }
+    },
+    [dispatcher, type, settleAborted],
+  );
+
+  useEffect(() => {
+    // skip: autoStart off — streams are usually user-triggered
+    if (!autoStart) return;
+    void start();
+  }, [autoStart, start]);
+
+  useEffect(() => {
+    return () => {
+      activeCtrl.current?.abort();
+    };
+  }, []);
+
+  return { chunks, status, error, start, abort, reset };
+}
+
+function asDispatcherError(e: unknown): DispatcherError {
+  if (e && typeof e === "object" && "code" in e && "message" in e && "i18nKey" in e) {
+    return e as DispatcherError;
+  }
+  return {
+    code: "stream_error",
+    httpStatus: 0,
+    i18nKey: "errors.unknown",
+    message: e instanceof Error ? e.message : String(e),
+  };
+}

package/src/i18n-defaults.ts

@@ -20,6 +20,8 @@ export const kumikoDefaultTranslations: TranslationsByLocale = {
     "kumiko.actions.reload": "Neu laden",
     "kumiko.actions.create": "Neu",
     "kumiko.actions.edit": "Bearbeiten",
+    "kumiko.actions.copyLink": "Link kopieren",
+    "kumiko.actions.copyLinkCopied": "Kopiert!",
 
     // Version — Update-Awareness-Banner (UpdateChecker).
     "kumiko.version.update-available": "Eine neue Version ist verfügbar.",
@@ -43,17 +45,40 @@ export const kumikoDefaultTranslations: TranslationsByLocale = {
     "kumiko.combobox.search-placeholder": "Suchen…",
     "kumiko.combobox.empty": "Keine Treffer.",
     "kumiko.combobox.loading": "Lade…",
+
+    // Dashboard — Default-Label für den "(alle)"-Eintrag im Screen-Filter,
+    // wenn DashboardFilterDefinition.allLabel nicht gesetzt ist.
+    "kumiko.dashboard.filter.all": "Alle",
     "kumiko.combobox.placeholder": "—",
 
+    // Widgets — Query-States (QueryTable, LoadingState, ErrorState).
+    "kumiko.widget.loading": "Lade…",
+    "kumiko.widget.error.title": "Konnte nicht geladen werden.",
+
     // Nav — Sidebar Tree (Toggle-aria-Labels).
     "kumiko.nav.expand": "Aufklappen",
     "kumiko.nav.collapse": "Zuklappen",
+    "kumiko.nav.search": "Navigation durchsuchen…",
 
     // Dialog — Confirm-Buttons + Close-aria-Label.
     "kumiko.dialog.confirm": "Bestätigen",
     "kumiko.dialog.cancel": "Abbrechen",
     "kumiko.dialog.close": "Schließen",
 
+    // AiTextField/AiTextArea — Ghost-Text-Hint, Toolbar-Aria-Labels, Diff-Dialog.
+    "kumiko.aiText.acceptHint": "Tab = übernehmen, Esc = verwerfen",
+    "kumiko.aiText.correct": "Korrigieren",
+    "kumiko.aiText.translate": "Übersetzen",
+    "kumiko.aiText.rewrite": "Umschreiben",
+    "kumiko.aiText.diff.before": "Vorher",
+    "kumiko.aiText.diff.after": "Nachher",
+    "kumiko.aiText.diff.generating": "Wird generiert…",
+    "kumiko.aiText.style.formal": "Formell",
+    "kumiko.aiText.style.casual": "Locker",
+    "kumiko.aiText.style.concise": "Kompakt",
+    "kumiko.aiText.style.expand": "Ausführlicher",
+    "kumiko.aiText.capExceeded": "Monatliches AI-Limit erreicht.",
+
     // Row-Actions — Fehler-Toast wenn ein Action-Write fehlschlägt.
     "kumiko.rowAction.failed": "Aktion fehlgeschlagen",
 
@@ -119,7 +144,13 @@ export const kumikoDefaultTranslations: TranslationsByLocale = {
     "errors.unconfigured": "Diese Funktion ist noch nicht konfiguriert.",
     "errors.internal": "Etwas ist schiefgegangen. Bitte versuche es später erneut.",
     "errors.rate_limited": "Zu viele Anfragen. Bitte versuche es in Kürze erneut.",
+    "errors.cap.exceeded":
+      "Limit erreicht. Bitte Tarif upgraden oder auf die nächste Periode warten.",
     "errors.download.urlMissing": "Download nicht verfügbar — bitte versuche es erneut.",
+    "auth.errors.originNotAllowed": "Zugriff von dieser Herkunft ist nicht erlaubt.",
+    "dispatcher.errors.network":
+      "Netzwerkfehler. Bitte überprüfe deine Verbindung und versuche es erneut.",
+    "dispatcher.errors.aborted": "Anfrage abgebrochen.",
   },
   en: {
     "kumiko.actions.save": "Save",
@@ -129,6 +160,8 @@ export const kumikoDefaultTranslations: TranslationsByLocale = {
     "kumiko.actions.reload": "Reload",
     "kumiko.actions.create": "New",
     "kumiko.actions.edit": "Edit",
+    "kumiko.actions.copyLink": "Copy link",
+    "kumiko.actions.copyLinkCopied": "Copied!",
 
     "kumiko.version.update-available": "A new version is available.",
 
@@ -149,13 +182,32 @@ export const kumikoDefaultTranslations: TranslationsByLocale = {
     "kumiko.combobox.loading": "Loading…",
     "kumiko.combobox.placeholder": "—",
 
+    "kumiko.dashboard.filter.all": "All",
+
+    "kumiko.widget.loading": "Loading…",
+    "kumiko.widget.error.title": "Couldn't load.",
+
     "kumiko.nav.expand": "Expand",
     "kumiko.nav.collapse": "Collapse",
+    "kumiko.nav.search": "Search navigation…",
 
     "kumiko.dialog.confirm": "Confirm",
     "kumiko.dialog.cancel": "Cancel",
     "kumiko.dialog.close": "Close",
 
+    "kumiko.aiText.acceptHint": "Tab = accept, Esc = discard",
+    "kumiko.aiText.correct": "Correct",
+    "kumiko.aiText.translate": "Translate",
+    "kumiko.aiText.rewrite": "Rewrite",
+    "kumiko.aiText.diff.before": "Before",
+    "kumiko.aiText.diff.after": "After",
+    "kumiko.aiText.diff.generating": "Generating…",
+    "kumiko.aiText.style.formal": "Formal",
+    "kumiko.aiText.style.casual": "Casual",
+    "kumiko.aiText.style.concise": "Concise",
+    "kumiko.aiText.style.expand": "Expand",
+    "kumiko.aiText.capExceeded": "Monthly AI limit reached.",
+
     "kumiko.rowAction.failed": "Action failed",
 
     "kumiko.config.source.user": "My value",
@@ -206,6 +258,10 @@ export const kumikoDefaultTranslations: TranslationsByLocale = {
     "errors.unconfigured": "This feature isn't configured yet.",
     "errors.internal": "Something went wrong. Please try again later.",
     "errors.rate_limited": "Too many requests. Please try again shortly.",
+    "errors.cap.exceeded": "Limit reached. Upgrade your plan or wait for the next period.",
     "errors.download.urlMissing": "Download unavailable — please try again.",
+    "auth.errors.originNotAllowed": "Requests from this origin are not allowed.",
+    "dispatcher.errors.network": "Network error. Please check your connection and try again.",
+    "dispatcher.errors.aborted": "Request was cancelled.",
   },
 };