@eifi1/ui-kit 0.16.1 → 0.18.0

package/src/i18n/locales/it.ts

@@ -89,6 +89,7 @@ export function uiKitLabelsIt(numberLocale = "it-IT"): UiKitLabels {
       passkeys: {
         title: "Passkey",
         description: "Accedi con impronta, volto o PIN del dispositivo invece che con una password.",
+        descriptionAlongside: "Accedi con impronta, volto o PIN del dispositivo. La tua password continua a funzionare.",
         empty: "Ancora nessuna passkey",
         loading: "Caricamento delle passkey…",
         list: "Le tue passkey",
@@ -498,6 +499,7 @@ export function uiKitLabelsIt(numberLocale = "it-IT"): UiKitLabels {
     confirmDialog: {
       confirm: "Conferma",
       cancel: "Annulla",
+      typed: (text) => `Digita «${text}» per confermare`,
     },
     floatingPanel: {
       close: "Chiudi",
@@ -583,6 +585,55 @@ export function uiKitLabelsIt(numberLocale = "it-IT"): UiKitLabels {
       noPreview: "Nessuna anteprima disponibile per questo file",
       openInNewTab: "Apri in una nuova scheda",
     },
+    writeLock: {
+      reason: "Puoi visualizzarlo, ma non modificarlo.",
+    },
+    accountState: {
+      // Agreeing with "account" (masculine): the chip is the state of an account.
+      active: "Attivo",
+      inactive: "Non attivo",
+      invited: "Invitato",
+      registered: "Registrato",
+      unverified: "Non verificato",
+      passwordChange: "Deve cambiare la password",
+    },
+    shareCard: {
+      dialogTitle: "Condividi",
+      close: "Chiudi",
+      email: "Indirizzo email",
+      emailOptional: "Indirizzo email (facoltativo)",
+      // example.com is reserved for examples (RFC 2606); a localised domain is real.
+      emailPlaceholder: "nome@example.com",
+      invalidEmail: "Inserisci un indirizzo email completo.",
+      role: "Ruolo",
+      roleOf: (name) => `Ruolo di ${name}`,
+      add: "Condividi",
+      whoHasAccess: "Chi ha accesso",
+      nobodyYet: "Nessun altro ha ancora accesso.",
+      pending: "In attesa",
+      openInvite: "Link di invito aperto",
+      copyLink: "Copia link",
+      team: "Team",
+      teamHint: (name) => `Tutti i membri di ${name} avranno accesso.`,
+      remove: "Rimuovi accesso",
+      removeConfirm: (name) => `Rimuovere l’accesso di ${name}?`,
+      revokePending: "Ritira invito",
+      revokePendingConfirm: (name) => `Ritirare l’invito per ${name}?`,
+      failed: "Non ha funzionato. Riprova.",
+      loading: "Caricamento…",
+    },
+    reauthDialog: {
+      title: "Conferma la tua identità",
+      description: "Inserisci la password attuale per continuare.",
+      password: "Password attuale",
+      submit: "Continua",
+      cancel: "Annulla",
+    },
+    serverWake: {
+      slow: "Caricamento in corso: ci vuole più del solito.",
+      waking: (appName) =>
+        `Il server va in sospensione quando nessuno usa ${appName ?? "l’app"}, quindi la prima richiesta dopo una pausa deve riavviarlo. Può volerci un momento: non si perde nulla, la pagina si completa da sola.`,
+    },
   };
 }
 

package/src/i18n/locales/zh.ts

@@ -87,6 +87,7 @@ export function uiKitLabelsZh(numberLocale = "zh-CN"): UiKitLabels {
       passkeys: {
         title: "通行密钥",
         description: "使用指纹、面容或设备 PIN 登录，无需密码。",
+        descriptionAlongside: "使用指纹、面容或设备 PIN 登录，密码仍可照常使用。",
         empty: "暂无通行密钥",
         loading: "正在加载通行密钥…",
         list: "已注册的通行密钥",
@@ -485,6 +486,7 @@ export function uiKitLabelsZh(numberLocale = "zh-CN"): UiKitLabels {
     confirmDialog: {
       confirm: "确认",
       cancel: "取消",
+      typed: (text) => `输入“${text}”以确认`,
     },
     floatingPanel: {
       close: "关闭",
@@ -570,6 +572,54 @@ export function uiKitLabelsZh(numberLocale = "zh-CN"): UiKitLabels {
       noPreview: "此文件无法预览",
       openInNewTab: "在新标签页中打开",
     },
+    writeLock: {
+      reason: "仅可查看，无法修改。",
+    },
+    accountState: {
+      active: "已启用",
+      inactive: "已停用",
+      invited: "已邀请",
+      registered: "已注册",
+      unverified: "未验证",
+      passwordChange: "需修改密码",
+    },
+    shareCard: {
+      dialogTitle: "共享",
+      close: "关闭",
+      email: "电子邮箱地址",
+      emailOptional: "电子邮箱地址（可选）",
+      emailPlaceholder: "name@example.com",
+      invalidEmail: "请输入完整的电子邮箱地址。",
+      role: "角色",
+      roleOf: (name) => `${name} 的角色`,
+      add: "共享",
+      whoHasAccess: "有权访问的人",
+      nobodyYet: "目前还没有其他人有权访问。",
+      pending: "待接受",
+      openInvite: "公开邀请链接",
+      copyLink: "复制链接",
+      team: "团队",
+      teamHint: (name) => `${name} 的所有成员都将获得访问权限。`,
+      remove: "移除访问权限",
+      removeConfirm: (name) => `移除 ${name} 的访问权限？`,
+      revokePending: "撤回邀请",
+      revokePendingConfirm: (name) => `撤回对 ${name} 的邀请？`,
+      failed: "操作未成功，请重试。",
+      loading: "加载中…",
+    },
+    reauthDialog: {
+      title: "验证身份",
+      description: "请输入当前密码以继续。",
+      password: "当前密码",
+      submit: "继续",
+      cancel: "取消",
+    },
+    serverWake: {
+      slow: "仍在加载，比平时耗时更长。",
+      // A Latin product name gets a space either side, as everywhere in this catalogue.
+      waking: (appName) =>
+        `无人使用${appName ? ` ${appName} ` : "本应用"}时，服务器会进入休眠，因此暂停后的第一个请求需要重新启动它。这可能需要一点时间——不会丢失任何内容，页面会自动加载完成。`,
+    },
   };
 }
 

package/src/i18n/swiss.ts

@@ -1,7 +1,7 @@
 /**
- * Swiss Standard German respelling, shared by the `de-CH` and `de-CH-informal`
- * translations. Internal: it lives outside `src/i18n/locales/` because every file there
- * becomes a public `@eifi1/ui-kit/i18n/<code>` subpath.
+ * Swiss Standard German respelling, applied to the internal German source (`german.ts`)
+ * to make the `de-CH` catalogue. Internal: it lives outside `src/i18n/locales/` because
+ * every file there becomes a public `@eifi1/ui-kit/i18n/<code>` subpath.
  *
  * "ss" for every "ß" (Schliessen, Grösse) is the one systematic difference in UI text.
  * Function labels are wrapped: their RESULT is respelled, so an argument the app passes

package/src/index.ts

@@ -109,7 +109,13 @@ export * from "./components/password-strength";
 export * from "./components/page-contents";
 export * from "./components/disclosure";
 export * from "./components/dialog-frame";
-export * from "./components/danger-confirm";
+// Named, not `*`: danger-confirm also holds the password field and pending hook that
+// ReauthDialog shares with it, which are kit-internal.
+export { DangerConfirm, DEFAULT_DANGER_CONFIRM_LABELS, typedMatches } from "./components/danger-confirm";
+export type { DangerConfirmLabels, DangerConfirmProps, TypedMatch } from "./components/danger-confirm";
+// 0.18: re-authentication before a sensitive action (Kurvenschmiede 4).
+export { ReauthDialog, DEFAULT_REAUTH_DIALOG_LABELS } from "./components/reauth-dialog";
+export type { ReauthDialogProps, ReauthDialogLabels } from "./components/reauth-dialog";
 // `useConfirm()` — the promise-based replacement for `window.confirm`, one host per app.
 export * from "./components/confirm-dialog";
 // A non-modal corner panel and its round trigger (keksdose's assistant launcher).
@@ -174,6 +180,22 @@ export * from "./components/description-list";
 // The Save / Cancel row forms and dialogs end in, and the editable line-item repeater
 // (journal lines, lease components, invoice positions). 0.12.0.
 export * from "./components/form-actions";
+// 0.18: lock every opted-in commit under one provider, the reason in its tooltip
+// (Kurvenschmiede 2). `useCommitReason` stays internal.
+export { WriteLockProvider, useWriteLock, DEFAULT_WRITE_LOCK_LABELS } from "./components/write-lock";
+export type { WriteLock, WriteLockLabels, WriteLockProviderProps } from "./components/write-lock";
+// 0.18: the parts both apps' admin rosters repeat (Kurvenschmiede 6).
+export { RoleChip, AccountStateChip, DateMark, dateColumn, DEFAULT_ACCOUNT_STATE_LABELS, ACCOUNT_STATE_TONES } from "./components/account-chips";
+export type { RoleChipProps, RoleDefinition, RoleVocabulary, AccountState, AccountStateLabels, AccountStateChipProps, DateMarkProps, DateColumnOptions } from "./components/account-chips";
+// 0.18: the cold-start notice keksdose built (#199), for every app: a framework-free
+// watchdog over the app's requests and the corner notice that explains the wait.
+export { createServerWake, serverWake, watchReadsAnd, attachServerWake, wrapFetch } from "./lib/server-wake";
+export type { ServerWakeStage, ServerWakeFilter, ServerWakeOptions, ServerWakeRequest, ServerWakeWatcher, ServerWakeAxiosConfig, AxiosLikeInstance } from "./lib/server-wake";
+export { ServerWakeNotice, useServerWakeStage, DEFAULT_SERVER_WAKE_LABELS } from "./components/server-wake";
+export type { ServerWakeLabels, ServerWakeNoticeProps } from "./components/server-wake";
+// 0.18: sharing — grantees, roles, pending grants, candidates (Kurvenschmiede 1).
+export { ShareCard, ShareDialog, SharePanel, DEFAULT_SHARE_CARD_LABELS } from "./components/share-card";
+export type { ShareCardProps, ShareDialogProps, SharePanelProps, ShareCardLabels, ShareRole, ShareGrantee, SharePendingGrant, ShareCandidate, ShareAddRequest } from "./components/share-card";
 export * from "./components/line-items";
 export * from "./components/progress-bar";
 // Named: skeleton.tsx also holds SKELETON_CLASS, the look StatTile shares — internal.

package/src/lib/server-wake.ts

@@ -0,0 +1,270 @@
+/**
+ * "Is the server asleep, or is the app broken?" — the cold-start watchdog, lifted
+ * from keksdose (feedback #199) so kastlan and Kurvenschmiede get it too.
+ *
+ * All three backends run on Cloud Run with `--min-instances=0`: after an idle
+ * period the container is gone and the first request has to start it, which takes
+ * several seconds and occasionally more. Nothing in the UI said so, and none of the
+ * axios instances has a timeout, so the honest experience was a spinner that looked
+ * stuck. This counts the in-flight requests a cold start would actually delay and
+ * escalates in two steps, so a merely slow response says "still loading" and only a
+ * genuinely long wait blames the sleeping server.
+ *
+ * Framework-free on purpose (no zustand, no axios, no React): a counter, two timers
+ * and a listener set, read by `useServerWakeStage` through `useSyncExternalStore`.
+ * The adapters below take the app's axios instance / fetch as an ARGUMENT, so the
+ * kit never imports either.
+ *
+ * WHAT ARMS IT, and why the default is narrow:
+ *   - reads (GET) — what every page does on open — always;
+ *   - writes only when the app says so (`watchReadsAnd(/\/auth\/login\b/)`): the
+ *     auth POSTs that gate the app are the only writes a user waits on before the
+ *     app exists at all, so a cold start there looks exactly like a broken login.
+ * An UPLOAD must never be watched — a statement PDF or a photo takes seconds on a
+ * perfectly warm server, and "the server is waking up" during a 4 s upload would
+ * simply be false. With the default that holds by itself (an upload is a POST);
+ * an app widening `shouldWatch` keeps its upload routes out of it.
+ *
+ * It never arms while the browser is offline, whatever `shouldWatch` says: that state
+ * has its own, truthful indicator, and a request that never left the device is not
+ * evidence of anything about the server.
+ */
+
+/** `slow` = longer than a warm server ever takes; `waking` = long enough that a cold
+ *  start is the only sensible explanation. */
+export type ServerWakeStage = "idle" | "slow" | "waking";
+
+/** Decides which requests count. `method` arrives lower-cased (`"get"` when the
+ *  request named none — axios's and fetch's default); `url` as the client had it. */
+export type ServerWakeFilter = (method: string, url: string) => boolean;
+
+export interface ServerWakeOptions {
+  /** Past this, a warm round trip is out of the question (a cold database query on a
+   *  free tier can still take a second, so it is not tighter). Default 2000 ms. */
+  slowMs?: number;
+  /** Past this, the container was almost certainly scaled to zero. Default 7000 ms. */
+  wakingMs?: number;
+  /** Which requests count. Default {@link watchReadsAnd}`()` — GETs only. The offline
+   *  guard runs before it and cannot be overridden. */
+  shouldWatch?: ServerWakeFilter;
+}
+
+/** What a request is, for {@link ServerWakeWatcher.track}. */
+export interface ServerWakeRequest {
+  method?: string;
+  url?: string;
+}
+
+export interface ServerWakeWatcher {
+  /**
+   * Count a request that is going out, and arm the escalation if it is the first.
+   * Returns whether it was counted — the caller MUST call {@link end} exactly once
+   * for every `true`, or the counter never returns to zero and the notice sticks.
+   * (The axios adapter stashes it on the request config for that reason.)
+   */
+  start(method?: string, url?: string): boolean;
+  /** A counted request settled — either way: an error still proves the server
+   *  answered or gave up. When the last one does, the notice goes away. Never takes
+   *  the counter below zero. */
+  end(): void;
+  /** `start` + `end` around a promise (or a function returning one), for a request
+   *  that does not go through an adapter. Resolves and rejects as the work does. */
+  track<T>(work: PromiseLike<T> | (() => PromiseLike<T>), request?: ServerWakeRequest): Promise<T>;
+  /** Back to a pristine watchdog — for tests, which share an instance across cases. */
+  reset(): void;
+  /** `useSyncExternalStore`'s pair. Listeners hear stage changes only. */
+  subscribe(listener: () => void): () => void;
+  getStage(): ServerWakeStage;
+  /** Counted requests currently outstanding. */
+  getInFlight(): number;
+}
+
+/**
+ * The usual filter: every GET, plus any other request whose URL matches `writes` —
+ * keksdose's `/\/auth\/(login|register|demo-session)\b/`. Keep upload routes out of
+ * the pattern (see the module comment).
+ */
+export function watchReadsAnd(writes?: RegExp): ServerWakeFilter {
+  return (method, url) => method === "get" || (writes !== undefined && writes.test(url));
+}
+
+function isOffline(): boolean {
+  return typeof navigator !== "undefined" && navigator.onLine === false;
+}
+
+export function createServerWake({
+  slowMs = 2000,
+  wakingMs = 7000,
+  shouldWatch = watchReadsAnd(),
+}: ServerWakeOptions = {}): ServerWakeWatcher {
+  let inFlight = 0;
+  let stage: ServerWakeStage = "idle";
+  let slowTimer: ReturnType<typeof setTimeout> | null = null;
+  let wakingTimer: ReturnType<typeof setTimeout> | null = null;
+  const listeners = new Set<() => void>();
+
+  const setStage = (next: ServerWakeStage) => {
+    if (next === stage) return;
+    stage = next;
+    for (const listener of listeners) listener();
+  };
+
+  const clearTimers = () => {
+    if (slowTimer !== null) clearTimeout(slowTimer);
+    if (wakingTimer !== null) clearTimeout(wakingTimer);
+    slowTimer = null;
+    wakingTimer = null;
+  };
+
+  const start = (method?: string, url?: string): boolean => {
+    if (isOffline()) return false;
+    if (!shouldWatch((method ?? "get").toLowerCase(), url ?? "")) return false;
+    inFlight += 1;
+    // The clock runs from the FIRST outstanding request: a page firing a second read
+    // at 1.9 s is still waiting on the same sleeping server, not starting afresh.
+    if (inFlight === 1) {
+      clearTimers();
+      slowTimer = setTimeout(() => setStage("slow"), slowMs);
+      wakingTimer = setTimeout(() => setStage("waking"), wakingMs);
+    }
+    return true;
+  };
+
+  const end = () => {
+    inFlight = Math.max(0, inFlight - 1);
+    if (inFlight > 0) return;
+    clearTimers();
+    setStage("idle");
+  };
+
+  return {
+    start,
+    end,
+    track<T>(work: PromiseLike<T> | (() => PromiseLike<T>), request: ServerWakeRequest = {}) {
+      const counted = start(request.method, request.url);
+      let promise: Promise<T>;
+      try {
+        promise = Promise.resolve(typeof work === "function" ? work() : work);
+      } catch (error) {
+        // A thunk that throws before it returns a promise settled too.
+        promise = Promise.reject(error);
+      }
+      return counted ? promise.finally(end) : promise;
+    },
+    reset() {
+      inFlight = 0;
+      clearTimers();
+      setStage("idle");
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    getStage: () => stage,
+    getInFlight: () => inFlight,
+  };
+}
+
+/**
+ * The shared instance: what `<ServerWakeNotice />`, `useServerWakeStage()`,
+ * {@link attachServerWake} and {@link wrapFetch} use when no watcher is passed. GETs
+ * only, default timings — an app that also watches its login POST creates its own
+ * with {@link createServerWake} and passes it to both ends.
+ */
+export const serverWake: ServerWakeWatcher = createServerWake();
+
+// ── axios ─────────────────────────────────────────────────────────────────────
+
+/** The two config fields the watchdog reads — what axios's request config has. */
+export interface ServerWakeAxiosConfig {
+  method?: string;
+  url?: string;
+}
+
+/** The slice of an interceptor manager the adapter uses. A method (not a function
+ *  property) so axios's wider `use(onFulfilled?, onRejected?, options?)` fits it. */
+interface InterceptorManagerLike<V> {
+  use(onFulfilled: (value: V) => V | Promise<V>, onRejected: (error: unknown) => unknown): number;
+  eject(id: number): void;
+}
+
+/** An axios instance, structurally — so the kit types the adapter without importing
+ *  axios. `axios.create()`'s result fits it as is. */
+export interface AxiosLikeInstance<C extends ServerWakeAxiosConfig, R extends { config: C }> {
+  interceptors: {
+    request: InterceptorManagerLike<C>;
+    response: InterceptorManagerLike<R>;
+  };
+}
+
+/** Whether the watchdog counted this request — the response side owes a matching
+ *  `end()` only then. On the config, as keksdose's `_wake` was: it travels with the
+ *  request onto the response and onto an error. Cleared once settled, so a 401 replay
+ *  of the same config re-enters the request interceptor and is counted afresh — the
+ *  pairing stays balanced. */
+const COUNTED = "_serverWake";
+type Marked = { [COUNTED]?: boolean };
+
+/**
+ * Drive a watcher from an axios instance's interceptors: `attachServerWake(api)`.
+ * Returns a function that ejects both interceptors again.
+ *
+ * Attach it BEFORE the app's own response interceptors: axios runs those in the order
+ * they were added, so the wake one ends the wait before a 401 handler awaits a token
+ * refresh — otherwise the notice would keep counting a request that has already been
+ * answered. (Request-side order does not matter.)
+ */
+export function attachServerWake<C extends ServerWakeAxiosConfig, R extends { config: C }>(
+  instance: AxiosLikeInstance<C, R>,
+  watcher: ServerWakeWatcher = serverWake,
+): () => void {
+  const settle = (config: unknown) => {
+    const marked = config as Marked | undefined;
+    if (marked?.[COUNTED]) {
+      marked[COUNTED] = false;
+      watcher.end();
+    }
+  };
+  const request = instance.interceptors.request.use(
+    (config) => {
+      (config as C & Marked)[COUNTED] = watcher.start(config.method, config.url);
+      return config;
+    },
+    (error) => Promise.reject(error),
+  );
+  const response = instance.interceptors.response.use(
+    (res) => {
+      settle(res.config);
+      return res;
+    },
+    (error) => {
+      settle((error as { config?: unknown } | null)?.config);
+      return Promise.reject(error);
+    },
+  );
+  return () => {
+    instance.interceptors.request.eject(request);
+    instance.interceptors.response.eject(response);
+  };
+}
+
+// ── fetch ─────────────────────────────────────────────────────────────────────
+
+/**
+ * A `fetch` that drives a watcher: `const apiFetch = wrapFetch(fetch)`. The wait ends
+ * when the response's HEADERS arrive (or the call fails) — the server is awake by then,
+ * however long the body takes.
+ */
+export function wrapFetch(
+  fetchImpl: typeof fetch = globalThis.fetch,
+  watcher: ServerWakeWatcher = serverWake,
+): typeof fetch {
+  return (input, init) => {
+    const request = typeof Request !== "undefined" && input instanceof Request ? input : undefined;
+    const method = init?.method ?? request?.method;
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : (request?.url ?? "");
+    return watcher.track(() => fetchImpl(input, init), { method, url });
+  };
+}

package/src/rhf/line-items.tsx

@@ -24,7 +24,8 @@
  * list's `error`. Each cell's `render` gets `name`, the row's path
  * (`"components.2"`), to bind its field to.
  *
- * `summary`, `fieldLabels` and `narrowColumns` pass through to {@link LineItems}. With
+ * `summary`, `fieldLabels`, `narrowColumns`, `removePlacement` and `removeAlign` pass
+ * through to {@link LineItems}. With
  * `fieldLabels="floating"` a cell's `fieldLabel` is the column's name; the bound
  * fields' own `label` is a `FormLabel` ABOVE the control, so for the floating
  * one render the kit field through `RhfField`:

package/src/search/global-search.tsx

@@ -42,8 +42,22 @@ export const DEFAULT_GLOBAL_SEARCH_LABELS: GlobalSearchLabels = {
 export interface GlobalSearchSource {
   /** Stable key — the effect that runs the source is keyed by it, not by identity. */
   id: string;
-  /** The group its results are shown under (an entry's own `group` is ignored). */
+  /** The group its results are shown under (an entry's own `group` is ignored) — unless
+   *  `groups` is set, where it is only the home of entries that name no declared group.
+   *  If every entry names a declared group, it is never shown: a catch-all heading such
+   *  as "Other" is the honest value, so a stray type would still surface, labelled. */
   group: string;
+  /**
+   * Split ONE request into several groups — kastlan's record search answers with
+   * properties, units, contacts, leases and invoices at once, and one source per group
+   * meant a dedupe layer so the network still saw one request. Each entry is then shown
+   * under the group its own `group` names: a declared `key` (shown by its `label`) or a
+   * plain string (key and heading at once). The groups appear in THIS order whatever the
+   * answer's order, each kept to `limit` rows; an entry naming no declared group falls
+   * under `group`. While the request runs, or when it fails, the source shows one status
+   * line under its first group, not one per group. Unset: one group, as before.
+   */
+  groups?: readonly (string | GlobalSearchSourceGroup)[];
   /** Called with the trimmed query. Its results are shown AS GIVEN — the source ranked
    *  them — and never re-filtered by the index's matcher. `signal` aborts when the query
    *  moves on or the palette closes; a stale answer is dropped either way. */
@@ -52,7 +66,7 @@ export interface GlobalSearchSource {
   minChars?: number;
   /** Quiet period after the last keystroke before it is asked. Default 200ms. */
   debounceMs?: number;
-  /** Rows kept. Default: `indexOptions.groupLimit` (8). */
+  /** Rows kept — per group, when `groups` is set. Default: `indexOptions.groupLimit` (8). */
   limit?: number;
   /** Mask every row of this source for session replay, hints (amounts) included. An
    *  entry's own `redact` still wins. */
@@ -62,6 +76,13 @@ export interface GlobalSearchSource {
   onError?: (error: unknown) => void;
 }
 
+/** One of a multi-group source's groups: the `key` its entries name in `group`, and the
+ *  heading shown — so a server's type ("unit") need not be translated per entry. */
+export interface GlobalSearchSourceGroup {
+  key: string;
+  label: string;
+}
+
 /** What a custom trigger gets: everything the default button uses. */
 export interface GlobalSearchTriggerProps {
   open: () => void;
@@ -90,7 +111,7 @@ export interface GlobalSearchProps {
    * neither re-indexes nor loops, and the icons and handlers used are always the latest.
    */
   entries?: readonly SearchEntry[];
-  /** The async sources, each streamed into its own group. */
+  /** The async sources, each streamed into its own group — or several (`groups`). */
   sources?: readonly GlobalSearchSource[];
   /** What the empty query shows, under the `suggestions` heading. */
   suggestions?: readonly GlobalSearchSuggestion[];
@@ -311,7 +332,17 @@ function GlobalSearchImpl({
   const byId = useMemo(() => new Map(list.map((e) => [e.id, e])), [sig]);
 
   const sourceKey = (sources ?? [])
-    .map((s) => [s.id, s.group, s.minChars ?? 2, s.debounceMs ?? 200, s.limit, s.redact].join("\u0001"))
+    .map((s) =>
+      [
+        s.id,
+        s.group,
+        (s.groups ?? []).map((g) => (typeof g === "string" ? g : `${g.key}\u0003${g.label}`)).join("\u0004"),
+        s.minChars ?? 2,
+        s.debounceMs ?? 200,
+        s.limit,
+        s.redact,
+      ].join("\u0001"),
+    )
     .join("\u0002");
   const sourceList = useMemo(() => sources ?? [], [sourceKey]);
 
@@ -434,10 +465,12 @@ function GlobalSearchImpl({
     for (const source of sourceList) {
       if (q.length < (source.minChars ?? 2)) continue;
       const result = sourceResults[source.id];
+      const declared = (source.groups ?? []).map((g) => (typeof g === "string" ? { key: g, label: g } : g));
       const status = (label: string, icon: ReactNode): CommandItem => ({
         id: `src:${source.id}:status`,
         label,
-        group: source.group,
+        // One line for the one request, under the group that will head its answer.
+        group: declared[0]?.label ?? source.group,
         icon,
         kind: "status",
         onSelect: noop,
@@ -448,10 +481,30 @@ function GlobalSearchImpl({
         out.push(status(pl.loading, <Loader2 className="size-3.5 animate-spin" />));
       } else if (result.status === "error") {
         out.push(status(pl.error ?? DEFAULT_COMMAND_PALETTE_LABELS.error!, <AlertCircle className="size-3.5" />));
-      } else {
+      } else if (!declared.length) {
         for (const entry of result.entries.slice(0, source.limit ?? groupLimit)) {
           out.push(toItem(`src:${source.id}:`, entry, source.group, source.redact ?? redactLabels));
         }
+      } else {
+        // Bucket by the entry's own group, then emit in the DECLARED order — the answer's
+        // order must not reshuffle the headings between keystrokes. Within a group the
+        // source's ranking stands. The group key is in the row id: two record types may
+        // share an id ("1"), and the palette keys rows by it.
+        const buckets = new Map<string, { label: string; entries: SearchEntry[] }>();
+        for (const g of declared) buckets.set(g.key, { label: g.label, entries: [] });
+        const rest: SearchEntry[] = [];
+        for (const entry of result.entries) {
+          const bucket = entry.group === undefined ? undefined : buckets.get(entry.group);
+          (bucket ? bucket.entries : rest).push(entry);
+        }
+        const limit = source.limit ?? groupLimit;
+        const emit = (key: string, label: string, list: SearchEntry[]) => {
+          for (const entry of list.slice(0, limit)) {
+            out.push(toItem(`src:${source.id}:${key}:`, entry, label, source.redact ?? redactLabels));
+          }
+        };
+        for (const [key, { label, entries: list }] of buckets) emit(key, label, list);
+        emit("~", source.group, rest);
       }
     }
 

package/dist/i18n/locales/de-CH-informal.d.ts

@@ -1,61 +0,0 @@
-import { aZ as UiKitLabels } from '../../kit-labels-DE--LmCk.js';
-import 'react';
-import '../../components/data-table-labels.js';
-import '../../components/mini-calendar.js';
-import '../../components/calendar-heatmap.js';
-import '../../components/popover.js';
-import '../../components/chip.js';
-import 'lucide-react';
-import '../../components/field-sync.js';
-import '../../components/tooltip.js';
-import '../../hooks/use-anchored-rect.js';
-import '../../lib/clipping.js';
-import '../../wizard/types.js';
-import '../../tour/tour.js';
-import '../../search/command-palette.js';
-import '../../search/global-search.js';
-import '../../search/search-index.js';
-import '../../components/month-picker.js';
-import '../../components/page-contents.js';
-import '../../components/series-chart-labels.js';
-import '../../components/pie-chart-labels.js';
-import '../../components/sparkline.js';
-import '../../components/stat-tile.js';
-import '../../components/signature-pad.js';
-import '../../components/password-strength.js';
-import '../../components/danger-confirm.js';
-import '../../components/swatch-picker.js';
-import '../../components/tile-radio.js';
-import '../../components/icon-picker.js';
-import '../../components/dialog-frame.js';
-import '../../components/modal.js';
-import '../../hooks/use-search-param-state.js';
-import '../../components/measured-grid.js';
-import '../../feedback-attachment-WFiXJ8We.js';
-import '../../feedback/feedback-thread.js';
-import '../../feedback/feedback-inbox.js';
-import '../../components/account-settings-labels.js';
-import '../../components/confirm-dialog.js';
-import '../../components/floating-panel.js';
-import '../../components/bulk-action-bar.js';
-import '../../components/list.js';
-import '../../components/signed-amount.js';
-import '../../components/breadcrumbs.js';
-import '../../components/toast.js';
-import '../../components/description-list.js';
-import '../../components/line-items.js';
-import '../../components/progress-bar.js';
-import '../../components/error-boundary.js';
-import '../../components/authed-image.js';
-import '../../hooks/use-authed-src.js';
-import '../../components/image-grid.js';
-import '../../components/lightbox.js';
-
-/**
- * Swiss Standard German, informal ("du"): the informal German labels with Swiss
- * spelling ("ss" for every "ß") and `de-CH` number formatting (1’234.5) — derived the
- * same way `de-CH` is from `de`, so both stay in sync with their source.
- */
-declare const UI_KIT_LABELS_DE_CH_INFORMAL: UiKitLabels;
-
-export { UI_KIT_LABELS_DE_CH_INFORMAL };

package/dist/i18n/locales/de-CH-informal.js

@@ -1,8 +0,0 @@
-"use client";
-import { swiss } from "../swiss.js";
-import { uiKitLabelsDeInformal } from "./de-informal.js";
-const UI_KIT_LABELS_DE_CH_INFORMAL = swiss(uiKitLabelsDeInformal("de-CH"));
-export {
-  UI_KIT_LABELS_DE_CH_INFORMAL
-};
-//# sourceMappingURL=de-CH-informal.js.map

package/dist/i18n/locales/de-CH-informal.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/i18n/locales/de-CH-informal.ts"],"sourcesContent":["import type { UiKitLabels } from \"../kit-labels\";\nimport { swiss } from \"../swiss\";\nimport { uiKitLabelsDeInformal } from \"./de-informal\";\n\n/**\n * Swiss Standard German, informal (\"du\"): the informal German labels with Swiss\n * spelling (\"ss\" for every \"ß\") and `de-CH` number formatting (1’234.5) — derived the\n * same way `de-CH` is from `de`, so both stay in sync with their source.\n */\nexport const UI_KIT_LABELS_DE_CH_INFORMAL: UiKitLabels = swiss(uiKitLabelsDeInformal(\"de-CH\"));\n"],"mappings":";AACA,SAAS,aAAa;AACtB,SAAS,6BAA6B;AAO/B,MAAM,+BAA4C,MAAM,sBAAsB,OAAO,CAAC;","names":[]}