nastech-tui 0.0.1

package/src/lib/openExternalUrl.test.ts

@@ -0,0 +1,217 @@
+import type { ChildProcess, spawn as SpawnFn } from 'node:child_process'
+import { EventEmitter } from 'node:events'
+
+import { describe, expect, it, vi } from 'vitest'
+
+import { openCommand, openExternalUrl, parseSafeUrl } from './openExternalUrl.js'
+
+type SpawnLike = typeof SpawnFn
+
+describe('parseSafeUrl', () => {
+  it('accepts http and https URLs', () => {
+    expect(parseSafeUrl('https://example.com')?.href).toBe('https://example.com/')
+    expect(parseSafeUrl('http://example.com/path?q=1')?.href).toBe('http://example.com/path?q=1')
+  })
+
+  it('rejects file: URLs (would let a hostile model trigger arbitrary local handlers)', () => {
+    expect(parseSafeUrl('file:///etc/passwd')).toBeNull()
+  })
+
+  it('rejects javascript:, data:, and vbscript: URLs', () => {
+    expect(parseSafeUrl('javascript:alert(1)')).toBeNull()
+    expect(parseSafeUrl('data:text/html,<script>alert(1)</script>')).toBeNull()
+    expect(parseSafeUrl('vbscript:msgbox')).toBeNull()
+  })
+
+  it('rejects mailto:, ftp:, and other non-web protocols', () => {
+    expect(parseSafeUrl('mailto:test@example.com')).toBeNull()
+    expect(parseSafeUrl('ftp://example.com')).toBeNull()
+    expect(parseSafeUrl('ssh://example.com')).toBeNull()
+  })
+
+  it('rejects unparseable strings', () => {
+    expect(parseSafeUrl('not a url')).toBeNull()
+    expect(parseSafeUrl('')).toBeNull()
+  })
+
+  it('rejects non-string inputs defensively', () => {
+    expect(parseSafeUrl(undefined as unknown as string)).toBeNull()
+    expect(parseSafeUrl(null as unknown as string)).toBeNull()
+    expect(parseSafeUrl(123 as unknown as string)).toBeNull()
+  })
+})
+
+describe('openCommand', () => {
+  it('returns macOS open(1) on darwin', () => {
+    expect(openCommand('darwin')).toEqual({ command: 'open', args: [] })
+  })
+
+  it('routes through explorer.exe on win32 — not cmd.exe — so URLs with & | ^ < > stay safe', () => {
+    // win32 must not route through cmd.exe — see comment in openCommand.
+    // Test pins the contract that we use explorer.exe (non-shell) so URLs
+    // with `&`/`|`/`^`/`<`/`>` aren't reparsed by cmd's tokenizer.
+    const cmd = openCommand('win32')
+    expect(cmd?.command).toBe('explorer.exe')
+    expect(cmd?.args).toEqual([])
+  })
+
+  it('falls back to xdg-open on linux/bsd', () => {
+    expect(openCommand('linux')).toEqual({ command: 'xdg-open', args: [] })
+    expect(openCommand('freebsd')).toEqual({ command: 'xdg-open', args: [] })
+    expect(openCommand('openbsd')).toEqual({ command: 'xdg-open', args: [] })
+  })
+
+  it('returns null for unknown platforms (aix, sunos, cygwin, etc.)', () => {
+    // Avoid optimistically dispatching xdg-open on platforms where it
+    // probably isn't installed — the caller's `if (!command) return false`
+    // path surfaces "no opener" honestly instead.
+    expect(openCommand('aix')).toBeNull()
+    expect(openCommand('sunos')).toBeNull()
+    expect(openCommand('cygwin')).toBeNull()
+    expect(openCommand('haiku')).toBeNull()
+    expect(openCommand('')).toBeNull()
+  })
+})
+
+describe('openExternalUrl on unsupported platforms', () => {
+  it('returns false without spawning when the platform has no known opener', () => {
+    const spawn = vi.fn() as unknown as SpawnLike
+
+    expect(openExternalUrl('https://example.com/', { spawn, platform: () => 'aix' })).toBe(false)
+    expect(spawn).not.toHaveBeenCalled()
+  })
+})
+
+describe('openExternalUrl', () => {
+  // Tracks the most recent fake child so tests can inspect its 'error'
+  // handlers and emit on it. Use a loose EventEmitter alias rather than
+  // ChildProcess — the latter's `unref` signature is strictly `() => void`
+  // and doesn't accept `vi.fn()` without a generic.
+  type FakeChild = EventEmitter & { unref: () => void }
+
+  function mockSpawn(): {
+    spawn: SpawnLike
+    calls: Array<{ command: string; args: readonly string[] }>
+    lastChild: () => FakeChild | undefined
+  } {
+    const calls: Array<{ command: string; args: readonly string[] }> = []
+    let lastChild: FakeChild | undefined
+
+    const spawn = vi.fn((command: string, args: readonly string[]) => {
+      calls.push({ command, args })
+
+      // Use a real EventEmitter so .once('error', cb) wires up correctly
+      // and we can synthesize async failures by emitting 'error' from the
+      // test. The cast is the same one Node uses internally — ChildProcess
+      // extends EventEmitter.
+      const child = new EventEmitter() as FakeChild
+
+      child.unref = () => {}
+      lastChild = child
+
+      return child as unknown as ChildProcess
+    }) as unknown as SpawnLike
+
+    return { spawn, calls, lastChild: () => lastChild }
+  }
+
+  it('opens a normal https URL via the platform command', () => {
+    const { spawn, calls } = mockSpawn()
+
+    expect(openExternalUrl('https://example.com/foo', { spawn, platform: () => 'darwin' })).toBe(true)
+    expect(calls).toHaveLength(1)
+    expect(calls[0]!.command).toBe('open')
+    expect(calls[0]!.args).toEqual(['https://example.com/foo'])
+  })
+
+  it('uses xdg-open on linux', () => {
+    const { spawn, calls } = mockSpawn()
+
+    openExternalUrl('https://example.com/', { spawn, platform: () => 'linux' })
+    expect(calls[0]!.command).toBe('xdg-open')
+  })
+
+  it('refuses to open file: URLs and does not spawn', () => {
+    const { spawn, calls } = mockSpawn()
+
+    expect(openExternalUrl('file:///etc/passwd', { spawn, platform: () => 'darwin' })).toBe(false)
+    expect(calls).toHaveLength(0)
+  })
+
+  it('refuses to open javascript: URLs and does not spawn', () => {
+    const { spawn, calls } = mockSpawn()
+
+    expect(openExternalUrl('javascript:alert(1)', { spawn, platform: () => 'darwin' })).toBe(false)
+    expect(calls).toHaveLength(0)
+  })
+
+  it('passes URLs containing shell metacharacters as plain args (no shell interpolation)', () => {
+    const { spawn, calls } = mockSpawn()
+
+    // A URL with `; & ` plus URL-encoded backticks. spawn(..., args) without
+    // shell:true means the OS receives these as a single argv element.
+    const hostile = 'https://example.com/path%3Bevil%20%26%20rm%20-rf'
+
+    openExternalUrl(hostile, { spawn, platform: () => 'darwin' })
+    expect(calls).toHaveLength(1)
+    expect(calls[0]!.args[calls[0]!.args.length - 1]).toBe(hostile)
+  })
+
+  it('on win32, a URL with & | ^ < > is forwarded as a single argv element via explorer.exe', () => {
+    const { spawn, calls } = mockSpawn()
+
+    // Plain http URL with & in query (very common, e.g. analytics params)
+    // plus other cmd metacharacters that would split or reinterpret the
+    // command if win32 routed through cmd.exe /c start. Note that the URL
+    // parser percent-encodes `<` and `>` (which is fine — encoded forms
+    // can't be reinterpreted by any shell), but `&`, `|`, `^` survive
+    // and would tokenize cmd.exe if we ever regressed back to it.
+    const meta = 'https://example.com/q?a=1&b=2|c^d<e>f'
+
+    expect(openExternalUrl(meta, { spawn, platform: () => 'win32' })).toBe(true)
+    expect(calls).toHaveLength(1)
+    expect(calls[0]!.command).toBe('explorer.exe')
+    // The URL must arrive as exactly one argv element — not split on &/|/^/etc.
+    const forwarded = calls[0]!.args[0]!
+    expect(calls[0]!.args).toHaveLength(1)
+    expect(forwarded).toContain('a=1&b=2')
+    expect(forwarded).toContain('|c^d')
+  })
+
+  it('on win32, common http URLs with & query params are forwarded intact', () => {
+    const { spawn, calls } = mockSpawn()
+    const url = 'https://example.com/search?q=foo&page=2&utm_source=nastech'
+
+    openExternalUrl(url, { spawn, platform: () => 'win32' })
+    expect(calls[0]!.args).toEqual([url])
+  })
+
+  it('returns false on synchronous spawn failure', () => {
+    const spawn = vi.fn(() => {
+      throw new Error('ENOENT')
+    }) as unknown as SpawnLike
+
+    expect(openExternalUrl('https://example.com/', { spawn, platform: () => 'linux' })).toBe(false)
+  })
+
+  it('does not crash the host when the spawned process emits an async error', () => {
+    // Real-world case: `xdg-open` / `explorer.exe` missing on PATH. spawn()
+    // returns a ChildProcess synchronously, then emits 'error' once the
+    // exec actually fails. Without a registered 'error' listener, Node
+    // re-throws the event as an uncaught exception → TUI dies. We attach
+    // a no-op listener inside openExternalUrl; this test pins that contract.
+    const { spawn, lastChild } = mockSpawn()
+
+    expect(openExternalUrl('https://example.com/', { spawn, platform: () => 'linux' })).toBe(true)
+
+    const child = lastChild()
+    expect(child).toBeDefined()
+    // Must have a listener registered BEFORE we emit, or EventEmitter will
+    // throw synchronously here (which is exactly the crash we're preventing).
+    expect(child!.listenerCount('error')).toBeGreaterThan(0)
+
+    // Emit and assert it doesn't throw. If the listener weren't attached,
+    // this would throw 'Unhandled error' and fail the test.
+    expect(() => child!.emit('error', new Error('ENOENT: xdg-open not found'))).not.toThrow()
+  })
+})

