@admin-layout/tailwind-ui 12.2.4-alpha.6 → 12.2.4-alpha.61

package/lib/components/AIToolbar/hooks/marketplaceCharactersRegistry.js

@@ -0,0 +1,6 @@
+/** Dispatched when {@link setMarketplaceCharacters} updates the overlay list. */
+const MARKETPLACE_CHARACTERS_CHANGED_EVENT = 'yantra:marketplace-characters-changed';
+let marketplaceOverlay = [];
+function getMarketplaceCharactersSnapshot() {
+  return marketplaceOverlay;
+}export{MARKETPLACE_CHARACTERS_CHANGED_EVENT,getMarketplaceCharactersSnapshot};//# sourceMappingURL=marketplaceCharactersRegistry.js.map

package/lib/components/AIToolbar/hooks/marketplaceCharactersRegistry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"marketplaceCharactersRegistry.js","sources":["../../../../src/components/AIToolbar/hooks/marketplaceCharactersRegistry.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAA;AACY,0CAA4B,GAAA;IACpC,kBAAa,GAAA,EAAA;;;"}

package/lib/components/AIToolbar/hooks/useActiveCharacter.d.ts

@@ -0,0 +1,52 @@
+export interface ActiveCharacter {
+    /** Manifest `name` (or filesystem stem) — e.g. "Seraphina". */
+    name: string;
+    /** PNG card filename without extension — used to fetch avatar / sprites. */
+    fileName?: string;
+    /** Pre-baked `data:` URL for the avatar PNG, or null if not yet loaded. */
+    avatarSrc: string | null;
+}
+export interface CharacterListEntry {
+    name: string;
+    fileName?: string;
+    avatarSrc: string | null;
+}
+export interface CharacterPicker {
+    /** All installed characters with resolved avatars. */
+    characters: CharacterListEntry[];
+    /** Currently active character name, or null if none picked / none installed. */
+    activeName: string | null;
+    /** Switch the active character by name. Pass null to clear (revert to first). */
+    setActive: (name: string | null) => void;
+}
+/**
+ * Marketplace character entry — produced from `contributes.uiLayout` rows
+ * under `marketplace.characters.*`. Fed in from yantra-app via
+ * `setMarketplaceCharacters` so this package stays free of GraphQL deps.
+ */
+export interface MarketplaceCharacterEntry {
+    name: string;
+    fileName?: string;
+    extensionId?: string;
+    extensionSlug?: string;
+    /** Optional pre-resolved data URL (e.g. CDN avatar). Filesystem install will override. */
+    avatarSrc?: string | null;
+}
+/**
+ * Publish the current list of marketplace-contributed characters. Called by
+ * yantra-app after `useSettingsLoader({ configKey: 'marketplace.characters' })`
+ * resolves. Triggers a re-render of any active character hook.
+ */
+export declare function setMarketplaceCharacters(entries: MarketplaceCharacterEntry[]): void;
+/**
+ * Return the active character (name + avatar) or null when none is installed
+ * / we're not running under Tauri. Selection follows `pickActiveMerged` (file_name
+ * pref, then name pref) and stays in sync with `useCharacterPicker` / desktop settings.
+ */
+export declare function useActiveCharacter(): ActiveCharacter | null;
+/**
+ * Enumerate installed characters and switch the active one. Empty list and
+ * `activeName === null` outside Tauri / when nothing is installed.
+ */
+export declare function useCharacterPicker(): CharacterPicker;
+//# sourceMappingURL=useActiveCharacter.d.ts.map

