markdown: drop dev-only tokenize/stats instrumentation

The onTokenizeMs + onStats probes — and the ChunkStats apparatus
(per-delta lex timing + prefix-diff bookkeeping in useMarkdownBlocks)
that fed them — only ever drove the /dev/chunked-markdown spike screen.
That screen's renderer has since shipped into the production transcript
path, leaving the probes as dead instrumentation threaded through
production components.

Remove the probes, the unused ChunkStats type, the spike screen, and
its dev-menu/route registrations. Rendering behavior is unchanged:
stability comes from positional keys + per-segment `raw` memo, not the
removed stats.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: yyq1025

packages/app/src/app/(main)/_layout.tsx

@@ -68,7 +68,6 @@ export default function MainLayout() {
         />
         {/* Dev probe pages — keep as standard pushes, no modal. */}
         <Stack.Screen name="dev/keyboard-extender" />
-        <Stack.Screen name="dev/chunked-markdown" />
       </Stack.Protected>
     </Stack>
   );

packages/app/src/app/(main)/dev/chunked-markdown.tsx

@@ -129,10 +129,6 @@ export default function SettingsIndexScreen() {
                 label="KeyboardExtender spike"
                 onPress={() => router.push("/dev/keyboard-extender")}
               />
-              <DisclosureRow
-                label="Chunked markdown spike"
-                onPress={() => router.push("/dev/chunked-markdown")}
-              />
               <Button
                 label="Clear last cwd (test placeholder)"
                 onPress={onClearLastCwd}

packages/app/src/app/(main)/settings/index.ios.tsx

@@ -16,7 +16,6 @@ import {
   LIGHT_PALETTE,
 } from "./chat-markdown";
 import { useCodeTokens } from "./code-highlighter";
-import type { ChunkStats } from "./markdown-chunking";
 import { type MarkdownSegment, useMarkdownBlocks } from "./markdown-chunking";
 import { useRemend } from "./remend";
 
@@ -32,8 +31,8 @@ import { useRemend } from "./remend";
  *    re-tokenize per delta (~1-3.5ms measured on device for typical
  *    blocks) + per-line memo keyed on token content, so settled lines
  *    skip reconciliation and only the streaming line re-renders.
- *  - Prefix-diff in useMarkdownBlocks guarantees completed segments
- *    never re-render while the tail streams.
+ *  - Positional keys + per-segment `raw` memo keep completed segments
+ *    from re-rendering while the tail streams.
  *
  * The code container is `TextInput multiline editable={false}` — a real
  * UITextView, which gives PARTIAL selection with handles (RN iOS <Text
@@ -115,17 +114,15 @@ const TokenLine = memo(
 const CodeBlockSegment = memo(function CodeBlockSegment({
   lang,
   code,
-  onTokenizeMs,
 }: {
   lang: string;
   code: string;
-  onTokenizeMs?: (ms: number) => void;
 }) {
   const scheme = useColorScheme() === "dark" ? "dark" : "light";
   const palette = scheme === "dark" ? DARK_PALETTE : LIGHT_PALETTE;
   // Sync tokenize — see useCodeTokens for why (drawer-settle gate keeps
   // mount bursts out of animation windows). null → plain, same metrics.
-  const lines = useCodeTokens(code, lang, scheme, onTokenizeMs);
+  const lines = useCodeTokens(code, lang, scheme);
 
   return (
     <View
@@ -176,23 +173,13 @@ const CodeBlockSegment = memo(function CodeBlockSegment({
 export function ChunkedMarkdown({
   markdown,
   streamDone,
-  onStats,
-  onTokenizeMs,
 }: {
   markdown: string;
   /** No settle signal available? Pass `true` — exact parity with
    *  whole-message ChatMarkdown (no remend, EOF fences counted closed). */
   streamDone: boolean;
-  /** Dev instrumentation. Called inline during render with the latest
-   *  chunk stats — consumers must only write to a ref (no setState). */
-  onStats?: (stats: ChunkStats) => void;
-  /** Dev instrumentation. Per-tokenize timing from code blocks (ref-write
-   *  only, same rule). Must be referentially stable or the CodeBlock memo
-   *  breaks. */
-  onTokenizeMs?: (ms: number) => void;
 }) {
-  const { segments, stats } = useMarkdownBlocks(markdown, streamDone);
-  onStats?.(stats);
+  const segments = useMarkdownBlocks(markdown, streamDone);
 
   const lastIndex = segments.length - 1;
   return (
@@ -203,12 +190,7 @@ export function ChunkedMarkdown({
       {segments.map((seg: MarkdownSegment, i: number) => {
         if (seg.kind === "code") {
           return (
-            <CodeBlockSegment
-              key={seg.key}
-              lang={seg.lang}
-              code={seg.code}
-              onTokenizeMs={onTokenizeMs}
-            />
+            <CodeBlockSegment key={seg.key} lang={seg.lang} code={seg.code} />
           );
         }
         // Tail run streams → remend; completed runs are frozen + memo'd.

packages/app/src/lib/markdown/chunked-markdown.tsx

@@ -222,15 +222,11 @@ export function useCodeTokens(
   code: string,
   infoString: string,
   scheme: "light" | "dark",
-  onTokenizeMs?: (ms: number) => void,
 ): TokenLines | null {
   const hl = useHighlighter();
   const langId = resolveLang(infoString);
   return useMemo(() => {
     if (hl === null || langId === null) return null;
-    const t0 = performance.now();
-    const lines = tokenizeCode(hl, code, langId, scheme);
-    onTokenizeMs?.(performance.now() - t0);
-    return lines;
-  }, [hl, langId, code, scheme, onTokenizeMs]);
+    return tokenizeCode(hl, code, langId, scheme);
+  }, [hl, langId, code, scheme]);
 }

packages/app/src/lib/markdown/code-highlighter.ts

@@ -1,4 +1,4 @@
 export type { ChatMarkdownProps } from "./chat-markdown";
 export { ChatMarkdown } from "./chat-markdown";
 export { ChunkedMarkdown } from "./chunked-markdown";
-export type { ChunkStats, MarkdownSegment } from "./markdown-chunking";
+export type { MarkdownSegment } from "./markdown-chunking";

packages/app/src/lib/markdown/index.ts

@@ -1,6 +1,6 @@
 import type { Token, Tokens } from "marked";
 import { lexer } from "marked";
-import { useMemo, useRef } from "react";
+import { useMemo } from "react";
 
 /**
  * Chunked markdown for the native transcript
@@ -45,13 +45,6 @@ export type MarkdownSegment =
       closed: boolean;
     };
 
-export interface ChunkStats {
-  lexMs: number;
-  segmentCount: number;
-  /** First segment index whose raw changed vs the previous call (-1 = none). */
-  firstChangedIndex: number;
-}
-
 /** Fence closer must sit on its own line — `foo\`\`\`` inside content is
  *  NOT a closer. Unclosed fences swallow to EOF (CommonMark), so only the
  *  LAST segment can ever be open. */
@@ -232,28 +225,9 @@ export function chunkMarkdown(
 export function useMarkdownBlocks(
   markdown: string,
   streamDone: boolean,
-): { segments: MarkdownSegment[]; stats: ChunkStats } {
-  const prevRef = useRef<MarkdownSegment[]>([]);
-  return useMemo(() => {
-    const t0 = performance.now();
-    const segments = chunkMarkdown(markdown, streamDone);
-    const lexMs = performance.now() - t0;
-
-    const prev = prevRef.current;
-    let firstChangedIndex = -1;
-    const max = Math.max(segments.length, prev.length);
-    for (let i = 0; i < max; i++) {
-      const a = segments[i];
-      const b = prev[i];
-      if (!a || !b || a.raw !== b.raw || a.kind !== b.kind) {
-        firstChangedIndex = i;
-        break;
-      }
-    }
-    prevRef.current = segments;
-    return {
-      segments,
-      stats: { lexMs, segmentCount: segments.length, firstChangedIndex },
-    };
-  }, [markdown, streamDone]);
+): MarkdownSegment[] {
+  return useMemo(
+    () => chunkMarkdown(markdown, streamDone),
+    [markdown, streamDone],
+  );
 }