@admin-layout/tailwind-ui 12.2.4-alpha.7 → 12.2.4-alpha.71

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"}

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

@@ -0,0 +1,126 @@
+import*as React from'react';// Chat-background image lookup for AIToolbar surfaces.
+//
+// The desktop app lets users pick a wallpaper that paints behind the `/chat`
+// route. The toolbar's Conversation popover and Message History popover render
+// in Radix portals (outside the chat tree), so the wallpaper does not bleed
+// through to them by default. This hook re-subscribes to the same contract
+// `yantra-app/packages-modules/account/browser/src/hooks/useChatBackground.tsx`
+// already publishes:
+//
+//   - localStorage key  `yantra:chat-background:selected-id`  → currently-selected background ID
+//   - cross-webview event `yantra:chat-background-change`     → fan-out when the picker mutates the selection
+//   - Tauri command `background_get` { id }                   → returns { mime_type, base64 }
+//
+// Reusing the same key/event lets the popovers stay in lock-step with the
+// `/chat` overlay without yantra-app having to inject anything through props.
+//
+// Degrades gracefully:
+//   - Outside Tauri (regular browser, SSR): returns null synchronously.
+//   - No selection / unknown ID: returns null.
+//   - Selection changes mid-session: re-fetches automatically.
+// constants
+const SELECTED_BG_STORAGE_KEY = 'yantra:chat-background:selected-id';
+const BG_CHANGE_EVENT = 'yantra:chat-background-change';
+// 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 readSelectedId() {
+  if (typeof window === 'undefined') return null;
+  try {
+    return window.localStorage.getItem(SELECTED_BG_STORAGE_KEY);
+  } catch {
+    return null;
+  }
+}
+// main API
+/**
+ * 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.
+ */
+function useChatBackgroundImage() {
+  const [selectedId, setSelectedId] = React.useState(() => readSelectedId());
+  const [imageUrl, setImageUrl] = React.useState(null);
+  // Subscribe to selection changes from three possible sources:
+  //   (a) same-window `dispatchEvent` (picker on this webview).
+  //   (b) cross-tab `storage` event (rare in the Tauri shell but free).
+  //   (c) Tauri `listen` (picker on the *other* webview — desktop-bar vs dashboard).
+  React.useEffect(() => {
+    function localHandler(e) {
+      const detail = e.detail;
+      setSelectedId(detail?.id ?? null);
+    }
+    function storageHandler(e) {
+      if (e.key !== SELECTED_BG_STORAGE_KEY) return;
+      setSelectedId(e.newValue);
+    }
+    if (typeof window !== 'undefined') {
+      window.addEventListener(BG_CHANGE_EVENT, localHandler);
+      window.addEventListener('storage', storageHandler);
+    }
+    let unlisten = null;
+    let cancelled = false;
+    safeListen(BG_CHANGE_EVENT, payload => {
+      setSelectedId(payload?.id ?? null);
+    }).then(fn => {
+      if (cancelled) fn();else unlisten = fn;
+    });
+    return () => {
+      cancelled = true;
+      if (typeof window !== 'undefined') {
+        window.removeEventListener(BG_CHANGE_EVENT, localHandler);
+        window.removeEventListener('storage', storageHandler);
+      }
+      if (unlisten) unlisten();
+    };
+  }, []);
+  // Resolve ID → data URL. Tauri returns base64 — we only build the data URL
+  // once per ID change to avoid churning the popover background.
+  React.useEffect(() => {
+    if (!selectedId) {
+      setImageUrl(null);
+      return;
+    }
+    let alive = true;
+    safeInvoke('background_get', {
+      id: selectedId
+    }).then(dto => {
+      if (!alive) return;
+      if (dto && dto.base64) {
+        setImageUrl(`data:${dto.mime_type || 'image/png'};base64,${dto.base64}`);
+      } else {
+        setImageUrl(null);
+      }
+    });
+    return () => {
+      alive = false;
+    };
+  }, [selectedId]);
+  return imageUrl;
+}export{useChatBackgroundImage};//# sourceMappingURL=useChatBackgroundImage.js.map

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

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

package/lib/components/AIToolbar/index.d.ts

