@pi-archimedes/core 0.2.0

package/src/index.ts

@@ -0,0 +1,157 @@
+import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext, KeybindingsManager } from "@earendil-works/pi-coding-agent";
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { TUI, EditorTheme, Component, type SettingItem } from "@earendil-works/pi-tui";
+
+import { HephaestusEditor } from "./editor/index.js";
+import { patchUserMessage, resetInstanceCount } from "./message/index.js";
+import { renderHeader, patchStartupListing, type ListingRef } from "./startup/index.js";
+import { patchConsoleLog } from "./startup/capture.js";
+import { patchThinkingRenderer } from "./thinking/patch.js";
+import { transformThinkingContent } from "./thinking/transform.js";
+import { loadCoreConfig, saveCoreConfig, DEFAULT_CORE_CONFIG, ANIMATION_STYLES, type CoreConfig } from "./config.js";
+import { initBus } from "./bus.js";
+
+// ── Settings items ────────────────────────────────────────────────────────
+
+export function getCoreSettingsItems(config: CoreConfig): SettingItem[] {
+  return [
+    {
+      id: "mutedTheme",
+      label: "Muted Theme",
+      description: "Use muted colors for thinking blocks",
+      currentValue: config.mutedTheme ? "On" : "Off",
+      values: ["On", "Off"],
+    },
+    {
+      id: "codeUnindent",
+      label: "Code Unindent",
+      description: "Remove 2-space indent from code blocks",
+      currentValue: config.codeUnindent ? "On" : "Off",
+      values: ["On", "Off"],
+    },
+    {
+      id: "labelText",
+      label: "Label Text",
+      description: "Text shown before thinking blocks",
+      currentValue: config.labelText,
+    },
+    {
+      id: "labelColor",
+      label: "Label Color",
+      description: "RGB color for thinking label (e.g. 255,215,0)",
+      currentValue: config.labelColor,
+    },
+    {
+      id: "animationStyle",
+      label: "Logo Animation",
+      description: "Splashscreen logo reveal style",
+      currentValue: config.animationStyle,
+      values: [...ANIMATION_STYLES],
+    },
+  ];
+}
+
+// ── Core registration ─────────────────────────────────────────────────────
+
+// Module-level state for session lifecycle (shared between session_start and session_shutdown)
+let coreRef: ListingRef | undefined;
+let coreResponseTimes: number[] | undefined;
+let coreCtx: ExtensionContext | undefined;
+
+export function registerCore(pi: ExtensionAPI): void {
+  // Patch console.log for model scope capture
+  patchConsoleLog();
+
+  // session_shutdown handler (top-level to prevent accumulation on /reload)
+  pi.on("session_shutdown", (_event, _ctx) => {
+    // Mark listing as settled
+    if (coreRef) { coreRef.settled = true; }
+    const g: Record<string | symbol, unknown> = globalThis as unknown as typeof global & Record<string | symbol, unknown>;
+    const listingRef = g["listingRef"] as ListingRef | undefined;
+    if (listingRef) { listingRef.settled = true; }
+
+    // Clear response times
+    if (coreResponseTimes) { coreResponseTimes.length = 0; }
+
+    // Reset instance count
+    resetInstanceCount();
+
+    // Clear editor component override
+    if (coreCtx) { coreCtx.ui.setEditorComponent(undefined); }
+  });
+
+  // session_start handler
+  pi.on("session_start", (_event, ctx: ExtensionContext) => {
+    // Initialize bus (flushes queued events)
+    initBus();
+
+    // Save context for shutdown cleanup
+    coreCtx = ctx;
+
+    // Set animated header
+    coreRef = {
+      sections: [],
+      frame: 0,
+      revealed: false,
+      revealedAt: 0,
+      scaffoldAt: 0,
+      settled: false,
+    };
+    const ref = coreRef;
+    const headerFactory = (tui: TUI, theme: Theme): Component & { dispose?(): void } => {
+      const comp: Component & { dispose?(): void } = {
+        invalidate(): void { /* no-op */ },
+        render(width: number): string[] {
+          return renderHeader(theme, ref, width, tui.terminal.rows - 3);
+        },
+      };
+      patchStartupListing(tui, theme, ref);
+      return comp;
+    };
+    ctx.ui.setHeader(headerFactory);
+
+    // Shared response times array (used by both patchUserMessage and message_end)
+    coreResponseTimes = [];
+    const responseTimes = coreResponseTimes;
+
+    // Set editor component
+    ctx.ui.setEditorComponent((tui: TUI, editorTheme: EditorTheme, keybindings: KeybindingsManager) => {
+      const theme = ctx.ui.theme;
+      return new HephaestusEditor(tui, editorTheme, keybindings, {
+        getTheme: () => theme,
+        isIdle: () => ctx.isIdle(),
+        shutdown: () => ctx.shutdown(),
+      });
+    });
+
+    // Patch thinking renderer
+    patchThinkingRenderer(() => ctx.ui.theme);
+
+    // Patch user message response time
+    patchUserMessage(() => ctx.ui.theme, responseTimes);
+
+    // Load config for thinking transformation
+    const config = loadCoreConfig();
+
+    // Register events
+    pi.on("message_end", (event, _ctx) => {
+      // Transform thinking content (unindent code blocks if enabled)
+      if (config.codeUnindent) {
+        transformThinkingContent(event.message as any);
+      }
+
+      // Track response time from the raw message
+      const rawMsg = event.message as any;
+      if (rawMsg.duration) {
+        const idx = rawMsg.instanceIndex ?? responseTimes.length;
+        responseTimes[idx] = rawMsg.duration;
+      }
+    });
+  });
+}
+
+// ── Default export (for standalone pi.extensions loading) ─────────────────
+
+export default function (pi: ExtensionAPI): void {
+  registerCore(pi);
+}