package/lib/components/AIToolbar/hooks/useActiveCharacter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActiveCharacter.d.ts","sourceRoot":"","sources":["../../../../src/components/AIToolbar/hooks/useActiveCharacter.ts"],"names":[],"mappings":"AAyCA,MAAM,WAAW,eAAe;IAC5B,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2EAA2E;IAC3E,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AAED,MAAM,WAAW,eAAe;IAC5B,sDAAsD;IACtD,UAAU,EAAE,kBAAkB,EAAE,CAAC;IACjC,gFAAgF;IAChF,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,iFAAiF;IACjF,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,KAAK,IAAI,CAAC;CAC5C;AASD;;;;GAIG;AACH,MAAM,WAAW,yBAAyB;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,0FAA0F;IAC1F,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC7B;AAiCD;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,yBAAyB,EAAE,GAAG,IAAI,CASnF;AAkMD;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,GAAG,IAAI,CAqC3D;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,IAAI,eAAe,CAmFpD"}

package/lib/components/AIToolbar/hooks/useActiveCharacter.js

@@ -0,0 +1,360 @@
+import*as React from'react';import {setPreferredActiveCharacterFileName,ACTIVE_CHARACTER_CHANGE_EVENT,readPreferredActiveCharacterFileName,ACTIVE_CHARACTER_FILE_NAME_STORAGE_KEY}from'../../../hooks/activeCharacterPreference.js';import {clearCharacterSpriteCache}from'./useCharacterSprite.js';import {MARKETPLACE_CHARACTERS_CHANGED_EVENT,getMarketplaceCharactersSnapshot}from'./marketplaceCharactersRegistry.js';// Active-character lookup for the AIToolbar.
+//
+// Surfaces the currently-selected character (name + avatar data URL) so the
+// completion popover and message history can show "Seraphina" with her avatar
+// instead of a generic "AI" label. Backed by the desktop Tauri commands
+// `character_list` and `character_get_avatar` (see
+// `yantra-app/portable-devices/desktop/src-tauri/src/features/character_feature/`).
+//
+// Degrades gracefully:
+//   - Outside Tauri (regular browser, SSR): returns null synchronously.
+//   - Tauri without any character-contributing extension installed: returns null.
+//   - Tauri with an extension but no avatar: returns name-only (avatarSrc = null).
+//
+// Re-fetches on the `yantra:character-refresh` Tauri event + the
+// `yantra:extensions-changed` window event (marketplace install/uninstall), and
+// re-resolves when either persisted preference changes:
+//   - `yantra:active-character-name` (name-based — CharacterPicker / toolbar), and/or
+//   - `yantra:active-character:file-name` + `yantra:active-character-change` (file_name
+//     + cross-webview emit — desktop settings / `activeCharacterPreference.ts`).
+//
+// When multiple characters are installed, resolution order is: **file_name**
+// preference first (so the dashboard bar and main app stay aligned), then
+// **name** preference (`yantra:active-character-name`), then `character_list[0]`.
+// Use `useCharacterPicker` to enumerate and switch by name (it also syncs
+// the file_name preference + Tauri fan-out).
+// constants
+const CHARACTER_REFRESH_EVENT = 'yantra:character-refresh';
+/**
+ * Window event dispatched by `yantra-app/portable-devices/desktop/src/utils/marketplaceInstall.ts`
+ * after the marketplace install / uninstall path triggers `character_refresh`.
+ * Listening here lets the avatar swap in without an app restart.
+ */
+const EXTENSIONS_CHANGED_EVENT = 'yantra:extensions-changed';
+/** Window event dispatched by `useCharacterPicker().setActive(...)` to notify subscribers. */
+const ACTIVE_CHARACTER_CHANGED_EVENT = 'yantra:active-character-changed';
+const ACTIVE_CHARACTER_STORAGE_KEY = 'yantra:active-character-name';
+/** Manifest contribution keys that should retrigger a character reload. */
+const CHARACTER_CONTRIBUTIONS = ['characters', 'uiLayout'];
+// marketplace registry (populated by yantra-app via setMarketplaceCharacters)
+let marketplaceRegistry = [];
+const marketplaceSubscribers = new Set();
+function subscribeMarketplace(cb) {
+  marketplaceSubscribers.add(cb);
+  return () => marketplaceSubscribers.delete(cb);
+}
+/**
+ * Publish the current list of marketplace-contributed characters. Called by
+ * yantra-app after `useSettingsLoader({ configKey: 'marketplace.characters' })`
+ * resolves. Triggers a re-render of any active character hook.
+ */
+function setMarketplaceCharacters(entries) {
+  marketplaceRegistry = Array.isArray(entries) ? entries : [];
+  marketplaceSubscribers.forEach(cb => {
+    try {
+      cb();
+    } catch {
+      // ignore subscriber errors
+    }
+  });
+}
+function getMarketplaceCharacters() {
+  return marketplaceRegistry;
+}
+/**
+ * Merge marketplace entries into the filesystem list. Filesystem wins on
+ * name conflicts (real avatar > stub), so the marketplace entry is dropped.
+ */
+function mergeWithMarketplace(filesystem, marketplace) {
+  if (marketplace.length === 0) return filesystem;
+  const seen = new Set(filesystem.map(c => c.name));
+  const extras = [];
+  for (const m of marketplace) {
+    if (!m.name || seen.has(m.name)) continue;
+    seen.add(m.name);
+    extras.push({
+      name: m.name,
+      file_name: m.fileName,
+      source: 'marketplace'
+    });
+  }
+  return extras.length ? [...filesystem, ...extras] : filesystem;
+}
+// helpers
+function isTauri() {
+  if (typeof window === 'undefined') return false;
+  const w = window;
+  return Boolean(w.__TAURI_INTERNALS__ ?? w.__TAURI__);
+}
+async function safeInvoke(cmd, args) {
+  if (!isTauri()) return null;
+  try {
+    // @ts-ignore — optional dynamic import, present as a peer dep in Tauri builds.
+    const mod = await import('@tauri-apps/api/core');
+    return await mod.invoke(cmd, args);
+  } catch {
+    return null;
+  }
+}
+async function safeListen(event, cb) {
+  if (!isTauri()) return () => {};
+  try {
+    // @ts-ignore — see safeInvoke note.
+    const mod = await import('@tauri-apps/api/event');
+    const unlisten = await mod.listen(event, e => cb(e.payload));
+    return unlisten;
+  } catch {
+    return () => {};
+  }
+}
+function readStoredActiveName() {
+  if (typeof window === 'undefined') return null;
+  try {
+    return window.localStorage.getItem(ACTIVE_CHARACTER_STORAGE_KEY);
+  } catch {
+    return null;
+  }
+}
+/**
+ * Decide whether an `extensions-changed` event is relevant to characters.
+ * Detail with no `contributes` array is treated as relevant (defensive
+ * reload) so we never miss a real change.
+ */
+function isCharacterRelevant(event) {
+  const detail = event.detail;
+  if (!detail || !Array.isArray(detail.contributes)) return true;
+  return detail.contributes.some(c => CHARACTER_CONTRIBUTIONS.includes(c));
+}
+function writeStoredActiveName(name) {
+  if (typeof window === 'undefined') return;
+  try {
+    if (name == null) window.localStorage.removeItem(ACTIVE_CHARACTER_STORAGE_KEY);else window.localStorage.setItem(ACTIVE_CHARACTER_STORAGE_KEY, name);
+  } catch {
+    // ignore quota / privacy-mode errors
+  }
+}
+async function fetchAvatarSrc(fileName) {
+  if (!fileName) return null;
+  const dto = await safeInvoke('character_get_avatar', {
+    fileName
+  });
+  if (!dto || !dto.base64 || dto.base64.length <= 100) return null;
+  return `data:${dto.mime_type || 'image/png'};base64,${dto.base64}`;
+}
+/**
+ * Choose the active row: **file_name** preference (desktop settings / cross-webview),
+ * else **name** preference (toolbar picker), else first in list.
+ */
+function pickActiveMerged(list) {
+  if (list.length === 0) return null;
+  const filePref = readPreferredActiveCharacterFileName();
+  if (filePref) {
+    const byFile = list.find(c => c.file_name === filePref);
+    if (byFile) return byFile;
+  }
+  const desiredName = readStoredActiveName();
+  if (desiredName) {
+    const byName = list.find(c => c.name === desiredName);
+    if (byName) return byName;
+  }
+  // No explicit selection: prefer an extension-contributed character over
+  // user-root cards so a freshly-installed extension (e.g. Seraphina) wins
+  // by default instead of dev/test residue sitting in the user data dir.
+  const extensionPick = list.find(c => c.source === 'extension');
+  if (extensionPick) return extensionPick;
+  return list[0];
+}
+/** Subscribe to both preference schemes + cross-webview Tauri event; bump resets derived selection. */
+function usePreferenceSyncBump() {
+  const [bump, setBump] = React.useState(0);
+  const bumpFn = React.useCallback(() => {
+    setBump(n => n + 1);
+  }, []);
+  return [bump, bumpFn];
+}
+function useCharacterPreferenceListeners(reload, bump) {
+  React.useEffect(() => {
+    let unlistenChar = null;
+    let unlistenFilePref = null;
+    let cancelled = false;
+    safeListen(CHARACTER_REFRESH_EVENT, () => {
+      clearCharacterSpriteCache();
+      void reload();
+      bump();
+    }).then(fn => {
+      if (cancelled) fn();else unlistenChar = fn;
+    });
+    safeListen(ACTIVE_CHARACTER_CHANGE_EVENT, () => {
+      clearCharacterSpriteCache();
+      bump();
+    }).then(fn => {
+      if (cancelled) fn();else unlistenFilePref = fn;
+    });
+    function onExtensionsChanged(e) {
+      if (!isCharacterRelevant(e)) return;
+      clearCharacterSpriteCache();
+      void reload();
+      bump();
+    }
+    function onActiveChanged() {
+      clearCharacterSpriteCache();
+      bump();
+    }
+    function onFilePrefLocal(e) {
+      clearCharacterSpriteCache();
+      bump();
+    }
+    function onStorageKey(ev) {
+      if (ev.key !== ACTIVE_CHARACTER_STORAGE_KEY && ev.key !== ACTIVE_CHARACTER_FILE_NAME_STORAGE_KEY && ev.key != null) {
+        return;
+      }
+      clearCharacterSpriteCache();
+      bump();
+    }
+    if (typeof window !== 'undefined') {
+      window.addEventListener(EXTENSIONS_CHANGED_EVENT, onExtensionsChanged);
+      window.addEventListener(ACTIVE_CHARACTER_CHANGED_EVENT, onActiveChanged);
+      window.addEventListener(ACTIVE_CHARACTER_CHANGE_EVENT, onFilePrefLocal);
+      window.addEventListener('storage', onStorageKey);
+    }
+    return () => {
+      cancelled = true;
+      if (unlistenChar) unlistenChar();
+      if (unlistenFilePref) unlistenFilePref();
+      if (typeof window !== 'undefined') {
+        window.removeEventListener(EXTENSIONS_CHANGED_EVENT, onExtensionsChanged);
+        window.removeEventListener(ACTIVE_CHARACTER_CHANGED_EVENT, onActiveChanged);
+        window.removeEventListener(ACTIVE_CHARACTER_CHANGE_EVENT, onFilePrefLocal);
+        window.removeEventListener('storage', onStorageKey);
+      }
+    };
+  }, [reload, bump]);
+}
+// main API
+/**
+ * Return the active character (name + avatar) or null when none is installed
+ * / we're not running under Tauri. Selection follows `pickActiveMerged` (file_name
+ * pref, then name pref) and stays in sync with `useCharacterPicker` / desktop settings.
+ */
+function useActiveCharacter() {
+  const [list, setList] = React.useState([]);
+  const [avatarSrc, setAvatarSrc] = React.useState(null);
+  const [bump, bumpFn] = usePreferenceSyncBump();
+  const reload = React.useCallback(async () => {
+    const next = await safeInvoke('character_list', {
+      shallow: false
+    });
+    setList(mergeWithMarketplace(next ?? [], getMarketplaceCharacters()));
+  }, []);
+  React.useEffect(() => {
+    void reload();
+    return subscribeMarketplace(() => {
+      void reload();
+    });
+  }, [reload]);
+  useCharacterPreferenceListeners(reload, bumpFn);
+  const active = React.useMemo(() => pickActiveMerged(list), [list, bump]);
+  React.useEffect(() => {
+    if (!active?.file_name) {
+      setAvatarSrc(null);
+      return;
+    }
+    let alive = true;
+    fetchAvatarSrc(active.file_name).then(src => {
+      if (alive) setAvatarSrc(src);
+    });
+    return () => {
+      alive = false;
+    };
+  }, [active?.file_name]);
+  if (!active) return null;
+  return {
+    name: active.name,
+    fileName: active.file_name,
+    avatarSrc
+  };
+}
+/**
+ * Enumerate installed characters and switch the active one. Empty list and
+ * `activeName === null` outside Tauri / when nothing is installed.
+ */
+function useCharacterPicker() {
+  const [list, setList] = React.useState([]);
+  const [avatars, setAvatars] = React.useState({});
+  const [bump, bumpFn] = usePreferenceSyncBump();
+  const [marketplaceBump, setMarketplaceBump] = React.useState(0);
+  React.useEffect(() => {
+    if (typeof window === 'undefined') return;
+    const onMk = () => setMarketplaceBump(n => n + 1);
+    window.addEventListener(MARKETPLACE_CHARACTERS_CHANGED_EVENT, onMk);
+    return () => window.removeEventListener(MARKETPLACE_CHARACTERS_CHANGED_EVENT, onMk);
+  }, []);
+  const reload = React.useCallback(async () => {
+    const next = await safeInvoke('character_list', {
+      shallow: false
+    });
+    setList(mergeWithMarketplace(next ?? [], getMarketplaceCharacters()));
+  }, []);
+  React.useEffect(() => {
+    void reload();
+    return subscribeMarketplace(() => {
+      void reload();
+    });
+  }, [reload]);
+  useCharacterPreferenceListeners(reload, bumpFn);
+  const activeName = React.useMemo(() => pickActiveMerged(list)?.name ?? null, [list, bump, marketplaceBump]);
+  // Resolve avatars for every character in the list (cached by file_name).
+  React.useEffect(() => {
+    let alive = true;
+    async function loadAll() {
+      const pending = list.filter(c => c.file_name && !(c.file_name in avatars));
+      if (pending.length === 0) return;
+      const entries = await Promise.all(pending.map(async c => [c.file_name, await fetchAvatarSrc(c.file_name)]));
+      if (!alive) return;
+      setAvatars(prev => {
+        const next = {
+          ...prev
+        };
+        for (const [key, src] of entries) next[key] = src;
+        return next;
+      });
+    }
+    void loadAll();
+    return () => {
+      alive = false;
+    };
+  }, [list, avatars]);
+  const characters = React.useMemo(() => {
+    const installed = list.map(c => ({
+      name: c.name,
+      fileName: c.file_name,
+      avatarSrc: c.file_name ? avatars[c.file_name] ?? null : null
+    }));
+    const seen = new Set(installed.map(c => c.name));
+    const extras = getMarketplaceCharactersSnapshot().filter(m => !seen.has(m.name)).map(m => ({
+      name: m.name,
+      fileName: m.fileName,
+      avatarSrc: m.avatarSrc ?? null
+    }));
+    return [...installed, ...extras];
+  }, [list, avatars, marketplaceBump]);
+  const setActive = React.useCallback(name => {
+    writeStoredActiveName(name);
+    const row = name ? list.find(c => c.name === name) : null;
+    void setPreferredActiveCharacterFileName(row?.file_name ?? null);
+    clearCharacterSpriteCache();
+    bumpFn();
+    if (typeof window !== 'undefined') {
+      window.dispatchEvent(new CustomEvent(ACTIVE_CHARACTER_CHANGED_EVENT, {
+        detail: {
+          name
+        }
+      }));
+    }
+  }, [list, bumpFn]);
+  return {
+    characters,
+    activeName,
+    setActive
+  };
+}export{setMarketplaceCharacters,useActiveCharacter,useCharacterPicker};//# sourceMappingURL=useActiveCharacter.js.map