@@ -0,0 +1,8 @@
+export { AIToolbar, AIToolbarLeading, AIToolbarMain, AIToolbarTrailing, AIToolbarInputSurface, AIToolbarStatusDot, } from './components/AIToolbarPrimitives';
+export type { AIToolbarProps, AIToolbarSectionProps, AIToolbarInputSurfaceProps, AIToolbarStatusDotProps, } from './components/AIToolbarPrimitives';
+export * from './components';
+export type { CompletionSubmitOptions, UseCompletionReturn, SystemAudioProps, AIToolbarAppProps, AIToolbarHostPlatform, ChatMessage, ChatConversation, VadConfig, ToolbarAiProvider, ToolbarSelectedProvider, ToolbarAudioDevices, ToolbarAttachedFile, ToolbarScreenshotConfiguration, } from './components/types';
+export { setMarketplaceCharacters, useActiveCharacter, useCharacterPicker } from './hooks/useActiveCharacter';
+export { readPreferredActiveCharacterFileName } from '../../hooks/activeCharacterPreference';
+export type { MarketplaceCharacterEntry, ActiveCharacter, CharacterListEntry, CharacterPicker, } from './hooks/useActiveCharacter';
+//# sourceMappingURL=index.d.ts.map

package/lib/components/AIToolbar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/components/AIToolbar/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,SAAS,EACT,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,GACrB,MAAM,kCAAkC,CAAC;AAC1C,YAAY,EACR,cAAc,EACd,qBAAqB,EACrB,0BAA0B,EAC1B,uBAAuB,GAC1B,MAAM,kCAAkC,CAAC;AAE1C,cAAc,cAAc,CAAC;AAE7B,YAAY,EACR,uBAAuB,EACvB,mBAAmB,EACnB,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,WAAW,EACX,gBAAgB,EAChB,SAAS,EACT,iBAAiB,EACjB,uBAAuB,EACvB,mBAAmB,EACnB,mBAAmB,EACnB,8BAA8B,GACjC,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,wBAAwB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAC;AAC9G,OAAO,EAAE,oCAAoC,EAAE,MAAM,uCAAuC,CAAC;AAC7F,YAAY,EACR,yBAAyB,EACzB,eAAe,EACf,kBAAkB,EAClB,eAAe,GAClB,MAAM,4BAA4B,CAAC"}

package/lib/components/AIToolbar/utils/emotionClassifier.d.ts

@@ -0,0 +1,19 @@
+export type EmotionLabel = 'admiration' | 'amusement' | 'anger' | 'annoyance' | 'approval' | 'caring' | 'confusion' | 'curiosity' | 'desire' | 'disappointment' | 'disapproval' | 'disgust' | 'embarrassment' | 'excitement' | 'fear' | 'gratitude' | 'grief' | 'joy' | 'love' | 'nervousness' | 'neutral' | 'optimism' | 'pride' | 'realization' | 'relief' | 'remorse' | 'sadness' | 'surprise';
+/** All 28 labels, in the SillyTavern canonical order. */
+export declare const ALL_EMOTIONS: EmotionLabel[];
+/**
+ * Classify a chat-message string into one of the 28 GoEmotions labels.
+ *
+ * Returns `'neutral'` when no rule fires, which is what every sprite pack
+ * uses as the fallback (and what `character_get_expression` falls back to
+ * server-side when the requested sprite is missing).
+ *
+ * @param text - The assistant's message text. Markdown formatting is fine —
+ *               the regexes only care about word content.
+ * @param available - Optional restrict-set: only return labels present here.
+ *                    Useful when the caller knows which sprites the
+ *                    character actually ships and wants to avoid a Tauri
+ *                    round-trip for labels that will fall back anyway.
+ */
+export declare function classifyEmotion(text: string | null | undefined, available?: readonly string[]): EmotionLabel;
+//# sourceMappingURL=emotionClassifier.d.ts.map

