omp-uwu 0.2.0 → 0.4.0

package/README.md

@@ -22,8 +22,11 @@ Restart omp. uwu mode is **on** by default in every session.
 - `/uwu on` / `/uwu off` sets it explicitly
 - `/uwu rewrite` uses omp's finalized-message rewrite hook when available
 - `/uwu prompt` asks the model to write in uwu style while it streams
+- `/uwu colors on` / `/uwu colors off` enables or disables the optional kawaii palette (off by default; preference persists)
 
-The TUI also shows a small, theme-accent-colored `(◕ᴗ◕✿) uwu` status badge. Other clients and plain output are not colorized.
+The palette colors chat markdown and the user-message bubble without putting ANSI codes into message text/history. It is applied as an in-memory TUI theme; components sharing those colors can change too. The host's in-memory theme setter pauses automatic theme detection until omp restarts. The TUI also shows a theme-accent `(◕ᴗ◕✿) uwu` status badge; other clients/plain output are not colorized.
+
+With colors on, the TUI also paints **sparkles** in the agent's chat prose: `uwu`/`owo` get a per-letter pastel rainbow, and kaomoji (listed or not, e.g. `(◕ᴗ◕✿)`, `(ﾉ◕ヮ◕)ﾉ`) and glyphs like `♡ ☆ ✧ ✿` get a pastel tint. This happens at render time through omp's per-message text color transform, which only ever sees plain prose runs, so inline code, code blocks, link targets and the stored message text stay untouched. omp's `AssistantMessageComponent` is not part of the extension API, so the plugin finds it through its shared `Container` base class when the first assistant message is created; if a future omp changes that shape, sparkles are simply skipped and the palette still applies.
 
 ## What gets uwufied, and what doesn't
 
@@ -35,7 +38,7 @@ The TUI also shows a small, theme-accent-colored `(◕ᴗ◕✿) uwu` status bad
 | | Tool-call arguments and file contents the agent writes or edits |
 | | Commit messages and prompts sent to subagents |
 