package/lib/components/AIToolbar/hooks/useActiveCharacter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useActiveCharacter.js","sources":["../../../../src/components/AIToolbar/hooks/useActiveCharacter.ts"],"sourcesContent":[null],"names":[],"mappings":"2ZAyCA;;;;;;AAMI;AACH;AAED;;;AAGI;AACH;AAED;;;;AAII;;;AAGH;AASD;;;;;MASI,uBAAuB,GAAA,0BAAA;;AAEvB;AACH;AAiCD;;;;AAIG,MAAA,8BAAA,GAAA,iCAAA;AACH,MAAA,4BAAgB,GAAA;AA2MhB;;;;AAIG,MAAA,sBAAA,GAAA,IAAA,GAAA,EAAA;AACH,SAAA,oBAAgB,CAAA,EAAA,EAAA;AAuChB,EAAA,sBAAA,CAAA,GAAA,CAAA,EAAA,CAAA;;;AAGG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/AIToolbar/hooks/useCharacterSprite.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Returns the data URL for `(characterFileName, label)` or `null` while the
+ * sprite is loading / when running outside Tauri / when no character is set.
+ *
+ * Re-evaluates whenever either input changes. Cached results resolve in the
+ * same render (no transient `null`).
+ */
+export declare function useCharacterSprite(characterFileName: string | null | undefined, label: string | null | undefined): string | null;
+/**
+ * Clears the sprite cache. Call after `character_refresh` so newly-installed
+ * sprite packs aren't shadowed by stale data URLs.
+ */
+export declare function clearCharacterSpriteCache(): void;
+//# sourceMappingURL=useCharacterSprite.d.ts.map

