omp-uwu 0.1.0 → 0.2.0

package/README.md

@@ -4,10 +4,11 @@
 
 Long sessions with an agent can get a little grey: diffs, stack traces, test output, repeat. omp-uwu is an [omp](https://github.com/can1357/oh-my-pi) extension that makes the agent write its chat replies in playful uwu-speak, while everything that has to be exact stays exact.
 
-> I've fixed the bug in `src/parser.ts` and all 42 tests pass uwu.
-> The pwobwem was an off-by-one in de woop, nyow it checks `i < len` instead of `i <= len` >w<
+<p align="center">
+  <img src="https://raw.githubusercontent.com/NaC-L/omp-uwu/main/demo/demo.gif" alt="omp streaming an uwu-speak answer about an off-by-one loop, with the corrected code block unchanged" width="784">
+</p>
 
-The prose is uwufied, but the file path, identifiers, code and numbers are not.
+The prose is uwufied, but the inline code, numbers and the fixed loop stay exactly as they should be.
 
 ## Quick start
 
@@ -19,6 +20,10 @@ Restart omp. uwu mode is **on** by default in every session.
 
 - `/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
+
+The TUI also shows a small, theme-accent-colored `(◕ᴗ◕✿) uwu` status badge. Other clients and plain output are not colorized.
 
 ## What gets uwufied, and what doesn't
 
@@ -30,18 +35,23 @@ Restart omp. uwu mode is **on** by default in every session.
 | | Tool-call arguments and file contents the agent writes or edits |
 | | Commit messages and prompts sent to subagents |
 
-Style rules the agent follows: `r`/`l` → `w` in most words, `th` → `d` sometimes, `na/ne/no` → `nya/nye/nyo` sometimes, the occasional stutter (`h-hewwo`), and at most one emoticon per sentence (`uwu`, `owo`, `>w<`, `^w^`, `:3`). Meaning, numbers and warnings must stay readable.
+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.
+
+Here's the same prompt and model, with the mode off and on:
+
+![Two real omp replies side by side: plain English on the left, uwu-speak on the right, with an identical code block in both](https://raw.githubusercontent.com/NaC-L/omp-uwu/main/demo/before-after.png)
+
+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).
 
 ## How it works
 
-omp has no extension hook for rewriting assistant text after it's generated. The `message_end` event only gets a detached copy of the message. So omp-uwu asks the model instead: on `before_agent_start` it adds a short style instruction to the end of the system prompt.
+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.
 
-This has some consequences:
+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.
 
-- **It depends on the model.** Most models follow it well, but the style isn't guaranteed. If code ever comes back uwufied, open an issue with the model name.
-- **History stays clean.** Nothing is rewritten after generation, so session history, compaction and tools see exactly what the model wrote.
-- **Small cost.** The instruction adds roughly 200 tokens to the system prompt while the mode is on. `/uwu off` removes it from the next request.
-- **Session-local toggle.** The on/off state isn't saved. Each new session starts with uwu mode on.
+- **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.
 
 ## Install options
 
@@ -63,14 +73,26 @@ omp plugin link .      # use this checkout instead of the installed copy
 omp -e ./src/index.ts  # or load it for a single run
 ```
 
+### 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:
+
+```sh
+mkdir -p /tmp/omp-demo && cp ~/.omp/agent/agent.db* /tmp/omp-demo/
+demo/record.sh
+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.
+
 ### 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`).
 
 ```sh
 # bump "version" in package.json, commit, then:
-git tag v0.1.1
-git push origin main v0.1.1
+git tag v0.2.0
+git push origin main v0.2.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,14 +1,15 @@
 {
   "name": "omp-uwu",
-  "version": "0.1.0",
-  "description": "omp extension: the agent answers in uwu-speak, while code, paths and commands stay byte-for-byte exact",
+  "version": "0.2.0",
+  "description": "omp extension for playful uwu chat styling, markdown-safe rewrites, and kawaii kaomoji",
   "type": "module",
   "license": "MIT",
   "keywords": [
     "omp",
     "oh-my-pi",
     "omp-plugin",
-    "uwu"
+    "uwu",
+    "kaomoji"
   ],
   "homepage": "https://github.com/NaC-L/omp-uwu#readme",
   "bugs": "https://github.com/NaC-L/omp-uwu/issues",

package/src/index.ts

@@ -1,41 +1,106 @@
-/**
- * uwu mode — makes the agent's chat replies uwu-speak.
- *
- * Why system-prompt based: OMP gives extensions no hook to rewrite displayed
- * assistant text (`message_end` receives a detached clone), so the style is
- * requested from the model via `before_agent_start` → `systemPrompt`.
- *
- * Toggle with `/uwu` (or `/uwu on` / `/uwu off`). Enabled by default.
- */
 import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { uwufy } 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 emoticons at sentence ends (uwu, owo, >w<, ^w^, :3), at most one per sentence
-- keep it readable; never let the style hide meaning, numbers, or warnings
+- occasional stutter ("h-hewwo") and cute kaomoji/emoticons, varied naturally: (◕ᴗ◕✿), (o^▽^o), (´｡• ω •｡\u0060), ٩(◕‿◕｡)۶, (✧ω✧), (๑˃ᴗ˂)ﻭ, ヽ(・∀・)ﾉ, (っ˘ω˘ς), (｡•̀ᴗ-)✧, (づ｡◕‿‿◕｡)づ, (ฅ^•ﻌ•^ฅ), (๑>◡<๑), owo, >w<, ^w^, :3; at most one at a sentence end
+- 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
 
 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 you write or edit, commit messages, and anything sent to subagents
+- tool call arguments, file contents the agent writes or edits, commit messages and prompts sent to subagents
 The style applies only to natural-language chat text shown to the user. Task quality and correctness are unchanged.
 `.trim();
 