package/src/lib/openExternalUrl.ts

@@ -0,0 +1,158 @@
+import { spawn, type SpawnOptions } from 'node:child_process'
+import { platform } from 'node:os'
+
+/**
+ * Opens an external URL in the user's default browser/handler.
+ *
+ * Wired into the Ink instance via `onHyperlinkClick` in entry.tsx, so any
+ * mouse click on a `<Link>` cell (or a row containing a plain-text URL the
+ * renderer detected) goes here. Mouse tracking inside the TUI prevents
+ * Terminal.app's native Cmd+click from firing — the click is captured
+ * before the terminal application sees it — so we have to handle the open
+ * ourselves.
+ *
+ * Safety:
+ * - http(s) only. Anything else (`file:`, `data:`, `javascript:`, etc.) is
+ *   rejected — a hostile model could otherwise emit `<Link url="file:///">`
+ *   and trick a click into running an arbitrary local handler.
+ * - Hostname is parsed via `URL`; only well-formed URLs are forwarded.
+ * - Spawned via `child_process.spawn` with arg array (no shell), so a URL
+ *   containing shell metacharacters (`;`, `&`, backticks) cannot be
+ *   interpreted as a command.
+ *
+ * Returns `true` if the spawn was attempted, `false` if the open could
+ * not proceed — covers (a) URL rejected by `parseSafeUrl` (non-http(s),
+ * malformed, etc.), (b) no known opener for the current platform
+ * (`openCommand` returned null), or (c) `spawn()` threw synchronously
+ * before the child was created. Async failures after spawn (`'error'`
+ * event because the binary couldn't exec) still return `true` because
+ * the spawn was attempted — the no-op error listener absorbs the event
+ * so the TUI doesn't crash, and the user just doesn't see their browser
+ * pop.
+ */
+export function openExternalUrl(rawUrl: string, dependencies: OpenDependencies = {}): boolean {
+  const url = parseSafeUrl(rawUrl)
+
+  if (!url) {
+    return false
+  }
+
+  const spawnFn = dependencies.spawn ?? spawn
+  const platformId = dependencies.platform?.() ?? platform()
+
+  const command = openCommand(platformId)
+
+  if (!command) {
+    return false
+  }
+
+  try {
+    const child = spawnFn(command.command, [...command.args, url.toString()], {
+      // Detach so closing the TUI later doesn't kill the browser process,
+      // and ignore stdio so we don't leak FDs into our raw-mode terminal.
+      // Without `ignore` here, Chrome's stderr can land in the alt screen.
+      detached: true,
+      stdio: 'ignore'
+    } satisfies SpawnOptions)
+
+    // Async failure path: spawn returns a ChildProcess synchronously even
+    // when the binary is missing (ENOENT on `xdg-open` / `explorer.exe`),
+    // unreachable (EACCES), or otherwise unusable — the failure surfaces
+    // later as an 'error' event. Without a handler, an unhandled 'error'
+    // on an EventEmitter crashes Node, which would tear down the whole
+    // TUI. Attach a no-op listener BEFORE unref() so the event has a
+    // consumer; we already returned `true` synchronously, so the user
+    // just won't see their browser open — same as if the URL had been
+    // rejected upstream.
+    child.once('error', () => {
+      // Intentional no-op. The TUI keeps running; user gets no browser
+      // pop, which is the failure mode we promised in the doc comment.
+    })
+
+    child.unref()
+
+    return true
+  } catch {
+    // spawn can also throw synchronously on argv-validation failures
+    // (e.g. NUL in the path). Treat it as a no-op rather than crashing.
+    return false
+  }
+}
+
+export type OpenDependencies = {
+  spawn?: typeof spawn
+  platform?: () => string
+}
+
+/**
+ * Validate and normalize a URL for opening externally.
+ * Exported for testing.
+ */
+export function parseSafeUrl(value: string): null | URL {
+  if (!value || typeof value !== 'string') {
+    return null
+  }
+
+  let parsed: URL
+
+  try {
+    parsed = new URL(value)
+  } catch {
+    return null
+  }
+
+  // http(s) only — opening file://, data:, javascript:, vbscript:, etc.
+  // would let a malicious model run a local handler with attacker-controlled
+  // input on a single click.
+  if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+    return null
+  }
+
+  // Reject empty or all-whitespace hostnames defensively. URL parsing
+  // accepts URLs like 'http:///foo' on some Node versions; we don't want
+  // to forward those to `open`.
+  if (!parsed.hostname.trim()) {
+    return null
+  }
+
+  return parsed
+}
+
+type OpenCommand = { command: string; args: readonly string[] }
+
+/**
+ * Per-platform open command. We deliberately avoid `cmd.exe /c start` on
+ * Windows even though it's the canonical example, because `start` is a cmd
+ * builtin: the URL string is reparsed by cmd's command-line tokenizer and
+ * characters like `&`, `|`, `^`, `<`, `>` either break the command or get
+ * interpreted as additional commands. That undermines the protocol
+ * allowlist's safety story and also breaks plain http(s) URLs with `&` in
+ * query strings. `explorer.exe <url>` is the safe, non-shell alternative —
+ * it invokes the registered protocol handler for http(s) without going
+ * through cmd. Linux/BSD use `xdg-open` directly with no shell wrapping.
+ *
+ * Returns null for platforms where we don't know a safe opener (e.g. `aix`,
+ * `sunos`, `cygwin`). The caller's `if (!command) return false` path then
+ * surfaces "no opener" instead of optimistically trying `xdg-open` on a
+ * platform that probably doesn't have it.
+ */
+export function openCommand(platformId: string): OpenCommand | null {
+  if (platformId === 'darwin') {
+    return { command: 'open', args: [] }
+  }
+
+  if (platformId === 'win32') {
+    return { command: 'explorer.exe', args: [] }
+  }
+
+  // Linux + the BSD family ship xdg-open via xdg-utils. Everything else
+  // (aix, sunos, cygwin, haiku, etc.) returns null so openExternalUrl's
+  // command-not-found fallback fires honestly.
+  const XDG_OPEN_PLATFORMS = new Set(['linux', 'freebsd', 'openbsd', 'netbsd', 'dragonfly'])
+
+  if (XDG_OPEN_PLATFORMS.has(platformId)) {
+    return { command: 'xdg-open', args: [] }
+  }
+
+  return null
+}