package/lib/components/AIToolbar/hooks/useCharacterSprite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCharacterSprite.d.ts","sourceRoot":"","sources":["../../../../src/components/AIToolbar/hooks/useCharacterSprite.ts"],"names":[],"mappings":"AAqFA;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAC9B,iBAAiB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAC5C,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACjC,MAAM,GAAG,IAAI,CAoBf;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,IAAI,CAGhD"}

package/lib/components/AIToolbar/hooks/useCharacterSprite.js

@@ -0,0 +1,103 @@
+import*as React from'react';// Expression-sprite lookup for assistant message bubbles.
+//
+// Resolves `(characterFileName, label)` → `data:image/png;base64,...` via the
+// Tauri command `character_get_expression`, with a module-level cache so the
+// same sprite is fetched at most once per session even when many messages map
+// to the same emotion.
+//
+// The Rust side (`character_get_expression`) already implements graceful
+// fallback through `neutral`/`joy`/avatar when the requested label is missing,
+// so callers can pass any of the 28 GoEmotions labels without first checking
+// which sprites the character actually ships.
+//
+// Degrades to `null` outside Tauri / when no character file_name is provided.
+function isTauri() {
+  if (typeof window === 'undefined') return false;
+  const w = window;
+  return Boolean(w.__TAURI_INTERNALS__ ?? w.__TAURI__);
+}
+async function safeInvoke(cmd, args) {
+  if (!isTauri()) return null;
+  try {
+    // @ts-ignore — optional dynamic import, present as a peer dep in Tauri builds.
+    const mod = await import('@tauri-apps/api/core');
+    return await mod.invoke(cmd, args);
+  } catch {
+    return null;
+  }
+}
+// Two layered caches keyed by `${fileName}::${label}`:
+//
+//   - `urlCache` resolves synchronously on subsequent calls (no re-render flicker).
+//   - `pendingCache` deduplicates concurrent fetches for the same key when
+//     several messages on screen happen to share the same emotion.
+const urlCache = new Map();
+const pendingCache = new Map();
+function cacheKey(fileName, label) {
+  return `${fileName}::${label}`;
+}
+async function fetchSprite(fileName, label) {
+  const key = cacheKey(fileName, label);
+  const cached = urlCache.get(key);
+  if (cached !== undefined) return cached;
+  const pending = pendingCache.get(key);
+  if (pending) return pending;
+  const promise = (async () => {
+    const dto = await safeInvoke('character_get_expression', {
+      fileName,
+      label
+    });
+    if (!dto || !dto.base64 || dto.base64.length < 100) {
+      urlCache.set(key, '');
+      return null;
+    }
+    const url = `data:${dto.mime_type || 'image/png'};base64,${dto.base64}`;
+    urlCache.set(key, url);
+    // If Rust fell back to a different label (sprite missing), also cache
+    // the resolved label so a subsequent call for it short-circuits.
+    if (dto.label && dto.label !== label) {
+      urlCache.set(cacheKey(fileName, dto.label), url);
+    }
+    return url;
+  })();
+  pendingCache.set(key, promise);
+  try {
+    return await promise;
+  } finally {
+    pendingCache.delete(key);
+  }
+}
+/**
+ * Returns the data URL for `(characterFileName, label)` or `null` while the
+ * sprite is loading / when running outside Tauri / when no character is set.
+ *
+ * Re-evaluates whenever either input changes. Cached results resolve in the
+ * same render (no transient `null`).
+ */
+function useCharacterSprite(characterFileName, label) {
+  const key = characterFileName && label ? cacheKey(characterFileName, label) : null;
+  const cachedInitial = key ? urlCache.get(key) ?? null : null;
+  const [src, setSrc] = React.useState(cachedInitial && cachedInitial !== '' ? cachedInitial : null);
+  React.useEffect(() => {
+    if (!characterFileName || !label) {
+      setSrc(null);
+      return;
+    }
+    let alive = true;
+    fetchSprite(characterFileName, label).then(url => {
+      if (alive) setSrc(url);
+    });
+    return () => {
+      alive = false;
+    };
+  }, [characterFileName, label]);
+  return src;
+}
+/**
+ * Clears the sprite cache. Call after `character_refresh` so newly-installed
+ * sprite packs aren't shadowed by stale data URLs.
+ */
+function clearCharacterSpriteCache() {
+  urlCache.clear();
+  pendingCache.clear();
+}export{clearCharacterSpriteCache,useCharacterSprite};//# sourceMappingURL=useCharacterSprite.js.map

package/lib/components/AIToolbar/hooks/useCharacterSprite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCharacterSprite.js","sources":["../../../../src/components/AIToolbar/hooks/useCharacterSprite.ts"],"sourcesContent":[null],"names":[],"mappings":"4BAqFA;;;;;;AAMG;AACH;AAyBA;;;AAGG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/AIToolbar/hooks/useChatBackgroundImage.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Returns the current chat-background image as a `data:` URL, or `null` when
+ * no wallpaper is selected / we are not running under Tauri.
+ *
+ * Re-fetches whenever the user picks a different wallpaper, regardless of
+ * which webview the picker lives in.
+ */
+export declare function useChatBackgroundImage(): string | null;
+export default useChatBackgroundImage;
+//# sourceMappingURL=useChatBackgroundImage.d.ts.map

package/lib/components/AIToolbar/hooks/useChatBackgroundImage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useChatBackgroundImage.d.ts","sourceRoot":"","sources":["../../../../src/components/AIToolbar/hooks/useChatBackgroundImage.ts"],"names":[],"mappings":"AA4EA;;;;;;GAMG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,GAAG,IAAI,CA+DtD;AAED,eAAe,sBAAsB,CAAC"}