package/src/message/index.ts

@@ -0,0 +1,138 @@
+import type { Theme, UserMessageComponent } from "@earendil-works/pi-coding-agent";
+import { RESET, resolvePalette, setThemeBg } from "../chrome.js";
+
+type UserMsgCtor = typeof UserMessageComponent & { [PATCHED]?: boolean };
+
+// ── Constants ──────────────────────────────────────────────
+
+const PATCHED = Symbol.for("splashscreen:userMsgPatched");
+// Match OSC133 B (zone end) or C (zone final). v0.67 moved these from line
+// tail to line head — we strip from wherever they sit and re-emit at the end.
+const OSC133_RE = /\x1b\]133;[BC]\x07/g;
+const MSG_PADDING_X = 3;
+const TIME_COL = 9;
+
+// ── Instance tracking ──────────────────────────────────────
+
+const instanceIndex = new WeakMap<object, number>();
+let instanceCount = 0;
+
+export function resetInstanceCount(): void {
+  instanceCount = 0;
+}
+
+function formatTime(ms: number): string {
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  const m = Math.floor(ms / 60000);
+  const s = Math.round((ms % 60000) / 1000);
+  return `${m}m ${s}s`;
+}
+
+// ── Patch ──────────────────────────────────────────────────
+
+export function patchUserMessage(
+  getTheme: () => Theme,
+  responseTimes: number[],
+): void {
+  try {
+    let lastBg = "";
+    const theme = getTheme();
+    const p = resolvePalette(theme);
+    lastBg = p.panelBg;
+    setThemeBg(theme, "userMessageBg", lastBg);
+
+    import("@earendil-works/pi-coding-agent").then(
+      ({ UserMessageComponent }: { UserMessageComponent: UserMsgCtor }) => {
+        if (UserMessageComponent[PATCHED]) return;
+
+        if (
+          typeof UserMessageComponent.prototype.addChild !== "function" ||
+          typeof UserMessageComponent.prototype.render !== "function"
+        ) {
+          console.warn("[splashscreen] UserMessageComponent shape changed — skipping patch");
+          return;
+        }
+
+        UserMessageComponent[PATCHED] = true;
+
+        const origAddChild = UserMessageComponent.prototype.addChild;
+        UserMessageComponent.prototype.addChild = function (child: any) {
+          if (child.paddingX !== undefined && !child._hephaestusPatched) {
+            child.paddingX = MSG_PADDING_X;
+            child._hephaestusPatched = true;
+          }
+          if (!instanceIndex.has(this)) {
+            instanceIndex.set(this, instanceCount++);
+          }
+          return origAddChild.call(this, child);
+        };
+
+        const origRender = UserMessageComponent.prototype.render;
+        UserMessageComponent.prototype.render = function (
+          width: number,
+        ): string[] {
+          try {
+            const currentTheme = getTheme();
+            const p = resolvePalette(currentTheme);
+            const bg = p.panelBg;
+            if (bg !== lastBg) { setThemeBg(currentTheme, "userMessageBg", bg); lastBg = bg; }
+
+            const idx = instanceIndex.get(this);
+            const elapsed = idx !== undefined ? responseTimes[idx] : 0;
+            const hasTime = idx !== undefined;
+
+            const contentWidth = width - TIME_COL;
+            const lines: string[] = origRender.call(this, contentWidth);
+            if (lines.length < 3) return lines;
+
+            const timeStr = elapsed > 0 ? formatTime(elapsed) : "";
+            const timeRight = 2;
+            const timeLabel = timeStr.length > 0 ? p.time(timeStr) : "";
+            // Column that shows "42ms" right-aligned with bg — spaces for visual
+            // alignment remain, but they're wrapped in panelBg so the copy buffer
+            // only contains the label text.
+            const timeContent =
+              p.panelBg +
+              " ".repeat(Math.max(0, TIME_COL - timeStr.length - timeRight)) +
+              timeLabel +
+              " ".repeat(timeRight);
+            // Use \x1b[K (erase-to-end-of-line) instead of literal spaces for the
+            // gap between content and time column. Visually fills with panelBg but
+            // leaves nothing in the copy buffer.
+            const gapFill = p.panelBg + "\x1b[K";
+            // Empty column: just bg fill to the end — no spaces in copy buffer
+            const emptyTimeCol = p.panelBg + "\x1b[K";
+
+            const firstContent = 0;
+
+            for (let i = 0; i < lines.length; i++) {
+              let line = lines[i]!;
+
+              // Extract any OSC133 B/C markers (shell zone end/final). v0.67 placed
+              // these at the head of the last line; older versions at the tail.
+              // Strip them from the content line; re-emit after the time column.
+              const oscMatches = line.match(OSC133_RE);
+              const oscSuffix = oscMatches ? oscMatches.join("") : "";
+              if (oscSuffix) line = line.replace(OSC133_RE, "");
+
+              // Strip trailing spaces from the content portion (PI pads to contentWidth
+              // with plain spaces) and replace with \x1b[K for visual fill without spaces
+              // in the copy buffer.
+              const strippedLine = line.replace(/((?:\x1b\[[\d;]*m)*)\s+$/, "$1");
+              const col = i === firstContent && hasTime ? timeContent : emptyTimeCol;
+              lines[i] = strippedLine + gapFill + col + oscSuffix;
+            }
+
+            return lines;
+          } catch {
+            // During /resume, getTheme() may throw — fall back to default render
+            return origRender.call(this, width);
+          }
+        };
+      },
+    );
+  } catch {
+    /* skip if theme not ready */
+  }
+}

package/src/startup/capture.ts

@@ -0,0 +1,30 @@
+const g: Record<string | symbol, unknown> = globalThis as unknown as typeof global & Record<string | symbol, unknown>;
+
+const MODEL_SCOPE_RE = /Model scope:\s*(.+)/;
+export const CAPTURED_MODELS = Symbol.for("splashscreen:capturedModels");
+export const PATCHED_LOG = Symbol.for("splashscreen:logPatched");
+
+export function patchConsoleLog(): void {
+  if (g[PATCHED_LOG]) return;
+  g[PATCHED_LOG] = true;
+  const origLog = console.log;
+  console.log = (...args: unknown[]) => {
+    try {
+      if (args.length === 1 && typeof args[0] === "string") {
+        const plain = (args[0] as string).replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+        const m = MODEL_SCOPE_RE.exec(plain);
+        if (m) {
+          const raw = m[1].replace(/\s*\(Ctrl\+\w[\w\s]*\)/gi, "");
+          g[CAPTURED_MODELS] = raw
+            .split(",")
+            .map((s: string) => s.trim())
+            .filter(Boolean);
+          return;
+        }
+      }
+    } catch {
+      /* ignore errors in patching logic */
+    }
+    origLog.apply(console, args);
+  };
+}

package/src/startup/index.ts

@@ -0,0 +1,277 @@
+import { VERSION, type Theme } from "@earendil-works/pi-coding-agent";
+import { getShinedLogo, TRUECOLOR, LOGO_PAD, LOGO_SETTLE_FRAME } from "./logo.js";
+import { loadCoreConfig } from "../config.js";
+import { detectSection, parseSectionText, parseModelScope, formatColumns, buildItemWrapper, type ParsedSection, SECTION_KEYS } from "./sections.js";
+import { fetchLatestVersion, compareVersions } from "./version.js";
+import { patchConsoleLog } from "./capture.js";
+import { stripAnsi } from "../text.js";
+import { resetInstanceCount } from "../message/index.js";
+import { Text, Spacer, Container, TUI, truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
+
+// Symbol keys (survive hot-reload)
+const LISTING_REF = Symbol.for("splashscreen:listingRef");
+const ANIM_INTERVAL = Symbol.for("splashscreen:animInterval");
+const DEBOUNCE_TIMER = Symbol.for("splashscreen:debounceTimer");
+const PATCHED_CLEAR = Symbol.for("splashscreen:clearPatched");
+const PATCHED_LISTING = Symbol.for("splashscreen:listingPatched");
+
+// Animation constants
+const MAX_RENDER_WIDTH = 9999;
+const MIN_HEADER_LINES = 11;
+const REVEAL_DEBOUNCE_MS = 150;
+const RAMP_FRAMES = 22;
+const STAGGER_FRAMES = 0;
+const BASE_FADE_DELAY = 3;
+const MAX_STAGGER = BASE_FADE_DELAY + 5 * STAGGER_FRAMES;
+
+export interface ListingRef {
+  sections: ParsedSection[];
+  frame: number;
+  revealed: boolean;
+  revealedAt: number;
+  scaffoldAt: number;
+  latestVersion?: string;
+  settled: boolean;
+  cachedLines?: string[];
+  cachedWidth?: number;
+  cachedHeight?: number;
+  maxHeaderHeight?: number;
+}
+
+// ── renderHeader() — composes logo + sections + padding ────────────────
+
+export function renderHeader(theme: Theme, ref: ListingRef, width: number, height: number): string[] {
+  const dim = (t: string) => theme.fg("dim", t);
+  const accent = (t: string) => theme.fg("accent", t);
+  const logoLines = getShinedLogo(ref.frame, loadCoreConfig().animationStyle);
+
+  // Use cached text lines if settled (no more animations)
+  let listingLines: string[];
+
+  if (ref.settled && ref.cachedLines && ref.cachedWidth === width && ref.cachedHeight === height) {
+    listingLines = ref.cachedLines;
+  } else {
+    const sectionsToRender: { name: "Version" | ParsedSection["name"]; items: string[] }[] = [];
+
+    if (!ref.revealed) {
+      // Logo only — sections appear together on reveal
+    } else {
+      const latest = ref.latestVersion ?? VERSION;
+      const hasUpdate = compareVersions(latest, VERSION) > 0;
+      const latestStr = hasUpdate ? `Latest: ${accent("v" + latest)}` : `Latest: v${latest}`;
+      sectionsToRender.push({ name: "Version", items: [`Local: v${VERSION}`, latestStr] });
+
+      // Display sections in SECTION_KEYS order, skip empty
+      const byName = new Map(ref.sections.map(s => [s.name, s]));
+      for (const key of SECTION_KEYS) {
+        const sec = byName.get(key);
+        if (sec && sec.items.length > 0) sectionsToRender.push(sec);
+      }
+    }
+
+    const listingMaxW = Math.floor(width * 0.7);
+    listingLines = formatColumns(sectionsToRender, theme, listingMaxW, ref);
+
+    // Cache once text animations are done
+    const textAge = ref.revealed ? ref.frame - ref.revealedAt : 0;
+    const textDone = ref.revealed && textAge > RAMP_FRAMES + MAX_STAGGER;
+    const logoDone = ref.frame >= LOGO_SETTLE_FRAME;
+
+    if (textDone && logoDone) {
+      ref.settled = true;
+      ref.cachedLines = listingLines;
+      ref.cachedWidth = width;
+      ref.cachedHeight = height;
+    }
+  }
+
+  // Build content: logo + separator + listing
+  const contentLines: string[] = [];
+
+  // Logo centered above listing (same center as listing text)
+  const listingMaxW = Math.floor(width * 0.7);
+  const listingLeftPad = Math.floor((width - listingMaxW) / 2);
+  for (const logoRow of logoLines) {
+    const pad = Math.floor((listingMaxW - visibleWidth(logoRow)) / 2);
+    contentLines.push(" ".repeat(LOGO_PAD) + " ".repeat(listingLeftPad + pad) + logoRow);
+  }
+
+  // Separator
+  contentLines.push("");
+
+  // Listing
+  for (const listRow of listingLines) {
+    contentLines.push(" ".repeat(LOGO_PAD) + " ".repeat(listingLeftPad) + listRow);
+  }
+
+  // Pad top and bottom to fill height (bias top by 2 for visual centering)
+  const contentHeight = contentLines.length;
+  const remaining = Math.max(0, height - contentHeight);
+  const topPad = Math.floor(remaining / 2) + 5;
+  const bottomPad = remaining - topPad;
+
+  const result: string[] = [];
+  for (let i = 0; i < topPad; i++) result.push("");
+  for (const line of contentLines) result.push(line);
+  for (let i = 0; i < bottomPad; i++) result.push("");
+
+  return result;
+}
+
+// ── Chat container discovery ────────────────────────────────────────────
+
+// Fragile: relies on TUI child ordering (header, chat, footer) which is an
+// internal layout detail of pi's InteractiveMode. If upstream changes the
+// child structure, this will need updating.
+function findChatContainer(tui: TUI): Container | undefined {
+  for (const child of tui.children) {
+    if (child instanceof Container && child.constructor.name.includes("Scrollable")) {
+      return child;
+    }
+  }
+  if (tui.children.length >= 3) {
+    return tui.children[1] as Container;
+  }
+  return undefined;
+}
+
+export function patchStartupListing(
+  tui: TUI,
+  _theme: Theme,
+  ref: ListingRef,
+): void {
+  const chat = findChatContainer(tui);
+  if (!chat) {
+    return;
+  }
+  const cc = chat as any;
+
+  // Always update ref + restart animation (critical for /reload)
+  cc[LISTING_REF] = ref;
+  ref.frame = 0;
+  ref.revealed = false;
+  ref.revealedAt = 0;
+  ref.scaffoldAt = 0;
+  ref.settled = false;
+  ref.cachedLines = undefined;
+  ref.cachedWidth = undefined;
+  ref.maxHeaderHeight = undefined;
+
+  if (cc[ANIM_INTERVAL]) clearInterval(cc[ANIM_INTERVAL]);
+  if (cc[DEBOUNCE_TIMER]) clearTimeout(cc[DEBOUNCE_TIMER]);
+
+  const interval = setInterval(() => {
+    try {
+      const current: ListingRef = cc[LISTING_REF];
+      if (!current) {
+        clearInterval(interval);
+        return;
+      }
+      current.frame++;
+      if (current.settled && current.frame >= LOGO_SETTLE_FRAME) {
+        clearInterval(interval);
+        cc[ANIM_INTERVAL] = null;
+        return;
+      }
+      tui.requestRender();
+    } catch {
+      clearInterval(interval);
+    }
+  }, 16);
+
+  cc[ANIM_INTERVAL] = interval;
+
+  // Fetch latest version from npm
+  fetchLatestVersion().then(v => {
+    if (v) {
+      const current: ListingRef = cc[LISTING_REF];
+      current.latestVersion = v;
+      // Invalidate cache so version updates on next render
+      current.cachedLines = undefined;
+      current.settled = false;
+    }
+  });
+
+  // Patch clear() to reset message instance tracking on container rebuild
+  if (!cc[PATCHED_CLEAR]) {
+    cc[PATCHED_CLEAR] = true;
+    const origClear = chat.clear.bind(chat);
+    chat.clear = () => {
+      resetInstanceCount();
+      return origClear();
+    };
+  }
+
+  // Only patch addChild once — the closure reads cc[LISTING_REF] dynamically
+  if (cc[PATCHED_LISTING]) {
+    chat.clear();
+    return;
+  }
+  cc[PATCHED_LISTING] = true;
+
+  const origAddChild = chat.addChild.bind(chat);
+  chat.clear();
+
+  chat.addChild = (component: Component) => {
+    try {
+      const currentRef: ListingRef = cc[LISTING_REF];
+
+      if (component instanceof Text) {
+      // pi ≥0.67.6 wraps startup sections in ExpandableText; collapsed body
+      // is a lossy comma-joined base-name list. Parse the expanded text so
+      // Extensions keep real names instead of "index.ts/index.js/index".
+      const getExpanded = (component as any).getExpandedText;
+      const plain = typeof getExpanded === "function"
+        ? stripAnsi(getExpanded.call(component))
+        : stripAnsi(component.render(MAX_RENDER_WIDTH).join("\n"));
+
+      const section = parseSectionText(plain) ?? parseModelScope(plain);
+      if (section) {
+        const existing = currentRef.sections.find(s => s.name === section.name);
+        if (existing) {
+          existing.items = [...new Set([...existing.items, ...section.items])];
+        } else {
+          currentRef.sections.push(section);
+        }
+
+        // Invalidate cache so late-arriving sections show up
+        currentRef.settled = false;
+        currentRef.cachedLines = undefined;
+
+        if (currentRef.revealed) {
+          // Already revealed — show new section immediately
+          tui.requestRender();
+        } else {
+          // Batch initial sections — reset debounce on each arrival
+          if (cc[DEBOUNCE_TIMER]) clearTimeout(cc[DEBOUNCE_TIMER]);
+          cc[DEBOUNCE_TIMER] = setTimeout(() => {
+            const ref: ListingRef = cc[LISTING_REF];
+            ref.revealed = true;
+            ref.revealedAt = ref.frame;
+            ref.scaffoldAt = ref.frame;
+            tui.requestRender();
+            cc[DEBOUNCE_TIMER] = null;
+          }, REVEAL_DEBOUNCE_MS);
+        }
+
+        return;
+      }
+
+      if (
+        plain.includes("Listing all available commands") ||
+        plain.includes("(Source: extension)") ||
+        plain.trim().startsWith("/skill:")
+      ) {
+        return;
+      }
+    }
+
+    if (component instanceof Spacer && !currentRef.revealed) return;
+    try {
+      origAddChild(component);
+    } catch (e) {
+    }
+  } catch (e) {
+  }
+  };
+}

package/src/startup/logo.ts

@@ -0,0 +1,85 @@
+import { gray, rgb, extractRgb, lerp } from "../color.js";
+import type { AnimationStyle } from "../config.js";
+
+// ── Truecolor detection ────────────────────────────────────────
+
+export const TRUECOLOR = /truecolor|24bit/i.test(process.env.COLORTERM ?? "")
+  || (process.env.TERM ?? "").includes("256color")
+  || process.env.TERM_PROGRAM === "iTerm.app"
+  || process.env.TERM_PROGRAM === "WezTerm"
+  || process.env.TERM_PROGRAM === "vscode"
+  || process.env.WT_SESSION !== undefined;
+
+// ── Logo ───────────────────────────────────────────────────────
+
+export const LOGO = [
+  "████████████    ",
+  "████████████    ",
+  "████    ████    ",
+  "████    ████    ",
+  "████████    ████",
+  "████████    ████",
+  "████        ████",
+  "████        ████",
+];
+
+export const CHAR_FADE_FRAMES = 22;
+export const LOGO_SETTLE_FRAME = 90;
+export const LOGO_PAD = 0;
+export const LOGO_GAP = 4;
+
+const LOGO_COLS = 14;
+const LOGO_ROWS = 8;
+const CENTER_X = (LOGO_COLS - 1) / 2;
+const CENTER_Y = (LOGO_ROWS - 1) / 2;
+
+function computeRevealAt(x: number, y: number, style: AnimationStyle): number {
+  switch (style) {
+    case "diagonal":
+      return ((x / 2) * 1.2 + (y / 2) * 3.5) * 1.4;
+    case "top-right":
+      return (((LOGO_COLS - 1 - x) / 2) * 1.2 + (y / 2) * 3.5) * 1.4;
+    case "bottom-left":
+      return ((x / 2) * 1.2 + ((LOGO_ROWS - 1 - y) / 2) * 3.5) * 1.4;
+    case "bottom-right":
+      return (((LOGO_COLS - 1 - x) / 2) * 1.2 + ((LOGO_ROWS - 1 - y) / 2) * 3.5) * 1.4;
+    case "center-out": {
+      const dist = Math.sqrt((x - CENTER_X) ** 2 + (y - CENTER_Y) ** 2);
+      return dist * 4.5;
+    }
+    case "wave": {
+      const base = ((x / 2) * 1.2 + (y / 2) * 3.5) * 1.4;
+      const wave = Math.sin((x * 0.8 + y * 0.5) * 1.2) * 8;
+      return base + wave;
+    }
+    case "horizontal":
+      return x * 3.5;
+    case "vertical":
+      return y * 5.5;
+    case "vertical-up":
+      return (LOGO_ROWS - 1 - y) * 5.5;
+  }
+}
+
+export function getShinedLogo(frame: number, style: AnimationStyle = "wave"): string[] {
+  if (!TRUECOLOR) return LOGO;
+
+  return LOGO.map((line, y) => {
+    let result = "";
+    for (let x = 0; x < line.length; x++) {
+      const char = line[x];
+      if (char === " ") { result += " "; continue; }
+
+      const revealAt = computeRevealAt(x, y, style);
+      const age = frame - revealAt;
+
+      if (age <= 0) { result += " "; continue; }
+
+      const t = Math.min(1, age / CHAR_FADE_FRAMES);
+      const eased = 1 - (1 - t) * (1 - t);
+      const brightness = Math.floor(lerp(50, 255, eased));
+      result += gray(brightness, char);
+    }
+    return result;
+  });
+}