@k2b/cloud 0.45.0 → 0.46.0

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")!,
+);

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

@@ -0,0 +1,301 @@
+import { Button, ButtonLink, ProgressBar, Select, useLocale } from "@k2b/ui";
+import { createEffect, createSignal, onCleanup, onMount, Show } from "solid-js";
+import { z } from "zod";
+import { invokeCapabilityWithDataSchema } from "../../capabilities/client";
+import { cloudResourceHref } from "../../contracts/resource-href";
+import type { AiMap } from "../map-contracts";
+import { type MapNotebookSaveCheckpoint, MapNotebookSaveCheckpointSchema, saveMapNotebook } from "../map-notebook-save";
+import { mapMessages, mapSaveMessage } from "./map-messages";
+
+const notebooks = z.array(z.object({ id: z.string(), name: z.string() }));
+const legacySchema = z.object({
+  status: z.enum(["pending", "unknown", "saved"]),
+  notebookId: z.string().regex(/^[A-Za-z0-9]{6}$/),
+  href: z.string().optional(),
+});
+const snapshotSchema = z.object({ content: z.string(), revision: z.number().int(), ownerUserId: z.string().min(1) });
+const storedSchema = z
+  .object({
+    checkpoint: MapNotebookSaveCheckpointSchema,
+    writeId: z.uuid().optional(),
+    status: z.enum(["paused", "saved", "cancelled", "conflict", "unknown", "error"]),
+    code: z.string().optional(),
+    message: z.string().optional(),
+  })
+  .strict()
+  .refine(
+    (stored) =>
+      stored.status !== "saved" ||
+      Boolean(stored.checkpoint.noteId && !stored.checkpoint.pending && stored.checkpoint.completed === stored.checkpoint.total),
+  );
+
+export function MapNotebookSave(props: { map: AiMap; onCancel: () => void }) {
+  const source = { id: props.map.id, conversationId: props.map.conversationId, revision: props.map.revision };
+  const sourceChanged = () =>
+    props.map.id !== source.id || props.map.conversationId !== source.conversationId || props.map.revision !== source.revision;
+  const locale = useLocale();
+  const t = () => mapMessages(locale());
+  const [selected, setSelected] = createSignal<string | null>(null);
+  const [error, setError] = createSignal("");
+  const [busy, setBusy] = createSignal(false);
+  const [ready, setReady] = createSignal(false);
+  const [checkpoint, setCheckpoint] = createSignal<MapNotebookSaveCheckpoint>();
+  const [legacy, setLegacy] = createSignal(false);
+  const [status, setStatus] = createSignal<z.infer<typeof storedSchema>["status"]>();
+  let controller: AbortController | undefined;
+  let storageKey = "";
+  let sourceKey = "";
+  let unpersisted: z.infer<typeof storedSchema> | undefined;
+  let observedRaw: string | null = null;
+  let unpersistedBases: (string | null)[] = [];
+  const noteHref = () => (checkpoint()?.noteId ? cloudResourceHref({ type: "notebooks.note", id: checkpoint()!.noteId! }) : undefined);
+  const notebookHref = () => (selected() ? cloudResourceHref({ type: "notebooks.notebook", id: selected()! }) : undefined);
+  const unknownCreate = () => checkpoint()?.pending?.kind === "create";
+  const saved = () => status() === "saved" && !sourceChanged();
+  const failureMessage = (cause: unknown) =>
+    cause instanceof Error && !(cause instanceof z.ZodError) && !(cause instanceof SyntaxError) && !(cause instanceof TypeError)
+      ? cause.message
+      : t().saveFailed;
+  const snapshot = async (signal: AbortSignal) => {
+    const response = await fetch(`/api/ai/conversations/${encodeURIComponent(source.conversationId)}/maps/${source.id}/export`, {
+      signal,
+    });
+    if (!response.ok) throw new Error(t().saveFailed);
+    // WebKit can reject invalid JSON with a DOMException named SyntaxError,
+    // which is not instanceof SyntaxError. Normalize at the response boundary.
+    const payload: unknown = await response.json().catch(() => {
+      throw new Error(t().saveFailed);
+    });
+    const value = snapshotSchema.parse(payload);
+    if (value.revision !== source.revision) throw new Error(t().conflict);
+    return value;
+  };
+  const restore = () => {
+    // A failed write may have reached storage. Only replace our own observed values;
+    // a different receipt belongs to a later lock holder and always takes precedence.
+    // Each write has its own identity, even when two tabs begin with identical helper checkpoints.
+    const raw = localStorage.getItem(storageKey);
+    observedRaw = raw;
+    const pending = unpersisted && unpersistedBases.includes(raw) ? unpersisted : undefined;
+    if (!pending) {
+      unpersisted = undefined;
+      unpersistedBases = [];
+    }
+    if (raw === null && !pending) {
+      // The old flow used an unscoped session receipt and different create keys.
+      // Do not silently abandon it or attribute it to a new owner: recover in Notebook.
+      const previous = sessionStorage.getItem(`cloud.ai.map-save:${source.id}:${source.revision}`);
+      if (previous !== null) {
+        const value = legacySchema.parse(JSON.parse(previous));
+        setSelected(value.notebookId);
+        setLegacy(true);
+        setError(t().previousSave);
+      }
+      return;
+    }
+    const stored = pending ?? storedSchema.parse(JSON.parse(raw!));
+    if (stored.checkpoint.sourceKey !== sourceKey) throw new Error(t().saveStorage);
+    setCheckpoint(stored.checkpoint);
+    setSelected(stored.checkpoint.notebookId);
+    setStatus(stored.status);
+    if (stored.status !== "saved")
+      setError(stored.checkpoint.pending?.kind === "create" ? t().unknownSave : mapSaveMessage(locale(), stored.code, stored.message));
+  };
+  const persist = (next: MapNotebookSaveCheckpoint, state: z.infer<typeof storedSchema>["status"], code?: string, message?: string) => {
+    setCheckpoint(next);
+    setSelected(next.notebookId);
+    if (!unpersisted) unpersistedBases = [observedRaw];
+    unpersisted = { checkpoint: next, writeId: crypto.randomUUID(), status: state, code, message };
+    const serialized = JSON.stringify(unpersisted);
+    const before = localStorage.getItem(storageKey);
+    unpersistedBases = [before, serialized];
+    localStorage.setItem(storageKey, serialized);
+    observedRaw = serialized;
+    unpersisted = undefined;
+    unpersistedBases = [];
+  };
+  const initialize = async () => {
+    if (busy()) return;
+    setBusy(true);
+    setError("");
+    controller = new AbortController();
+    try {
+      const value = await snapshot(controller.signal);
+      // Identity comes from the authorized export, never from a browser account hint.
+      const nextSourceKey = JSON.stringify([value.ownerUserId, source.conversationId, source.id, source.revision]);
+      if (sourceKey && nextSourceKey !== sourceKey) throw new Error(t().saveOwnerChanged);
+      sourceKey = nextSourceKey;
+      storageKey = `cloud.ai.map-save:v1:${sourceKey}`;
+      try {
+        restore();
+      } catch {
+        throw new Error(t().saveStorage);
+      }
+      if (!navigator.locks) throw new Error(t().saveLockUnavailable);
+      setReady(true);
+    } catch (cause) {
+      setError(controller.signal.aborted ? t().saveCancelled : failureMessage(cause));
+    } finally {
+      setBusy(false);
+    }
+  };
+  createEffect(() => {
+    if (sourceChanged()) controller?.abort();
+  });
+  onMount(() => void initialize());
+  onCleanup(() => controller?.abort());
+  const save = async () => {
+    if (sourceChanged() || !ready() || !selected() || busy() || legacy() || saved() || unknownCreate() || status() === "conflict") return;
+    setBusy(true);
+    setError("");
+    controller = new AbortController();
+    const signal = controller.signal;
+    try {
+      await navigator.locks.request(storageKey, { ifAvailable: true }, async (lock) => {
+        if (!lock) {
+          setError(t().saveLocked);
+          return;
+        }
+        // Another tab may have advanced or completed this save since the panel opened.
+        try {
+          restore();
+          if (unpersisted) persist(unpersisted.checkpoint, unpersisted.status, unpersisted.code, unpersisted.message);
+        } catch {
+          setReady(false);
+          throw new Error(t().saveStorage);
+        }
+        if (legacy() || saved() || unknownCreate() || status() === "conflict") return;
+        setError("");
+        const value = await snapshot(signal);
+        if (JSON.stringify([value.ownerUserId, source.conversationId, source.id, value.revision]) !== sourceKey)
+          throw new Error(t().saveOwnerChanged);
+        let persistenceFailed = false;
+        const result = await saveMapNotebook({
+          content: value.content,
+          notebookId: selected()!,
+          sourceKey,
+          checkpoint: checkpoint(),
+          signal,
+          onCheckpoint: (next) => {
+            try {
+              persist(next, "paused");
+            } catch {
+              persistenceFailed = true;
+              throw new Error(t().saveStorage);
+            }
+          },
+        });
+        setCheckpoint(result.checkpoint);
+        setStatus(result.status);
+        setError(
+          persistenceFailed
+            ? t().saveStorage
+            : result.status === "saved"
+              ? ""
+              : result.checkpoint?.pending?.kind === "create"
+                ? t().unknownSave
+                : result.status === "cancelled"
+                  ? t().saveCancelled
+                  : mapSaveMessage(locale(), result.code, result.message),
+        );
+        if (result.checkpoint) {
+          try {
+            persist(
+              result.checkpoint,
+              result.status,
+              persistenceFailed ? "persistence_failed" : result.status === "cancelled" ? "cancelled" : result.code,
+              persistenceFailed ? undefined : result.message,
+            );
+          } catch {
+            setStatus("error");
+            setError(t().saveStorage);
+          }
+        }
+      });
+    } catch (cause) {
+      setError(signal.aborted ? t().saveCancelled : failureMessage(cause));
+    } finally {
+      setBusy(false);
+    }
+  };
+  const action = () =>
+    unknownCreate() ? t().save : checkpoint() ? (checkpoint()?.pending ? t().reconcileSave : t().resumeSave) : t().save;
+  return (
+    <div class="ai-map__save">
+      <Show
+        when={!saved()}
+        fallback={
+          <div role="status">
+            <ButtonLink href={noteHref()!} variant="ghost">
+              {t().saved}
+            </ButtonLink>
+          </div>
+        }
+      >
+        <Select
+          label={t().notebook}
+          value={selected()}
+          onValueChange={setSelected}
+          disabled={sourceChanged() || !ready() || busy() || legacy() || Boolean(checkpoint())}
+          loadOptions={async (query, signal) => {
+            const result = await invokeCapabilityWithDataSchema(
+              {
+                kind: "query",
+                appId: "notebooks",
+                capabilityId: "notebook.list",
+                input: { query, minimumPermission: "write", limit: 100 },
+                signal,
+              },
+              notebooks,
+            );
+            if (!result.ok) throw new Error(result.error.message);
+            return result.data.data.map((n) => ({ value: n.id, label: n.name }));
+          }}
+        />
+        <Show when={checkpoint()}>
+          <div role="status" aria-live="polite">
+            <ProgressBar
+              label={t().saveProgress}
+              value={checkpoint()!.total ? (checkpoint()!.completed / checkpoint()!.total) * 100 : 0}
+              showValue
+            />
+          </div>
+        </Show>
+        <div class="ai-map__actions">
+          <Show
+            when={ready()}
+            fallback={
+              <Button size="sm" disabled={busy() || sourceChanged()} onClick={() => void initialize()}>
+                {busy() ? t().saveLoading : t().retry}
+              </Button>
+            }
+          >
+            <Button
+              size="sm"
+              disabled={sourceChanged() || !selected() || busy() || legacy() || unknownCreate() || status() === "conflict"}
+              onClick={() => void save()}
+            >
+              {busy() ? t().pending : action()}
+            </Button>
+          </Show>
+          <Button size="sm" variant="ghost" onClick={() => (busy() ? controller?.abort() : props.onCancel())}>
+            {t().cancel}
+          </Button>
+        </div>
+      </Show>
+      <Show when={sourceChanged() || error()}>
+        <p role="alert">{sourceChanged() ? t().saveSourceChanged : error()}</p>
+      </Show>
+      <Show when={noteHref() && !saved()}>
+        <ButtonLink size="sm" variant="ghost" href={noteHref()!}>
+          {t().partialNote}
+        </ButtonLink>
+      </Show>
+      <Show when={notebookHref() && (checkpoint() || legacy()) && !saved()}>
+        <ButtonLink size="sm" variant="ghost" href={notebookHref()!}>
+          {t().inspectNotebook}
+        </ButtonLink>
+      </Show>
+    </div>
+  );
+}

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