+type RewriteEvent = {
+  message: { role: string; content: Array<{ type: string; text?: string; [key: string]: unknown }> };
+};
+type MessageEndEvent = { message: { role: string; stopReason?: string } };
+type UiContext = {
+  mode?: string;
+  agent?: { kind?: string };
+  ui?: {
+    notify(message: string, level: "info"): void;
+    setStatus?(key: string, text: string | undefined): void;
+    theme?: { fg(color: string, text: string): string };
+  };
+};
+
 export default function uwuExtension(pi: ExtensionAPI) {
-	let enabled = true;
-
-	pi.registerCommand("uwu", {
-		description: "Toggle uwu mode (usage: /uwu [on|off])",
-		handler: async (args, ctx) => {
-			const arg = String(args ?? "").trim().toLowerCase();
-			enabled = arg === "on" ? true : arg === "off" ? false : !enabled;
-			ctx.ui.notify(enabled ? "uwu mode enabwed! (◕ᴗ◕✿)" : "uwu mode disabled", "info");
-		},
-	});
-
-	pi.on("before_agent_start", async event => {
-		if (!enabled) return undefined;
-		return { systemPrompt: [...event.systemPrompt, UWU_PROMPT] };
-	});
+  let enabled = true;
+  let style: "rewrite" | "prompt" = "rewrite";
+  let hookSupport: boolean | undefined;
+  let promptAddedThisTurn = false;
+  let notifiedFallback = false;
+
+  const updateBadge = (ctx: UiContext) => {
+    if (ctx.mode !== "tui" || ctx.agent?.kind === "sub" || !ctx.ui?.setStatus) return;
+    const badge = enabled ? "(◕ᴗ◕✿) uwu" : undefined;
+    ctx.ui.setStatus("omp-uwu", badge && ctx.ui.theme ? ctx.ui.theme.fg("accent", badge) : badge);
+  };
+
+  pi.registerCommand("uwu", {
+    description: "UwU chat style and mode (usage: /uwu [on|off|prompt|rewrite])",
+    handler: async (args, rawCtx) => {
+      const ctx = rawCtx as UiContext;
+      const arg = String(args ?? "").trim().toLowerCase();
+      if (arg === "prompt" || arg === "rewrite") {
+        style = arg;
+        enabled = true;
+      } else if (arg === "on") enabled = true;
+      else if (arg === "off") enabled = false;
+      else if (!arg) enabled = !enabled;
+      else {
+        ctx.ui?.notify("Usage: /uwu [on|off|prompt|rewrite]", "info");
+        return;
+      }
+      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("before_agent_start", async (event, rawCtx) => {
+    promptAddedThisTurn = false;
+    const ctx = rawCtx as UiContext;
+    if (ctx.agent?.kind === "sub") 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;
+    if (!enabled || !needsPrompt) return undefined;
+    promptAddedThisTurn = true;
+    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)(
+    "assistant_message",
+    (event) => {
+      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);
+        if (text === block.text) return block;
+        changed = true;
+        return { ...block, text };
+      });
+      return changed ? { content } : undefined;
+    },
+  );
+
+  pi.on("message_end", (rawEvent) => {
+    const message = (rawEvent as MessageEndEvent).message;
+    if (message.role === "assistant" && message.stopReason !== "aborted" && message.stopReason !== "error" && hookSupport === undefined) {
+      hookSupport = false;
+      // The current response has already streamed; prompt fallback applies next turn.
+      if (!notifiedFallback) notifiedFallback = true;
+    }
+  });
 }

package/src/uwufy.ts

@@ -0,0 +1,331 @@
+/**
+ * Deterministic, markdown-aware uwu rewriter for finalized assistant text.
+ *
+ * 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
+ * looks like an identifier, path, number, flag, acronym, or warning word.
+ *
+ * Every "sometimes" decision is keyed on the word's position (paragraph,
+ * sentence, word) rather than on its text, and no transform adds or removes a
+ * word token. Rewriting already-rewritten text therefore makes the same
+ * decisions and finds nothing left to do: `uwufy(uwufy(x)) === uwufy(x)`.
+ * That matters because rewritten replies go back into the model's context, and
+ * the model may start answering in uwu-speak on its own.
+ */
+
+/** Emoticons the rewriter appends at sentence ends. */
+export const EMOTICONS = [
+	"uwu", "owo", ">w<", "^w^", ":3", "(◕ᴗ◕✿)",
+	"(o^▽^o)", "(´｡• ω •｡`)", "٩(◕‿◕｡)۶", "o(≧▽≦)o", "(✧ω✧)",
+	"(๑˃ᴗ˂)ﻭ", "(ᵔ◡ᵔ)", "ヽ(・∀・)ﾉ", "(´• ω •`)", "(｡•́︿•̀｡)",
+	"(ノ_<。)", "(っ˘ω˘ς)", "(≧◡≦)", "٩(◕‿◕)۶", "(o˘◡˘o)",
+	"(♡˙︶˙♡)", "ヽ(♡‿♡)ノ", "(´꒳`)♡", "(ﾉ´ з `)ノ", "ヾ(・ω・*)",
+	"(⌒ω⌒)ﾉ", "(ᵔ⩊ᵔ)", "(=^･ω･^=)", "(ฅ^•ﻌ•^ฅ)", "(ᵕ—ᴗ—)",
+	"(｡•̀ᴗ-)✧", "(づ｡◕‿‿◕｡)づ", "(っ´▽`)っ", "( ˶ˆᗜˆ˵ )", "(๑>◡<๑)",
+] as const;
+
+/** Tokens treated as emoticons: never counted as words, never rewritten. */
+const EMOTICON_TOKENS = new Set<string>([
+	...EMOTICONS,
+	"UwU",
+	"OwO",
+	"^_^",
+	"^^",
+	":)",
+	":D",
+	"<3",
+	"x3",
+]);
+
+/** Words that carry meaning a reader must not miss. Kept exact. */
+const KEEP_WORDS = new Set([
+	"no",
+	"not",
+	"nor",
+	"never",
+	"none",
+	"nothing",
+	"nowhere",
+	"neither",
+	"cannot",
+	"can't",
+	"don't",
+	"doesn't",
+	"didn't",
+	"won't",
+	"wouldn't",
+	"shouldn't",
+	"mustn't",
+	"isn't",
+	"aren't",
+	"wasn't",
+	"weren't",
+	"haven't",
+	"hasn't",
+	"hadn't",
+	"couldn't",
+	"warning",
+	"caution",
+	"danger",
+	"dangerous",
+	"careful",
+	"irreversible",
+	"destructive",
+	"error",
+	"errors",
+	"fail",
+	"fails",
+	"failed",
+	"failure",
+]);
+
+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;
+
+/**
+ * Inline spans that are never rewritten. Only the first alternative captures,
+ * so `\1` is the opening backtick run of a code span.
+ */
+const PROTECTED_INLINE = new RegExp(
+	[
+		String.raw`(\`+)[\s\S]*?\1(?!\`)`, // code span
+		String.raw`\`.*$`, // 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”
+	].join("|"),
+	"gi",
+);
+
+const FENCE_OPEN = /^ {0,3}(`{3,}|~{3,})/;
+const FENCE_CLOSE = /^ {0,3}(`{3,}|~{3,})\s*$/;
+const MATH_FENCE = /^\s*\$\$/;
+const INDENTED_CODE = /^(?: {4}|\t)/;
+const LIST_ITEM = /^\s*(?:[-*+]|\d+[.)])\s/;
+const HTML_LINE = /^\s*<[A-Za-z/!]/;
+const LINK_DEFINITION = /^ {0,3}\[[^\]]+\]:\s/;
+const HEADING = /^ {0,3}#{1,6}(?:\s|$)/;
+const TABLE_ROW = /^\s*\|/;
+
+const TOKEN_PARTS = /^([(\[{"'“‘*_~]*)(.*?)([)\]}"'”’*_~.,;:!?…]*)$/su;
+const WORD = /^[\p{L}\p{M}][\p{L}\p{M}'’-]*$/u;
+const SENTENCE_END = /[.!?…]/;
+const STUTTERED = /^(\p{L})-\1/iu;
+
+type LineKind = "code" | "blank" | "prose";
+
+interface ProseLine {
+	index: number;
+	/** Headings and tables get word rewrites but no stutters or emoticons. */
+	decorate: boolean;
+}
+
+/** Rewrite the prose of a markdown string in uwu-speak. */
+export function uwufy(text: string): string {
+	const lines = text.split("\n");
+	const kinds = classifyLines(lines);
+
+	const paragraphs: ProseLine[][] = [];
+	let current: ProseLine[] | undefined;
+	for (const [index, line] of lines.entries()) {
+		if (kinds[index] !== "prose") {
+			current = undefined;
+			continue;
+		}
+		const heading = HEADING.test(line);
+		// Headings, list items and table rows each start their own paragraph.
+		if (!current || heading || LIST_ITEM.test(line) || TABLE_ROW.test(line)) {
+			current = [];
+			paragraphs.push(current);
+		}
+		current.push({ index, decorate: !heading && !TABLE_ROW.test(line) });
+		if (heading) current = undefined;
+	}
+
+	const out = [...lines];
+	for (const [paragraphIndex, paragraph] of paragraphs.entries()) {
+		// Count once, then rewrite: the word count seeds this paragraph's decisions,
+		// 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);
+	}
+	return out.join("\n");
+}
+
+function classifyLines(lines: string[]): LineKind[] {
+	const kinds: LineKind[] = [];
+	let fence: { char: string; length: number } | undefined;
+	let math = false;
+	let previous: LineKind = "blank";
+	for (const line of lines) {
+		let kind: LineKind;
+		if (fence) {
+			const close = FENCE_CLOSE.exec(line);
+			if (close?.[1] && close[1][0] === fence.char && close[1].length >= fence.length) fence = undefined;
+			kind = "code";
+		} else if (math) {
+			if (MATH_FENCE.test(line)) math = false;
+			kind = "code";
+		} else if (FENCE_OPEN.test(line)) {
+			const open = FENCE_OPEN.exec(line)?.[1] ?? "```";
+			fence = { char: open[0] ?? "`", length: open.length };
+			kind = "code";
+		} else if (MATH_FENCE.test(line)) {
+			// A one-line `$$ x $$` block opens and closes on the same line.
+			math = !/^\s*\$\$.*\$\$\s*$/.test(line) || line.trim() === "$$";
+			kind = "code";
+		} else if (line.trim() === "") {
+			kind = "blank";
+		} else if (
+			(INDENTED_CODE.test(line) && !LIST_ITEM.test(line) && previous !== "prose") ||
+			HTML_LINE.test(line) ||
+			LINK_DEFINITION.test(line)
+		) {
+			kind = "code";
+		} else {
+			kind = "prose";
+		}
+		kinds.push(kind);
+		previous = kind;
+	}
+	return kinds;
+}
+
+interface TokenEvent {
+	token: string;
+	/** Text after the token within its prose segment, for emoticon lookahead. */
+	rest: string;
+	/** Whether the segment ends the line (nothing protected follows it). */
+	lineEnd: boolean;
+	decorate: boolean;
+	sentence: number;
+	wordInSentence: number;
+	word: number;
+}
+
+/**
+ * Walk the word tokens of one paragraph. When `out` is given, each prose
+ * segment is rebuilt from the callback's replacements. Returns the word count.
+ */
+function walkParagraph(
+	lines: string[],
+	paragraph: ProseLine[],
+	visit: (event: TokenEvent) => string | undefined,
+	out?: string[],
+): number {
+	let sentence = 0;
+	let wordInSentence = 0;
+	let word = 0;
+	for (const { index, decorate } of paragraph) {
+		const line = lines[index] ?? "";
+		let rebuilt = "";
+		let cursor = 0;
+		const segments: Array<{ prose: boolean; text: string }> = [];
+		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] });
+			cursor = start + match[0].length;
+		}
+		if (cursor < line.length) segments.push({ prose: true, text: line.slice(cursor) });
+
+		for (const [segmentIndex, segment] of segments.entries()) {
+			if (!segment.prose) {
+				rebuilt += segment.text;
+				continue;
+			}
+			const lineEnd = segmentIndex === segments.length - 1;
+			rebuilt += segment.text.replace(/\S+/g, (token, offset: number) => {
+				if (EMOTICON_TOKENS.has(token)) return token;
+				const [, , core = "", trail = ""] = TOKEN_PARTS.exec(token) ?? [];
+				const isWord = WORD.test(core);
+				let replacement: string | undefined;
+				if (isWord) {
+					replacement = visit({
+						token,
+						rest: segment.text.slice(offset + token.length),
+						lineEnd,
+						decorate,
+						sentence,
+						wordInSentence,
+						word,
+					});
+					word++;
+					wordInSentence++;
+				}
+				if ((isWord || core === "") && SENTENCE_END.test(trail)) {
+					sentence++;
+					wordInSentence = 0;
+				}
+				return replacement ?? token;
+			});
+		}
+		if (out) out[index] = rebuilt;
+	}
+	return word;
+}
+
+function rewriteToken(event: TokenEvent, seed: string): string {
+	const [, lead = "", core = "", trail = ""] = TOKEN_PARTS.exec(event.token) ?? [];
+	const key = `${seed}|${event.sentence}|${event.word}`;
+	let result = event.token;
+
+	if (!isKeptWord(core)) {
+		let word = core;
+		if (TH_WORDS.has(word.toLowerCase()) && roll(`${key}|th`) < P_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 (
+			event.decorate &&
+			event.wordInSentence === 0 &&
+			word.length >= 3 &&
+			!STUTTERED.test(word) &&
+			roll(`${key}|stutter`) < P_STUTTER
+		) {
+			word = `${word[0]}-${word}`;
+		}
+		// Never turn a word into something that reads as an emoticon (e.g. "ulu").
+		if (!EMOTICON_TOKENS.has(word)) result = lead + word + trail;
+	}
+
+	if (
+		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
+	) {
+		result += ` ${EMOTICONS[Math.floor(roll(`${seed}|${event.sentence}|pick`) * EMOTICONS.length)]}`;
+	}
+	return result;
+}
+
+/** Acronyms, camelCase names, flags and meaning-critical words stay exact. */
+function isKeptWord(core: string): boolean {
+	if (KEEP_WORDS.has(core.toLowerCase().replaceAll("’", "'"))) 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, "");
+	return letters.length >= 2 && letters === letters.toUpperCase() && letters !== letters.toLowerCase();
+}
+
+/** FNV-1a hash of `key`, scaled to [0, 1). */
+function roll(key: string): number {
+	let hash = 0x811c9dc5;
+	for (let i = 0; i < key.length; i++) {
+		hash ^= key.charCodeAt(i);
+		hash = Math.imul(hash, 0x01000193);
+	}
+	return (hash >>> 0) / 2 ** 32;
+}