package/src/lib/osc52.ts

@@ -0,0 +1,73 @@
+const ESC = '\x1b'
+const BEL = '\x07'
+const ST = `${ESC}\\`
+
+export const OSC52_CLIPBOARD_QUERY = `${ESC}]52;c;?${BEL}`
+
+type OscResponse = { code: number; data: string; type: 'osc' }
+
+type OscQuerier = {
+  flush: () => Promise<void>
+  send: <T>(query: { match: (r: unknown) => r is T; request: string }) => Promise<T | undefined>
+}
+
+function wrapForMultiplexer(sequence: string): string {
+  if (process.env['TMUX']) {
+    return `${ESC}Ptmux;${sequence.split(ESC).join(ESC + ESC)}${ST}`
+  }
+
+  if (process.env['STY']) {
+    return `${ESC}P${sequence}${ST}`
+  }
+
+  return sequence
+}
+
+export function buildOsc52ClipboardQuery(): string {
+  return wrapForMultiplexer(OSC52_CLIPBOARD_QUERY)
+}
+
+export function parseOsc52ClipboardData(data: string): null | string {
+  const firstSep = data.indexOf(';')
+
+  if (firstSep === -1) {
+    return null
+  }
+
+  const selection = data.slice(0, firstSep)
+  const payload = data.slice(firstSep + 1)
+
+  if ((selection !== 'c' && selection !== 'p') || !payload || payload === '?') {
+    return null
+  }
+
+  try {
+    return Buffer.from(payload, 'base64').toString('utf8')
+  } catch {
+    return null
+  }
+}
+
+export async function readOsc52Clipboard(querier: null | OscQuerier, timeoutMs = 500): Promise<null | string> {
+  if (!querier) {
+    return null
+  }
+
+  const timeout = new Promise<undefined>(resolve => setTimeout(resolve, timeoutMs))
+
+  const query = querier.send<OscResponse>({
+    request: buildOsc52ClipboardQuery(),
+    match: (r: unknown): r is OscResponse => {
+      return !!r && typeof r === 'object' && (r as OscResponse).type === 'osc' && (r as OscResponse).code === 52
+    }
+  })
+
+  const response = await Promise.race([query, timeout])
+
+  await querier.flush()
+
+  return response ? parseOsc52ClipboardData(response.data) : null
+}
+
+export const writeOsc52Clipboard = (s: string) =>
+  process.stdout.write(`\x1b]52;c;${Buffer.from(s, 'utf8').toString('base64')}\x07`)

