omp-uwu 0.3.0 → 0.5.0

package/README.md

@@ -16,16 +16,23 @@ The prose is uwufied, but the inline code, numbers and the fixed loop stay exact
 omp plugin install omp-uwu
 ```
 
-Restart omp. uwu mode is **on** by default in every session.
+Restart omp. Defaults are **on**, **rewrite**, **mid**, **auto**, with colors **off** (unless saved preferences say otherwise).
 
 - `/uwu` toggles it
 - `/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 display` explicitly opts into **experimental, ANSI-TUI-only** display styling; never changes history or adds a prompt
+- `/uwu level low` / `/uwu level mid` / `/uwu level max` selects light, standard or stronger intensity
+- `/uwu locale auto` / `/uwu locale en` / `/uwu locale tr` selects critical-word protection and prompt language guidance
+- `/uwu status` reports settings and observed capabilities (unknown/pending is not a support guarantee)
+- `/uwu preview <text>` shows a deterministic sample with its original case, without changing any settings—even if uwu is off
 - `/uwu colors on` / `/uwu colors off` enables or disables the optional kawaii palette (off by default; preference persists)
 
 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 ANSI 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, so inline code, code blocks, link targets and stored message text stay untouched. Display styling works independently of colors; when both are on, prose is transformed first, then painted. A host-owned transform (such as live-voice transcript coloring) wins over both. omp's `AssistantMessageComponent` is not public extension API, so the plugin discovers it through the shared `Container` base class. If discovery is unavailable, display/sparkles do nothing; the palette can still apply. There is **no silent prompt fallback for display**.
+
 ## What gets uwufied, and what doesn't
 
 | uwufied | kept byte-for-byte |
@@ -36,7 +43,9 @@ The palette colors chat markdown and the user-message bubble without putting ANS
 | | 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.
+
+Intensity and locale apply to rewrite, prompt and display. `mid` keeps the original rewrite strength; `low` changes fewer words and adds fewer decorations; `max` is stronger. `auto` protects English **and** Turkish critical words, not automatic language detection. `tr` also protects Turkish forms while retaining English protection; `en` uses English protection. These settings never translate text. Negations/warnings and common Turkish inflections are protected conservatively, not by a complete linguistic parser.
 
 Here's the same prompt and model, with the mode off and on:
 
@@ -54,19 +63,24 @@ Only the two scores come from the benchmark run. The other numbers on the chart
 
 ## 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.
+In the default **rewrite** style, the first turn uses prompt styling until the host demonstrates support for the awaited `assistant_message` hook; after that, finalized assistant text is deterministically uwufied before it is added to history and context. This first-turn check supports both older and newer omp builds. Only existing text blocks change; code/tool blocks and metadata stay untouched. Rewrites preserve fenced/inline code, URLs, paths, numbers, quoted spans, identifiers and safety-critical words. Subagent prompts, messages and tool-call arguments are never styled.
 
 The hook runs after streaming has finished. The TUI refreshes the current assistant message at completion, but clients that render only streamed chunks may continue showing the original text. If the hook is unavailable (including omp `18.4.3`), prompt style remains enabled as the compatibility fallback. `/uwu prompt` selects live prompt styling directly.
 
 - **Deterministic rewrite.** No style instruction/token overhead once the hook is detected.
 - **Prompt style.** Model-dependent, with live uwu output while streaming.
-- **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.
+- **Experimental display.** Explicit opt-in, ANSI TUI only: `uwufyProse` transforms individual Markdown prose runs before width/wrapping, without rewriting stored content or injecting instructions. No appended emoticons or stutters. Display/level/locale/on/off changes invalidate existing discovered assistant components even with colors off.
+- **Persistent settings.** Enabled state, colors, style, level and locale are saved in `~/.omp/agent/omp-uwu.json`. Older enabled/colors-only files load with rewrite/mid/auto defaults; invalid individual values keep their defaults.
+
+Display is deliberately **fragment-based**: inline formatting, links, newlines and streaming edits can split runs and reset deterministic word positions, so effects may differ from a whole-message rewrite or preview. Identifiers, numbers and complete quoted spans within a run stay protected; a quote split across Markdown runs cannot be protected as a whole. Host paths that bypass its prose transform (including blockquotes, some table/heading/math rendering) may remain unchanged or differ from normal paragraphs. This is not a universal Markdown rewriting layer. Prompt-mode preview is only a deterministic approximation, not a prediction of model output.
+
+Capability fallback is explicit: `/uwu status` distinguishes a missing `Container`, pending assistant discovery and an observed ANSI hook; rewrite support is reported as unknown/detected/not observed. Discovery alone does not prove every render path works. Native/client rendering is **unsupported**: the installed omp `18.4.4` native description sends raw Markdown rather than using the ANSI text transform. RPC/print/export output and history stay original in display mode. Use `/uwu rewrite` or `/uwu prompt` explicitly if you want another style; display never switches to them automatically.
 
 ## Install options
 
 ```sh
 omp plugin install omp-uwu          # from npm (recommended)
