pi-pretty-tui 0.3.0 → 0.3.2

package/extensions/index.ts

@@ -1,7 +1,15 @@
+import { installSelectionCopy, selectableRow, selectionMetadataActive } from "./selection-ranges.js";
 import { isNativeImageRow } from "./ansi-style.js";
 import { cardMargin, cardBackground, frameNativeRows, nativeFrameWidth } from "./full-frame.js";
+import {
+  themedInlineContext,
+  withNativeEmphasis,
+  type InlineStyleContext,
+  type InlineToken,
+} from "./markdown-emphasis.js";
+import { gapRowsAfterBlock, renderSpacedList } from "./markdown-spacing.js";
 import { ThoughtPresentation } from "./thought-presentation.js";
-import { isThirdPartyTool, renderToolProjection, toolLabel, type ToolProjection } from "./tool-presentation.js";
+import { isThirdPartyTool, renderToolProjection, THIRD_PARTY_TOOL, toolLabel, type ToolProjection } from "./tool-presentation.js";
 import { NestedTools, NESTED_SNAPSHOT_ENTRY } from "./nested-tools.js";
 import {
   AssistantMessageComponent,
@@ -62,6 +70,10 @@ const RESPONSE_FOOTER_ENTRY_TYPE = "pretty-tui-response-footer";
 type PrettyTuiConfig = {
   enabled?: boolean;
   mode?: PrettyTuiMode;
+  /** Exclude plugin decoration from fullscreen selections. Opt-in. */
+  selectionCopy?: boolean;
+  /** "native" keeps Pi's flags-only strong and emphasis. Read when the extension loads. */
+  markdownEmphasis?: "themed" | "native";
   /** Legacy location used by the first mode implementation. */
   bash?: {
     mode?: "full" | "compact";
@@ -300,6 +312,17 @@ export default function prettyTui(pi: ExtensionAPI) {
     }
   };
   const transcriptMarkdownActive = () => transcriptMarkdownDepth > 0;
+  // Assistant answers only. The transcript scope also covers user messages,
+  // thinking and activity updates, which keep Pi's strong and emphasis styling.
+  const assistantBodyMarkdown = new WeakSet<object>();
+  const markAssistantBodyMarkdown = (component: any) => {
+    // Pi adds answer text directly; a thought block is wrapped in a MouseRegion.
+    // A component built before this runtime is covered too: the rendered-mode
+    // symbols are per runtime, so its first render here re-runs updateContent.
+    for (const child of component.contentContainer?.children ?? []) {
+      if (child instanceof Markdown && !(child as any).defaultTextStyle) assistantBodyMarkdown.add(child);
+    }
+  };
 
   const setCleanGroupMembers = (lastToolCallId: string, toolCallIds: string[]) => {
     cleanGroupToolCallIds.set(lastToolCallId, toolCallIds);
@@ -676,7 +699,9 @@ export default function prettyTui(pi: ExtensionAPI) {
         { value: "full", label: "full", description: "Full tool details and output" },
         { value: "compact", label: "compact", description: "Concise summaries for all built-in tools" },
         { value: "clean", label: "clean", description: "Group supported tools into Running/Done status" },
-        { value: "status", label: "status", description: "Show the current mode" },
+        { value: "selection-copy on", label: "selection-copy on", description: "Copy selected text without UI borders in fullscreen mode; enable and reload" },
+        { value: "selection-copy off", label: "selection-copy off", description: "Restore native selection copying and reload" },
+        { value: "status", label: "status", description: "Show the current settings" },
       ];
       const filtered = items.filter((item) => item.value.startsWith(prefix.trim().toLowerCase()));
       return filtered.length > 0 ? filtered : null;
@@ -687,7 +712,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       if (!requested) {
         if (!ctx.hasUI) {
           ctx.ui.notify(
-            `pi-pretty-tui: ${config.enabled !== false ? "enabled" : "disabled"} · mode: ${renderMode}`,
+            `pi-pretty-tui: ${config.enabled !== false ? "enabled" : "disabled"} · mode: ${renderMode} · selection copy: ${config.selectionCopy === true ? "on" : "off"}`,
             "info",
           );
           return;
@@ -696,9 +721,12 @@ export default function prettyTui(pi: ExtensionAPI) {
         const full = `Full — full tool details and output${renderMode === "full" ? " (current)" : ""}`;
         const compact = `Compact — concise tool summaries and nested calls${renderMode === "compact" ? " (current)" : ""}`;
         const clean = `Clean — group supported tools into Running/Done status${renderMode === "clean" ? " (current)" : ""}`;
-        const selected = await ctx.ui.select("pi-pretty-tui settings", [enabled, full, compact, clean]);
+        const selectionCopy = `Selection copy — ${config.selectionCopy === true ? "on" : "off"} · copy text without UI borders (fullscreen, experimental)`;
+        const selected = await ctx.ui.select("pi-pretty-tui settings", [enabled, full, compact, clean, selectionCopy]);
         if (!selected) return;
-        requested = selected === enabled
+        requested = selected === selectionCopy
+          ? config.selectionCopy === true ? "selection-copy off" : "selection-copy on"
+          : selected === enabled
           ? config.enabled !== false ? "disable" : "enable"
           : selected === full
             ? "full"
@@ -709,11 +737,28 @@ export default function prettyTui(pi: ExtensionAPI) {
 
       if (requested === "status") {
         ctx.ui.notify(
-          `pi-pretty-tui: ${config.enabled !== false ? "enabled" : "disabled"} · mode: ${renderMode}`,
+          `pi-pretty-tui: ${config.enabled !== false ? "enabled" : "disabled"} · mode: ${renderMode} · selection copy: ${config.selectionCopy === true ? "on" : "off"}`,
           "info",
         );
         return;
       }
+      if (requested === "selection-copy on" || requested === "selection-copy off") {
+        const selectionCopy = requested.endsWith(" on");
+        try {
+          saveConfig({ ...config, selectionCopy });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          ctx.ui.notify(`Could not save selection-copy setting: ${message}`, "error");
+          return;
+        }
+        ctx.ui.notify(`Border-free selection copying ${selectionCopy ? "enabled" : "disabled"}; reloading…`, "info");
+        try { await ctx.reload(); }
+        catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          ctx.ui.notify(`Setting saved, but automatic reload failed: ${message}`, "warning");
+        }
+        return;
+      }
       if (requested === "enable" || requested === "disable") {
         const enabled = requested === "enable";
         try {
@@ -737,7 +782,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         }
       }
       if (requested !== "full" && requested !== "compact" && requested !== "clean") {
-        ctx.ui.notify("Usage: /pretty-tui [enable|disable|full|compact|clean|status]", "error");
+        ctx.ui.notify("Usage: /pretty-tui [enable|disable|full|compact|clean|status|selection-copy on|selection-copy off]", "error");
         return;
       }
 
@@ -764,6 +809,7 @@ export default function prettyTui(pi: ExtensionAPI) {
   // render patches or override built-in tools until the next enabled reload.
   if (!activeForSession) return;
   pi.on("session_shutdown", stopWorkingElapsedTimer);
+  if (config.selectionCopy === true) pi.on("session_shutdown", installSelectionCopy());
 
   // Give Pi's main prompt editor a complete rounded frame. Render the native
   // editor at a two-column narrower width so cursor layout, wrapping, IME, and
@@ -812,9 +858,9 @@ export default function prettyTui(pi: ExtensionAPI) {
 
       return lines.map((line, index) => {
         const fitted = fitInnerWidth(line);
-        if (index === 0) return this.borderColor("╭") + fitted + this.borderColor("╮");
-        if (index === bottomBorderIndex) return this.borderColor("╰") + fitted + this.borderColor("╯");
-        if (index < bottomBorderIndex) return this.borderColor("│") + fitted + this.borderColor("│");
+        if (index === 0) return selectableRow(this.borderColor("╭") + fitted + this.borderColor("╮"), width, []);
+        if (index === bottomBorderIndex) return selectableRow(this.borderColor("╰") + fitted + this.borderColor("╯"), width, []);
+        if (index < bottomBorderIndex) return selectableRow(this.borderColor("│") + fitted + this.borderColor("│"), width, [[1, width - 1]]);
         // Autocomplete remains outside the input frame, aligned to its content.
         return " " + fitted + " ";
       });
@@ -980,9 +1026,10 @@ export default function prettyTui(pi: ExtensionAPI) {
           const bottom = border("╰" + "─".repeat(Math.max(0, measured.frameWidth - 2)) + "╯");
           const body = measured.body.map((line: string) => {
             const padding = " ".repeat(Math.max(0, measured.contentWidth - visibleWidth(line)));
-            return border("│ ") + line + padding + border(" │");
+            return selectableRow(border("│ ") + line + padding + border(" │"), measured.frameWidth, [[2, 2 + Math.max(1, Math.min(measured.contentWidth, visibleWidth(line)))]]);
           });
-          return [top, ...body, bottom].map((line: string) => left + line + right);
+          return [selectableRow(top, measured.frameWidth, []), ...body, selectableRow(bottom, measured.frameWidth, [])]
+            .map((line: string) => selectableRow(left + line + right, width, [[measured.leftPad, width - measured.rightPad]]));
         },
         handleMouse(event: any) {
           const measured = layout(event.width);
@@ -1378,6 +1425,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         originalUpdateContent.call(this, renderMode === "compact" && assistantTerminalState(message)
           ? { ...message, errorMessage: undefined, stopReason: "stop" } : message, isStreaming);
         this.lastMessage = message;
+        markAssistantBodyMarkdown(this);
         if (eligibleThinking(message)) thinkingComponents.set(assistantMessageKey(message), this);
         return;
       }
@@ -1405,6 +1453,7 @@ export default function prettyTui(pi: ExtensionAPI) {
         this.hideThinkingBlock = previousHideThinkingBlock;
       }
       this.lastMessage = message;
+      markAssistantBodyMarkdown(this);
     };
 
     const renderAssistantTranscript = function (this: any, width: number): string[] {
@@ -2261,6 +2310,11 @@ export default function prettyTui(pi: ExtensionAPI) {
   const codeBlockRegionsKey = Symbol("pretty-tui.code-block-regions");
   const transcriptMarkdownStateKey = Symbol("pretty-tui.transcript-markdown-state");
   if (!markdownPrototype[codeBlockPatchKey]) {
+    // Pi 1.5 reuses rendered top-level blocks while text streams. Keep copy
+    // descriptors with each native block's highlighting-cache identity, weakly,
+    // so reused pixels retain their hit regions without disabling that cache.
+    const blockCopyDescriptors = new WeakMap<object, { generation: number; blocks: any[] }>();
+    let copyRenderGeneration = 0;
     const originalInvalidate = markdownPrototype.invalidate;
     const originalRender = markdownPrototype.render;
     const originalRenderToken = markdownPrototype.renderToken;
@@ -2274,6 +2328,21 @@ export default function prettyTui(pi: ExtensionAPI) {
       return originalInvalidate.call(this);
     };
 
+    const copyRows = new WeakMap<object, { source: string[]; padding: number; lines: string[] }>();
+    const selectableMarkdown = (owner: any, source: string[]) => {
+      if (!selectionMetadataActive()) return source;
+      const padding = Math.max(0, Number(owner.paddingX) || 0);
+      if (!padding) return source;
+      const cached = copyRows.get(owner);
+      if (cached?.source === source && cached.padding === padding) return cached.lines;
+      const lines = source.map(line => {
+        const width = visibleWidth(line);
+        return selectableRow(line, width, [[Math.min(padding, width), Math.max(Math.min(padding, width), width - padding)]]);
+      });
+      copyRows.set(owner, { source, padding, lines });
+      return lines;
+    };
+
     const patchedRender = function (this: any, width: number): string[] {
       const scoped = transcriptMarkdownActive();
       mouseClickHitTests.set(this, (event) => fullscreenTui &&
@@ -2290,14 +2359,22 @@ export default function prettyTui(pi: ExtensionAPI) {
 
       const needsRender =
         !this.cachedLines || this.cachedText !== this.text || this.cachedWidth !== width;
-      if (needsRender) this[codeBlockCollectionKey] = [];
+      if (needsRender) this[codeBlockCollectionKey] = Object.assign([], { generation: ++copyRenderGeneration });
 
       const lines = originalRender.call(this, width);
-      if (!needsRender) return lines;
+      if (!needsRender) return selectableMarkdown(this, lines);
 
       const regions: Array<{ xStart: number; xEnd: number; y: number; code: string }> = [];
       let searchFrom = 0;
-      for (const block of this[codeBlockCollectionKey] ?? []) {
+      const nativeBlocks = this.blocks?.deref();
+      const nativeTokens = this.cachedTokens?.deref()?.tokens;
+      const copyBlocks = nativeBlocks && nativeTokens
+        ? nativeTokens.flatMap((token: any) => {
+            const block = nativeBlocks.get(token.raw);
+            return block ? blockCopyDescriptors.get(block.highlightedCode)?.blocks ?? [] : [];
+          })
+        : this[codeBlockCollectionKey] ?? [];
+      for (const block of copyBlocks) {
         let headerLine = -1;
         for (let lineIndex = searchFrom; lineIndex < lines.length; lineIndex += 1) {
           const renderedLine = lines[lineIndex] ?? "";
@@ -2321,7 +2398,7 @@ export default function prettyTui(pi: ExtensionAPI) {
       }
       this[codeBlockRegionsKey] = regions;
       delete this[codeBlockCollectionKey];
-      return lines;
+      return selectableMarkdown(this, lines);
     };
 
     const patchedRenderToken = function (
@@ -2343,36 +2420,20 @@ export default function prettyTui(pi: ExtensionAPI) {
           return lines;
         };
         const headingStyle = (text: string) => this.theme.heading(text);
-        const foregroundLuminance = (styled: string): number | undefined => {
-          const trueColor = /\x1b\[38;2;(\d+);(\d+);(\d+)m/.exec(styled);
-          if (!trueColor) return undefined;
-          const [, red, green, blue] = trueColor.map(Number);
-          return red * 0.2126 + green * 0.7152 + blue * 0.0722;
-        };
-        const defaultLuminance = foregroundLuminance(this.applyDefaultStyle("M"));
-        const headingLuminance = foregroundLuminance(headingStyle("M"));
-        const darkTheme =
-          defaultLuminance !== undefined
-            ? defaultLuminance >= 128
-            : (headingLuminance ?? 255) >= 160;
-        const whiteStyle = (text: string) => `\x1b[97m${text}\x1b[39m`;
+        // Descending emphasis: framed H1, underlined H2, bold H3,
+        // plain H4, decorative H5, and quote-colored italic H6.
         const titleStyle =
-          level === 1 || level === 3
+          level === 1 || level === 2
             ? (text: string) => headingStyle(this.theme.bold(this.theme.underline(text)))
-            : level === 2
-              ? (text: string) =>
-                  (darkTheme ? whiteStyle : headingStyle)(
-                    this.theme.bold(this.theme.underline(text)),
-                  )
-              : level === 4
-                ? (text: string) => headingStyle(this.theme.bold(text))
-                : level === 5
-                  ? headingStyle
-                  : (text: string) => this.theme.quote(this.theme.italic(text));
-        const titleContext = {
+            : level === 3
+              ? (text: string) => headingStyle(this.theme.bold(text))
+              : level === 4 || level === 5
+                ? headingStyle
+                : (text: string) => this.theme.quote(this.theme.italic(text));
+        const titleContext = withNativeEmphasis({
           applyText: titleStyle,
           stylePrefix: this.getStylePrefix(titleStyle),
-        };
+        });
         const title = this.renderInlineTokens(token.tokens || [], titleContext);
 
         if (level === 1 && maxWidth >= 6) {
@@ -2395,17 +2456,6 @@ export default function prettyTui(pi: ExtensionAPI) {
           return addHeadingSpacing(lines);
         }
 
-        if (level === 2) {
-          // Reverse only the rendered title cells: the theme's heading color
-          // becomes a compact, content-width background label with no frame.
-          const lines = wrapTextWithAnsi(title, maxWidth).map((line: string) =>
-            darkTheme
-              ? `\x1b[48;5;94m${line}\x1b[49m`
-              : `\x1b[107m\x1b[7m${line}\x1b[27m\x1b[49m`
-          );
-          return addHeadingSpacing(lines);
-        }
-
         if (level === 5 && maxWidth >= 8) {
           const prefix = "┄┄ ";
           const suffix = " ┄┄";
@@ -2426,7 +2476,10 @@ export default function prettyTui(pi: ExtensionAPI) {
       }
 
       if (token?.type !== "code") {
-        return originalRenderToken.call(this, token, width, nextTokenType, styleContext);
+        return [
+          ...originalRenderToken.call(this, token, width, nextTokenType, styleContext),
+          ...gapRowsAfterBlock(token?.type, nextTokenType),
+        ];
       }
 
       const maxWidth = Math.max(1, width);
@@ -2479,24 +2532,32 @@ export default function prettyTui(pi: ExtensionAPI) {
         (showCopyButton ? this.theme.codeBlockBorder(` ${copyLabel} `) : "") + frameBorder("╮");
       const framedCodeWidth = Math.max(1, frameWidth - 4);
       const lines = [
-        styledTopRule,
-        ...codeLines.map((line) =>
-          frameBorder("│ ") +
-          line +
-          " ".repeat(Math.max(0, framedCodeWidth - visibleWidth(line))) +
-          frameBorder(" │")
-        ),
-        frameBorder(`╰${"─".repeat(Math.max(0, frameWidth - 2))}╯`),
+        selectableRow(styledTopRule, frameWidth, []),
+        ...codeLines.map((line) => selectableRow(
+          frameBorder("│ ") + line +
+          " ".repeat(Math.max(0, framedCodeWidth - visibleWidth(line))) + frameBorder(" │"),
+          frameWidth, [[2, frameWidth - 2]])),
+        selectableRow(frameBorder(`╰${"─".repeat(Math.max(0, frameWidth - 2))}╯`), frameWidth, []),
       ];
 
       if (showCopyButton && Array.isArray(this[codeBlockCollectionKey])) {
-        this[codeBlockCollectionKey].push({
+        const descriptor = {
           buttonStart,
           buttonWidth: visibleWidth(copyLabel),
           code,
           styledTopRule,
           topRule,
-        });
+        };
+        const collection = this[codeBlockCollectionKey] as any[] & { generation: number };
+        collection.push(descriptor);
+        if (this.blockHighlightedCode) {
+          let cached = blockCopyDescriptors.get(this.blockHighlightedCode);
+          if (!cached || cached.generation !== collection.generation) {
+            cached = { generation: collection.generation, blocks: [] };
+            blockCopyDescriptors.set(this.blockHighlightedCode, cached);
+          }
+          cached.blocks.push(descriptor);
+        }
       }
       if (nextTokenType && nextTokenType !== "space") lines.push("");
       return lines;
@@ -2581,7 +2642,11 @@ export default function prettyTui(pi: ExtensionAPI) {
       this.theme.listBullet = (marker: string) =>
         originalListBullet(marker.replace(/^- /, "• "));
       try {
-        return originalRenderList.call(this, token, depth, width, styleContext);
+        if (!transcriptMarkdownActive()) {
+          return originalRenderList.call(this, token, depth, width, styleContext);
+        }
+        return renderSpacedList(token, (singleItemList) =>
+          originalRenderList.call(this, singleItemList, depth, width, styleContext));
       } finally {
         this.theme.listBullet = originalListBullet;
       }
@@ -2599,6 +2664,37 @@ export default function prettyTui(pi: ExtensionAPI) {
     });
   }
 
+  const inlineEmphasisPatchKey = Symbol.for("pretty-tui.inline-emphasis");
+  if (config.markdownEmphasis !== "native" && !markdownPrototype[inlineEmphasisPatchKey]) {
+    const originalRenderInlineTokens = markdownPrototype.renderInlineTokens;
+    const patchedRenderInlineTokens = function (
+      this: any,
+      tokens: InlineToken[],
+      styleContext?: InlineStyleContext,
+    ): string {
+      const theme = currentExtensionUi?.theme;
+      if (!transcriptMarkdownActive() || !assistantBodyMarkdown.has(this) || !theme?.fg) {
+        return originalRenderInlineTokens.call(this, tokens, styleContext);
+      }
+      return originalRenderInlineTokens.call(
+        this,
+        tokens,
+        themedInlineContext(tokens, styleContext ?? this.getDefaultInlineStyleContext(), theme),
+      );
+    };
+
+    markdownPrototype[inlineEmphasisPatchKey] = { originalRenderInlineTokens, patchedRenderInlineTokens };
+    markdownPrototype.renderInlineTokens = patchedRenderInlineTokens;
+
+    pi.on("session_shutdown", () => {
+      const patch = markdownPrototype[inlineEmphasisPatchKey];
+      if (patch?.patchedRenderInlineTokens === markdownPrototype.renderInlineTokens) {
+        markdownPrototype.renderInlineTokens = patch.originalRenderInlineTokens;
+      }
+      if (patch) delete markdownPrototype[inlineEmphasisPatchKey];
+    });
+  }
+
   const textContent = (result: any): string =>
     result.content
       ?.filter((item: any) => item.type === "text")
@@ -3182,13 +3278,12 @@ export default function prettyTui(pi: ExtensionAPI) {
           if (lines.length === 0) return lines;
           contentLines = lines[0] === "" ? lines.slice(1) : lines;
         }
-        decoratedContent = contentLines.map((line: string, index: number) =>
-          truncateToWidth(
-            (index === 0 ? childPrefix : continuation) + line,
-            Math.max(1, width),
-            "",
-          )
-        );
+        decoratedContent = contentLines.map((line: string, index: number) => {
+          const prefix = index === 0 ? childPrefix : continuation;
+          const rendered = truncateToWidth(prefix + line, Math.max(1, width), "");
+          return selectionMetadataActive()
+            ? selectableRow(rendered, visibleWidth(rendered), [[visibleWidth(prefix), visibleWidth(rendered)]]) : rendered;
+        });
         if (cacheable) {
           this[cleanChildRenderCacheKey] = {
             width,
@@ -4333,21 +4428,31 @@ export default function prettyTui(pi: ExtensionAPI) {
     grep: createGrepToolDefinition(cwd), find: createFindToolDefinition(cwd), ls: createLsToolDefinition(cwd),
   };
   const registerStyledTool = (definition: any) => {
-    const native = nativeDefinitions[definition.name];
-    const select = (kind: "renderCall" | "renderResult", args: any[]) => {
-      const context = args.at(-1);
-      const useNative = renderMode === "full" || renderMode === "compact" && context.expanded;
-      const namespace = useNative ? "nativeFull" : "pretty";
-      const state = context.state[namespace] ??= { state: {} };
-      const scoped = { ...context, state: state.state, lastComponent: state[kind] };
-      const renderer = useNative ? native[kind] : definition[kind];
-      const component = renderer?.(...args.slice(0, -1), scoped);
-      state[kind] = component;
-      return component;
-    };
-    pi.registerTool({ ...definition,
-      renderCall: (...args: any[]) => select("renderCall", args),
-      renderResult: (...args: any[]) => select("renderResult", args),
+    pi.registerToolRenderer((name, next) => {
+      const downstream = next();
+      if (name !== definition.name) return downstream;
+      // A same-named extension/SDK tool owns its own rendering and parameters.
+      // In particular, do not apply built-in summaries to an unrelated schema.
+      const source = pi.getAllTools().find((tool) => tool.name === name)?.sourceInfo;
+      if (source && source.path !== `builtin:${name}`) {
+        return downstream ? { ...downstream, [THIRD_PARTY_TOOL]: true } : downstream;
+      }
+      const native = nativeDefinitions[name];
+      const select = (kind: "renderCall" | "renderResult", args: any[]) => {
+        const context = args.at(-1);
+        const useNative = renderMode === "full" || renderMode === "compact" && context.expanded;
+        const namespace = useNative ? "nativeFull" : "pretty";
+        const state = context.state[namespace] ??= { state: {} };
+        const scoped = { ...context, state: state.state, lastComponent: state[kind] };
+        const renderer = useNative ? downstream?.[kind] ?? native[kind] : definition[kind];
+        const component = renderer?.(...args.slice(0, -1), scoped);
+        state[kind] = component;
+        return component;
+      };
+      return { ...downstream, renderShell: "self",
+        renderCall: (...args: any[]) => select("renderCall", args),
+        renderResult: (...args: any[]) => select("renderResult", args),
+      };
     });
   };
 

package/extensions/markdown-emphasis.ts

@@ -0,0 +1,87 @@
+/**
+ * Foreground colors for Markdown strong and emphasis in the assistant's answer.
+ *
+ * Pi has no strong or emphasis color token, so these reuse existing ones. Each is
+ * read from the active theme on every render, so dark, light, custom themes and
+ * `/theme` all apply. `syntaxType` looks like an option for emphasis, but it equals
+ * `mdCode` in Pi's built-in themes, which would make emphasis look like inline code.
+ */
+export const MARKDOWN_EMPHASIS_COLORS = {
+  strong: "syntaxNumber",
+  em: "warning",
+} as const;
+
+type EmphasisType = keyof typeof MARKDOWN_EMPHASIS_COLORS;
+type EmphasisColor = (typeof MARKDOWN_EMPHASIS_COLORS)[EmphasisType];
+type ChildOwner = EmphasisType | "link";
+
+export interface EmphasisTheme {
+  fg(color: EmphasisColor, text: string): string;
+}
+
+/** Pi's inline style context: how text is styled, and what restores it after a nested span closes. */
+export interface InlineStyleContext {
+  applyText: (text: string) => string;
+  stylePrefix: string;
+}
+
+export interface InlineToken {
+  type: string;
+  tokens?: InlineToken[];
+}
+
+const SENTINEL = "\0";
+
+const isChildOwner = (type: string): type is ChildOwner =>
+  type === "strong" || type === "em" || type === "link";
+
+// Pi passes a token's children to renderInlineTokens with the parent's context and
+// does not say who the parent was. Keyed by array, so Pi's cached tokens stay unmodified.
+const childOwners = new WeakMap<readonly InlineToken[], ChildOwner>();
+const nativeContexts = new WeakSet<InlineStyleContext>();
+const surroundingContexts = new WeakMap<InlineStyleContext, InlineStyleContext>();
+
+/** Marks a context whose text keeps its own foreground, such as a heading title. */
+export function withNativeEmphasis(context: InlineStyleContext): InlineStyleContext {
+  nativeContexts.add(context);
+  return context;
+}
+
+function emphasisContext(
+  surrounding: InlineStyleContext,
+  color: EmphasisColor,
+  theme: EmphasisTheme,
+): InlineStyleContext {
+  const context: InlineStyleContext = {
+    // The inner color wins, so a surrounding default style cannot hide the emphasis color.
+    applyText: (text) => surrounding.applyText(theme.fg(color, text)),
+    // A nested span's foreground close falls back to the terminal default, so
+    // Pi's stylePrefix has to reopen the emphasis color for the text after it.
+    stylePrefix: surrounding.stylePrefix + theme.fg(color, SENTINEL).split(SENTINEL)[0],
+  };
+  surroundingContexts.set(context, surrounding);
+  return context;
+}
+
+/**
+ * Returns the context Pi should use for these tokens. Only the context changes:
+ * Pi's own recursion still emits every flag and every nested span.
+ *
+ * The innermost strong or emphasis sets the foreground. A link label uses the
+ * context outside all emphasis, so it keeps Pi's link color, and emphasis inside
+ * it stays flags-only for the same reason. Inline code is untouched by contexts.
+ */
+export function themedInlineContext(
+  tokens: readonly InlineToken[],
+  context: InlineStyleContext,
+  theme: EmphasisTheme,
+): InlineStyleContext {
+  const owner = childOwners.get(tokens);
+  for (const token of tokens) {
+    if (token.tokens && isChildOwner(token.type)) childOwners.set(token.tokens, token.type);
+  }
+  if (!owner || nativeContexts.has(context)) return context;
+  const surrounding = surroundingContexts.get(context) ?? context;
+  if (owner === "link") return withNativeEmphasis({ ...surrounding });
+  return emphasisContext(surrounding, MARKDOWN_EMPHASIS_COLORS[owner], theme);
+}