package/src/lib/parentLog.ts

@@ -0,0 +1,57 @@
+import { appendFileSync, mkdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+
+// Mirror the Python gateway's panic log (tui_gateway/server.py::_CRASH_LOG) from
+// the Node parent so lifecycle breadcrumbs interleave, by timestamp, with the
+// child's `=== SIGTERM received ===` / `=== gateway exit ===` entries.
+//
+// A backend SIGTERM is *usually* a parent action — `gw.kill()` (graceful-exit on
+// a signal to Node, or an explicit /quit) or `start()` replacing a live child —
+// but it can also come straight from an external supervisor (s6, a cgroup OOM
+// reaper, a stray `kill`) signalling the child directly. Telling those apart is
+// exactly the point: #31051 left these breadcrumbs in an in-memory CircularBuffer
+// that dies with the process, so SIGTERM crash reports arrived with no parent
+// context. A `[tui-parent]` line immediately before the child's panic means a
+// parent kill; its absence *suggests* an external signal — not definitive,
+// since this logger is best-effort (disabled under VITEST, and a failed append
+// is swallowed). Persisting the death-explaining events here is what makes that
+// distinction (and a memory-critical `process.exit(137)`, which closes stdin →
+// clean EOF, not SIGTERM) diagnosable after the fact.
+const logDir = join(process.env.NASTECH_HOME?.trim() || join(homedir(), '.nastech'), 'logs')
+const CRASH_LOG = join(logDir, 'tui_gateway_crash.log')
+
+// Skipped under vitest so unit tests exercising start()/kill() can't write into
+// a real ~/.nastech (tests must stay hermetic — see AGENTS.md).
+const enabled = !process.env.VITEST
+// Slice a single breadcrumb's value to MAX_BREADCRUMB chars (a short
+// "[truncated …]" marker is appended, so the written line is slightly longer)
+// so a pathological value (e.g. a giant error) can't bloat the shared crash log
+// or add noticeable blocking on the synchronous append. Mirrors the spirit of
+// GatewayClient's in-memory log-line cap.
+const MAX_BREADCRUMB = 4096
+let warned = false
+
+export function recordParentLifecycle(line: string): void {
+  if (!enabled) {
+    return
+  }
+
+  try {
+    // Collapse embedded newlines so a multi-line value (e.g. an error message)
+    // stays one breadcrumb and can't masquerade as a separate log entry or as
+    // the child's panic output sharing this file.
+    const oneLine = line.replace(/[\r\n]+/g, ' ↵ ')
+
+    const capped =
+      oneLine.length > MAX_BREADCRUMB ? `${oneLine.slice(0, MAX_BREADCRUMB)}… [truncated ${oneLine.length} chars]` : oneLine
+
+    mkdirSync(logDir, { recursive: true })
+    appendFileSync(CRASH_LOG, `[tui-parent] ${new Date().toISOString()} ${capped}\n`)
+  } catch {
+    if (!warned) {
+      warned = true
+      process.stderr.write('nastech-tui: parent lifecycle log unavailable\n')
+    }
+  }
+}

package/src/lib/perfPane.tsx

@@ -0,0 +1,107 @@
+// Perf instrumentation for the full render pipeline.
+//
+//   PerfPane (React.Profiler)  → per-pane commit times
+//   logFrameEvent (ink.onFrame) → yoga / renderer / diff / optimize / write
+//                                 phases + yoga counters + scroll fast-path
+//
+// Both gate on NASTECH_DEV_PERF=1 and dump JSON-lines (default ~/.nastech/perf.log,
+// override NASTECH_DEV_PERF_LOG). Tagged { src: 'react' | 'frame' } for jq.
+// NASTECH_DEV_PERF_MS (default 2) skips sub-ms idle frames; set 0 to capture all.
+//
+// Zero cost when unset: PerfPane returns children directly, logFrameEvent is
+// undefined so ink doesn't pay the timing cost.
+
+import { appendFileSync, mkdirSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+
+import type { FrameEvent } from '@nastechai/ink'
+import { scrollFastPathStats } from '@nastechai/ink'
+import { Profiler, type ProfilerOnRenderCallback, type ReactNode } from 'react'
+
+const ENABLED = /^(?:1|true|yes|on)$/i.test((process.env.NASTECH_DEV_PERF ?? '').trim())
+const THRESHOLD_MS = Number(process.env.NASTECH_DEV_PERF_MS ?? '2') || 0
+const LOG_PATH = process.env.NASTECH_DEV_PERF_LOG?.trim() || join(homedir(), '.nastech', 'perf.log')
+
+let logReady = false
+
+const writeRow = (row: Record<string, unknown>) => {
+  if (!logReady) {
+    logReady = true
+
+    try {
+      mkdirSync(dirname(LOG_PATH), { recursive: true })
+    } catch {
+      // Best-effort — never crash the TUI to log a sample.
+    }
+  }
+
+  try {
+    appendFileSync(LOG_PATH, `${JSON.stringify(row)}\n`)
+  } catch {
+    /* best-effort */
+  }
+}
+
+const round2 = (n: number) => Math.round(n * 100) / 100
+
+const onRender: ProfilerOnRenderCallback = (id, phase, actualMs, baseMs, startTime, commitTime) => {
+  if (actualMs < THRESHOLD_MS) {
+    return
+  }
+
+  writeRow({
+    actualMs: round2(actualMs),
+    baseMs: round2(baseMs),
+    commitTimeMs: round2(commitTime),
+    id,
+    phase,
+    src: 'react',
+    startTimeMs: round2(startTime),
+    ts: Date.now()
+  })
+}
+
+export function PerfPane({ children, id }: { children: ReactNode; id: string }) {
+  if (!ENABLED) {
+    return children
+  }
+
+  return (
+    <Profiler id={id} onRender={onRender}>
+      {children}
+    </Profiler>
+  )
+}
+
+export const logFrameEvent = ENABLED
+  ? (event: FrameEvent) => {
+      if (event.durationMs < THRESHOLD_MS) {
+        return
+      }
+
+      writeRow({
+        durationMs: round2(event.durationMs),
+        // Cumulative counters — consumers diff pairs to get per-frame deltas.
+        fastPath: { ...scrollFastPathStats, declined: { ...scrollFastPathStats.declined } },
+        flickers: event.flickers.length ? event.flickers : undefined,
+        phases: event.phases
+          ? {
+              ...event.phases,
+              commit: round2(event.phases.commit),
+              diff: round2(event.phases.diff),
+              optimize: round2(event.phases.optimize),
+              prevFrameDrainMs: round2(event.phases.prevFrameDrainMs),
+              renderer: round2(event.phases.renderer),
+              write: round2(event.phases.write),
+              yoga: round2(event.phases.yoga)
+            }
+          : undefined,
+        src: 'frame',
+        ts: Date.now()
+      })
+    }
+  : undefined
+
+export const PERF_ENABLED = ENABLED
+export const PERF_LOG_PATH = LOG_PATH