-omp plugin install omp-uwu@0.3.0    # pin a version
+omp plugin install omp-uwu@0.5.0    # pin a version
 omp plugin uninstall omp-uwu        # remove
 ```
 
@@ -82,6 +96,10 @@ omp plugin link .      # use this checkout instead of the installed copy
 omp -e ./src/index.ts  # or load it for a single run
 ```
 
+The full-module integration tests exercise real omp Markdown/Assistant components, narrow wrapping, inline/fenced code preservation, unchanged raw messages, cache invalidation without colors, and host-transform precedence. They restore patched prototypes after each case. An additional installed-host test automatically uses `~/.bun/install/global/node_modules/@oh-my-pi/pi-tui` if present; set `OMP_UWU_HOST_TUI` to a different pi-tui package directory to test another installation (otherwise that case is skipped).
+
+For an interactive smoke check, start `omp -e ./src/index.ts` in an isolated test agent directory, run `/uwu colors off`, `/uwu display`, then `/uwu status`. Ask for ordinary prose plus inline/fenced code and narrow the terminal; prose should be styled and rewrapped while code stays exact. Change `/uwu level low` to `max`, switch locales and `/uwu off` without enabling colors: existing assistant paragraphs should refresh. Reopen the saved transcript/export to confirm raw text is unchanged, and verify the next model prompt has no uwu instruction. On a native client, expect unchanged prose, not fallback prompt styling.
+
 ### Re-recording the demo
 
 The GIF and the side-by-side image are rendered from real transcripts in `demo/`. `record.sh` captures one reply with the extension loaded and one without it. It runs in a throwaway agent dir, so your personal rules and extensions don't affect the replies. `render.py` then draws both images:
@@ -106,8 +124,8 @@ CI (`.github/workflows/ci.yml`) runs `check` and the tests on pushes to `main` a
 
 ```sh
 # bump "version" in package.json, commit, then:
-git tag v0.2.0
-git push origin main v0.2.0
+git tag v0.5.0
+git push origin main v0.5.0
 ```
 
 The workflow uses npm [trusted publishing](https://docs.npmjs.com/trusted-publishers/), so the repository has no npm token. npm only allows trusted publishing on a package that already exists, so the first version is published by hand with `npm publish --access public`. After that, go to the package's Settings → Trusted publishing on npmjs.com and add GitHub Actions with user `NaC-L`, repository `omp-uwu`, and workflow `publish.yml`.

package/package.json

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

package/src/index.ts

@@ -1,24 +1,51 @@
 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";
+import { type UwuLevel, type UwuLocale, uwufy, uwufyProse } from "./uwufy.ts";
 
 export const UWU_PROMPT = `
 # uwu mode (display style only)
 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
 - tool call arguments, file contents the agent writes or edits, commit messages and prompts sent to subagents
+- English negations, warnings and errors; in auto/tr also Turkish negations, warnings and errors (including inflected forms)
 The style applies only to natural-language chat text shown to the user. Task quality and correctness are unchanged.
 `.trim();
 
+type UwuStyle = "rewrite" | "prompt" | "display";
+const USAGE = "Usage: /uwu [on|off|rewrite|prompt|display|level low|mid|max|locale auto|en|tr|status|preview <text>|colors [on|off]]";
+
+function stylePrompt(level: UwuLevel, locale: UwuLocale): string {
+  let prompt = UWU_PROMPT;
+  if (level === "low") {
+    prompt = prompt
+      .replace('replace r/l with w in most words ("weawwy", "hewwo"), "th" → "d" occasionally, "na/ne/no" → "nya/nye/nyo" sometimes',
+        'use a light, mostly unchanged style: rarely replace r/l with w; very rarely use "th" → "d" or "na/ne/no" → "nya/nye/nyo"')
+      .replace('occasional stutter ("h-hewwo") and cute kaomoji/emoticons', 'very rare stutter ("h-hewwo") and cute kaomoji/emoticons');
+  } else if (level === "max") {
+    prompt = prompt
+      .replace('replace r/l with w in most words ("weawwy", "hewwo"), "th" → "d" occasionally, "na/ne/no" → "nya/nye/nyo" sometimes',
+        'use a stronger but readable style: replace r/l with w in ordinary words; frequently use "th" → "d" and "na/ne/no" → "nya/nye/nyo"')
+      .replace('occasional stutter ("h-hewwo") and cute kaomoji/emoticons', 'more frequent stutter ("h-hewwo") and cute kaomoji/emoticons');
+  }
+  if (locale === "en") {
+    prompt = prompt.replace("in auto/tr also Turkish negations, warnings and errors (including inflected forms)", "English-focused style and critical-word protection");
+  } else if (locale === "tr") {
+    prompt += "\nUse Turkish-aware prose styling and protect Turkish critical words/inflections; English critical words remain protected. Do not translate the reply.";
+  }
+  return prompt;
+}
+
 type RewriteEvent = {
   message: { role: string; content: Array<{ type: string; text?: string; [key: string]: unknown }> };
 };
@@ -37,7 +64,11 @@ export default function uwuExtension(pi: ExtensionAPI) {
   let enabled = true;
   let colorsEnabled = false;
   let stateReady: Promise<void> | undefined;
-  let style: "rewrite" | "prompt" = "rewrite";
+  let style: UwuStyle = "rewrite";
+  let level: UwuLevel = "mid";
+  let locale: UwuLocale = "auto";
+  let subagentTurn = false;
+  let renderAllowed = true;
   let hookSupport: boolean | undefined;
   let promptAddedThisTurn = false;
   let notifiedFallback = false;
@@ -50,11 +81,14 @@ export default function uwuExtension(pi: ExtensionAPI) {
         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;
+        if ("style" in state && (state.style === "rewrite" || state.style === "prompt" || state.style === "display")) style = state.style;
+        if ("level" in state && (state.level === "low" || state.level === "mid" || state.level === "max")) level = state.level;
+        if ("locale" in state && (state.locale === "auto" || state.locale === "en" || state.locale === "tr")) locale = state.locale;
       })
       .catch(() => {});
     return stateReady;
   };
