@k2b/cloud 0.44.0 → 0.46.0

package/src/access/GroupCoverage.tsx

@@ -2,16 +2,18 @@ import { query } from "@k2b/stdlib/solid";
 import { Button, InlineGuidance, useLocale } from "@k2b/ui";
 import { createSignal, createUniqueId, For, Show } from "solid-js";
 import { CloudAvatar } from "../account/Avatar";
-import type { BaseUser, EntityListItem, PaginationResponse } from "../contracts/shared";
+import type { EntityListItem, PaginationResponse } from "../contracts/shared";
 import { accessMessages } from "./messages";
+import { serviceAccountKindDisplay } from "./service-account-kind";
 
 /** Members per request. Further pages load only when the viewer asks for them. */
 const PAGE_SIZE = 20;
+type GroupMember = Exclude<EntityListItem, { kind: "group" }>;
 
 type MembersPage =
   /** The directory withholds group members from this viewer (guest accounts). */
   | { visible: false; directoryGroup: boolean }
-  | { visible: true; directoryGroup: boolean; members: BaseUser[]; total: number; page: number; hasNext: boolean };
+  | { visible: true; directoryGroup: boolean; members: GroupMember[]; total: number; page: number; hasNext: boolean };
 
 /** Reads the Accounts directory with the viewer's own visibility: `null` when it is withheld. */
 const listEntities = async (params: Record<string, string>, signal: AbortSignal) => {
@@ -38,7 +40,7 @@ export const createGroupCoverage = (groupId: string) => {
       const page = cursor ?? 1;
       const [list, group] = await Promise.all([
         listEntities(
-          { kinds: "user", member_of_group_id: id, recursive: "true", page: String(page), per_page: String(PAGE_SIZE) },
+          { kinds: "user,service_account", member_of_group_id: id, recursive: "true", page: String(page), per_page: String(PAGE_SIZE) },
           abortSignal,
         ),
         // Only the first page needs the group itself, for the directory hint.
@@ -49,7 +51,7 @@ export const createGroupCoverage = (groupId: string) => {
       return {
         visible: true,
         directoryGroup,
-        members: list.items.flatMap((item) => (item.kind === "user" ? [item.user] : [])),
+        members: list.items.filter((item) => item.kind !== "group"),
         total: list.pagination.total,
         page,
         hasNext: list.pagination.has_next,
@@ -146,7 +148,20 @@ export function GroupCoveragePanel(props: { coverage: GroupCoverage; groupName:
       <Show when={shown().length > 0}>
         <ul ref={list} tabindex="-1" aria-label={t().groupMembersOf({ name: props.groupName })} class="flex flex-col gap-1 outline-none">
           <For each={shown()}>
-            {(user) => {
+            {(member) => {
+              if (member.kind === "service_account") {
+                const kind = () => serviceAccountKindDisplay(member.serviceAccount.kind, t());
+                return (
+                  <li class="flex min-w-0 items-center gap-2 text-sm">
+                    <span class="flex h-6 w-6 shrink-0 items-center justify-center rounded-full bg-zinc-200 text-secondary dark:bg-zinc-700">
+                      <i class={`ti ${kind().icon}`} aria-hidden="true" />
+                    </span>
+                    <span class="truncate">{member.serviceAccount.name}</span>
+                    <span class="shrink-0 text-xs text-muted">{kind().label}</span>
+                  </li>
+                );
+              }
+              const user = member.user;
               const name = user.displayName || user.mail || user.uid;
               return (
                 <li class="flex min-w-0 items-center gap-2 text-sm">

package/src/access/PermissionEditor.tsx

@@ -449,6 +449,8 @@ export default function PermissionEditor(props: PermissionEditorProps) {
                   allowPublic={allowPublic()}
                   allowAuthenticated={allowAuthenticated()}
                   allowServiceAccounts={props.allowServiceAccounts}
+                  serviceAccountKinds={props.serviceAccountKinds}
+                  serviceAccountStatus={props.serviceAccountStatus ?? "active"}
                   placeholder={props.placeholder}
                   signedIn={props.signedIn}
                   disabled={saving()}
@@ -651,7 +653,7 @@ function AccessEntryRow(props: {
       >
         <Show when={!props.expanded} fallback={<PrincipalAvatar entry={props.entry} label={displayName()} />}>
           <Show
-            when={props.entry.principal.type === "user"}
+            when={props.entry.principal.type === "user" || props.entry.principal.type === "service_account"}
             fallback={
               <div class="flex h-7 w-7 shrink-0 items-center justify-center rounded-full bg-zinc-200 text-secondary dark:bg-zinc-700">
                 <i class={`ti ${getPrincipalIcon(props.entry, t())} text-sm`} />
@@ -660,8 +662,15 @@ function AccessEntryRow(props: {
           >
             <CloudAvatar
               username={displayName()}
-              userId={props.entry.principal.type === "user" ? props.entry.principal.userId : undefined}
+              userId={
+                props.entry.principal.type === "user"
+                  ? props.entry.principal.userId
+                  : props.entry.principal.type === "service_account"
+                    ? props.entry.principal.serviceAccountId
+                    : undefined
+              }
               avatarHash={props.entry.avatarHash}
+              kind={props.entry.principal.type === "service_account" ? "service_account" : "user"}
               size="xs"
               class="h-7 w-7"
             />

package/src/access/PrincipalAvatar.tsx

@@ -2,9 +2,9 @@ import { Show } from "solid-js";
 import { CloudAvatar } from "../account/Avatar";
 import type { AccessEntry } from "../contracts/shared";
 
-// One hue per principal kind from the avatar palette, so a group, a service account and all signed-in people
-// read apart at a glance. People use a neutral background.
-const hues = { group: "#22c55e", service_account: "#8b5cf6", authenticated: "#3b82f6" } as const;
+// One hue per principal kind from the avatar palette, so a group and all signed-in people read apart at a glance.
+// People use a neutral background; a service account shows its robot or photo, never a bare icon.
+const hues = { group: "#22c55e", authenticated: "#3b82f6" } as const;
 
 /** The 32px avatar of an access entry in the expanded editor and on the denial page. */
 export default function PrincipalAvatar(props: {
@@ -15,8 +15,6 @@ export default function PrincipalAvatar(props: {
     switch (props.entry.principal.type) {
       case "group":
         return "ti-users-group";
-      case "service_account":
-        return "ti-robot";
       case "authenticated":
         return "ti-world";
       default:
@@ -25,27 +23,38 @@ export default function PrincipalAvatar(props: {
   };
   const hue = () => {
     const type = props.entry.principal.type;
-    return type === "group" || type === "service_account" || type === "authenticated" ? hues[type] : undefined;
+    return type === "group" || type === "authenticated" ? hues[type] : undefined;
   };
   return (
     <Show
       when={props.entry.principal.type === "user" ? props.entry.principal : undefined}
       fallback={
-        <span
-          class="flex h-8 w-8 shrink-0 items-center justify-center rounded-full bg-[var(--ui-surface-muted)] text-secondary"
-          // The avatar formula: a light share of the hue on the surface, a dark share on the text, in both themes.
-          style={
-            hue()
-              ? {
-                  background: `color-mix(in srgb, ${hue()} 18%, var(--k2b-surface))`,
-                  color: `color-mix(in srgb, ${hue()} 55%, var(--k2b-text))`,
-                }
-              : undefined
-          }
-          aria-hidden="true"
-        >
-          <i class={`ti ${icon()} text-xs`} />
-        </span>
+        props.entry.principal.type === "service_account" ? (
+          <CloudAvatar
+            username={props.label}
+            userId={props.entry.principal.serviceAccountId}
+            avatarHash={props.entry.avatarHash}
+            kind="service_account"
+            size="sm"
+            class="h-8 w-8"
+          />
+        ) : (
+          <span
+            class="flex h-8 w-8 shrink-0 items-center justify-center rounded-full bg-[var(--ui-surface-muted)] text-secondary"
+            // The avatar formula: a light share of the hue on the surface, a dark share on the text, in both themes.
+            style={
+              hue()
+                ? {
+                    background: `color-mix(in srgb, ${hue()} 18%, var(--k2b-surface))`,
+                    color: `color-mix(in srgb, ${hue()} 55%, var(--k2b-text))`,
+                  }
+                : undefined
+            }
+            aria-hidden="true"
+          >
+            <i class={`ti ${icon()} text-xs`} />
+          </span>
+        )
       }
     >
       {(user) => (

package/src/access/messages.ts

@@ -47,8 +47,8 @@ export const accessMessages = i18n.define({
         count === 0
           ? "No one receives access through this group right now."
           : count === 1
-            ? "1 person receives access through this group right now."
-            : `${count.toLocaleString("en")} people receive access through this group right now.`,
+            ? "1 account receives access through this group right now."
+            : `${count.toLocaleString("en")} accounts receive access through this group right now.`,
       groupMembersLoading: "Loading members…",
       groupMembersHidden: "Your account can't see who belongs to this group.",
       groupMembersFailed: "Members couldn't be loaded.",
@@ -137,8 +137,8 @@ export const accessMessages = i18n.define({
         count === 0
           ? "Über diese Gruppe erhält gerade niemand Zugriff."
           : count === 1
-            ? "Über diese Gruppe erhält gerade 1 Person Zugriff."
-            : `Über diese Gruppe erhalten gerade ${count.toLocaleString("de")} Personen Zugriff.`,
+            ? "Über diese Gruppe erhält gerade 1 Konto Zugriff."
+            : `Über diese Gruppe erhalten gerade ${count.toLocaleString("de")} Konten Zugriff.`,
       groupMembersLoading: "Mitglieder werden geladen…",
       groupMembersHidden: "Dein Konto kann nicht sehen, wer zu dieser Gruppe gehört.",
       groupMembersFailed: "Die Mitglieder konnten nicht geladen werden.",

package/src/account/EntitySearch.tsx

@@ -5,6 +5,7 @@ import { createSignal, For, Show } from "solid-js";
 import { accessMessages } from "../access/messages";
 import { principalLabel } from "../access/principal-label";
 import { serviceAccountKindDisplay } from "../access/service-account-kind";
+import type { ServiceAccountKind, ServiceAccountStatus } from "../contracts/shared";
 import { groupDisplayName } from "../shared/account-display";
 import { CloudAvatar } from "./Avatar";
 
@@ -52,6 +53,10 @@ type EntitySearchProps = {
   includeGroups?: boolean;
   /** Surface service accounts in the result list. Off by default. */
   includeServiceAccounts?: boolean;
+  /** Restrict service-account kinds before pagination. Omitted or empty allows all kinds. */
+  serviceAccountKinds?: ServiceAccountKind[];
+  /** Restrict service-account status before pagination. Omitted allows both statuses. */
+  serviceAccountStatus?: ServiceAccountStatus;
   /** Inject a synthetic "All authenticated users" row at the top. */
   includeAuthenticated?: boolean;
   /** Inject a synthetic "Public" row at the top. */
@@ -171,6 +176,12 @@ const EntitySearch = (props: EntitySearchProps) => {
       if (props.excludeServiceAccountIds?.length) {
         url.searchParams.set("exclude_service_account_ids", props.excludeServiceAccountIds.join(","));
       }
+      if (props.includeServiceAccounts && props.serviceAccountKinds?.length) {
+        url.searchParams.set("service_account_kinds", props.serviceAccountKinds.join(","));
+      }
+      if (props.includeServiceAccounts && props.serviceAccountStatus) {
+        url.searchParams.set("service_account_status", props.serviceAccountStatus);
+      }
       if (props.onlyMembersOf?.length) {
         url.searchParams.set("user_member_of_group_ids", props.onlyMembersOf.join(","));
       }
@@ -296,6 +307,7 @@ const EntitySearch = (props: EntitySearchProps) => {
               {(serviceAccount) => (
                 <ResultRow
                   icon={serviceAccountKind(serviceAccount).icon}
+                  avatar={<CloudAvatar username={serviceAccount.name} userId={serviceAccount.id} kind="service_account" size="sm" />}
                   title={serviceAccount.name}
                   subtitle={
                     // Resource-bound accounts often share a name; their binding tells them apart.

package/src/ai/capabilities.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import type { Tool, ToolContext, ToolResolver } from "@k2b/nessi";
 import { z } from "zod";
-import { resolveCapabilityActionWording, resolveCapabilityOperationTitle } from "../_internal/capabilities";
+import { isPersonVisibleCapabilityQuery, resolveCapabilityActionWording, resolveCapabilityOperationTitle } from "../_internal/capabilities";
 import { capabilityReviewView } from "../_internal/capability-reviews";
 import {
   CAPABILITY_APPROVAL_REASON_FIELD,
@@ -164,7 +164,9 @@ export const buildAiCapabilityCatalog = (apps: CapabilityRegistryEntry[], locale
         : app.appName;
       return [
         ...app.manifest.actions.map((operation) => ({ app, appName, operation, kind: "action" as const })),
-        ...app.manifest.queries.map((operation) => ({ app, appName, operation, kind: "query" as const })),
+        ...app.manifest.queries
+          .filter(isPersonVisibleCapabilityQuery)
+          .map((operation) => ({ app, appName, operation, kind: "query" as const })),
       ];
     })
     .map(

package/src/ai/chat/map-messages.ts

@@ -0,0 +1,270 @@
+import { i18n } from "@k2b/stdlib";
+
+const messages = i18n.define({
+  baseLocale: "en",
+  messages: {
+    en: {
+      places: "Places",
+      museum: "Museum",
+      changeStop: "Change stop",
+      without: "avoiding",
+      route: "Route",
+      searched: "Places searched",
+      calculated: "Route calculated",
+      loading: "Loading places and route …",
+      here: "Route here",
+      nearby: "More nearby",
+      save: "Save as Notebook",
+      locate: "I am here",
+      unknown: "Opening hours unknown",
+      source: "Place and hours",
+      description: "Description",
+      all: "All",
+      less: "Show fewer",
+      jump: "Jump to map",
+      noPlaces: "No places found.",
+      expand: "Search within 10 km",
+      retry: "Try again",
+      failed: "Places or route could not be loaded. Your question and answer are kept.",
+      off: "Places and maps are not configured.",
+      configure: "Configure places and maps",
+      budget: "Map allowance reached",
+      person: "Daily allowance",
+      cloud: "Monthly budget",
+      reset: "Available again",
+      limits: "Change allowances",
+      insert: "Insert stop",
+      optimize: "Optimize stop order",
+      options: "Options",
+      along: "Eat along the route",
+      nav: "Open navigation app",
+      discard: "Discard",
+      cancel: "Cancel",
+      preview: "Preview for",
+      undo: "Undo",
+      before: "Before",
+      after: "After",
+      distance: "Distance",
+      duration: "Travel time",
+      choose: "Which place did you mean?",
+      useStop: "Use this stop",
+      stopSearch: "Find a place near the route",
+      search: "Search",
+      category: "Category",
+      placeName: "Place name (optional)",
+      placeNamePlaceholder: "e.g. waterfall",
+      waterfall: "Attractions",
+      cafe: "Cafés",
+      restaurant: "Restaurants",
+      whole: "Whole tour",
+      mode: "Travel mode",
+      car: "Car",
+      bike: "Bike",
+      walk: "Walk",
+      avoid: "Avoid",
+      highways: "Highways",
+      tolls: "Tolls",
+      ferries: "Ferries",
+      scope: "Apply to",
+      calculate: "Calculate preview",
+      prefs: "Geoapify avoids where possible; this is not guaranteed.",
+      from: "From km",
+      to: "To km",
+      corridor: "Distance from route",
+      noRoute: "No usable route. Change a stop or the options.",
+      noLocation: "Location denied · allow it in your browser",
+      locationFailed: "Location unavailable. Enter a starting place.",
+      start: "Starting place",
+      go: "Plan route",
+      conflict: "This map has changed. Load its current state and choose your change again.",
+      reload: "Load current state",
+      pending: "Saving …",
+      changed: "Changed",
+      stops: "Stops",
+      noTraffic: "Times without traffic, calculated",
+      resumeRoute: "Continue calculation",
+      routeLimit:
+        "This route needs more credits than the configured limit. Use fewer stops, select address suggestions, or ask an administrator to raise the budget.",
+      budgetNumbers: ({ required, available, missing }: { required: string; available: string; missing: string }) =>
+        `Required: ${required} credits. Available: ${available}. Missing: ${missing}.`,
+      recordedCosts: ({ settled, unknown }: { settled: string; unknown: string }) =>
+        `Last attempt: ${settled} credits charged. Reserved with an unknown outcome: ${unknown}.`,
+      noInvoiceCap: "Cloud reserves estimated costs; Geoapify does not guarantee a cap on its side.",
+      cost: "The route cost more than estimated. Calculation stopped. Continuing can incur further costs.",
+      notebook: "Choose notebook",
+      inspectNotebook: "Inspect notebook",
+      noNotebooks: "No writable notebook found.",
+      saved: "Saved in Notebook",
+      previousSave: "This map has an earlier save receipt. Open the notebook to find the note before starting another save.",
+      resumeSave: "Resume save",
+      reconcileSave: "Check save outcome",
+      partialNote: "Open partial note",
+      saveProgress: "Map save progress",
+      saveLoading: "Preparing save …",
+      saveCancelled: "Saving stopped. Any saved part is kept. You can resume here.",
+      savePaused: "This save is unfinished. Resume to check the note and continue.",
+      saveStorage: "Save progress could not be stored in this browser. Allow local storage and try again before continuing.",
+      saveLockUnavailable: "This browser cannot protect the save across tabs. Use a browser with Web Locks support.",
+      saveLocked: "This map is being saved in another tab. Wait for it to finish, then check again.",
+      saveOwnerChanged: "The signed-in account has changed. Reload the page before saving.",
+      saveFailed: "The map could not be saved. Try again or open the notebook to check it.",
+      saveSourceChanged: "The map source has changed. Reload the map. Open any partial note before starting another save.",
+      saveContentChanged: "The note has changed. Open it to review your changes; this save cannot continue.",
+      saveInvalid: "The saved progress or map source cannot be used. Open the notebook to recover any saved part.",
+      saveTooLarge: "The map title cannot fit in a save request. Shorten it before saving.",
+      saveAppendUnknown: "The last part may still be saving. Check the outcome again later. It will not be sent twice.",
+      unknownSave: "The note may have been created. Open the notebook to recover it. This save will not be sent again.",
+    },
+    de: {
+      places: "Orte",
+      museum: "Museum",
+      changeStop: "Stopp ändern",
+      without: "ohne",
+      route: "Route",
+      searched: "Orte gesucht",
+      calculated: "Route berechnet",
+      loading: "Orte und Route werden geladen …",
+      here: "Route hierher",
+      nearby: "Mehr in der Nähe",
+      save: "Als Notebook speichern",
+      locate: "Ich bin hier",
+      unknown: "Öffnungszeiten unbekannt",
+      source: "Ort und Zeiten",
+      description: "Beschreibung",
+      all: "Alle",
+      less: "Weniger zeigen",
+      jump: "Zur Karte",
+      noPlaces: "Keine Orte gefunden.",
+      expand: "Umkreis 10 km",
+      retry: "Erneut versuchen",
+      failed: "Die Orte oder Route konnten nicht geladen werden. Deine Frage und die Antwort bleiben stehen.",
+      off: "Orte und Karten sind nicht eingerichtet.",
+      configure: "Orte und Karten einrichten",
+      budget: "Kartengrenze erreicht",
+      person: "Tagesgrenze",
+      cloud: "Monatsbudget",
+      reset: "Wieder verfügbar",
+      limits: "Grenzen ändern",
+      insert: "Stopp einfügen",
+      optimize: "Reihenfolge optimieren",
+      options: "Optionen",
+      along: "Unterwegs essen",
+      nav: "In Navi-App öffnen",
+      discard: "Verwerfen",
+      cancel: "Abbrechen",
+      preview: "Vorschau für",
+      undo: "Rückgängig",
+      before: "Bisher",
+      after: "Neu",
+      distance: "Strecke",
+      duration: "Fahrzeit",
+      choose: "Welcher Ort ist gemeint?",
+      useStop: "Als Stopp übernehmen",
+      stopSearch: "Ort nahe der Strecke suchen",
+      search: "Suchen",
+      category: "Kategorie",
+      placeName: "Ortsname (optional)",
+      placeNamePlaceholder: "z. B. Wasserfall",
+      waterfall: "Sehenswürdigkeiten",
+      cafe: "Cafés",
+      restaurant: "Restaurants",
+      whole: "Ganze Tour",
+      mode: "Verkehrsmittel",
+      car: "Auto",
+      bike: "Rad",
+      walk: "Zu Fuß",
+      avoid: "Meiden",
+      highways: "Autobahn",
+      tolls: "Maut",
+      ferries: "Fähren",
+      scope: "Gilt für",
+      calculate: "Vorschau berechnen",
+      prefs: "Geoapify meidet so gut es geht; garantiert ist es nicht.",
+      from: "Von km",
+      to: "Bis km",
+      corridor: "Abstand zur Strecke",
+      noRoute: "Keine befahrbare Strecke. Ändere einen Stopp oder die Optionen.",
+      noLocation: "Standort nicht erlaubt · im Browser freigeben",
+      locationFailed: "Standort nicht verfügbar. Gib einen Startort ein.",
+      start: "Startort",
+      go: "Route planen",
+      conflict: "Diese Karte wurde inzwischen geändert. Aktuellen Stand laden und die Änderung erneut wählen.",
+      reload: "Aktuellen Stand laden",
+      pending: "Wird gespeichert …",
+      changed: "Geändert",
+      stops: "Stopps",
+      noTraffic: "Zeiten ohne Verkehr, gerechnet",
+      resumeRoute: "Berechnung fortsetzen",
+      routeLimit:
+        "Diese Route benötigt mehr Credits als die eingestellte Grenze. Wähle weniger Stopps oder Adressvorschläge, oder lass das Budget durch einen Administrator erhöhen.",
+      budgetNumbers: ({ required, available, missing }) => `Benötigt: ${required} Credits. Verfügbar: ${available}. Fehlend: ${missing}.`,
+      recordedCosts: ({ settled, unknown }) => `Letzter Versuch: ${settled} Credits gebucht. Mit unklarem Ergebnis reserviert: ${unknown}.`,
+      noInvoiceCap: "Cloud reserviert geschätzte Kosten; Geoapify garantiert auf seiner Seite keine Obergrenze.",
+      cost: "Die Route war teurer als geschätzt. Die Berechnung wurde gestoppt. Beim Fortsetzen können weitere Kosten entstehen.",
+      notebook: "Notebook auswählen",
+      inspectNotebook: "Notebook prüfen",
+      noNotebooks: "Kein beschreibbares Notebook gefunden.",
+      saved: "Im Notebook gespeichert",
+      previousSave:
+        "Für diese Karte liegt ein früherer Speicherbeleg vor. Öffne das Notebook, um die Notiz zu finden, bevor du erneut speicherst.",
+      resumeSave: "Speichern fortsetzen",
+      reconcileSave: "Speicherstand prüfen",
+      partialNote: "Teilweise gespeicherte Notiz öffnen",
+      saveProgress: "Fortschritt beim Speichern der Karte",
+      saveLoading: "Speichern wird vorbereitet …",
+      saveCancelled: "Speichern gestoppt. Bereits gespeicherte Teile bleiben erhalten. Du kannst hier fortsetzen.",
+      savePaused: "Das Speichern ist noch nicht abgeschlossen. Beim Fortsetzen wird die Notiz geprüft.",
+      saveStorage:
+        "Der Fortschritt konnte in diesem Browser nicht gespeichert werden. Erlaube lokalen Speicher und versuche es erneut, bevor du fortsetzt.",
+      saveLockUnavailable:
+        "Dieser Browser kann das Speichern nicht über mehrere Tabs absichern. Verwende einen Browser mit Web-Locks-Unterstützung.",
+      saveLocked: "Diese Karte wird in einem anderen Tab gespeichert. Warte, bis er fertig ist, und prüfe erneut.",
+      saveOwnerChanged: "Das angemeldete Konto hat sich geändert. Lade die Seite vor dem Speichern neu.",
+      saveFailed: "Die Karte konnte nicht gespeichert werden. Versuche es erneut oder prüfe das Notebook.",
+      saveSourceChanged:
+        "Die Kartenquelle hat sich geändert. Lade die Karte neu. Öffne eine teilweise gespeicherte Notiz, bevor du erneut speicherst.",
+      saveContentChanged:
+        "Die Notiz hat sich geändert. Öffne sie, um deine Änderungen zu prüfen. Dieser Speichervorgang kann nicht fortgesetzt werden.",
+      saveInvalid:
+        "Der gespeicherte Fortschritt oder die Kartenquelle ist nicht verwendbar. Öffne das Notebook, um bereits gespeicherte Teile zu finden.",
+      saveTooLarge: "Der Kartentitel passt nicht in eine Speicheranfrage. Kürze ihn vor dem Speichern.",
+      saveAppendUnknown:
+        "Der letzte Teil wird möglicherweise noch gespeichert. Prüfe den Stand später erneut. Er wird nicht doppelt gesendet.",
+      unknownSave:
+        "Die Notiz wurde möglicherweise erstellt. Öffne das Notebook, um sie zu finden. Dieser Speichervorgang wird nicht erneut gesendet.",
+    },
+  },
+});
+
+export const mapMessages = (locale: string) => messages.resolve([locale]).t;
+
+/** Helper codes are internal; owning capabilities may supply a final human message. */
+export const mapSaveMessage = (locale: string, code?: string, message?: string): string => {
+  const t = mapMessages(locale);
+  switch (code) {
+    case "source_changed":
+      return t.saveSourceChanged;
+    case "checkpoint_failed":
+    case "persistence_failed":
+      return t.saveStorage;
+    case "content_changed":
+    case "note_moved":
+    case "unexpected_receipt":
+      return t.saveContentChanged;
+    case "invalid_checkpoint":
+    case "invalid_title":
+      return t.saveInvalid;
+    case "request_too_large":
+      return t.saveTooLarge;
+    case "create_outcome_unknown":
+      return t.unknownSave;
+    case "append_outcome_unknown":
+      return t.saveAppendUnknown;
+    case "cancelled":
+      return t.saveCancelled;
+    case "save_failed":
+      return t.saveFailed;
+    default:
+      return message || t.savePaused;
+  }
+};

package/src/ai/chat/map-notebook.browser-harness.tsx

@@ -0,0 +1,28 @@
+/** Focused save fixture: real controls and persistence without starting the map renderer. */
+import { Button, LocaleProvider, useLocale } from "@k2b/ui";
+import { createSignal, Show } from "solid-js";
+import { render } from "solid-js/web";
+import type { AiMap } from "../map-contracts";
+import { mapMessages } from "./map-messages";
+import { MapNotebookSave } from "./map-notebook";
+
+const snapshot: { map: AiMap } = JSON.parse(document.getElementById("snapshot")!.textContent!);
+function SaveFixture() {
+  const [saving, setSaving] = createSignal(false);
+  const locale = useLocale();
+  return (
+    <section class="ai-map">
+      <Show when={saving()} fallback={<Button onClick={() => setSaving(true)}>{mapMessages(locale()).save}</Button>}>
+        <MapNotebookSave map={snapshot.map} onCancel={() => setSaving(false)} />
+      </Show>
+    </section>
+  );
+}
+render(
+  () => (
+    <LocaleProvider locale={document.documentElement.lang}>
+      <SaveFixture />
+    </LocaleProvider>
+  ),
+  document.getElementById("fixture-mount")!,
+);