Import AITURK IDE 1.0.0-beta.1 from Hermes 63279301; preserve MIT license

apps/desktop/scripts/probe-command-palette.mjs

@@ -0,0 +1,146 @@
+// ⌘K open latency, measured in-page (no CDP round-trip in the number).
+//
+//   node scripts/probe-command-palette.mjs [--port 9222] [--rounds 8]
+//
+// Reports, per round, the time from the keydown the app actually receives to:
+//   frame_ms  — the dialog frame + input in the DOM and painted (what "instant"
+//               means: the overlay owes you a frame immediately)
+//   rows_ms   — the row list painted (may lag frame_ms; rows are deferred)
+// plus any long tasks in the window, so a slow open is attributable.
+import { CDP, sleep } from './perf/lib/cdp.mjs'
+
+const args = process.argv.slice(2)
+const flag = name => {
+  const i = args.indexOf(`--${name}`)
+
+  return i >= 0 ? args[i + 1] : undefined
+}
+
+const port = Number(flag('port') ?? 9222)
+const rounds = Number(flag('rounds') ?? 8)
+
+const cdp = await CDP.connect({ port })
+
+await cdp.send('Runtime.enable')
+
+const INSTALL = `
+  (() => {
+    if (window.__CMDK__) window.__CMDK__.stop()
+
+    const state = { t0: null, frame: null, rows: 0, rowsAt: null, tasks: [], armed: false }
+
+    // Time from the keydown the APP receives — excludes CDP transport, so the
+    // number is what a user's finger actually experiences.
+    const onKey = e => {
+      if (state.armed && (e.metaKey || e.ctrlKey) && e.key.toLowerCase() === 'k') {
+        state.t0 = performance.now()
+        state.armed = false
+      }
+    }
+
+    window.addEventListener('keydown', onKey, true)
+
+    const obs = new MutationObserver(() => {
+      if (state.t0 === null) return
+      if (state.frame === null && document.querySelector('[cmdk-input]')) {
+        state.frame = performance.now() - state.t0
+      }
+      const n = document.querySelectorAll('[cmdk-item]').length
+      if (n > state.rows) { state.rows = n; state.rowsAt = performance.now() - state.t0 }
+    })
+
+    obs.observe(document.body, { childList: true, subtree: true })
+
+    const po = new PerformanceObserver(list => {
+      for (const e of list.getEntries()) state.tasks.push({ start: e.startTime, dur: Math.round(e.duration) })
+    })
+
+    try { po.observe({ entryTypes: ['longtask'] }) } catch {}
+
+    window.__CMDK__ = {
+      arm: () => { state.t0 = null; state.frame = null; state.rows = 0; state.rowsAt = null; state.tasks = []; state.armed = true },
+      read: () => ({
+        frame_ms: state.frame === null ? -1 : Math.round(state.frame),
+        rows_ms: state.rowsAt === null ? -1 : Math.round(state.rowsAt),
+        rows: state.rows,
+        longtask_ms: state.t0 === null ? 0 : state.tasks.filter(t => t.start >= state.t0).reduce((s, t) => s + t.dur, 0)
+      }),
+      stop: () => { window.removeEventListener('keydown', onKey, true); obs.disconnect(); po.disconnect() }
+    }
+
+    return true
+  })()
+`
+
+// Settle: frame painted AND rows stopped growing for two frames.
+const WAIT = `
+  new Promise(resolve => {
+    let stable = 0
+    let last = -1
+    const started = performance.now()
+    const tick = () => {
+      const r = window.__CMDK__.read()
+      if (r.frame_ms >= 0 && r.rows === last && r.rows > 0) {
+        if (++stable >= 2) { resolve(r); return }
+      } else { stable = 0 }
+      last = r.rows
+      if (performance.now() - started > 8000) { resolve(window.__CMDK__.read()); return }
+      requestAnimationFrame(tick)
+    }
+    requestAnimationFrame(tick)
+  })
+`
+
+const key = async type =>
+  cdp.send('Input.dispatchKeyEvent', {
+    type,
+    key: 'k',
+    code: 'KeyK',
+    windowsVirtualKeyCode: 75,
+    nativeVirtualKeyCode: 75,
+    modifiers: 4
+  })
+
+const esc = async () => {
+  for (const type of ['keyDown', 'keyUp']) {
+    await cdp.send('Input.dispatchKeyEvent', { type, key: 'Escape', code: 'Escape', windowsVirtualKeyCode: 27 })
+  }
+
+  await sleep(400)
+}
+
+await cdp.eval(INSTALL)
+await esc()
+
+const samples = []
+
+for (let i = 0; i < rounds; i++) {
+  await sleep(250)
+  await cdp.eval('window.__CMDK__.arm()')
+  await key('rawKeyDown')
+  await key('keyUp')
+  const r = await cdp.eval(WAIT)
+  samples.push(r)
+  console.log(`round ${i}:`, r)
+  await esc()
+}
+
+await cdp.eval('window.__CMDK__.stop()')
+
+const stat = k => {
+  const v = samples.map(s => s[k]).filter(n => n >= 0).sort((a, b) => a - b)
+
+  if (!v.length) return null
+
+  return {
+    min: v[0],
+    median: v[Math.floor(v.length / 2)],
+    max: v[v.length - 1]
+  }
+}
+
+console.log('\nkeydown → dialog frame painted (ms):', stat('frame_ms'))
+console.log('keydown → rows painted        (ms):', stat('rows_ms'))
+console.log('long-task time in window      (ms):', stat('longtask_ms'))
+
+cdp.close()