-  const saveState = () => writeFile(statePath, `${JSON.stringify({ enabled, colors: colorsEnabled }, null, 2)}\n`, "utf8");
+  const saveState = () => writeFile(statePath, `${JSON.stringify({ enabled, colors: colorsEnabled, style, level, locale }, null, 2)}\n`, "utf8");
 
   const updateBadge = (ctx: UiContext) => {
     if (ctx.mode !== "tui" || ctx.agent?.kind === "sub" || !ctx.ui?.setStatus) return;
@@ -62,6 +96,18 @@ export default function uwuExtension(pi: ExtensionAPI) {
     ctx.ui.setStatus("omp-uwu", badge && ctx.ui.theme ? ctx.ui.theme.fg("accent", badge) : badge);
   };
 
+  // Display and sparkle composition share the host's per-prose ANSI hook.
+  // Prose is transformed before Markdown wrapping; no message/history changes.
+  const paint = themePaint(() => pi.pi.theme);
+  const host = pi.pi as { Container?: ContainerClass };
+  const rendering = host.Container && installSparkles(host.Container, {
+    isActive: () => renderAllowed && enabled && (style === "display" || colorsEnabled),
+    transform: (text) => {
+      const prose = style === "display" ? uwufyProse(text, { level, locale }) : text;
+      return colorsEnabled ? sparkle(prose, paint) : prose;
+    },
+  });
+
   const syncColors = (ctx: UiContext) => {
     if (ctx.mode !== "tui" || ctx.agent?.kind === "sub" || !ctx.ui?.theme) return;
     if (enabled && colorsEnabled) kawaiiTheme.enable(ctx.ui.theme);
@@ -69,38 +115,43 @@ export default function uwuExtension(pi: ExtensionAPI) {
   };
 
   pi.registerCommand("uwu", {
-    description: "UwU chat style and mode (usage: /uwu [on|off|prompt|rewrite|colors [on|off]])",
+    description: "UwU style, intensity, locale and experimental display (use /uwu status)",
     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");
+      if (ctx.agent?.kind === "sub") return;
+      const input = String(args ?? "").trim();
+      const match = /^(\S+)(?:\s+([\s\S]*))?$/.exec(input);
+      const arg = (match?.[1] ?? "").toLowerCase();
+      const option = (match?.[2] ?? "").trim();
+      const value = option.toLowerCase();
+      if (arg === "status" && !option) {
+        const display = !host.Container ? "unavailable (no Container)" : rendering?.isSupported() ? "ANSI hook detected" : "pending component discovery";
+        ctx.ui?.notify(`uwu ${enabled ? "on" : "off"}; style=${style}; level=${level}; locale=${locale}; colors=${colorsEnabled ? "on" : "off"}; rewrite=${hookSupport === undefined ? "unknown" : hookSupport ? "detected" : "not observed"}; display=${display}; native/client display=unsupported; prompt fallback=${enabled && style === "rewrite" && hookSupport !== true ? "on" : "off"}`, "info");
+        return;
+      }
+      if (arg === "preview") {
+        if (!option) {
+          ctx.ui?.notify(USAGE, "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");
+        ctx.ui?.notify(style === "display" ? uwufyProse(option, { level, locale }) : uwufy(option, { level, locale }), "info");
         return;
       }
-      if (arg === "prompt" || arg === "rewrite") {
+      if (arg === "colors" && (value === "on" || value === "off" || !value)) {
+        colorsEnabled = value ? value === "on" : !colorsEnabled;
+      } else if (arg === "level" && (value === "low" || value === "mid" || value === "max")) {
+        level = value;
+      } else if (arg === "locale" && (value === "auto" || value === "en" || value === "tr")) {
+        locale = value;
+      } else if (!option && (arg === "prompt" || arg === "rewrite" || arg === "display")) {
         style = arg;
         enabled = true;
-      } else if (arg === "on") enabled = true;
-      else if (arg === "off") enabled = false;
-      else if (!arg) enabled = !enabled;
+      } else if (!option && arg === "on") enabled = true;
+      else if (!option && arg === "off") enabled = false;
+      else if (!input) enabled = !enabled;
       else {
-        ctx.ui?.notify("Usage: /uwu [on|off|prompt|rewrite|colors [on|off]]", "info");
+        ctx.ui?.notify(USAGE, "info");
         return;
       }
       try {
@@ -108,9 +159,18 @@ export default function uwuExtension(pi: ExtensionAPI) {
       } catch {
         ctx.ui?.notify("uwu setting could not be saved; it may reset next session", "info");
       }
+      renderAllowed = ctx.mode === "tui";
       syncColors(ctx);
+      rendering?.refresh();
       updateBadge(ctx);
-      ctx.ui?.notify(enabled ? `uwu mode ${style === "rewrite" ? "rewrite" : "prompt"}! (◕ᴗ◕✿)` : "uwu mode off", "info");
+      if (arg === "colors") {
+        ctx.ui?.notify(`kawaii chat colors ${colorsEnabled ? "on" : "off"}${colorsEnabled && !enabled ? " (active when uwu mode is on)" : ""}`, "info");
+      } else {
+        ctx.ui?.notify(enabled ? `uwu mode ${style}; level=${level}; locale=${locale}! (◕ᴗ◕✿)` : "uwu mode off", "info");
+      }
+      if (enabled && style === "display") {
+        ctx.ui?.notify(`Experimental display: ANSI TUI prose only; ${!host.Container ? "render hook unavailable" : rendering?.isSupported() ? "render hook detected" : "awaiting assistant component discovery"}. Native/client rendering is unsupported; history stays unchanged and no prompt fallback is used.`, "info");
+      }
     },
   });
 
@@ -118,6 +178,8 @@ export default function uwuExtension(pi: ExtensionAPI) {
     await loadState();
     const ctx = rawCtx as UiContext;
     syncColors(ctx);
+    renderAllowed = ctx.mode === "tui" && ctx.agent?.kind !== "sub";
+    rendering?.refresh();
     updateBadge(ctx);
   });
 
@@ -125,27 +187,29 @@ export default function uwuExtension(pi: ExtensionAPI) {
     await loadState();
     promptAddedThisTurn = false;
     const ctx = rawCtx as UiContext;
-    if (ctx.agent?.kind === "sub") return undefined;
+    subagentTurn = ctx.agent?.kind === "sub";
+    if (subagentTurn) return undefined;
     // Start with the prompt until this host proves it has the finalized hook.
     // That styles the first reply on both old and new omp versions.
-    const needsPrompt = style === "prompt" || hookSupport !== true;
+    const needsPrompt = style === "prompt" || (style === "rewrite" && hookSupport !== true);
     if (!enabled || !needsPrompt) return undefined;
     promptAddedThisTurn = true;
-    return { systemPrompt: [...event.systemPrompt, UWU_PROMPT] };
+    return { systemPrompt: [...event.systemPrompt, stylePrompt(level, locale)] };
   });
 
 
   // 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)(
+  (pi.on as unknown as (name: string, handler: (event: RewriteEvent, ctx?: UiContext) => unknown) => void)(
     "assistant_message",
-    (event) => {
+    (event, ctx) => {
+      if (ctx?.agent?.kind === "sub" || (!ctx?.agent && subagentTurn)) return;
       hookSupport = true;
       if (!enabled || style !== "rewrite" || promptAddedThisTurn || event.message.role !== "assistant") return;
       let changed = false;
       const content = event.message.content.map((block) => {
         if (block.type !== "text" || typeof block.text !== "string") return block;
-        const text = uwufy(block.text);
+        const text = uwufy(block.text, { level, locale });
         if (text === block.text) return block;
         changed = true;
         return { ...block, text };
@@ -154,7 +218,9 @@ export default function uwuExtension(pi: ExtensionAPI) {
     },
   );
 
-  pi.on("message_end", (rawEvent) => {
+  pi.on("message_end", (rawEvent, rawCtx) => {
+    const ctx = rawCtx as UiContext | undefined;
+    if (ctx?.agent?.kind === "sub" || (!ctx?.agent && subagentTurn)) return;
     const message = (rawEvent as MessageEndEvent).message;
     if (message.role === "assistant" && message.stopReason !== "aborted" && message.stopReason !== "error" && hookSupport === undefined) {
       hookSupport = false;

package/src/kawaii.ts

@@ -57,7 +57,7 @@ export function buildKawaiiTheme(ThemeClass: ThemeRuntime["Theme"], base: Theme)
   }
 
   const preset = base.getSymbolPreset();
-  return new ThemeClass(
+  const theme = new ThemeClass(
     fg as Record<ThemeColor, string>,
     bg as Record<ThemeBg, string>,
     base.getColorMode(),
@@ -65,6 +65,15 @@ export function buildKawaiiTheme(ThemeClass: ThemeRuntime["Theme"], base: Theme)
     {},
     { 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. */

package/src/sparkle.ts

@@ -0,0 +1,233 @@
+/**
+ * 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 assistant prose should be transformed (independent of colors). */
+	isActive(): boolean;
+	transform: ColorTransform;
+}
+
+export interface SparkleInstallation {
+	/** Discovery proves only the ANSI render hook, not native/client rendering. */
+	isSupported(): boolean;
+	/** Refresh existing components, including when no theme change occurs. */
+	refresh(): void;
+	/** Restore host methods; useful for isolated integration tests. */
+	dispose(): void;
+}
+
+/** Shared per host Container, so reloads replace controls without double patches. */
+interface Registry {
+	control: SparkleControl;
+	transform: ColorTransform;
+	assistant?: AssistantPrototype;
+	components: Set<WeakRef<object & { invalidate?: () => void }>>;
+	seen: WeakSet<object>;
+	restoreAssistant?: () => void;
+	restoreWatch?: () => void;
+}
+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);
+	};
+	proto.updateContent = function (this: object, ...args: unknown[]) {
+		if (!registry.seen.has(this)) {
+			registry.seen.add(this);
+			registry.components.add(new WeakRef(this));
+		}
+		if (!hostTransforms.has(this)) {
+			const wanted = registry.control.isActive() ? registry.transform : undefined;
+			if (applied.get(this) !== wanted) {
+				applied.set(this, wanted);
+				originalSet.call(this, wanted);
+			}
+		}
+		return originalUpdate.apply(this, args);
+	};
+	const patchedSet = proto.setTextColorTransform;
+	const patchedUpdate = proto.updateContent;
+	registry.restoreAssistant = () => {
+		if (proto.setTextColorTransform === patchedSet) proto.setTextColorTransform = originalSet;
+		if (proto.updateContent === patchedUpdate) proto.updateContent = originalUpdate;
+	};
+}
+
+/**
+ * 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): SparkleInstallation {
+	const containerProto = Container.prototype as ContainerClass["prototype"] & { [REGISTRY]?: Registry };
+	const registry = (containerProto[REGISTRY] ??= {
+		control,
+		transform: (text: string) => control.transform(text),
+		components: new Set(),
+		seen: new WeakSet(),
+	});
+	registry.control = control;
+	const refresh = () => {
+		// A new identity also drops the host's stable-row and Markdown caches.
+		registry.transform = (text) => registry.control.transform(text);
+		for (const ref of registry.components) {
+			const component = ref.deref();
+			if (component) component.invalidate?.();
+			else registry.components.delete(ref);
+		}
+	};
+	if (!registry.assistant && !registry.restoreWatch) {
+		const originalAdd = containerProto.addChild;
+		const watch = function (this: object, child: unknown) {
+			const assistant = findAssistantPrototype(this) ?? findAssistantPrototype(child);
+			if (assistant) {
+				registry.restoreWatch?.();
+				registry.restoreWatch = undefined;
+				registry.assistant = assistant;
+				patchAssistant(assistant, registry);
+			}
+			return originalAdd.call(this, child);
+		};
+		registry.restoreWatch = () => {
+			if (containerProto.addChild === watch) containerProto.addChild = originalAdd;
+		};
+		containerProto.addChild = watch;
+	}
+	refresh();
+	return {
+		isSupported: () => registry.assistant !== undefined,
+		refresh,
+		dispose: () => {
+			registry.control = { isActive: () => false, transform: (text) => text };
+			refresh();
+			registry.restoreWatch?.();
+			registry.restoreAssistant?.();
+			delete containerProto[REGISTRY];
+		},
+	};
+}

package/src/uwufy.ts

@@ -3,7 +3,7 @@
  *
  * Only natural-language words are touched. Everything that has to stay exact is
  * left byte-for-byte alone: fenced/indented code, math blocks, inline code,
- * URLs and link targets, HTML tags, double-quoted spans, and any token that
+ * URLs and link targets, HTML tags, quoted spans, and any token that
  * looks like an identifier, path, number, flag, acronym, or warning word.
  *
  * Every "sometimes" decision is keyed on the word's position (paragraph,
@@ -14,6 +14,14 @@
  * the model may start answering in uwu-speak on its own.
  */
 
+export type UwuLevel = "low" | "mid" | "max";
+export type UwuLocale = "auto" | "en" | "tr";
+
+export interface UwuOptions {
+	level?: UwuLevel;
+	locale?: UwuLocale;
+}
+
 /** Emoticons the rewriter appends at sentence ends. */
 export const EMOTICONS = [
 	"uwu", "owo", ">w<", "^w^", ":3", "(◕ᴗ◕✿)",
@@ -23,10 +31,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",
@@ -38,6 +47,11 @@ const EMOTICON_TOKENS = new Set<string>([
 	"x3",
 ]);
 
+const EMOTICON_PATTERN = [...EMOTICON_TOKENS]
+	.map((token) => token.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
+	.join("|");
+const EMOTICON_AHEAD = new RegExp(String.raw`^\s+(?:${EMOTICON_PATTERN})(?=\s|$)`, "iu");
+
 /** Words that carry meaning a reader must not miss. Kept exact. */
 const KEEP_WORDS = new Set([
 	"no",
@@ -82,11 +96,22 @@ const KEEP_WORDS = new Set([
 
 const TH_WORDS = new Set(["the", "this", "that", "these", "those", "them", "then", "there", "their", "they", "than"]);
 
-// Probabilities for the "sometimes" transforms.
-const P_TH = 0.35;
-const P_NY = 0.5;
-const P_STUTTER = 0.12;
-const P_EMOTICON = 0.3;
+// Mid retains the original probabilities; low also softens the r/l rewrite.
+const INTENSITY = {
+	low: { rl: 0.4, th: 0.15, ny: 0.2, stutter: 0.04, emoticon: 0.1 },
+	mid: { rl: 1, th: 0.35, ny: 0.5, stutter: 0.12, emoticon: 0.3 },
+	max: { rl: 1, th: 0.75, ny: 0.85, stutter: 0.25, emoticon: 0.6 },
+} as const satisfies Record<UwuLevel, { rl: number; th: number; ny: number; stutter: number; emoticon: number }>;
+
+const TURKISH_KEEP_WORDS: Record<string, true> = { hayır: true, asla: true, hiç: true, hiçbir: true, sakın: true };
+// Conservative lexical guards, not a morphological analyzer. Keep common
+// case/possessive forms and conjugations (including negative deletion forms).
+const TURKISH_CRITICAL = [
+	/^değil[\p{L}\p{M}]*$/u,
+	/^yok[\p{L}\p{M}]*$/u,
+	/^(?:hata|uyarı)(?:lar|ler)?(?:[ıiuü]?m(?:[ıiuü]z)?|[ıiuü]?n(?:[ıiuü]z)?|s?[ıiuü])?(?:[ny]?[ıiuüae]|n?[dt][ae]n?|n?[ıiuü]n|y?l[ae]|s[ıiuü]z|l[ıiuü])?(?:ki)?(?:(?:[dt][ıiuü]|y[dt][ıiuü]|ym[ıiuü]ş|y[ıiuü]|s[ıiuü]n)[\p{L}\p{M}]*)?$/u,
+	/^sil(?:e(?:r|ce[kğ]|lim|bil|me|mi)[\p{L}\p{M}]*|i(?:n|yor|ver|p)[\p{L}\p{M}]*|(?:me|mi|di|se|sin)[\p{L}\p{M}]*)?$/u,
+];
 
 /**
  * Inline spans that are never rewritten. Only the first alternative captures,
@@ -94,15 +119,20 @@ const P_EMOTICON = 0.3;
  */
 const PROTECTED_INLINE = new RegExp(
 	[
-		String.raw`(\`+)[\s\S]*?\1(?!\`)`, // code span
-		String.raw`\`.*$`, // unmatched backtick: keep the rest of the line
+		"(`+)[\\s\\S]*?\\1(?!`)", // code span
+		"`.*$", // unmatched backtick: keep the rest of the line
 		String.raw`\]\([^)\s]*(?:\s+"[^"]*")?\)`, // markdown link target
 		String.raw`<\/?[A-Za-z][^>\n]*>`, // HTML tag or autolink
 		String.raw`\b(?:[a-z][a-z0-9+.-]*:\/\/|www\.)\S*`, // bare URL
 		String.raw`"[^"\n]*"`, // "quoted text"
 		String.raw`“[^”\n]*”`, // “quoted text”
+		// Word boundaries distinguish quote delimiters from we're / they're.
+		String.raw`(?<![\p{L}\p{M}\p{N}_])'(?:[^'\n]|'(?=[\p{L}\p{M}\p{N}_]))*'(?![\p{L}\p{M}\p{N}_])`,
+		String.raw`(?<![\p{L}\p{M}\p{N}_])‘(?:[^’\n]|’(?=[\p{L}\p{M}\p{N}_]))*’(?![\p{L}\p{M}\p{N}_])`,
+		// Multi-token kaomoji must not change the word-position seed on re-runs.
+		String.raw`(?<!\S)(?:${EMOTICON_PATTERN})(?!\S)`,
 	].join("|"),
-	"gi",
+	"giu",
 );
 
 const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
@@ -128,8 +158,25 @@ interface ProseLine {
 	decorate: boolean;
 }
 
-/** Rewrite the prose of a markdown string in uwu-speak. */
-export function uwufy(text: string): string {
+/** Rewrite markdown prose. Defaults to the original mid intensity and auto locale. */
+export function uwufy(text: string, options: UwuOptions = {}): string {
+	return rewriteText(text, options, true);
+}
+
+/**
+ * Rewrite a render-time prose run without adding stutters or emoticons.
+ * Quoted spans, identifiers and markdown protected surfaces still stay exact.
+ * Positions reset per supplied run; changing renderer fragment boundaries can
+ * change probabilistic choices. This is a lexical rewriter, not a translator.
+ * Only balanced quotes contained in one supplied line/run are guarded; callers
+ * must not split quoted or technical spans across independently rewritten runs.
+ */
+export function uwufyProse(text: string, options: UwuOptions = {}): string {
+	return rewriteText(text, options, false);
+}
+
+function rewriteText(text: string, options: UwuOptions, decorate: boolean): string {
+	const resolved: Required<UwuOptions> = { level: options.level ?? "mid", locale: options.locale ?? "auto" };
 	const lines = text.split("\n");
 	const kinds = classifyLines(lines);
 
@@ -146,7 +193,7 @@ export function uwufy(text: string): string {
 			current = [];
 			paragraphs.push(current);
 		}
-		current.push({ index, decorate: !heading && !TABLE_ROW.test(line) });
+		current.push({ index, decorate: decorate && !heading && !TABLE_ROW.test(line) });
 		if (heading) current = undefined;
 	}
 
@@ -156,7 +203,7 @@ export function uwufy(text: string): string {
 		// which keeps them varied between paragraphs yet stable across re-runs.
 		const wordCount = walkParagraph(lines, paragraph, () => undefined);
 		const seed = `${paragraphIndex}|${wordCount}`;
-		walkParagraph(lines, paragraph, (event) => rewriteToken(event, seed), out);
+		walkParagraph(lines, paragraph, (event) => rewriteToken(event, seed, resolved), out);
 	}
 	return out.join("\n");
 }
@@ -202,7 +249,7 @@ function classifyLines(lines: string[]): LineKind[] {
 
 interface TokenEvent {
 	token: string;
-	/** Text after the token within its prose segment, for emoticon lookahead. */
+	/** Text after the token on its full line, including protected emoticons. */
 	rest: string;
 	/** Whether the segment ends the line (nothing protected follows it). */
 	lineEnd: boolean;
@@ -229,14 +276,14 @@ function walkParagraph(
 		const line = lines[index] ?? "";
 		let rebuilt = "";
 		let cursor = 0;
-		const segments: Array<{ prose: boolean; text: string }> = [];
+		const segments: Array<{ prose: boolean; text: string; start: number }> = [];
 		for (const match of line.matchAll(PROTECTED_INLINE)) {
 			const start = match.index ?? 0;
-			if (start > cursor) segments.push({ prose: true, text: line.slice(cursor, start) });
-			segments.push({ prose: false, text: match[0] });
+			if (start > cursor) segments.push({ prose: true, text: line.slice(cursor, start), start: cursor });
+			segments.push({ prose: false, text: match[0], start });
 			cursor = start + match[0].length;
 		}
-		if (cursor < line.length) segments.push({ prose: true, text: line.slice(cursor) });
+		if (cursor < line.length) segments.push({ prose: true, text: line.slice(cursor), start: cursor });
 
 		for (const [segmentIndex, segment] of segments.entries()) {
 			if (!segment.prose) {
@@ -252,7 +299,7 @@ function walkParagraph(
 				if (isWord) {
 					replacement = visit({
 						token,
-						rest: segment.text.slice(offset + token.length),
+						rest: line.slice(segment.start + offset + token.length),
 						lineEnd,
 						decorate,
 						sentence,
@@ -274,24 +321,25 @@ function walkParagraph(
 	return word;
 }
 
-function rewriteToken(event: TokenEvent, seed: string): string {
+function rewriteToken(event: TokenEvent, seed: string, options: Required<UwuOptions>): string {
+	const intensity = INTENSITY[options.level];
 	const [, lead = "", core = "", trail = ""] = TOKEN_PARTS.exec(event.token) ?? [];
 	const key = `${seed}|${event.sentence}|${event.word}`;
 	let result = event.token;
 
-	if (!isKeptWord(core)) {
+	if (!isKeptWord(core, options.locale)) {
 		let word = core;
-		if (TH_WORDS.has(word.toLowerCase()) && roll(`${key}|th`) < P_TH) {
+		if (TH_WORDS.has(word.toLowerCase()) && roll(`${key}|th`) < intensity.th) {
 			word = (word[0] === "T" ? "D" : "d") + word.slice(2);
 		}
-		word = word.replace(/[rl]/g, "w").replace(/[RL]/g, "W");
-		if (roll(`${key}|ny`) < P_NY) word = word.replace(/([nN])(?=[aeo])/g, "$1y");
+		if (roll(`${key}|rl`) < intensity.rl) word = word.replace(/[rl]/g, "w").replace(/[RL]/g, "W");
+		if (roll(`${key}|ny`) < intensity.ny) word = word.replace(/([nN])(?=[aeo])/g, "$1y");
 		if (
 			event.decorate &&
 			event.wordInSentence === 0 &&
 			word.length >= 3 &&
 			!STUTTERED.test(word) &&
-			roll(`${key}|stutter`) < P_STUTTER
+			roll(`${key}|stutter`) < intensity.stutter
 		) {
 			word = `${word[0]}-${word}`;
 		}
@@ -303,8 +351,8 @@ function rewriteToken(event: TokenEvent, seed: string): string {
 		event.decorate &&
 		SENTENCE_END.test(trail) &&
 		(/^\s/.test(event.rest) || (event.rest === "" && event.lineEnd)) &&
-		!EMOTICON_TOKENS.has(/^\s+(\S+)/.exec(event.rest)?.[1] ?? "") &&
-		roll(`${seed}|${event.sentence}|emoticon`) < P_EMOTICON
+		!EMOTICON_AHEAD.test(event.rest) &&
+		roll(`${seed}|${event.sentence}|emoticon`) < intensity.emoticon
 	) {
 		result += ` ${EMOTICONS[Math.floor(roll(`${seed}|${event.sentence}|pick`) * EMOTICONS.length)]}`;
 	}
@@ -312,8 +360,12 @@ function rewriteToken(event: TokenEvent, seed: string): string {
 }
 
 /** Acronyms, camelCase names, flags and meaning-critical words stay exact. */
-function isKeptWord(core: string): boolean {
+function isKeptWord(core: string, locale: UwuLocale): boolean {
 	if (KEEP_WORDS.has(core.toLowerCase().replaceAll("’", "'"))) return true;
+	if (locale !== "en") {
+		const turkish = core.normalize("NFC").toLocaleLowerCase("tr");
+		if (Object.hasOwn(TURKISH_KEEP_WORDS, turkish) || TURKISH_CRITICAL.some((pattern) => pattern.test(turkish))) return true;
+	}
 	if (core.endsWith("-") || core.includes("--")) return true;
 	if (/\p{Ll}\p{Lu}/u.test(core)) return true; // camelCase, GitHub, iOS
 	const letters = core.replace(/[^\p{L}]/gu, "");