@@ -0,0 +1,71 @@
+import { LocaleProvider } from "@k2b/ui";
+import { createMemo, createSignal, For } from "solid-js";
+import { render } from "solid-js/web";
+import type { AiMap, AiMapCommand, AiMapToolResult } from "../map-contracts";
+import type { AiTurnBlock } from "../protocol";
+import { AiReaderTimeZoneProvider } from "./action-sentences";
+import { AiChatActionsProvider } from "./presentation";
+import { createAiToolDisclosureState } from "./tool-disclosure";
+import { layoutAiTurn } from "./turn-layout";
+import { AiTurnView } from "./turn-view";
+
+const snapshot: { map: AiMap; followups: AiMapToolResult[] } = JSON.parse(document.getElementById("snapshot")!.textContent!);
+const initial = snapshot.map;
+const block = (map: unknown, anchor: boolean, id = "original"): AiTurnBlock => ({
+  kind: "tool",
+  id,
+  callId: id,
+  name: "map",
+  status: initial.pending ? "running" : "completed",
+  args: {},
+  result: { map, anchor },
+});
+const text = (id: string, followup = false): AiTurnBlock => ({
+  kind: "text",
+  id,
+  text: followup
+    ? "Ich habe dieselbe Karte ergänzt. Deine bisherigen Antworten bleiben erhalten."
+    : "Hier sind die verifizierten Orte. Die Namen und die Karte sind fiktive Testdaten.",
+});
+const [turns, setTurns] = createSignal<AiTurnBlock[][]>([
+  [block(initial, true), text("answer")],
+  ...snapshot.followups.map((result, i) => [block(result.map, false, `followup-${i + 1}`), text(`followup-text-${i + 1}`, true)]),
+]);
+const mount = document.getElementById("fixture-mount")!;
+Object.assign(window, {
+  mapFollowup: async (command: AiMapCommand) => {
+    const response = await fetch(`/fixtures/${initial.conversationId}/followup`, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(command),
+    });
+    if (!response.ok) throw new Error("FIXTURE_FOLLOWUP_FAILED");
+    const result: AiMapToolResult = await response.json();
+    setTurns([...turns(), [block(result.map, false, `followup-${turns().length}`), text(`followup-text-${turns().length}`, true)]]);
+  },
+});
+mount.replaceChildren();
+render(
+  () => (
+    <LocaleProvider locale={document.documentElement.lang}>
+      <AiReaderTimeZoneProvider value="Europe/Berlin">
+        <AiChatActionsProvider actions={{}}>
+          <For each={turns()}>
+            {(blocks) => {
+              const segment = createMemo(() => ({
+                id: blocks[0]!.id,
+                turnId: blocks[0]!.id,
+                phase: "completed" as const,
+                layout: layoutAiTurn(blocks, { phase: "completed" }),
+                earlier: false,
+                duration: () => null,
+              }));
+              return <AiTurnView segment={segment} disclosureState={createAiToolDisclosureState()} />;
+            }}
+          </For>
+        </AiChatActionsProvider>
+      </AiReaderTimeZoneProvider>
+    </LocaleProvider>
+  ),
+  mount,
+);