-Style rules include `r`/`l` → `w`, occasional `th` → `d`, `na/ne/no` → `nya/nye/nyo`, occasional stutter, and a broad rotating selection of kaomoji. The kaomoji selection includes examples from [kaomoji.you](https://kaomoji.you/), such as `٩(◕‿◕｡)۶`, `(ฅ^•ﻌ•^ฅ)`, and `(づ｡◕‿‿◕｡)づ`. Meaning, numbers and warnings must stay readable.
+Style rules include `r`/`l` → `w`, occasional `th` → `d`, `na/ne/no` → `nya/nye/nyo`, occasional stutter, a broad rotating selection of kaomoji, and the odd cute emoji (`✨ 💖 🌸 🎀`). The kaomoji selection includes examples from [kaomoji.you](https://kaomoji.you/), such as `٩(◕‿◕｡)۶`, `(ฅ^•ﻌ•^ฅ)`, and `(づ｡◕‿‿◕｡)づ`. Meaning, numbers and warnings must stay readable.
 
 Here's the same prompt and model, with the mode off and on:
 
@@ -43,6 +46,14 @@ Here's the same prompt and model, with the mode off and on:
 
 These are real, unedited replies from `anthropic/claude-opus-5-5`, rendered as images. Both code blocks are identical byte for byte. The transcripts are in [`demo/`](demo).
 
+### kawaii/uwu-bench
+
+On kawaii/uwu-bench, Opus 5.5 scores 0.1% on its own and 98.5% with omp-uwu enabled:
+
+![kawaii/uwu-bench: Opus 5.5 scores 0.1%, Opus 5.5 with omp-uwu scores 98.5%](https://raw.githubusercontent.com/NaC-L/omp-uwu/main/demo/uwu-bench.png)
+
+Only the two scores come from the benchmark run. The other numbers on the chart are computed from them, and the terminal and config panels are decoration.
+
 ## How it works
 
 On the first turn, omp-uwu uses the prompt style until the host demonstrates support for the awaited `assistant_message` hook; after that, the default **rewrite** style deterministically uwufies finalized assistant text before it is added to history and context. This first-turn check makes the experience work on both older and newer omp builds. Only text in existing text blocks is changed; code/tool blocks and their metadata stay untouched. Rewrites are markdown-aware and preserve fenced/inline code, URLs, paths, numbers, quoted text, identifiers, and safety-critical words.
@@ -51,13 +62,13 @@ The hook runs after streaming has finished. The TUI refreshes the current assist
 
 - **Deterministic rewrite.** No style instruction/token overhead once the hook is detected.
 - **Prompt style.** Model-dependent, with live uwu output while streaming.
-- **Session-local toggle.** Mode and enabled state reset for each new session.
+- **Persistent settings.** `/uwu off` is remembered across sessions; `/uwu on` re-enables uwu. The colors preference is remembered too. Settings are stored in `~/.omp/agent/omp-uwu.json`. UwU mode remains on by default until explicitly changed.
 
 ## Install options
 
 ```sh
 omp plugin install omp-uwu          # from npm (recommended)
-omp plugin install omp-uwu@0.1.0    # pin a version
+omp plugin install omp-uwu@0.4.0    # pin a version
 omp plugin uninstall omp-uwu        # remove
 ```
 
@@ -85,6 +96,12 @@ uv run --with pillow python demo/render.py
 
 Model output varies between runs, so re-run `record.sh` until you get a reply that reads well.
 
+The uwu-bench chart is drawn from [`demo/uwu-bench.html`](demo/uwu-bench.html). Edit the HTML, then take a 1536×960 screenshot with headless Chrome:
+
+```sh
+chrome --headless=new --hide-scrollbars --window-size=1536,960 --screenshot="$PWD/demo/uwu-bench.png" "file://$PWD/demo/uwu-bench.html"
+```
+
 ### Releasing
 
 CI (`.github/workflows/ci.yml`) runs `check` and the tests on pushes to `main` and on pull requests. Pushing a `v*` tag runs them again, checks that the tag matches `version` in `package.json`, and publishes to npm with provenance (`.github/workflows/publish.yml`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omp-uwu",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "omp extension for playful uwu chat styling, markdown-safe rewrites, and kawaii kaomoji",
   "type": "module",
   "license": "MIT",

package/src/index.ts

@@ -1,4 +1,9 @@
-import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { KawaiiTheme } from "./kawaii.ts";
+import { type ContainerClass, installSparkles, sparkle, themePaint } from "./sparkle.ts";
+
+import type { ExtensionAPI, Theme } from "@oh-my-pi/pi-coding-agent";
 import { uwufy } from "./uwufy.ts";
 
 export const UWU_PROMPT = `
@@ -6,8 +11,9 @@ export const UWU_PROMPT = `
 Write your prose replies to the user in playful "uwu" speak:
 - replace r/l with w in most words ("weawwy", "hewwo"), "th" → "d" occasionally, "na/ne/no" → "nya/nye/nyo" sometimes
 - occasional stutter ("h-hewwo") and cute kaomoji/emoticons, varied naturally: (◕ᴗ◕✿), (o^▽^o), (´｡• ω •｡\u0060), ٩(◕‿◕｡)۶, (✧ω✧), (๑˃ᴗ˂)ﻭ, ヽ(・∀・)ﾉ, (っ˘ω˘ς), (｡•̀ᴗ-)✧, (づ｡◕‿‿◕｡)づ, (ฅ^•ﻌ•^ฅ), (๑>◡<๑), owo, >w<, ^w^, :3; at most one at a sentence end
+- now and then a cute emoji or sparkle instead (✨, 💖, 🌸, 🎀, ♡, ☆), never more than one per paragraph
 - keep it readable; never let the style hide meaning, numbers or warnings
-- colors are only for UI chrome; never insert ANSI color codes into chat text
+- the TUI colors kaomoji, uwu and sparkles by itself; never insert ANSI color codes into chat text
 
 NEVER uwufy any of these — keep them exact and byte-for-byte correct:
 - code, code blocks, inline code, shell commands, file paths, URLs, identifiers, config keys, error messages you quote
@@ -25,16 +31,32 @@ type UiContext = {
   ui?: {
     notify(message: string, level: "info"): void;
     setStatus?(key: string, text: string | undefined): void;
-    theme?: { fg(color: string, text: string): string };
+    theme?: Theme;
   };
 };
 
 export default function uwuExtension(pi: ExtensionAPI) {
   let enabled = true;
+  let colorsEnabled = false;
+  let stateReady: Promise<void> | undefined;
   let style: "rewrite" | "prompt" = "rewrite";
   let hookSupport: boolean | undefined;
   let promptAddedThisTurn = false;
   let notifiedFallback = false;
+  const statePath = join(pi.pi.getAgentDir(), "omp-uwu.json");
+  const kawaiiTheme = new KawaiiTheme(pi.pi);
+  const loadState = () => {
+    stateReady ??= readFile(statePath, "utf8")
+      .then((raw) => {
+        const state: unknown = JSON.parse(raw);
+        if (typeof state !== "object" || state === null) return;
+        if ("enabled" in state && typeof state.enabled === "boolean") enabled = state.enabled;
+        if ("colors" in state && typeof state.colors === "boolean") colorsEnabled = state.colors;
+      })
+      .catch(() => {});
+    return stateReady;
+  };
+  const saveState = () => writeFile(statePath, `${JSON.stringify({ enabled, colors: colorsEnabled }, null, 2)}\n`, "utf8");
 
   const updateBadge = (ctx: UiContext) => {
     if (ctx.mode !== "tui" || ctx.agent?.kind === "sub" || !ctx.ui?.setStatus) return;
@@ -42,11 +64,45 @@ export default function uwuExtension(pi: ExtensionAPI) {
     ctx.ui.setStatus("omp-uwu", badge && ctx.ui.theme ? ctx.ui.theme.fg("accent", badge) : badge);
   };
 
+  // Paints kaomoji/uwu in rendered chat prose at display time only (see sparkle.ts).
+  // Installed at load so the first assistant component, even a resumed one, is caught.
+  const paint = themePaint(() => pi.pi.theme);
+  const host = pi.pi as { Container?: ContainerClass };
+  if (host.Container) {
+    installSparkles(host.Container, { isActive: () => enabled && colorsEnabled, transform: (text) => sparkle(text, paint) });
+  }
+
+  const syncColors = (ctx: UiContext) => {
+    if (ctx.mode !== "tui" || ctx.agent?.kind === "sub" || !ctx.ui?.theme) return;
+    if (enabled && colorsEnabled) kawaiiTheme.enable(ctx.ui.theme);
+    else kawaiiTheme.disable(ctx.ui.theme);
+  };
+
   pi.registerCommand("uwu", {
-    description: "UwU chat style and mode (usage: /uwu [on|off|prompt|rewrite])",
+    description: "UwU chat style and mode (usage: /uwu [on|off|prompt|rewrite|colors [on|off]])",
     handler: async (args, rawCtx) => {
+      await loadState();
       const ctx = rawCtx as UiContext;
       const arg = String(args ?? "").trim().toLowerCase();
+      if (arg.startsWith("colors")) {
+        const option = arg.slice("colors".length).trim();
+        if (option === "on") colorsEnabled = true;
+        else if (option === "off") colorsEnabled = false;
+        else if (!option) colorsEnabled = !colorsEnabled;
+        else {
+          ctx.ui?.notify("Usage: /uwu [on|off|prompt|rewrite|colors [on|off]]", "info");
+          return;
+        }
+        try {
+          await saveState();
+        } catch {
+          ctx.ui?.notify("uwu setting could not be saved; it may reset next session", "info");
+        }
+        syncColors(ctx);
+        updateBadge(ctx);
+        ctx.ui?.notify(`kawaii chat colors ${colorsEnabled ? "on" : "off"}${colorsEnabled && !enabled ? " (active when uwu mode is on)" : ""}`, "info");
+        return;
+      }
       if (arg === "prompt" || arg === "rewrite") {
         style = arg;
         enabled = true;
@@ -54,17 +110,29 @@ export default function uwuExtension(pi: ExtensionAPI) {
       else if (arg === "off") enabled = false;
       else if (!arg) enabled = !enabled;
       else {
-        ctx.ui?.notify("Usage: /uwu [on|off|prompt|rewrite]", "info");
+        ctx.ui?.notify("Usage: /uwu [on|off|prompt|rewrite|colors [on|off]]", "info");
         return;
       }
+      try {
+        await saveState();
+      } catch {
+        ctx.ui?.notify("uwu setting could not be saved; it may reset next session", "info");
+      }
+      syncColors(ctx);
       updateBadge(ctx);
       ctx.ui?.notify(enabled ? `uwu mode ${style === "rewrite" ? "rewrite" : "prompt"}! (◕ᴗ◕✿)` : "uwu mode off", "info");
     },
   });
 
-  pi.on("session_start", (_event, rawCtx) => updateBadge(rawCtx as UiContext));
+  pi.on("session_start", async (_event, rawCtx) => {
+    await loadState();
+    const ctx = rawCtx as UiContext;
+    syncColors(ctx);
+    updateBadge(ctx);
+  });
 
   pi.on("before_agent_start", async (event, rawCtx) => {
+    await loadState();
     promptAddedThisTurn = false;
     const ctx = rawCtx as UiContext;
     if (ctx.agent?.kind === "sub") return undefined;
@@ -76,6 +144,7 @@ export default function uwuExtension(pi: ExtensionAPI) {
     return { systemPrompt: [...event.systemPrompt, UWU_PROMPT] };
   });
 
+
   // The hook is newer than the bundled 18.4.3 types, so register structurally.
   // ExtensionAPI.on stores event names as strings; old hosts simply never emit it.
   (pi.on as unknown as (name: string, handler: (event: RewriteEvent) => unknown) => void)(

package/src/kawaii.ts

@@ -0,0 +1,103 @@
+import type * as PiCodingAgent from "@oh-my-pi/pi-coding-agent";
+import type { Theme, ThemeBg, ThemeColor } from "@oh-my-pi/pi-coding-agent";
+
+export type ThemeRuntime = Pick<typeof PiCodingAgent, "Theme" | "setThemeInstance">;
+
+const FG_KEYS: ThemeColor[] = [
+  "accent", "border", "borderAccent", "borderMuted", "success", "error", "warning", "muted", "dim", "text",
+  "thinkingText", "userMessageText", "customMessageText", "customMessageLabel", "toolTitle", "toolOutput",
+  "mdHeading", "mdLink", "mdLinkUrl", "mdCode", "mdCodeBlock", "mdCodeBlockBorder", "mdQuote", "mdQuoteBorder",
+  "mdHr", "mdListBullet", "toolDiffAdded", "toolDiffRemoved", "toolDiffContext", "syntaxComment", "syntaxKeyword",
+  "syntaxFunction", "syntaxVariable", "syntaxString", "syntaxNumber", "syntaxType", "syntaxOperator", "syntaxPunctuation",
+  "thinkingOff", "thinkingMinimal", "thinkingLow", "thinkingMedium", "thinkingHigh", "thinkingXhigh", "thinkingMax",
+  "bashMode", "pythonMode", "statusLineSep", "statusLineModel", "statusLinePath", "statusLineGitClean", "statusLineGitDirty",
+  "statusLineContext", "statusLineSpend", "statusLineStaged", "statusLineDirty", "statusLineUntracked", "statusLineOutput",
+  "statusLineCost", "statusLineSubagents",
+];
+
+const BG_KEYS: ThemeBg[] = ["selectedBg", "userMessageBg", "customMessageBg", "toolPendingBg", "toolSuccessBg", "toolErrorBg", "statusLineBg"];
+const FG_DEFAULT = "\x1b[39m";
+const BG_DEFAULT = "\x1b[49m";
+
+const DARK_PALETTE: Partial<Record<ThemeColor | ThemeBg, string>> = {
+  accent: "#ff8fcf", border: "#b99aca", borderAccent: "#ff8fcf", thinkingText: "#cbb8ef",
+  mdHeading: "#ff9ed8", mdLink: "#b5a8ff", mdLinkUrl: "#a08fd8", mdCode: "#8fe8c3",
+  mdCodeBlockBorder: "#b99aca", mdQuote: "#ffc4e1", mdQuoteBorder: "#ff8fcf", mdHr: "#b99aca",
+  mdListBullet: "#ffb38a", userMessageBg: "#3a2433",
+};
+
+const LIGHT_PALETTE: Partial<Record<ThemeColor | ThemeBg, string>> = {
+  accent: "#c52f80", border: "#9c75b6", borderAccent: "#c52f80", thinkingText: "#735f9e",
+  mdHeading: "#b32470", mdLink: "#624ac6", mdLinkUrl: "#7663b1", mdCode: "#087b5c",
+  mdCodeBlockBorder: "#9c75b6", mdQuote: "#99416f", mdQuoteBorder: "#c52f80", mdHr: "#9c75b6",
+  mdListBullet: "#c35424", userMessageBg: "#fde8f3",
+};
+
+/** Build a pastel copy of a host theme, retaining its colors outside the palette. */
+export function buildKawaiiTheme(ThemeClass: ThemeRuntime["Theme"], base: Theme): Theme {
+  const palette = base.isLight ? LIGHT_PALETTE : DARK_PALETTE;
+  const fg: Partial<Record<ThemeColor, string>> = {};
+  const bg: Partial<Record<ThemeBg, string>> = {};
+
+  for (const key of FG_KEYS) {
+    try {
+      const ansi = base.getFgAnsi(key);
+      fg[key] = palette[key] ?? (ansi === FG_DEFAULT ? "" : base.getColorHex(key));
+    } catch {
+      // A host newer than the plugin's type dependency may expose extra colors.
+    }
+  }
+  for (const key of BG_KEYS) {
+    try {
+      const ansi = base.getBgAnsi(key);
+      bg[key] = palette[key] ?? (ansi === BG_DEFAULT ? "" : base.getBgHex(key));
+    } catch {
+      // Missing theme colors are left to the host defaults.
+    }
+  }
+
+  const preset = base.getSymbolPreset();
+  const theme = new ThemeClass(
+    fg as Record<ThemeColor, string>,
+    bg as Record<ThemeBg, string>,
+    base.getColorMode(),
+    preset,
+    {},
+    { status: base.getSpinnerFrames("status"), activity: base.getSpinnerFrames("activity") },
+  );
+  // A nested colored span (a sparkle, an inline code span) ends in a
+  // foreground reset, which would drop the enclosing heading/link color for the
+  // rest of the span. Switch back to the enclosing color there instead.
+  const plainFg = theme.fg.bind(theme);
+  theme.fg = (color, text) => {
+    const open = theme.getFgAnsi(color);
+    return plainFg(color, open === FG_DEFAULT ? text : text.replaceAll(FG_DEFAULT, open));
+  };
+  return theme;
+}
+
+/** A reversible, ephemeral kawaii theme; never edits the user's theme file. */
+export class KawaiiTheme {
+  #runtime: ThemeRuntime;
+  #base: Theme | undefined;
+  #overlay: Theme | undefined;
+
+  constructor(runtime: ThemeRuntime) {
+    this.#runtime = runtime;
+  }
+
+
+  enable(current: Theme): void {
+    if (this.#overlay && current === this.#overlay) return;
+    this.#base = current;
+    this.#overlay = buildKawaiiTheme(this.#runtime.Theme, current);
+    this.#runtime.setThemeInstance(this.#overlay);
+  }
+
+  disable(current: Theme | undefined): void {
+    if (!this.#overlay) return;
+    if (current === this.#overlay && this.#base) this.#runtime.setThemeInstance(this.#base);
+    this.#base = undefined;
+    this.#overlay = undefined;
+  }
+}

package/src/sparkle.ts

@@ -0,0 +1,187 @@
+/**
+ * Render-time "sparkles": paints kaomoji, uwu/owo and cute symbols in the
+ * assistant's chat prose with the kawaii palette.
+ *
+ * Nothing is written into message text, history or model context. omp renders
+ * assistant prose through a per-component text color transform that Markdown
+ * applies to plain-text runs only — never to inline code, code blocks or link
+ * targets — so painting there leaves every exact-text surface untouched.
+ */
+import type { Theme, ThemeColor } from "@oh-my-pi/pi-coding-agent";
+import { EMOTICON_TOKENS } from "./uwufy.ts";
+
+/** Palette keys the kawaii theme sets; painting rotates through them. */
+const TONES: readonly ThemeColor[] = ["accent", "mdLink", "mdCode", "mdListBullet", "mdHeading", "thinkingText"];
+
+/**
+ * Decorative monochrome glyphs worth a tint on their own. Color emoji ignore fg,
+ * and a glyph carrying VS16 renders as emoji, so those are left alone.
+ */
+const SYMBOLS = "♡✧☆★✿❀⋆";
+
+// Known emoticons, longest first so a kaomoji wins over the uwu/♡ inside it.
+// Word-edge guards keep `:3` in `a:3` or `owo` in `owowl` unpainted.
+const KNOWN = [...EMOTICON_TOKENS]
+	.filter((token) => !/^\p{Extended_Pictographic}+$/u.test(token))
+	.sort((a, b) => b.length - a.length)
+	.map((token) => token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+	.join("|");
+// Unlisted kaomoji: parentheses holding at least one face feature (eyes,
+// mouths, cheeks), no digits and no two letters in a row, optionally hugged by
+// up to two arm glyphs, and not glued to a word. So `(x−y)`, `(a—b)`,
+// `(şimdi)` and `ş(a…)ı` stay plain.
+const FEATURES = "◕ᴗω▽◡•ᵔ˘≧≦˃˂・･︶﹏‿꒳ᗜﻌ∀ヮ´︿◉⊙ಠ︵□ᴥ＾｡⌒⩊ᵕ≖ˆ˶˵ᐛ⁀﹃ↀ✧♡";
+const ARMS = String.raw`٩۶ヽﾉノづっ✧♡☆⌒ヾᕕᕗ\\/`;
+const FACE = String.raw`(?<![\p{L}\p{N}])[${ARMS}]{0,2}\((?=[^()\n]*[${FEATURES}])(?![^()\n]*(?:\p{L}\p{M}*){2})[^()\n\p{N}]{1,16}\)[${ARMS}]{0,2}(?![\p{L}\p{N}])`;
+// Symbols take their combining marks along, so no color code splits a grapheme.
+const SPARKLE = new RegExp(
+	String.raw`(?<![\p{L}\p{N}_])(?:${KNOWN})(?![\p{L}\p{N}_])|${FACE}|[${SYMBOLS}](?!\p{M}*\uFE0F)\p{M}*`,
+	"gu",
+);
+const LETTERS = /^\p{L}+$/u;
+
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+export type Paint = (tone: ThemeColor, text: string) => string;
+
+/** FNV-1a; picks a stable starting tone per token. */
+function hash(value: string): number {
+	let h = 0x811c9dc5;
+	for (let i = 0; i < value.length; i++) h = Math.imul(h ^ value.charCodeAt(i), 0x01000193);
+	return h >>> 0;
+}
+
+/**
+ * Paint every sparkle in one plain-text run. Word emoticons (`uwu`, `OwO`) get
+ * a per-letter rainbow; faces and symbols get one tone. Deterministic, so a
+ * re-render of the same run yields the same bytes.
+ */
+export function sparkle(text: string, paint: Paint): string {
+	let ordinal = 0;
+	return text.replace(SPARKLE, (match) => {
+		const start = hash(match) + ordinal++;
+		if (!LETTERS.test(match)) return paint(TONES[start % TONES.length]!, match);
+		let index = 0;
+		let out = "";
+		for (const { segment } of graphemes.segment(match)) out += paint(TONES[(start + index++) % TONES.length]!, segment);
+		return out;
+	});
+}
+
+/** A paint function over the live host theme; unknown colors fall back to plain text. */
+export function themePaint(getTheme: () => Theme | undefined): Paint {
+	return (tone, text) => {
+		try {
+			return getTheme()?.fg(tone, text) ?? text;
+		} catch {
+			return text;
+		}
+	};
+}
+
+type ColorTransform = (text: string) => string;
+
+/** The two public methods of omp's AssistantMessageComponent this relies on. */
+interface AssistantPrototype {
+	updateContent(...args: unknown[]): unknown;
+	setTextColorTransform(transform?: ColorTransform): void;
+}
+
+/** omp's TUI `Container`, the base class of AssistantMessageComponent. */
+export interface ContainerClass {
+	prototype: { addChild(child: unknown): unknown };
+}
+
+export interface SparkleControl {
+	/** Whether new/updated assistant messages should be painted. */
+	isActive(): boolean;
+	/** Stable transform identity; Markdown caches renders by it. */
+	transform: ColorTransform;
+}
+
+/** Process-wide state, so extension reloads swap the control instead of re-patching. */
+interface Registry {
+	control?: SparkleControl;
+	assistant?: AssistantPrototype;
+	watching?: boolean;
+}
+const REGISTRY = Symbol.for("omp-uwu.sparkles");
+
+/** Walk up from an instance to the prototype that defines both assistant methods. */
+function findAssistantPrototype(value: unknown): AssistantPrototype | undefined {
+	for (let proto = value && typeof value === "object" ? Object.getPrototypeOf(value) : null; proto; proto = Object.getPrototypeOf(proto)) {
+		if (
+			Object.hasOwn(proto, "setTextColorTransform") &&
+			Object.hasOwn(proto, "updateContent") &&
+			typeof proto.setTextColorTransform === "function" &&
+			typeof proto.updateContent === "function"
+		) {
+			return proto as AssistantPrototype;
+		}
+	}
+	return undefined;
+}
+
+/**
+ * Give every assistant message component the sparkle transform while
+ * `control.isActive()`. A transform set by the host itself (e.g. the
+ * live-voice transcript tint) always wins over sparkles.
+ */
+function patchAssistant(proto: AssistantPrototype, registry: Registry): void {
+	const originalSet = proto.setTextColorTransform;
+	const originalUpdate = proto.updateContent;
+	const hostTransforms = new WeakMap<object, ColorTransform>();
+	const applied = new WeakMap<object, ColorTransform | undefined>();
+
+	proto.setTextColorTransform = function (this: object, transform?: ColorTransform) {
+		if (transform) hostTransforms.set(this, transform);
+		else hostTransforms.delete(this);
+		applied.delete(this);
+		originalSet.call(this, transform);
+	};
+	// Theme changes re-enter updateContent through invalidate(), so toggling
+	// colors repaints existing messages too.
+	proto.updateContent = function (this: object, ...args: unknown[]) {
+		if (!hostTransforms.has(this)) {
+			const control = registry.control;
+			const wanted = control?.isActive() ? control.transform : undefined;
+			if (applied.get(this) !== wanted) {
+				applied.set(this, wanted);
+				originalSet.call(this, wanted);
+			}
+		}
+		return originalUpdate.apply(this, args);
+	};
+}
+
+/**
+ * Hook sparkles into omp's AssistantMessageComponent.
+ *
+ * That class is not part of the extension API, and importing its module by
+ * path loads a second, unused copy when omp runs from its bundle. What
+ * extensions do share with the host is `Container`, its base class, and the
+ * component adds its first child in its constructor before any content
+ * update. So `addChild` is watched until the first assistant component shows
+ * up, its prototype is patched, and the watch is removed again.
+ */
+export function installSparkles(Container: ContainerClass, control: SparkleControl): void {
+	const holder = globalThis as { [REGISTRY]?: Registry };
+	const registry = (holder[REGISTRY] ??= {});
+	registry.control = control;
+	if (registry.assistant || registry.watching) return;
+
+	registry.watching = true;
+	const containerProto = Container.prototype;
+	const originalAdd = containerProto.addChild;
+	const watch = function (this: object, child: unknown) {
+		const assistant = findAssistantPrototype(this) ?? findAssistantPrototype(child);
+		if (assistant) {
+			if (containerProto.addChild === watch) containerProto.addChild = originalAdd;
+			registry.watching = false;
+			registry.assistant = assistant;
+			patchAssistant(assistant, registry);
+		}
+		return originalAdd.call(this, child);
+	};
+	containerProto.addChild = watch;
+}

package/src/uwufy.ts

@@ -23,10 +23,11 @@ export const EMOTICONS = [
 	"(♡˙︶˙♡)", "ヽ(♡‿♡)ノ", "(´꒳`)♡", "(ﾉ´ з `)ノ", "ヾ(・ω・*)",
 	"(⌒ω⌒)ﾉ", "(ᵔ⩊ᵔ)", "(=^･ω･^=)", "(ฅ^•ﻌ•^ฅ)", "(ᵕ—ᴗ—)",
 	"(｡•̀ᴗ-)✧", "(づ｡◕‿‿◕｡)づ", "(っ´▽`)っ", "( ˶ˆᗜˆ˵ )", "(๑>◡<๑)",
+	"✨", "💖", "🌸", "🎀",
 ] as const;
 
 /** Tokens treated as emoticons: never counted as words, never rewritten. */
-const EMOTICON_TOKENS = new Set<string>([
+export const EMOTICON_TOKENS: ReadonlySet<string> = new Set<string>([
 	...EMOTICONS,
 	"UwU",
 	"OwO",