@aparte/core 0.16.10 → 0.17.0

package/dist/{dialog-triggers-cYGTlfZf.js → dialog-triggers-Bb-3EkT4.js}

@@ -147,6 +147,8 @@ const APARTE_DEFAULT_LOCALE = {
   rejectTool: "Reject",
   messageInfo: "Details",
   newChat: "New Chat",
+  loadingConversations: "Loading conversations",
+  loadingConversation: "Loading the conversation",
   deleteConversation: "Delete",
   archiveConversation: "Archive",
   unarchiveConversation: "Unarchive",
@@ -165,8 +167,7 @@ const APARTE_DEFAULT_LOCALE = {
   scrollRailLabel: "Conversation outline",
   sidebarLabel: "Conversations",
   splitHandleLabel: "Resize the panes",
-  transcript: "Transcript",
-  direction: "ltr"
+  transcript: "Transcript"
 };
 function isFormatAdapter(p) {
   return typeof p.buildRequest === "function" && typeof p.parseStream === "function" && typeof p.defaultEndpoint === "string" && (typeof p.authHeaders === "function" || typeof p.authQuery === "function");
@@ -982,7 +983,7 @@ const ALLOWED_TAGS = /* @__PURE__ */ new Set([
   "picture",
   "source",
   "input",
-  // GFM task-list checkboxes only (attributes locked down below)
+  // GFM task-list checkboxes only — `copyAttributes` refuses every other `type`
   "abbr",
   "details",
   "summary",
@@ -1086,6 +1087,7 @@ function copyAttributes(src, dest, tag) {
     if (name.startsWith("on") || name.startsWith("formaction")) continue;
     if (!name.startsWith("data-") && !GLOBAL_ATTRS.has(name) && !(extra && extra.has(name))) continue;
     if (URL_ATTRS.has(name) && !isSafeUrl(value, tag)) continue;
+    if (tag === "input" && name === "type" && value.toLowerCase() !== "checkbox") continue;
     if (name === "srcset" && !isSafeSrcset(value, tag)) continue;
     if (name === "style") {
       const scrubbed = scrubStyle(value);
@@ -1233,6 +1235,11 @@ class AparteConfig {
   _iconProvider;
   _avatarProvider;
   _keyProvider;
+  /**
+   * Sources added with `registerKeyProvider` — consulted before `_keyProvider`,
+   * newest first (see `getKey`).
+   */
+  _extraKeyProviders = /* @__PURE__ */ new Set();
   _locale = APARTE_DEFAULT_LOCALE;
   _actions = [];
   _listeners = /* @__PURE__ */ new Set();
@@ -1307,7 +1314,7 @@ class AparteConfig {
    * (soon) the tool-approval gate. A custom presenter registered by a consumer gets
    * the same protection for free, which it previously had none of.
    */
-  _elicitationQueue = null;
+  _elicitationQueue = /* @__PURE__ */ new Map();
   // Tool Registry
   _tools = /* @__PURE__ */ new Map();
   _toolRenderers = /* @__PURE__ */ new Map();
@@ -1323,9 +1330,10 @@ class AparteConfig {
   // Provider Setters (Dependency Injection)
   // ─────────────────────────────────────────────────────────────────────────
   /**
-   * Register a custom action button. `zones` places it in the composer toolbar
-   * and/or the message (bubble) toolbar. Re-registering the same id overwrites
-   * it. Notifies mounted elements so they re-render.
+   * Register a custom action button. `zones` places it in the message (bubble)
+   * toolbar. Re-registering the same id overwrites it. Notifies mounted elements
+   * so they re-render. A button in the composer is an `<aparte-composer-action>`
+   * element you write in your markup, not a registry entry.
    */
   registerAction(action) {
     const existing = this._actions.findIndex((a) => a.id === action.id);
@@ -1347,17 +1355,6 @@ class AparteConfig {
     this._actions = this._actions.filter((a) => a.id !== id);
     if (this._actions.length !== before) this._notify();
   }
-  /**
-   * Show or hide a composer action button by id.
-   * Triggers a config update so all mounted composer elements react immediately.
-   */
-  setActionHidden(id, hidden) {
-    const action = this._actions.find((a) => a.id === id);
-    if (action) {
-      action.composer = { ...action.composer, hidden };
-      this._notify();
-    }
-  }
   /**
    * Configure which action buttons appear in message bubbles.
    * Unset keys keep their defaults — see {@link APARTE_DEFAULT_BUBBLE_ACTIONS}: `copy`
@@ -1418,8 +1415,11 @@ class AparteConfig {
    * Set an incremental (streaming) Markdown renderer provider. Optional —
    * when set, the chat bubble uses it to render the assistant message
    * token-by-token DURING streaming (incremental parse + DOM append, O(n)),
-   * instead of re-parsing the whole string on every token. The one-shot
-   * `setMarkdownProvider` is still used for finished / re-rendered messages.
+   * instead of re-parsing the whole string on every token. When the turn ends,
+   * a registered one-shot `setMarkdownProvider` re-renders the finished message
+   * at full fidelity; with no one-shot provider registered, what the streaming
+   * renderer drew is kept (sanitised), rather than replaced by the built-in
+   * escape-and-line-break fallback.
    */
   setStreamingMarkdownProvider(fn) {
     this._streamingMarkdownProvider = fn;
@@ -1676,11 +1676,57 @@ class AparteConfig {
     this._keyProvider = provider;
   }
   /**
-   * Get API key for a provider
+   * Add a key source, without replacing the one `setKeyProvider` holds. Returns a
+   * teardown.
+   *
+   * This is how `AparteClient({ keyResolver })` — the channel the docs teach as
+   * primary — reaches everything that needs a key rather than the chat alone. It
+   * used to reach the chat ONLY, so the model selector, whose one data path is
+   * `refreshProviderModels`, showed an empty list on every cloud provider while
+   * the chat worked: `fetchModels` returns `[]` without a key, so there was
+   * nothing to see and nothing said.
+   *
+   * The direction matters (decision #9): the client registers a source ON the
+   * config, so the capability is never hostage to the client — a page that only
+   * ever calls `setKeyProvider` is unchanged, and a page that constructs no
+   * client at all still lists models.
+   *
+   * Every call is its own source, even when the same function is handed in
+   * twice: two panes sharing one module-level resolver are two mounts, and the
+   * first one to unmount must not take the second one's key with it. A `Set`
+   * keyed by the function itself made them one entry, which either teardown
+   * removed.
+   */
+  registerKeyProvider(provider) {
+    const entry = (providerId) => provider(providerId);
+    this._extraKeyProviders.add(entry);
+    return () => {
+      this._extraKeyProviders.delete(entry);
+    };
+  }
+  /**
+   * The credentials for a provider: a key, or the `{ apiKey, endpoint }` record
+   * the transport and `fetchModels` both read.
+   *
+   * ONE resolution order, so the chat and the model list cannot disagree about
+   * what an endpoint is: a registered resolver (`AparteClient`'s `keyResolver`)
+   * first — which is the precedence the client has always documented — then
+   * `setKeyProvider`.
+   *
+   * Registered sources answer NEWEST first. A page that mounts a second chat, or
+   * remounts one to swap its options — the swap the wrappers document — leaves
+   * more than one source here, and insertion order made the first resolver the
+   * page ever registered answer for every later one, so the key could not be
+   * changed. The snapshot is deliberate too: a source torn down while an earlier
+   * one is being awaited must not shift the iteration underneath it.
    */
   async getKey(providerId) {
+    for (const provider of [...this._extraKeyProviders].reverse()) {
+      const resolved = await provider(providerId);
+      if (resolved) return resolved;
+    }
     if (this._keyProvider) {
-      return await this._keyProvider(providerId);
+      return await this._keyProvider(providerId) || void 0;
     }
     return void 0;
   }
@@ -1693,8 +1739,8 @@ class AparteConfig {
     const provider = this._aiProviders.get(providerId);
     if (!provider || !provider.fetchModels) return [];
     try {
-      const apiKey = await this.getKey(providerId);
-      const models = await provider.fetchModels(apiKey);
+      const auth = await this.getKey(providerId);
+      const models = await provider.fetchModels(auth);
       this._fetchedModels.set(providerId, models);
       return models;
     } catch (error) {
@@ -2064,6 +2110,13 @@ class AparteConfig {
    * Controls what appears in the chat bubble when the AI calls this tool.
    * Use this instead of the generic `tool_call` segment renderer for tool-specific UI.
    *
+   * A renderer that needs a popover (a `<aparte-select>`, a menu) cannot open one
+   * inside the row: the bubble is `content-visibility: auto`, which makes it the
+   * containing block for `position: fixed` descendants and clips a popover to its
+   * own box. Mount it on `document.body` and position it from the trigger's rect
+   * instead — see [Custom tool
+   * renderer](https://apartejs.dev/guides/tools/#custom-tool-renderer).
+   *
    * @example
    * // Hide the segment entirely (UI-only tool like ask_user)
    * aparteGlobalConfig.registerToolRenderer('ask_user', { render: () => '' });
@@ -2257,17 +2310,32 @@ class AparteConfig {
    * "installs itself — nothing to register", which is how that was found.
    */
   requestUserInput(request) {
-    const previous = this._elicitationQueue;
-    const settled = previous === null ? this._present(request) : previous.then(
+    const queue = this._elicitationQueueKey(request);
+    const previous = this._elicitationQueue.get(queue);
+    const settled = previous === void 0 ? this._present(request) : previous.then(
       () => this._present(request),
       () => this._present(request)
     );
     const mine = settled.then(NOOP, NOOP).then(() => {
-      if (this._elicitationQueue === mine) this._elicitationQueue = null;
+      if (this._elicitationQueue.get(queue) === mine) this._elicitationQueue.delete(queue);
     });
-    this._elicitationQueue = mine;
+    this._elicitationQueue.set(queue, mine);
     return settled;
   }
+  /**
+   * Which queue a request waits in: its own chat's.
+   *
+   * The wait exists so a second question cannot take the panel away from the one on
+   * screen — a property of ONE panel, and `_present` routes by target, so a chat is
+   * the right unit. It used to be one queue for the whole config: two chats on the
+   * global config shared it, and an approval waiting for an answer in the first (which
+   * is all an approval does) held the second's question behind it for ever, with
+   * nothing on screen to answer. Requests that name no chat keep sharing the `null`
+   * queue, because they all reach the same presenter — the top of the stack.
+   */
+  _elicitationQueueKey(request) {
+    return chatBoundaryOf(request.target);
+  }
   /** Hand ONE request to the presenter. Called only from the queue. */
   _present(request) {
     const presenter = this._presenterFor(request.target);
@@ -2306,7 +2374,7 @@ class AparteConfig {
     this._keyProvider = void 0;
     this._conversationManager = void 0;
     this._elicitationPresenters = [];
-    this._elicitationQueue = null;
+    this._elicitationQueue.clear();
     this._locale = APARTE_DEFAULT_LOCALE;
     this._actions = [];
     this._sanitizer = defaultSanitizer;
@@ -2399,6 +2467,10 @@ function subscribeConfigChange(el2, handler) {
   window.addEventListener(APARTE_CONFIG_CHANGE, listener);
   return () => window.removeEventListener(APARTE_CONFIG_CHANGE, listener);
 }
+const ONE_SHOT_PROBE = "<i>a</i>";
+function hasOneShotMarkdownProvider() {
+  return contextConfig().renderMarkdown(ONE_SHOT_PROBE) !== escapeHtml(ONE_SHOT_PROBE);
+}
 function writeStreamedMarkdown(host, contentEl, content, streaming) {
   if (streaming) {
     if (host._aparteSmd === void 0) {
@@ -2420,8 +2492,18 @@ function writeStreamedMarkdown(host, contentEl, content, streaming) {
       return;
     }
   } else if (host._aparteSmd) {
-    host._aparteSmd.renderer.end();
+    const smd = host._aparteSmd;
+    const tail = content.slice(smd.written);
+    if (tail) {
+      smd.renderer.write(tail);
+      smd.written = content.length;
+    }
+    smd.renderer.end();
     host._aparteSmd = void 0;
+    if (!hasOneShotMarkdownProvider()) {
+      contentEl.innerHTML = contextConfig().sanitizeHtml(contentEl.innerHTML);
+      return;
+    }
   }
   contentEl.innerHTML = contextConfig().renderMarkdown(content);
 }
@@ -3115,6 +3197,7 @@ function populateBubbleFromMessage(bubble, message, siblingInfo) {
   }
 }
 const APARTE_CONVERSATION_SCHEMA_VERSION = 2;
+const APARTE_DERIVED_SEGMENTS = Symbol.for("aparte.derivedSegments");
 function applyRetention(messages, tree, maxMessages) {
   if (maxMessages <= 0 || messages.length <= maxMessages) return { messages, tree };
   const trimmedFlat = messages.slice(messages.length - maxMessages);
@@ -3144,6 +3227,20 @@ function applyRetention(messages, tree, maxMessages) {
   };
   return { messages: trimmedFlat, tree: trimmedTree };
 }
+function withoutDerived(message) {
+  if (!message[APARTE_DERIVED_SEGMENTS]) return message;
+  const { segments: _derived, ...rest } = message;
+  return rest;
+}
+function withoutDerivedSegments(messages) {
+  return messages.map(withoutDerived);
+}
+function withoutDerivedTree(tree) {
+  return {
+    ...tree,
+    messages: tree.messages.map((entry) => ({ ...entry, message: withoutDerived(entry.message) }))
+  };
+}
 class AparteConversationManager {
   _adapter;
   _conversations = [];
@@ -3152,6 +3249,14 @@ class AparteConversationManager {
   _initialized = false;
   _retention = null;
   _titleProvider = null;
+  /** Ids whose messages are in memory. Every id, after a loadAll(); only fetched ones after loadMeta(). */
+  _loaded = /* @__PURE__ */ new Set();
+  /** One fetch per id at a time: a second ensureFull(id) while the first is in flight joins it. */
+  _fetching = /* @__PURE__ */ new Map();
+  /** One append per id at a time: the next addMessage(id) reads what the previous one wrote. */
+  _appending = /* @__PURE__ */ new Map();
+  /** The list on its way: a conversation created meanwhile waits for it, or the list would replace it. */
+  _initPromise = null;
   constructor(adapter, options) {
     this._adapter = adapter;
     this._retention = options?.retention ?? null;
@@ -3171,11 +3276,86 @@ class AparteConversationManager {
     return this._titleProvider;
   }
   // ─── Initialisation ────────────────────────────────────────────────────
-  /** Load all conversations from the adapter. Call once at app startup. */
+  /**
+   * Load all conversations from the adapter. Call once at app startup.
+   *
+   * A later call re-reads the list from the store: rows it no longer lists are
+   * dropped, and a conversation whose messages are already in memory keeps them —
+   * so the one on screen goes on being persisted.
+   */
   async init() {
-    this._conversations = await this._adapter.loadAll();
-    this._initialized = true;
-    this._notify();
+    const load = (async () => {
+      const split = !!(this._adapter.loadMeta && this._adapter.loadFull);
+      if (this._adapter.loadMeta && !this._adapter.loadFull) {
+        console.warn("[AparteConversationManager] the adapter lists through loadMeta() but has no loadFull(): everything is loaded through loadAll() instead.");
+      }
+      const held = new Map(this._conversations.filter((c) => this._loaded.has(c.id)).map((c) => [c.id, c]));
+      this._loaded.clear();
+      const rows = split ? (await this._adapter.loadMeta()).map((m) => {
+        const kept = held.get(m.id);
+        return kept ? { ...m, messages: kept.messages, ...kept.tree ? { tree: kept.tree } : {} } : { ...m, messages: [] };
+      }) : (await this._adapter.loadAll()).map((c) => ({ ...c, messages: c.messages ?? [] }));
+      const seen = /* @__PURE__ */ new Set();
+      const unique = rows.filter((c) => !seen.has(c.id) && (seen.add(c.id), true));
+      if (unique.length !== rows.length) {
+        console.warn(`[AparteConversationManager] ${rows.length - unique.length} repeated id(s) in the list; the first row wins.`);
+      }
+      this._conversations = unique;
+      for (const c of unique) if (!split || held.has(c.id)) this._loaded.add(c.id);
+      this._initialized = true;
+      this._notify();
+    })();
+    this._initPromise = load;
+    try {
+      await load;
+    } finally {
+      if (this._initPromise === load) this._initPromise = null;
+    }
+  }
+  /** Whether a conversation's messages are in memory (always, without split storage). */
+  isLoaded(id) {
+    return this._loaded.has(id);
+  }
+  /**
+   * Fetch a conversation's messages through the adapter's loadFull(), the first time
+   * they are needed; later calls resolve at once. The row keeps its place and its meta;
+   * the messages (and the tree) come from the full record, and a message written to
+   * the row while the fetch ran goes after them. Resolves `false` when the store has no
+   * such record (or answers with another id) — the row is then NOT loaded, and says so,
+   * rather than counting as an empty conversation.
+   */
+  async ensureFull(id) {
+    if (this._loaded.has(id)) return true;
+    if (!this._adapter.loadFull) return false;
+    const inFlight = this._fetching.get(id);
+    if (inFlight) return inFlight;
+    const fetch2 = (async () => {
+      const full = await this._adapter.loadFull(id);
+      const row = this._find(id);
+      if (!row || !full) return false;
+      if (full.id !== id) {
+        console.warn(`[AparteConversationManager] loadFull('${id}') answered with '${full.id}': ignored.`);
+        return false;
+      }
+      this._replace({ ...row, ...full, id, messages: full.messages ?? [] });
+      this._loaded.add(id);
+      this._notify();
+      return true;
+    })().finally(() => this._fetching.delete(id));
+    this._fetching.set(id, fetch2);
+    return fetch2;
+  }
+  /**
+   * The row with its messages in memory — fetched first when they are not, so a
+   * metadata change never writes a row back without them. `null` when the id is
+   * unknown or the store has no record to fetch.
+   */
+  async _full(id) {
+    if (!this._loaded.has(id) && this._adapter.loadFull) {
+      const loaded = await this.ensureFull(id);
+      if (!loaded) return null;
+    }
+    return this._find(id) ?? null;
   }
   /**
    * Whether `init()` has completed at least once. Consumers use this to
@@ -3207,8 +3387,12 @@ class AparteConversationManager {
     return this._conversations.filter((c) => !!c.archivedAt).sort((a, b) => b.updatedAt - a.updatedAt);
   }
   // ─── Mutations ──────────────────────────────────────────────────────────
-  /** Create a new empty conversation, persist it, and make it active. */
-  async createNew(title = "New Chat") {
+  /**
+   * Create a new empty conversation, persist it, and make it active. Untitled by
+   * default: the list shows its locale's `newChat` word for an empty title, so the
+   * store never carries an English string a French UI would then display.
+   */
+  async createNew(title = "") {
     const now = Date.now();
     const conv = {
       id: uuid(),
@@ -3218,9 +3402,16 @@ class AparteConversationManager {
       messages: [],
       schemaVersion: APARTE_CONVERSATION_SCHEMA_VERSION
     };
-    this._conversations = [conv, ...this._conversations];
     this._activeId = conv.id;
-    await this._adapter.save(conv);
+    this._loaded.add(conv.id);
+    if (this._initPromise) await this._initPromise.catch(() => {
+    });
+    this._conversations = [conv, ...this._conversations];
+    try {
+      await this._adapter.save(conv);
+    } catch (err) {
+      console.warn("[AparteConversationManager] save() failed for a new conversation; it stays in memory and the next write retries.", err);
+    }
     this._notify();
     return conv;
   }
@@ -3235,17 +3426,41 @@ class AparteConversationManager {
     this._activeId = null;
     this._notify();
   }
-  /** Append a message to a conversation. Auto-generates title from first user message. */
+  /**
+   * Append a message to a conversation. Auto-generates title from first user message.
+   *
+   * One append at a time per conversation: two sends that overlap (a suggestion and a
+   * quick type, coalesced into one new conversation) both suspend before reading the
+   * record — for the messages, then for the title provider — so both used to read a
+   * conversation with no user message in it yet, and the second one's text became the
+   * title.
+   */
   async addMessage(convId, msg) {
-    const conv = this._find(convId);
+    const previous = this._appending.get(convId);
+    const run = previous ? previous.then(() => this._append(convId, msg)) : this._append(convId, msg);
+    const tail = run.catch(() => {
+    });
+    this._appending.set(convId, tail);
+    void tail.then(() => {
+      if (this._appending.get(convId) === tail) this._appending.delete(convId);
+    });
+    return run;
+  }
+  async _append(convId, msg) {
+    const conv = await this._full(convId);
     if (!conv) return;
     const isFirstUserMsg = msg.role === "user" && conv.messages.every((m) => m.role !== "user");
+    const title = isFirstUserMsg ? await this._title(msg) : null;
+    const fresh = this._find(convId);
+    if (!fresh) return;
+    const present = fresh.messages.some((m) => m.id === msg.id);
     const updated = {
-      ...conv,
-      messages: [...conv.messages, msg],
+      ...fresh,
+      messages: present ? fresh.messages : [...fresh.messages, msg],
       updatedAt: Date.now(),
-      title: isFirstUserMsg ? await this._title(msg) : conv.title
+      title: title ?? fresh.title
     };
+    if (isFirstUserMsg) updated.autoTitle = true;
     this._replace(updated);
     await this._adapter.save(updated);
     this._notify();
@@ -3258,20 +3473,44 @@ class AparteConversationManager {
   async updateMessages(convId, messages, tree) {
     const conv = this._find(convId);
     if (!conv) return;
+    if (!this._loaded.has(convId)) {
+      console.warn(`[AparteConversationManager] updateMessages('${convId}') before its messages were loaded: ignored.`);
+      return;
+    }
+    const firstUser = messages.find((m) => m.role === "user");
     if (this._retention) {
       ({ messages, tree } = applyRetention(messages, tree, this._retention.maxMessages));
     }
+    const storedMessages = withoutDerivedSegments(messages);
+    const storedTree = tree === void 0 ? void 0 : withoutDerivedTree(tree);
     let contentChanged = true;
+    let treeChanged = tree !== void 0;
     try {
-      contentChanged = JSON.stringify(messages) !== JSON.stringify(conv.messages);
+      contentChanged = JSON.stringify(storedMessages) !== JSON.stringify(withoutDerivedSegments(conv.messages));
+      if (storedTree !== void 0) treeChanged = JSON.stringify(storedTree) !== JSON.stringify(conv.tree);
     } catch {
     }
+    let title;
+    if (conv.autoTitle) {
+      const before = conv.messages.find((m) => m.role === "user");
+      if (firstUser && (firstUser.content ?? "") !== (before?.content ?? "")) {
+        title = await this._title(firstUser);
+      }
+    }
+    if (!contentChanged && !treeChanged && title === void 0) return;
+    const fresh = this._find(convId);
+    if (!fresh) return;
     const updated = {
-      ...conv,
-      messages,
-      updatedAt: contentChanged ? Date.now() : conv.updatedAt
+      ...fresh,
+      // What is stored is what the caller sent: segments a viewport DERIVED on
+      // display are not the app's content. Stored, they would fill the record with
+      // core-generated ids and freeze the parse as it stood the day it was saved —
+      // a block grammar registered later would never apply to that message.
+      messages: storedMessages,
+      updatedAt: contentChanged ? Date.now() : fresh.updatedAt
     };
-    if (tree !== void 0) updated.tree = tree;
+    if (storedTree !== void 0) updated.tree = storedTree;
+    if (title !== void 0) updated.title = title;
     this._replace(updated);
     await this._adapter.save(updated);
     this._notify();
@@ -3279,35 +3518,41 @@ class AparteConversationManager {
   /** Permanently delete a conversation. */
   async delete(id) {
     this._conversations = this._conversations.filter((c) => c.id !== id);
+    this._loaded.delete(id);
     if (this._activeId === id) this._activeId = null;
     await this._adapter.delete(id);
     this._notify();
   }
   /** Archive a conversation (soft-delete). */
   async archive(id) {
-    const conv = this._find(id);
-    if (!conv) return;
-    const updated = { ...conv, archivedAt: Date.now() };
-    this._replace(updated);
-    if (this._adapter.archive) {
-      await this._adapter.archive(id);
-    } else {
-      await this._adapter.save(updated);
-    }
+    if (!await this._meta(id, (conv) => ({ ...conv, archivedAt: Date.now() }), this._adapter.archive)) return;
     if (this._activeId === id) this._activeId = null;
     this._notify();
   }
+  /**
+   * A metadata change, through the adapter's own hook when it has one (the row is
+   * updated in memory, nothing else travels), else through `save()` — with the
+   * messages fetched first, so a row the list came with (`messages: []`) is never
+   * written back over the stored ones.
+   */
+  async _meta(id, change, hook) {
+    if (hook) {
+      const conv2 = this._find(id);
+      if (!conv2) return false;
+      this._replace(change(conv2));
+      await hook.call(this._adapter, id);
+      return true;
+    }
+    const conv = await this._full(id);
+    if (!conv) return false;
+    const updated = change(conv);
+    this._replace(updated);
+    await this._adapter.save(updated);
+    return true;
+  }
   /** Restore an archived conversation. */
   async unarchive(id) {
-    const conv = this._find(id);
-    if (!conv) return;
-    const updated = { ...conv, archivedAt: void 0 };
-    this._replace(updated);
-    if (this._adapter.unarchive) {
-      await this._adapter.unarchive(id);
-    } else {
-      await this._adapter.save(updated);
-    }
+    if (!await this._meta(id, (conv) => ({ ...conv, archivedAt: void 0 }), this._adapter.unarchive)) return;
     this._notify();
   }
   /**
@@ -3317,28 +3562,12 @@ class AparteConversationManager {
    * does not gets the whole record through `save()`.
    */
   async pin(id) {
-    const conv = this._find(id);
-    if (!conv) return;
-    const updated = { ...conv, pinnedAt: Date.now() };
-    this._replace(updated);
-    if (this._adapter.pin) {
-      await this._adapter.pin(id);
-    } else {
-      await this._adapter.save(updated);
-    }
+    if (!await this._meta(id, (conv) => ({ ...conv, pinnedAt: Date.now() }), this._adapter.pin)) return;
     this._notify();
   }
   /** Unpin a conversation. Metadata only — see `pin()`. */
   async unpin(id) {
-    const conv = this._find(id);
-    if (!conv) return;
-    const updated = { ...conv, pinnedAt: void 0 };
-    this._replace(updated);
-    if (this._adapter.unpin) {
-      await this._adapter.unpin(id);
-    } else {
-      await this._adapter.save(updated);
-    }
+    if (!await this._meta(id, (conv) => ({ ...conv, pinnedAt: void 0 }), this._adapter.unpin)) return;
     this._notify();
   }
   /** Update the title manually. The full input is preserved — UI surfaces
@@ -3346,12 +3575,17 @@ class AparteConversationManager {
    *  (`min-w-0` + `truncate`). Auto-titles produced internally by
    *  `_autoTitle()` remain capped at a sensible length on input. */
   async updateTitle(id, title) {
-    const conv = this._find(id);
-    if (!conv) return;
-    const updated = { ...conv, title: title.trim(), updatedAt: Date.now() };
-    this._replace(updated);
-    await this._adapter.save(updated);
-    this._notify();
+    if (!this._find(id)) {
+      console.warn(`[AparteConversationManager] updateTitle('${id}'): unknown conversation.`);
+      return;
+    }
+    const next = title.trim();
+    const done = await this._meta(
+      id,
+      (conv) => ({ ...conv, title: next, autoTitle: false }),
+      this._adapter.rename ? (convId) => this._adapter.rename(convId, next) : void 0
+    );
+    if (done) this._notify();
   }
   // ─── Observer ───────────────────────────────────────────────────────────
   subscribe(listener) {
@@ -3378,8 +3612,9 @@ class AparteConversationManager {
     });
   }
   /**
-   * The title of a conversation, decided once, on its first user message: the
-   * provider's answer when one is registered and answers, else the default.
+   * The title of a conversation, decided on its first user message — and again if
+   * that message is edited while the title is still the manager's: the provider's
+   * answer when one is registered and answers, else the default.
    */
   async _title(msg) {
     const fallback = this._autoTitle(msg);
@@ -3393,7 +3628,7 @@ class AparteConversationManager {
     }
   }
   _autoTitle(msg) {
-    return (msg.content ?? "").trim() || "New Chat";
+    return (msg.content ?? "").trim();
   }
 }
 function filesToAttachments(files) {
@@ -3432,6 +3667,8 @@ class AparteConversationController {
   _subscribedTo = null;
   /** Between bind() and unbind(): the only time a manager subscription may be installed. */
   _bound = false;
+  /** The binding shows the wait this controller asked for — see `_showWait`. */
+  _waitShown = false;
   /**
    * React to an external mutation of the manager (another component deleting or
    * archiving the active conversation). Without this the binding would keep
@@ -3452,6 +3689,7 @@ class AparteConversationController {
       }
       this._activeId = null;
       this._binding.clearMessages();
+      this._showWait(false);
     }
   };
   constructor(binding, options = {}) {
@@ -3558,7 +3796,7 @@ class AparteConversationController {
       void this.setConversationId(evt.detail?.id ?? null);
     };
     if (typeof window !== "undefined") {
-      window.addEventListener("aparte-select-conversation", this._onSelectConversation);
+      window.addEventListener("aparte-conversation-select", this._onSelectConversation);
     }
     this._bound = true;
     this._manager();
@@ -3599,7 +3837,7 @@ class AparteConversationController {
       this._onMessageAborted = null;
     }
     if (this._onSelectConversation && typeof window !== "undefined") {
-      window.removeEventListener("aparte-select-conversation", this._onSelectConversation);
+      window.removeEventListener("aparte-conversation-select", this._onSelectConversation);
       this._onSelectConversation = null;
     }
     if (this._unsubscribeManager) {
@@ -3645,6 +3883,7 @@ class AparteConversationController {
       this._activeId = null;
       manager?.clearActive();
       if (isSwitch) this._binding.clearMessages();
+      this._showWait(false);
       return;
     }
     const conv = manager?.conversations.find((c) => c.id === id);
@@ -3660,29 +3899,68 @@ class AparteConversationController {
             console.warn("[ConversationController] id still unknown after hydration — clearing. id:", id);
             manager.clearActive();
             this._binding.clearMessages();
+            this._showWait(false);
           }
         });
         this._stopHydrationRetry = stop;
+        this._showWait(false);
         return;
       }
       console.warn("[ConversationController] unknown id or no manager — clearing. manager:", !!manager, "conv:", !!conv);
       this._activeId = null;
       manager?.clearActive();
       this._binding.clearMessages();
+      this._showWait(false);
       return;
     }
     this._activeId = id;
     manager.select(id);
+    let record = conv;
+    const fetching = !manager.isLoaded(id);
+    if (fetching) {
+      this._showWait(true);
+      this._binding.clearMessages();
+      let loaded = false;
+      try {
+        loaded = await manager.ensureFull(id);
+      } catch (err) {
+        console.warn("[ConversationController] the conversation could not be loaded:", id, err);
+      }
+      if (this._activeId !== id) return;
+      if (!loaded) {
+        if (manager.conversations.some((c) => c.id === id)) {
+          console.warn("[ConversationController] no messages came back for", id, "— leaving it.");
+        }
+        this._activeId = null;
+        manager.clearActive();
+        this._binding.clearMessages();
+        this._showWait(false);
+        return;
+      }
+      record = manager.conversations.find((c) => c.id === id) ?? conv;
+    }
     this._isLoadingConversation = true;
     try {
-      this._binding.setMessages([...conv.messages]);
-      if (conv.tree && this._binding.importTree) {
-        this._binding.importTree(conv.tree);
+      this._binding.setMessages([...record.messages ?? []]);
+      if (record.tree && this._binding.importTree) {
+        this._binding.importTree(record.tree);
       }
     } finally {
       this._isLoadingConversation = false;
+      this._showWait(false);
     }
   }
+  /**
+   * The binding's wait, owned here: whoever runs `setConversationId` last clears it
+   * — a loaded conversation or a new chat that replaces a fetch, a delete of the
+   * one being fetched — so a wait shown for one call never outlives the call that
+   * superseded it.
+   */
+  _showWait(on) {
+    if (this._waitShown === on) return;
+    this._waitShown = on;
+    this._binding.setLoading?.(on);
+  }
   // ─────────────────────────────────────────────────────────────────────
   // Internal
   // ─────────────────────────────────────────────────────────────────────
@@ -3700,6 +3978,7 @@ class AparteConversationController {
     if (!this._activeId) return;
     const manager = this._manager();
     if (!manager) return;
+    if (!manager.isLoaded(this._activeId)) return;
     const msgs = this._binding.getMessages().map(
       (m) => m.status === "streaming" || m.status === "pending" ? { ...m, status: "completed" } : m
     );
@@ -3729,12 +4008,12 @@ class AparteConversationController {
     }
     if (!convId) {
       if (!this._ensureInFlight) {
-        const text = (userMsg.content ?? "").toString().trim() || "New Chat";
+        const text = (userMsg.content ?? "").toString().trim();
         this._ensureInFlight = manager.createNew(text).then((conv) => conv.id);
       }
       convId = await this._ensureInFlight;
       this._ensureInFlight = null;
-      if (this._activeId !== wasActiveId) {
+      if (this._activeId !== wasActiveId && this._activeId !== convId) {
         void manager.delete(convId).catch(() => {
         });
         return;
@@ -3872,7 +4151,9 @@ class AparteChatHost {
       setMessages: (msgs) => {
         this._beginConversationSwap();
         this._vp()?.resetSpacer?.();
-        this.binding.setMessages(msgs.map(adoptMessageSegments));
+        const adopted = msgs.map(adoptMessageSegments);
+        this.binding.setMessages(adopted);
+        this._vp()?.setMessages?.(adopted);
       },
       appendMessage: (msg) => this.appendMessage(msg),
       getMessages: () => this.binding.getMessages(),
@@ -3887,6 +4168,17 @@ class AparteChatHost {
       },
       importTree: (tree) => {
         this._vp()?.importTree?.(tree);
+      },
+      // One writer for the wait. A wrapper that hears `onLoadingChange` draws the
+      // wait itself and writes the viewport's attribute from its own
+      // `loading || hostLoading` — so the host writing it too meant that, with the
+      // consumer's own prop on, a `setLoading(false)` here removed the attribute
+      // (and `aria-busy`) while the wrapper still drew the skeleton and still held
+      // the composer shut. A binding that cannot hear it has no other way to know,
+      // and there the attribute stays the host's to write.
+      setLoading: (on) => {
+        if (this.binding.onLoadingChange) this.binding.onLoadingChange(on);
+        else this._vp()?.setLoading?.(on);
       }
     };
     this._controller = new AparteConversationController(convBinding, {
@@ -3992,7 +4284,7 @@ class AparteChatHost {
       // defaults rather than the page's.
       resolveConfig(this.binding.host).getSegmentDefaults(segment.type)
     ) : segment;
-    this._lastBubble()?.addSegment?.(stamped);
+    this._streamBubble(last?.id)?.addSegment?.(stamped);
     if (!last) return;
     const segments = [...last.segments || [], stamped];
     const next = [...msgs.slice(0, -1), { ...last, segments }];
@@ -4007,7 +4299,7 @@ class AparteChatHost {
     if (last && this._isOrphan(last.id)) return;
     const current = last?.segments?.find((s) => s.id === segmentId);
     const stamped = current ? stampSegmentOnUpdate(current, updates) : updates;
-    this._lastBubble()?.updateSegment?.(segmentId, stamped);
+    this._streamBubble(last?.id)?.updateSegment?.(segmentId, stamped);
     if (!last || !last.segments) return;
     const segments = last.segments.map(
       (s) => s.id === segmentId ? mergeSegmentUpdate(s, stamped) : s
@@ -4019,7 +4311,7 @@ class AparteChatHost {
   /** Remove a transient segment (a status row the host added itself). */
   removeSegment(segmentId) {
     this._flushStreamState();
-    this._lastBubble()?.removeSegment?.(segmentId);
+    this._streamBubble(this.binding.getMessages().at(-1)?.id)?.removeSegment?.(segmentId);
     const msgs = this.binding.getMessages();
     const last = msgs[msgs.length - 1];
     if (!last?.segments) return;
@@ -4331,6 +4623,27 @@ class AparteChatHost {
       `aparte-chat-bubble[message-id="${cssEscape(id)}"]`
     );
   }
+  /**
+   * The bubble the streaming writes below belong to: the one carrying that message's
+   * id, and NOTHING when it is not on the page yet.
+   *
+   * It used to be "the last bubble in the viewport", which is a different message
+   * whenever the DOM is a render behind the list — which is every framework here.
+   * `appendMessage` puts the new reply in React's state and React paints it on its own
+   * schedule, so a first chunk arriving in between went into the PREVIOUS reply's
+   * bubble; `syncBubbles` then wrote the same segment onto the real one, and the same
+   * `data-segment-id` was on two bubbles.
+   *
+   * Skipping the paint is safe because it is only ever a paint: the message list is
+   * written either way, and `syncBubbles` — called by the framework after each render,
+   * always re-syncing the last message — puts it on screen as soon as the bubble
+   * exists. Without an id there is nothing to resolve, so the last bubble stands: that
+   * is a host writing into a transcript it has not appended to.
+   */
+  _streamBubble(messageId) {
+    if (messageId) return this._bubbleById(messageId);
+    return this._lastBubble();
+  }
   _lastBubble() {
     const vp = this.binding.viewport;
     if (!vp) return null;
@@ -4357,9 +4670,15 @@ class AparteChatHost {
       const d = e?.detail;
       if (d?.messageId) this._setStreamingId(d.messageId);
     };
+    const endsThisTurn = (e) => {
+      const id = e?.detail?.messageId;
+      return !id || this._streamingId === null || id === this._streamingId;
+    };
     const onDone = (e) => {
-      this.binding.onTypingChange?.(false);
-      this._setStreamingId(null);
+      if (endsThisTurn(e)) {
+        this.binding.onTypingChange?.(false);
+        this._setStreamingId(null);
+      }
       const d = e?.detail;
       if (!d?.messageId || !d.usage) return;
       const next = this.binding.getMessages().map(
@@ -4369,7 +4688,8 @@ class AparteChatHost {
       this.binding.onMessagesChange?.(next);
       this._bubbleById(d.messageId)?.setUsage?.(d.usage);
     };
-    const onEnd = () => {
+    const onEnd = (e) => {
+      if (!endsThisTurn(e)) return;
       this.binding.onTypingChange?.(false);
       this._setStreamingId(null);
     };
@@ -4589,6 +4909,15 @@ function readableToAsyncIterable(stream, signal) {
     }
   };
 }
+function eventOrigin(e) {
+  return e.composedPath?.()[0] ?? e.target;
+}
+function rootOf(node) {
+  return node.getRootNode();
+}
+function activeElementIn(node) {
+  return node.getRootNode().activeElement ?? document.activeElement;
+}
 let steppedPanelSeq = 0;
 let _relabels = null;
 function onRelabel(fn) {
@@ -5110,11 +5439,14 @@ function requestUserInput(request) {
   return resolveConfig(request.target ?? null).requestUserInput(request);
 }
 const COMPACTION_PREAMBLE = "The earlier part of this conversation was compacted. This is a summary of what came before; continue from it.";
+const warnedUninlinedFiles = /* @__PURE__ */ new Set();
+const CHAT_SELECTOR = "aparte-chat, aparte-chat-viewport, [data-aparte-chat]";
 class AparteClient {
   _boundHandler = null;
   _boundAbortHandler = null;
   _boundRetryHandler = null;
   _boundEditHandler = null;
+  _releaseKeyResolver = null;
   _isAborted = false;
   /**
    * Does this window event belong to this client?
@@ -5135,7 +5467,7 @@ class AparteClient {
     const scope = this.options.scopeToTargetId;
     if (scope) return detail?.targetId === scope;
     if (this._config === aparteGlobalConfig) return true;
-    const target = this._resolveTarget(detail?.targetId);
+    const target = this._resolveTarget(detail?.targetId, e);
     if (!target) return true;
     const owner = resolveConfig(target);
     return owner === this._config || owner === aparteGlobalConfig;
@@ -5151,6 +5483,7 @@ class AparteClient {
       ...options
     };
     this._config = options.config ?? aparteGlobalConfig;
+    this._registerKeyResolver();
     if (this.options.autoRegister) {
       registerDefaultRenderers(this._config);
     } else {
@@ -5176,6 +5509,20 @@ class AparteClient {
   _beginUserTurn() {
     this._isAborted = false;
   }
+  /**
+   * Put this client's `keyResolver` on its config, and hold the teardown so
+   * `stop()` can take it back off.
+   *
+   * The registration used to be fire-and-forget, so it outlived the client that
+   * made it: a stopped client kept signing model-list requests, and a remount —
+   * the way the wrappers document swapping options — added a source behind the
+   * one it meant to replace instead of replacing it. Idempotent, so the usual
+   * `new AparteClient({…}).start()` registers once.
+   */
+  _registerKeyResolver() {
+    if (this._releaseKeyResolver || !this.options.keyResolver) return;
+    this._releaseKeyResolver = this._config.registerKeyProvider(this.options.keyResolver);
+  }
   /**
    * Sets up the event listeners.
    * This is called once in the constructor.
@@ -5194,6 +5541,7 @@ class AparteClient {
    * Start listening for aparte-send events on the window.
    */
   start() {
+    this._registerKeyResolver();
     if (!this._boundHandler) {
       this._setupListeners();
     }
@@ -5229,6 +5577,8 @@ class AparteClient {
    */
   stop() {
     this.abort();
+    this._releaseKeyResolver?.();
+    this._releaseKeyResolver = null;
     if (!this._boundHandler) return;
     window.removeEventListener("aparte-send", this._boundHandler);
     this._boundHandler = null;
@@ -5429,7 +5779,7 @@ class AparteClient {
     const { messageId, targetId } = event.detail ?? {};
     this._beginUserTurn();
     if (!messageId) return;
-    const targetElement = this._resolveTarget(targetId);
+    const targetElement = this._resolveTarget(targetId, event);
     if (!targetElement) {
       console.warn("[AparteClient] aparte-retry — no target found");
       return;
@@ -5490,7 +5840,7 @@ class AparteClient {
     const { messageId, content: newContent, targetId } = event.detail ?? {};
     this._beginUserTurn();
     if (!messageId || newContent === void 0) return;
-    const targetElement = this._resolveTarget(targetId);
+    const targetElement = this._resolveTarget(targetId, event);
     if (!targetElement) {
       console.warn("[AparteClient] aparte-edit — no target found");
       return;
@@ -5532,24 +5882,83 @@ class AparteClient {
       authConfig
     );
   }
+  /**
+   * The chain the gesture really came up, nearest node first.
+   *
+   * Read from a `window` listener, `event.target` is the shadow HOST when the event
+   * left a tree of the consumer's own, and `parentElement` stops at that tree's root —
+   * so a walk from either starts, or ends, outside the chat the person typed into.
+   * `composedPath()` is the one chain that crosses. The fallback is for an event
+   * dispatched by hand, which has no path.
+   */
+  _originChain(event) {
+    const path = event?.composedPath?.() ?? [];
+    if (path.length > 0) return path;
+    const chain = [];
+    let node = event ? eventOrigin(event) : null;
+    while (node) {
+      chain.push(node);
+      node = node.parentElement;
+    }
+    return chain;
+  }
+  /**
+   * The trees a lookup must search, the one the gesture came from FIRST.
+   *
+   * `document.getElementById` and `document.querySelectorAll` cannot see into a shadow
+   * root, so a chat mounted in one — the arrangement the theming guide endorses — was
+   * invisible to both: alone, the send was dropped with a warning; on a page that also
+   * holds a chat in the light DOM, the scan answered with the WRONG chat, so the
+   * person's message AND the model's reply landed in a transcript they never typed
+   * into. Nearest tree first is what keeps it from swapping the other way round.
+   */
+  _rootsFor(event) {
+    const roots = [];
+    for (const node of this._originChain(event)) {
+      if (typeof node.getRootNode !== "function") continue;
+      const root = rootOf(node);
+      if (!roots.includes(root)) roots.push(root);
+    }
+    if (!roots.includes(document)) roots.push(document);
+    return roots;
+  }
+  /** The element an id names, looked up in the gesture's own tree before the document. */
+  _byId(targetId, event) {
+    for (const root of this._rootsFor(event)) {
+      const el2 = root.getElementById?.(targetId);
+      if (el2) return el2;
+    }
+    return null;
+  }
+  /** The first chat that can render, own tree first — the path when nothing names one. */
+  _scanForTarget(event) {
+    for (const root of this._rootsFor(event)) {
+      for (const candidate of root.querySelectorAll(CHAT_SELECTOR)) {
+        const target = this._asRenderTarget(candidate);
+        if (target) return target;
+      }
+    }
+    return null;
+  }
   /**
    * Resolve a target element by id (from event detail.targetId) or via targetResolver / DOM scan.
    */
-  _resolveTarget(targetId) {
+  _resolveTarget(targetId, event) {
     if (targetId) {
-      const el2 = document.getElementById(targetId);
+      const el2 = this._byId(targetId, event);
       if (el2) return this._asRenderTarget(el2) ?? el2;
     }
     if (this.options.targetResolver) {
       const el2 = this.options.targetResolver();
       if (el2) return this._asRenderTarget(el2) ?? el2;
     }
-    const candidates = document.querySelectorAll("aparte-chat, aparte-chat-viewport, [data-aparte-chat]");
-    for (const candidate of candidates) {
-      const target = this._asRenderTarget(candidate);
-      if (target) return target;
+    const scanned = this._scanForTarget(event);
+    if (scanned) return scanned;
+    for (const root of this._rootsFor(event)) {
+      const first = root.querySelector(CHAT_SELECTOR);
+      if (first) return first;
     }
-    return candidates[0] ?? null;
+    return null;
   }
   /**
    * Resolve an element to a usable render target: itself when it exposes
@@ -5640,7 +6049,7 @@ class AparteClient {
     let targetElement = null;
     const targetId = event.detail?.targetId;
     if (targetId) {
-      const byId = document.getElementById(targetId);
+      const byId = this._byId(targetId, event);
       const resolved = this._asRenderTarget(byId);
       if (resolved) {
         targetElement = resolved;
@@ -5649,32 +6058,22 @@ class AparteClient {
       }
     }
     if (!targetElement && this.options.targetResolver) {
-      const resolved = this.options.targetResolver();
-      if (resolved && typeof resolved.appendMessage === "function") {
-        targetElement = resolved;
-      }
-    }
-    if (!targetElement) {
-      let walker = event.target;
-      while (walker && typeof walker.appendMessage !== "function") {
-        walker = walker.parentElement;
-      }
-      if (walker) {
-        targetElement = walker;
-      }
+      targetElement = this._asRenderTarget(
+        this.options.targetResolver()
+      );
     }
     if (!targetElement) {
-      const candidates = document.querySelectorAll(
-        "aparte-chat, aparte-chat-viewport, [data-aparte-chat]"
-      );
-      for (const candidate of candidates) {
-        const resolved = this._asRenderTarget(candidate);
-        if (resolved) {
-          targetElement = resolved;
+      for (const node of this._originChain(event)) {
+        const walker = node;
+        if (typeof walker?.appendMessage === "function") {
+          targetElement = walker;
           break;
         }
       }
     }
+    if (!targetElement) {
+      targetElement = this._scanForTarget(event);
+    }
     if (!targetElement) {
       console.warn("[AparteClient] ⚠️ No target element found with appendMessage support. Provide a targetResolver in AparteClientOptions or ensure the composer has a `target` attribute.");
       return;
@@ -5841,7 +6240,8 @@ ${text}` : text;
    *
    * `thinking` and `tool_call` stay out on purpose — the first is the model's own
    * scratchpad, and most APIs neither want it back nor bill for it kindly; the
-   * second is already in the history as a call and a result.
+   * second was already carried, within the turn, as the assistant's calls and the
+   * `tool` messages answering them.
    */
   _segmentsToText(segments) {
     if (!segments?.length) return "";
@@ -5885,7 +6285,8 @@ ${fence}`);
    * - Images → AparteImagePart (base64 data URL)
    * - Text files (txt, md, json, csv, xml, html, css, js, ts, …) → AparteTextPart
    *   injected as a fenced block so all models (including local) can read them.
-   * - Other binary files → silently ignored.
+   * - Other binary files → no content part, and a one-time `console.warn` naming the
+   *   file (see the branch below for why it is not silent).
    */
   async _filesToContentParts(files) {
     const TEXT_TYPES = /^(text\/|application\/(json|xml|javascript|typescript|x-yaml|yaml|toml|csv|markdown))/i;
@@ -5918,6 +6319,12 @@ ${content}
             reader.readAsText(file);
           });
         }
+        if (!warnedUninlinedFiles.has(file.name)) {
+          warnedUninlinedFiles.add(file.name);
+          console.warn(
+            `[aparte] ${file.name} (${file.type || "unknown type"}) is attached to the message but is not sent to the model: aparté inlines images and text files only. Handle it in your app (RAG, an upload) — the chip stays visible either way.`
+          );
+        }
         return Promise.resolve(null);
       })
     );
@@ -6107,6 +6514,20 @@ class AparteMessageRepository {
   getMessageById(id) {
     return this._nodes.get(id)?.current;
   }
+  /**
+   * Every message the tree holds — every branch, not just the active path.
+   *
+   * `getMessages()` walks head → root, so a question about the whole conversation
+   * ("is anything still streaming?") answered from it could not see a turn that a
+   * retry had just taken off the path — and the viewport wrote that turn's remaining
+   * segments into the bubble which replaced it. No order is promised beyond
+   * insertion: a caller that needs the topology reads `export()`.
+   */
+  getAllMessages() {
+    const all = [];
+    for (const node of this._nodes.values()) all.push(node.current);
+    return all;
+  }
   /**
    * Returns the IDs of all siblings of `messageId`
    * (i.e. all children of its parent, including itself).
@@ -6165,15 +6586,19 @@ class AparteMessageRepository {
     this._head = findHead(node);
   }
   /**
-   * Remove all descendants of `messageId` (inclusive) and set `head` to
-   * the parent of `messageId`. Used by edit/truncate flows.
+   * Remove all descendants of `messageId` (inclusive) and, when the head was among
+   * them, set `head` to the parent of `messageId`. Used by edit/truncate flows.
+   *
+   * A head in a branch this call did not touch stays where it is: it used to be
+   * relocated regardless, which took the active path out of the version the reader was
+   * on for a truncate somewhere else entirely.
    *
    * @param messageId  The first message to remove
-   * @param newParentId  Optional explicit parent to set head to
    */
   resetHead(messageId) {
     const node = this._nodes.get(messageId);
     if (!node) return;
+    const headBefore = this._head;
     this._deleteDescendants(node);
     const parentOrRoot = node.prev ?? this._root;
     parentOrRoot.children = parentOrRoot.children.filter((id) => id !== messageId);
@@ -6181,7 +6606,8 @@ class AparteMessageRepository {
       parentOrRoot.next = null;
     }
     this._nodes.delete(messageId);
-    this._head = node.prev;
+    const headSurvived = headBefore !== null && headBefore !== node && this._nodes.get(headBefore.current.id) === headBefore;
+    if (!headSurvived) this._head = node.prev;
   }
   /**
    * Update a message's data without changing its position in the tree.
@@ -6336,13 +6762,13 @@ const APARTE_DEFAULT_UI_EVENTS = [
   "aparte-reset-done",
   "aparte-path-changed",
   // <aparte-conversation-list>
-  "aparte-select-conversation",
-  "aparte-delete-conversation",
-  "aparte-archive-conversation",
-  "aparte-unarchive-conversation",
-  "aparte-rename-conversation",
-  "aparte-pin-conversation",
-  "aparte-unpin-conversation",
+  "aparte-conversation-select",
+  "aparte-conversation-delete",
+  "aparte-conversation-archive",
+  "aparte-conversation-unarchive",
+  "aparte-conversation-rename",
+  "aparte-conversation-pin",
+  "aparte-conversation-unpin",
   // the select primitives
   "aparte-select-change",
   "aparte-select-open",
@@ -6470,15 +6896,19 @@ export {
   subscribeConfigChange as a4,
   unregisterSegmentRenderer as a5,
   uuid as a6,
-  mergeSegmentUpdate as a7,
-  writeStreamedMarkdown as a8,
-  stampSegmentActivity as a9,
-  stampSegmentOnInsert as aa,
-  stampSegmentOnUpdate as ab,
-  renumberSegments as ac,
-  openSegmentIds as ad,
-  isTerminalStatus as ae,
-  adoptMessageSegments as af,
+  eventOrigin as a7,
+  activeElementIn as a8,
+  mergeSegmentUpdate as a9,
+  writeStreamedMarkdown as aa,
+  stampSegmentActivity as ab,
+  stampSegmentOnInsert as ac,
+  stampSegmentOnUpdate as ad,
+  renumberSegments as ae,
+  openSegmentIds as af,
+  isTerminalStatus as ag,
+  adoptMessageSegments as ah,
+  APARTE_DERIVED_SEGMENTS as ai,
+  rootOf as aj,
   APARTE_DEFAULT_BUBBLE_ACTIONS as b,
   APARTE_DEFAULT_HOST_HANDLERS as c,
   APARTE_DEFAULT_ICON_FALLBACKS as d,
@@ -6505,4 +6935,4 @@ export {
   collectRendererStyles as y,
   contentToText as z
 };
-//# sourceMappingURL=dialog-triggers-cYGTlfZf.js.map
+//# sourceMappingURL=dialog-triggers-Bb-3EkT4.js.map