package/lib/components/AIToolbar/utils/emotionClassifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"emotionClassifier.d.ts","sourceRoot":"","sources":["../../../../src/components/AIToolbar/utils/emotionClassifier.ts"],"names":[],"mappings":"AAqBA,MAAM,MAAM,YAAY,GAClB,YAAY,GACZ,WAAW,GACX,OAAO,GACP,WAAW,GACX,UAAU,GACV,QAAQ,GACR,WAAW,GACX,WAAW,GACX,QAAQ,GACR,gBAAgB,GAChB,aAAa,GACb,SAAS,GACT,eAAe,GACf,YAAY,GACZ,MAAM,GACN,WAAW,GACX,OAAO,GACP,KAAK,GACL,MAAM,GACN,aAAa,GACb,SAAS,GACT,UAAU,GACV,OAAO,GACP,aAAa,GACb,QAAQ,GACR,SAAS,GACT,SAAS,GACT,UAAU,CAAC;AAEjB,yDAAyD;AACzD,eAAO,MAAM,YAAY,EAAE,YAAY,EA6BtC,CAAC;AAgNF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,YAAY,CAuB5G"}

package/lib/components/AIToolbar/utils/emotionClassifier.js

@@ -0,0 +1,142 @@
+// Lightweight emotion classifier for assistant message text.
+//
+// Picks one of the 28 SillyTavern / GoEmotions labels so the AIToolbar can
+// switch the assistant's avatar to the matching expression sprite (see
+// `packages-extensions/seraphina-character-extension/characters/Seraphina/`
+// for the canonical sprite layout: `neutral.png`, `joy.png`, `caring.png`,
+// `surprise.png`, etc.).
+//
+// This is intentionally a heuristic (regex/keyword scoring) — fast, offline,
+// no model dependency — and is the same shape (`text → label`) as a real
+// GoEmotions classifier, so it can be transparently swapped for an ONNX
+// transformer later without touching the call sites.
+//
+// Limitations:
+//   - English only; would need rework for i18n responses.
+//   - Misses subtle nuance (sarcasm, mixed emotions) — picks the *strongest*
+//     signal and never returns more than one label.
+//   - Stage directions in italics ("smiles warmly") count the same as inline
+//     dialogue; that's actually desirable for character-card style replies
+//     where mood lives in the prose.
+/** All 28 labels, in the SillyTavern canonical order. */
+const RULES = [{
+  label: 'joy',
+  patterns: [/\b(happy|happiness|joy(ful)?|delight(ed|ful)?|cheerful|glad)\b/gi, /\b(smile[sd]?|grin(s|ned|ning)?|beam(s|ing|ed)?)\b/gi, /:\)|=\)|<3+/g]
+}, {
+  label: 'amusement',
+  patterns: [/\b(laugh(s|ed|ing|ter)?|chuckle[sd]?|giggle[sd]?|snicker(s|ed|ing)?)\b/gi, /\b(amus(ed|ing|ement)|funny|hilarious|teasing)\b/gi, /\bha+ha+\b/gi, /lol\b/gi]
+}, {
+  label: 'love',
+  patterns: [/\b(i love you|love you|my love|beloved|darling|sweetheart|dearest)\b/gi, /\b(adore[sd]?|cherish(ed|es)?|smitten)\b/gi],
+  weight: 2
+}, {
+  label: 'caring',
+  patterns: [/\b(gentle(ly)?|tender(ly)?|softly|kind(ly|ness)?|warm(ly|th)?|reassuring(ly)?)\b/gi, /\b(comfort(s|ed|ing)?|soothing(ly)?|protect(s|ing|ed)?|nurturing)\b/gi, /\b(are you (ok|okay|alright)|how are you feeling|don'?t worry)\b/gi]
+}, {
+  label: 'admiration',
+  patterns: [/\b(impressive|impressed|brilliant|magnificent|incredible|amazing|remarkable|astonishing|stunning|breathtaking)\b/gi, /\b(well done|great job|so proud of you)\b/gi]
+}, {
+  label: 'approval',
+  patterns: [/\b(approve|agree|exactly|precisely|that'?s right|good idea|sounds good|works for me)\b/gi, /\b(yes,?\s+(of course|absolutely|certainly))/gi]
+}, {
+  label: 'disapproval',
+  patterns: [/\b(disapprove|that'?s wrong|i don'?t agree|i wouldn'?t|shouldn'?t have)\b/gi, /\b(unacceptable|not okay)\b/gi]
+}, {
+  label: 'anger',
+  patterns: [/\b(angry|furious|enraged|seething|livid|outraged)\b/gi, /\b(scowl(s|ed|ing)?|glare[sd]?|snarl(s|ed|ing)?|growl(s|ed|ing)?)\b/gi, /\bhow dare you\b/gi],
+  weight: 2
+}, {
+  label: 'annoyance',
+  patterns: [/\b(annoy(ed|ing|ance)?|irritat(ed|ing|ion)|frustrat(ed|ing|ion))\b/gi, /\b(sigh(s|ed|ing)?|huff(s|ed|ing)?|rolls? (her|his|their) eyes)\b/gi, /\b(ugh|tsk)\b/gi]
+}, {
+  label: 'fear',
+  patterns: [/\b(afraid|scared|terrified|frightened|fearful|horrified)\b/gi, /\b(trembl(es|ed|ing)|shiver(s|ed|ing)?|flinch(es|ed|ing)?)\b/gi, /\b(panic(ked|king)?|dread)\b/gi],
+  weight: 2
+}, {
+  label: 'nervousness',
+  patterns: [/\b(nervous(ly|ness)?|anxious(ly)?|uneasy|jittery|tense(ly)?|on edge)\b/gi, /\b(fidget(s|ed|ing)?|bites? (her|his|their) lip|wrings? (her|his|their) hands)\b/gi]
+}, {
+  label: 'sadness',
+  patterns: [/\b(sad(ness|ly)?|unhappy|sorrow(ful)?|heartbroken|miserable|melancholy|forlorn)\b/gi, /\b(tear(s|ful|y)|crying|weep(s|ing|ed)?|sob(s|bing|bed)?)\b/gi, /:\(/g],
+  weight: 2
+}, {
+  label: 'grief',
+  patterns: [/\b(grief|grieving|mourn(s|ed|ing)?|bereaved|devastated)\b/gi, /\b(loss of|passed away|gone forever)\b/gi],
+  weight: 2
+}, {
+  label: 'remorse',
+  patterns: [/\b(i'?m sorry|i am sorry|my apologies|apologi[sz]e|forgive me|regret(s|ted|ting)?|guilty|guilt)\b/gi, /\b(shouldn'?t have|wish i hadn'?t)\b/gi],
+  weight: 2
+}, {
+  label: 'disappointment',
+  patterns: [/\b(disappointed|disappointing|let down|underwhelm(ed|ing)?|expected (more|better))\b/gi]
+}, {
+  label: 'embarrassment',
+  patterns: [/\b(embarrass(ed|ing|ment)?|flustered|mortified|sheepish(ly)?)\b/gi, /\b(blush(es|ed|ing)?|cheeks (turn|burn|flush))\b/gi]
+}, {
+  label: 'disgust',
+  patterns: [/\b(disgust(ed|ing)?|revolted|repulsed|nauseat(ed|ing)|gross|yuck|ew)\b/gi, /\b(grimace[sd]?|wrinkles? (her|his|their) nose)\b/gi]
+}, {
+  label: 'excitement',
+  patterns: [/\b(excited(ly)?|thrilled|exhilarat(ed|ing)|exhilaration|elated|ecstatic|stoked|pumped)\b/gi, /\b(can'?t wait|bouncing|jumps? up)\b/gi]
+}, {
+  label: 'gratitude',
+  patterns: [/\b(thank you|thanks|thank(ful|fully)?|grateful(ly)?|appreciat(e|ed|ing|ion))\b/gi],
+  weight: 2
+}, {
+  label: 'pride',
+  patterns: [/\b(proud(ly)?|pride)\b/gi, /\b(chin (held )?high|stands? tall)\b/gi]
+}, {
+  label: 'relief',
+  patterns: [/\b(relief|relieved|reliev(es|ed|ing)?)\b/gi, /\b(exhale[sd]? (deeply|slowly)|breathes? out)\b/gi]
+}, {
+  label: 'optimism',
+  patterns: [/\b(hopeful(ly)?|optimist(ic)?|things will (work|turn) out|look(ing)? forward|we'?ll figure)\b/gi]
+}, {
+  label: 'desire',
+  patterns: [/\b(crave[sd]?|yearn(s|ed|ing)?|long(s|ed|ing) for|want(s|ed|ing)? you|need(s|ed|ing)? you)\b/gi, /\b(lean(s|ed|ing)? in close|breathless)\b/gi]
+}, {
+  label: 'curiosity',
+  patterns: [/\b(curious(ly)?|curiosity|intrigu(ed|ing)|wonder(s|ed|ing)? (about|what|why|how))\b/gi, /\btell me more\b/gi]
+}, {
+  label: 'confusion',
+  patterns: [/\b(confus(ed|ing|ion)|puzzl(ed|ing)|baffl(ed|ing)|perplex(ed|ing))\b/gi, /\b(tilts? (her|his|their) head|raises? an eyebrow|i don'?t understand|what do you mean)\b/gi, /\?\?+/g]
+}, {
+  label: 'realization',
+  patterns: [/\b(realiz(es|ed|ing)|realisation|i see now|of course!|that makes sense|finally understand)\b/gi, /\b(aha|eureka)\b/gi]
+}, {
+  label: 'surprise',
+  patterns: [/\b(surpris(ed|ing|e)|astonish(ed|ing)|astounded|shocked|stunned|taken aback)\b/gi, /\b(gasp(s|ed|ing)?|eyes (widen|go wide))\b/gi, /\b(oh!|wha[at]?\?!)/gi]
+}];
+/**
+ * Classify a chat-message string into one of the 28 GoEmotions labels.
+ *
+ * Returns `'neutral'` when no rule fires, which is what every sprite pack
+ * uses as the fallback (and what `character_get_expression` falls back to
+ * server-side when the requested sprite is missing).
+ *
+ * @param text - The assistant's message text. Markdown formatting is fine —
+ *               the regexes only care about word content.
+ * @param available - Optional restrict-set: only return labels present here.
+ *                    Useful when the caller knows which sprites the
+ *                    character actually ships and wants to avoid a Tauri
+ *                    round-trip for labels that will fall back anyway.
+ */
+function classifyEmotion(text, available) {
+  if (!text) return 'neutral';
+  let bestLabel = 'neutral';
+  let bestScore = 0;
+  for (const rule of RULES) {
+    const weight = rule.weight ?? 1;
+    let score = 0;
+    for (const pattern of rule.patterns) {
+      const matches = text.match(pattern);
+      if (matches) score += matches.length * weight;
+    }
+    if (score > bestScore) {
+      bestScore = score;
+      bestLabel = rule.label;
+    }
+  }
+  return bestLabel;
+}export{classifyEmotion};//# sourceMappingURL=emotionClassifier.js.map

package/lib/components/AIToolbar/utils/emotionClassifier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"emotionClassifier.js","sources":["../../../../src/components/AIToolbar/utils/emotionClassifier.ts"],"sourcesContent":[null],"names":[],"mappings":"AAqBA;AA8BA;AACA;AA6OA;;;;;;;;;;;;;AAaG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/Button/Button.d.ts

@@ -8,6 +8,6 @@ export interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElemen
     fullWidth?: boolean;
     children: React.ReactNode;
 }
-declare const Button: ({ variant, size, isLoading, fullWidth, className, children, disabled, ...props }: ButtonProps) => React.JSX.Element;
+declare const Button: ({ variant, size, isLoading, fullWidth, className, children, disabled, ...props }: ButtonProps) => import("react/jsx-runtime").JSX.Element;
 export { Button as TailwindUiButton };
 //# sourceMappingURL=Button.d.ts.map

package/lib/components/Button/Button.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Button.d.ts","sourceRoot":"","sources":["../../../src/components/Button/Button.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;AACrF,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEtD,MAAM,WAAW,WAAY,SAAQ,KAAK,CAAC,oBAAoB,CAAC,iBAAiB,CAAC;IAC9E,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC7B;AAED,QAAA,MAAM,MAAM,GAAI,kFASb,WAAW,sBA6Cb,CAAC;AAEF,OAAO,EAAE,MAAM,IAAI,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"Button.d.ts","sourceRoot":"","sources":["../../../src/components/Button/Button.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAG1B,MAAM,MAAM,aAAa,GAAG,SAAS,GAAG,WAAW,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;AACrF,MAAM,MAAM,UAAU,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,CAAC;AAEtD,MAAM,WAAW,WAAY,SAAQ,KAAK,CAAC,oBAAoB,CAAC,iBAAiB,CAAC;IAC9E,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAC;CAC7B;AAED,QAAA,MAAM,MAAM,GAAI,kFASb,WAAW,4CA6Cb,CAAC;AAEF,OAAO,EAAE,MAAM,IAAI,gBAAgB,EAAE,CAAC"}

package/lib/components/Button/Button.js

@@ -1,4 +1,4 @@
-import React__default from'react';import {Loader2}from'lucide-react';const Button = ({
+import {jsxs,jsx}from'react/jsx-runtime';import {Loader2}from'lucide-react';const Button = ({
   variant = 'primary',
   size = 'medium',
   isLoading = false,
@@ -39,11 +39,12 @@ import React__default from'react';import {Loader2}from'lucide-react';const Butto
   const sizeClasses = getSizeClasses();
   const widthClass = fullWidth ? 'w-full' : '';
   const disabledClass = isLoading || disabled ? 'opacity-50 cursor-not-allowed' : 'cursor-pointer interactive-hover';
-  return React__default.createElement("button", {
+  return jsxs("button", {
     className: `${baseClasses} ${variantClasses} ${sizeClasses} ${widthClass} ${disabledClass} ${className}`,
     disabled: isLoading || disabled,
-    ...props
-  }, isLoading && React__default.createElement(Loader2, {
-    className: "w-4 h-4 mr-2 animate-spin"
-  }), children);
+    ...props,
+    children: [isLoading && jsx(Loader2, {
+      className: "w-4 h-4 mr-2 animate-spin"
+    }), children]
+  });
 };export{Button as TailwindUiButton};//# sourceMappingURL=Button.js.map

package/lib/components/Button/Button.js.map

@@ -1 +1 @@
-{"version":3,"file":"Button.js","sources":["../../../src/components/Button/Button.tsx"],"sourcesContent":[null],"names":[],"mappings":"qEAIA,MAAM,MAAM;AAEZ,EAAA,OAAM,GAAA;MACF,GAAA,QAAU;WACH,GAAA,KAAA;WACP,GAAU,KAAE;WACZ,GAAU,EAAE;AACZ,EAAA,QAAA;AACH,EAAA,QAAA;AAED,EAAA,GAAA;AAwDA,CAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"Button.js","sources":["../../../src/components/Button/Button.tsx"],"sourcesContent":[null],"names":[],"mappings":"4EAIA,MAAM,MAAM;AAEZ,EAAA,OAAM,GAAA;MACF,GAAA,QAAU;WACH,GAAA,KAAA;WACP,GAAU,KAAE;WACZ,GAAU,EAAE;AACZ,EAAA,QAAA;AACH,EAAA,QAAA;AAED,EAAA,GAAA;AAwDA,CAAA,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/components/CharacterSlotPicker/CharacterSlotPicker.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 3×3 grid of character slots (1–9).
+ *
+ * - Click an empty tile → opens a small "pick" popover listing installed
+ *   characters; clicking one assigns it to the slot.
+ * - Click a filled tile → activates that character (`setActive(name)`).
+ * - Right-click (or "×" badge) a filled tile → clears the slot.
+ * - The default slot wears a ring + star; any tile's ⋆ button promotes it
+ *   to default.
+ *
+ * Self-contained: pulls the installed character list from
+ * `useCharacterPicker()` and stores assignments via
+ * `useCharacterSlots()`.  No props required.
+ */
+export interface CharacterSlotPickerProps {
+    /** Optional className applied to the outer wrapper. */
+    className?: string;
+}
+export declare function CharacterSlotPicker({ className }: CharacterSlotPickerProps): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=CharacterSlotPicker.d.ts.map

package/lib/components/CharacterSlotPicker/CharacterSlotPicker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CharacterSlotPicker.d.ts","sourceRoot":"","sources":["../../../src/components/CharacterSlotPicker/CharacterSlotPicker.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAqQH,MAAM,WAAW,wBAAwB;IACrC,uDAAuD;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,mBAAmB,CAAC,EAAE,SAAS,EAAE,EAAE,wBAAwB,2CA6D1E"}