rnxsim 0.1.379 → 0.1.381

package/cli/commands/cpu-profile.ts

@@ -1,10 +1,10 @@
-// rnx perf cpu — capture a sampled CPU trace from the tenant worker.
+// rnx perf cpu — capture sampled CPU traces from the page and every worker.
 //
 // the JS Self-Profiler API (`new Profiler()`) cannot be constructed in a
 // dedicated-worker scope, and sootsim runs the guest app in the tenant worker,
 // so the old in-worker approach was unsupported (F28). this implementation
-// attaches Chromium's `Profiler` CDP domain to the worker target instead —
-// which works for workers and returns the .cpuprofile shape directly.
+// attaches Chromium's `Profiler` CDP domain to the page and worker targets —
+// which returns the .cpuprofile shape directly for every execution context.
 //
 // dedicated workers are not top-level CDP targets, so we connect to the page
 // target, `Target.setAutoAttach` to discover the worker child sessions, and
@@ -25,9 +25,12 @@
 // also drives the interaction itself lives at
 // scripts/debug/cdp-worker-cpu-profile.ts.
 
-import { mkdirSync, writeFileSync } from 'fs'
-import { dirname, resolve } from 'path'
+import { createHash } from 'node:crypto'
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
 import { WebSocket } from 'ws'
+import { getCliVersion } from '../../src/cli-version'
+import { IS_STANDALONE } from '../standalone'
 
 interface ProfileOptions {
   port?: number
@@ -41,8 +44,15 @@ const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms))
 class Cdp {
   private ws: WebSocket
   private nextId = 1
-  private pending = new Map<number, { res: (v: any) => void; rej: (e: any) => void }>()
-  private listeners = new Set<(method: string, params: any) => void>()
+  private pending = new Map<
+    number,
+    {
+      res: (v: any) => void
+      rej: (e: any) => void
+      timeout: ReturnType<typeof setTimeout>
+    }
+  >()
+  private listeners = new Set<(method: string, params: any, sessionId?: string) => void>()
   private ready: Promise<void>
 
   constructor(wsUrl: string) {
@@ -54,12 +64,20 @@ class Cdp {
     this.ws.on('message', (data) => {
       const msg = JSON.parse(data.toString())
       if (msg.id && this.pending.has(msg.id)) {
-        const { res, rej } = this.pending.get(msg.id)!
+        const { res, rej, timeout } = this.pending.get(msg.id)!
         this.pending.delete(msg.id)
+        clearTimeout(timeout)
         msg.error ? rej(new Error(JSON.stringify(msg.error))) : res(msg.result)
       } else if (msg.method) {
-        for (const l of this.listeners) l(msg.method, msg.params)
+        for (const l of this.listeners) l(msg.method, msg.params, msg.sessionId)
+      }
+    })
+    this.ws.on('close', () => {
+      for (const [id, request] of this.pending) {
+        clearTimeout(request.timeout)
+        request.rej(new Error(`CDP connection closed with request ${id} pending`))
       }
+      this.pending.clear()
     })
   }
 
@@ -67,7 +85,7 @@ class Cdp {
     return this.ready
   }
 
-  on(l: (method: string, params: any) => void) {
+  on(l: (method: string, params: any, sessionId?: string) => void) {
     this.listeners.add(l)
   }
 
@@ -78,7 +96,11 @@ class Cdp {
   ): Promise<any> {
     const id = this.nextId++
     return new Promise((res, rej) => {
-      this.pending.set(id, { res, rej })
+      const timeout = setTimeout(() => {
+        this.pending.delete(id)
+        rej(new Error(`CDP ${method} timed out after 5s`))
+      }, 5_000)
+      this.pending.set(id, { res, rej, timeout })
       this.ws.send(
         JSON.stringify({ id, method, params, ...(sessionId ? { sessionId } : {}) }),
       )
@@ -94,10 +116,135 @@ class Cdp {
 
 interface CdpTarget {
   type: string
+  title?: string
   url: string
   webSocketDebuggerUrl: string
 }
 
+interface AttachedTarget {
+  attachedAtMs: number
+  detached: boolean
+  detachedAtMs?: number
+  error?: string
+  profile?: any
+  profileStartedAtMs?: number
+  profileStoppedAtMs?: number
+  role: string
+  sessionId?: string
+  started: boolean
+  title: string
+  type: string
+  url: string
+}
+
+export interface CpuProfileInteractionBarrier {
+  marker: string
+  reachedAtEpochMs: number
+  releasedBy: string
+  releasedAtEpochMs: number
+}
+
+export interface CpuProfileCoverage {
+  coverageMs: number
+  coverageRatio: number
+  startedOffsetMs: number | null
+  stoppedOffsetMs: number | null
+}
+
+export function cpuProfileCoverage(
+  profileStartedAtMs: number | undefined,
+  profileStoppedAtMs: number | undefined,
+  windowStartedAtMs: number,
+  windowEndedAtMs: number,
+): CpuProfileCoverage {
+  const requestedMs = Math.max(0, windowEndedAtMs - windowStartedAtMs)
+  if (
+    profileStartedAtMs === undefined ||
+    profileStoppedAtMs === undefined ||
+    requestedMs === 0
+  ) {
+    return {
+      coverageMs: 0,
+      coverageRatio: 0,
+      startedOffsetMs:
+        profileStartedAtMs === undefined ? null : profileStartedAtMs - windowStartedAtMs,
+      stoppedOffsetMs:
+        profileStoppedAtMs === undefined ? null : profileStoppedAtMs - windowStartedAtMs,
+    }
+  }
+  const coverageMs = Math.max(
+    0,
+    Math.min(profileStoppedAtMs, windowEndedAtMs) -
+      Math.max(profileStartedAtMs, windowStartedAtMs),
+  )
+  return {
+    coverageMs,
+    coverageRatio: coverageMs / requestedMs,
+    startedOffsetMs: profileStartedAtMs - windowStartedAtMs,
+    stoppedOffsetMs: profileStoppedAtMs - windowStartedAtMs,
+  }
+}
+
+export function cpuProfileActionsWithinWindow(
+  actionEpochMs: readonly number[],
+  windowStartedAtEpochMs: number,
+  windowEndedAtEpochMs: number,
+): boolean {
+  return (
+    actionEpochMs.length > 0 &&
+    actionEpochMs.every(
+      (epochMs) =>
+        Number.isFinite(epochMs) &&
+        epochMs >= windowStartedAtEpochMs &&
+        epochMs <= windowEndedAtEpochMs,
+    )
+  )
+}
+
+export function cpuProfileInteractionBarrierValid(
+  barrier: CpuProfileInteractionBarrier | null,
+  windowStartedAtEpochMs: number,
+  windowEndedAtEpochMs: number,
+): boolean {
+  return (
+    barrier !== null &&
+    barrier.marker.length > 0 &&
+    barrier.releasedBy === 'profiler' &&
+    Number.isFinite(barrier.reachedAtEpochMs) &&
+    Number.isFinite(barrier.releasedAtEpochMs) &&
+    barrier.reachedAtEpochMs <= barrier.releasedAtEpochMs &&
+    barrier.releasedAtEpochMs >= windowStartedAtEpochMs &&
+    barrier.releasedAtEpochMs <= windowEndedAtEpochMs
+  )
+}
+
+function readInteractionBarrierState(
+  value: unknown,
+): CpuProfileInteractionBarrier | null {
+  if (!value || typeof value !== 'object') return null
+  const marker = Reflect.get(value, 'marker')
+  const reachedAtEpochMs = Reflect.get(value, 'reachedAtEpochMs')
+  const releasedBy = Reflect.get(value, 'releasedBy')
+  const releasedAtEpochMs = Reflect.get(value, 'releasedAtEpochMs')
+  if (
+    typeof marker !== 'string' ||
+    typeof reachedAtEpochMs !== 'number' ||
+    typeof releasedBy !== 'string' ||
+    typeof releasedAtEpochMs !== 'number'
+  ) {
+    return null
+  }
+  return { marker, reachedAtEpochMs, releasedBy, releasedAtEpochMs }
+}
+
+function readActionEpochs(value: unknown): number[] {
+  if (!Array.isArray(value)) return []
+  return value.filter(
+    (epochMs): epochMs is number =>
+      typeof epochMs === 'number' && Number.isFinite(epochMs),
+  )
+}
+
 export async function runCpuProfile(
   args: string[],
   opts: ProfileOptions,
@@ -108,6 +255,21 @@ export async function runCpuProfile(
     return 1
   }
   const sampleInterval = Number(valueOf(args, '--sample-interval') ?? '0.1') // ms
+  const interactionBarrierEnabled = args.includes('--interaction-barrier')
+  const interactionBarrierTimeoutSeconds = Number(
+    valueOf(args, '--interaction-barrier-timeout') ?? '90',
+  )
+  if (
+    !Number.isFinite(interactionBarrierTimeoutSeconds) ||
+    interactionBarrierTimeoutSeconds <= 0
+  ) {
+    console.error('  --interaction-barrier-timeout must be positive (seconds)')
+    return 1
+  }
+  const interactionBarrierLeaseMs = Math.min(
+    2_147_000_000,
+    Math.ceil((interactionBarrierTimeoutSeconds + duration + 5) * 1000),
+  )
   const cdpPort = Number(
     valueOf(args, '--cdp-port') ?? process.env.RNX_CDP_PORT ?? '9222',
   )
@@ -141,65 +303,396 @@ export async function runCpuProfile(
 
   const cdp = new Cdp(page.webSocketDebuggerUrl)
   await cdp.waitOpen()
+  let interactionBarrierInstalled = false
+  const evaluatePage = async (expression: string): Promise<unknown> => {
+    const response = await cdp.send('Runtime.evaluate', {
+      expression,
+      returnByValue: true,
+    })
+    if (response?.exceptionDetails) {
+      throw new Error(
+        `page evaluation failed: ${response.exceptionDetails.text ?? 'unknown error'}`,
+      )
+    }
+    return response?.result?.value
+  }
+  const releaseInteractionBarrier = (releasedBy: 'cleanup' | 'profiler') =>
+    evaluatePage(`(() => {
+      const release = Reflect.get(globalThis, '__sootsimReleaseCpuProfileBarrier')
+      return typeof release === 'function'
+        ? Reflect.apply(release, globalThis, [${JSON.stringify(releasedBy)}])
+        : null
+    })()`)
   try {
-    // discover worker child sessions via auto-attach.
-    const workers = new Map<string, string>() // sessionId -> url
+    if (interactionBarrierEnabled) {
+      const installed = await evaluatePage(`(() => {
+        const state = {
+          marker: null,
+          reachedAtEpochMs: null,
+          releasedBy: null,
+          releasedAtEpochMs: null,
+        }
+        let releaseGate = () => {}
+        const gate = new Promise((resolve) => {
+          releaseGate = resolve
+        })
+        Reflect.set(globalThis, '__sootsimCpuProfileBarrierState', state)
+        Reflect.set(globalThis, '__sootsimCpuProfileBarrier', async (marker) => {
+          if (state.marker === null) {
+            state.marker = String(marker)
+            state.reachedAtEpochMs = Date.now()
+          }
+          await gate
+        })
+        let lease = null
+        const releaseBarrier = (releasedBy) => {
+          if (state.releasedAtEpochMs === null) {
+            state.releasedAtEpochMs = Date.now()
+            state.releasedBy = String(releasedBy)
+            if (lease !== null) clearTimeout(lease)
+            releaseGate()
+          }
+          return { ...state }
+        }
+        lease = setTimeout(
+          () => releaseBarrier('lease'),
+          ${interactionBarrierLeaseMs},
+        )
+        Reflect.set(globalThis, '__sootsimReleaseCpuProfileBarrier', releaseBarrier)
+        return true
+      })()`)
+      if (installed !== true) {
+        console.error('  failed to install the interaction profile barrier')
+        return 1
+      }
+      interactionBarrierInstalled = true
+    }
+
+    // discover every child worker. keep detached entries in the manifest: a
+    // worker can exit during the capture, and deleting it used to make the
+    // command either mislabel the busiest survivor as "tenant" or lose the
+    // entire run when Profiler.stop hit the detached session first.
+    const workers = new Map<string, AttachedTarget>()
+    let captureStarted = false
+    let captureWindowClosed = false
+    const startPromises: Array<Promise<void>> = []
+    const discoveryPromises: Array<Promise<void>> = []
+    let attachmentGeneration = 0
+    let awaitedDiscoveryCount = 0
+    let awaitedStartCount = 0
+    const enableRecursiveAutoAttach = (sessionId?: string) =>
+      cdp.send(
+        'Target.setAutoAttach',
+        {
+          autoAttach: true,
+          waitForDebuggerOnStart: false,
+          flatten: true,
+        },
+        sessionId,
+      )
+    const startTarget = async (target: AttachedTarget) => {
+      try {
+        await cdp.send('Profiler.enable', {}, target.sessionId)
+        await cdp.send(
+          'Profiler.setSamplingInterval',
+          { interval: sampleInterval * 1000 },
+          target.sessionId,
+        )
+        await cdp.send('Profiler.start', {}, target.sessionId)
+        target.started = true
+        target.profileStartedAtMs = performance.now()
+      } catch (error) {
+        target.error = error instanceof Error ? error.message : String(error)
+      }
+    }
+    const waitForStableTargetSetup = async () => {
+      while (true) {
+        const observedGeneration = attachmentGeneration
+        if (awaitedDiscoveryCount < discoveryPromises.length) {
+          const pendingDiscoveries = discoveryPromises.slice(awaitedDiscoveryCount)
+          awaitedDiscoveryCount = discoveryPromises.length
+          await Promise.all(pendingDiscoveries)
+        }
+        if (awaitedStartCount < startPromises.length) {
+          const pendingStarts = startPromises.slice(awaitedStartCount)
+          awaitedStartCount = startPromises.length
+          await Promise.all(pendingStarts)
+        }
+        // recursive auto-attach notifications can arrive just after the CDP
+        // command resolves. require a quiet generation before releasing work.
+        await sleep(50)
+        if (
+          observedGeneration === attachmentGeneration &&
+          awaitedDiscoveryCount === discoveryPromises.length &&
+          awaitedStartCount === startPromises.length
+        ) {
+          return
+        }
+      }
+    }
     cdp.on((method, params) => {
       if (method === 'Target.attachedToTarget' && params.targetInfo?.type === 'worker') {
-        workers.set(params.sessionId, params.targetInfo.url)
+        if (captureWindowClosed) return
+        const sessionId = params.sessionId
+        const targetInfo = params.targetInfo
+        const target: AttachedTarget = {
+          attachedAtMs: performance.now(),
+          detached: false,
+          role: cpuProfileTargetRole(targetInfo.url, targetInfo.title),
+          sessionId,
+          started: false,
+          title: targetInfo.title ?? '',
+          type: targetInfo.type,
+          url: targetInfo.url,
+        }
+        workers.set(sessionId, target)
+        attachmentGeneration += 1
+        discoveryPromises.push(
+          enableRecursiveAutoAttach(sessionId).catch((error: unknown) => {
+            target.error = `recursive auto-attach failed: ${error instanceof Error ? error.message : String(error)}`
+          }),
+        )
+        if (captureStarted) startPromises.push(startTarget(target))
+      }
+      if (method === 'Target.detachedFromTarget') {
+        const target = workers.get(params.sessionId)
+        if (target) {
+          target.detached = true
+          target.detachedAtMs = performance.now()
+        }
       }
-      if (method === 'Target.detachedFromTarget') workers.delete(params.sessionId)
-    })
-    await cdp.send('Target.setAutoAttach', {
-      autoAttach: true,
-      waitForDebuggerOnStart: false,
-      flatten: true,
     })
+    await enableRecursiveAutoAttach()
     // auto-attach events arrive asynchronously after the call resolves.
     await sleep(500)
-    if (workers.size === 0) {
-      console.error('  no worker targets attached — is the app loaded in this tab?')
+    await waitForStableTargetSetup()
+    const pageTarget: AttachedTarget = {
+      attachedAtMs: performance.now(),
+      detached: false,
+      role: 'page',
+      started: false,
+      title: page.title ?? '',
+      type: 'page',
+      url: page.url,
+    }
+    if (interactionBarrierEnabled) {
+      console.log('  waiting for the workload interaction barrier…')
+      const deadline = performance.now() + interactionBarrierTimeoutSeconds * 1000
+      let reached = false
+      while (performance.now() < deadline) {
+        const value = await evaluatePage(`(() => {
+          const state = Reflect.get(globalThis, '__sootsimCpuProfileBarrierState')
+          if (!state || typeof state !== 'object') return null
+          return {
+            marker: Reflect.get(state, 'marker'),
+            reachedAtEpochMs: Reflect.get(state, 'reachedAtEpochMs'),
+          }
+        })()`)
+        if (
+          value &&
+          typeof value === 'object' &&
+          typeof Reflect.get(value, 'marker') === 'string' &&
+          typeof Reflect.get(value, 'reachedAtEpochMs') === 'number'
+        ) {
+          reached = true
+          break
+        }
+        await sleep(25)
+      }
+      if (!reached) {
+        console.error(
+          `  workload interaction barrier was not reached within ${interactionBarrierTimeoutSeconds}s`,
+        )
+        return 1
+      }
+    }
+    captureStarted = true
+    startPromises.push(startTarget(pageTarget))
+    for (const target of workers.values()) startPromises.push(startTarget(target))
+    await waitForStableTargetSetup()
+    const startedCount = [pageTarget, ...workers.values()].filter(
+      (target) => target.started,
+    ).length
+    if (startedCount === 0) {
+      console.error('  no CDP targets accepted Profiler.start')
       return 1
     }
-
-    for (const sid of workers.keys()) {
-      await cdp.send('Profiler.enable', {}, sid)
-      await cdp.send(
-        'Profiler.setSamplingInterval',
-        { interval: sampleInterval * 1000 },
-        sid,
-      ) // µs
-      await cdp.send('Profiler.start', {}, sid)
+    const captureWindowStartedAtMs = performance.now()
+    const captureWindowStartedAtEpochMs = Date.now()
+    const captureWindowEndedAtMs = captureWindowStartedAtMs + duration * 1000
+    const captureWindowEndedAtEpochMs = captureWindowStartedAtEpochMs + duration * 1000
+    const interactionBarrier = interactionBarrierEnabled
+      ? readInteractionBarrierState(await releaseInteractionBarrier('profiler'))
+      : null
+    if (opts.verbose) {
+      for (const target of [pageTarget, ...workers.values()]) {
+        console.log(
+          `  target ${target.role} ${target.type} ${target.title || '(untitled)'} ${target.url}`,
+        )
+      }
     }
     console.log(
-      `  recording ${duration}s across ${workers.size} worker(s) — interact now…`,
+      `  recording ${duration}s across ${startedCount} target(s) — interact now…`,
     )
-    await sleep(duration * 1000)
-
-    const results: Array<{ url: string; profile: any }> = []
-    for (const [sid, url] of workers) {
-      const { profile } = await cdp.send('Profiler.stop', {}, sid)
-      results.push({ url, profile })
-    }
-    results.sort((a, b) => b.profile.samples.length - a.profile.samples.length)
+    await sleep(Math.max(0, captureWindowEndedAtMs - performance.now()))
+    captureStarted = false
+    captureWindowClosed = true
+    await Promise.allSettled(startPromises)
+    const results = [pageTarget, ...workers.values()]
+    await Promise.all(
+      results.map(async (target) => {
+        if (!target.started) return
+        try {
+          const { profile } = await cdp.send('Profiler.stop', {}, target.sessionId)
+          target.profile = profile
+          target.profileStoppedAtMs = performance.now()
+        } catch (error) {
+          target.error = error instanceof Error ? error.message : String(error)
+          target.profileStoppedAtMs = target.detachedAtMs
+        }
+        await cdp.send('Profiler.disable', {}, target.sessionId).catch(() => {})
+      }),
+    )
+    // querying the page while five high-frequency profilers are still active
+    // can itself time out and lengthen the requested sampling interval. stop
+    // first, then read the already-recorded action timestamps.
+    const workloadActionEpochMs = interactionBarrierEnabled
+      ? readActionEpochs(
+          await evaluatePage(`(() => {
+            const partial = Reflect.get(globalThis, '__sootsimInteractionPartialResult')
+            const captures = partial && typeof partial === 'object'
+              ? Reflect.get(partial, 'captures')
+              : null
+            if (!Array.isArray(captures)) return []
+            return captures.map((capture) => {
+              if (!capture || typeof capture !== 'object') return null
+              const note = Reflect.get(capture, 'note')
+              return note && typeof note === 'object'
+                ? Reflect.get(note, 'actionEpochMs')
+                : null
+            })
+          })()`),
+        )
+      : []
 
     mkdirSync(dirname(outputPath), { recursive: true })
-    // save the busiest worker (the tenant during interaction) to the main path;
-    // others get a suffix so a multi-worker capture isn't lost.
-    results.forEach((r, i) => {
-      const path =
-        i === 0 ? outputPath : outputPath.replace(/(\.[^.]+)?$/, `.worker${i}$1`)
-      writeFileSync(path, JSON.stringify(r.profile))
-      console.log(`  ${shortUrl(r.url)}: ${r.profile.samples.length} samples → ${path}`)
-      if (opts.verbose && r.profile.samples.length > 0) {
-        for (const fn of topSelfTime(r.profile, 12)) {
+    const roleCounts = new Map<string, number>()
+    const manifest = results.map((target) => {
+      const coverage = cpuProfileCoverage(
+        target.profileStartedAtMs,
+        target.profileStoppedAtMs,
+        captureWindowStartedAtMs,
+        captureWindowEndedAtMs,
+      )
+      const priorCount = roleCounts.get(target.role) ?? 0
+      roleCounts.set(target.role, priorCount + 1)
+      const role = priorCount === 0 ? target.role : `${target.role}-${priorCount + 1}`
+      const profilePath = target.profile
+        ? outputPath.replace(/(\.[^.]+)?$/, `.${role}$1`)
+        : null
+      if (profilePath) {
+        writeFileSync(profilePath, JSON.stringify(target.profile))
+        console.log(
+          `  ${role} ${shortUrl(target.url)}: ${target.profile.samples.length} samples → ${profilePath}`,
+        )
+      } else {
+        console.error(
+          `  ${role} ${shortUrl(target.url)}: no profile${target.error ? ` — ${target.error}` : ''}`,
+        )
+      }
+      if (opts.verbose && target.profile?.samples.length > 0) {
+        for (const fn of topSelfTime(target.profile, 12)) {
           console.log(`      ${fn.pct.toFixed(1).padStart(5)}%  ${fn.name}  ${fn.url}`)
         }
       }
+      return {
+        role,
+        type: target.type,
+        title: target.title,
+        url: target.url,
+        detached: target.detached,
+        attachedOffsetMs: target.attachedAtMs - captureWindowStartedAtMs,
+        ...coverage,
+        samples: target.profile?.samples.length ?? 0,
+        profilePath,
+        error: target.error ?? null,
+      }
     })
+    const requiredRoles = ['page', 'shell', 'compositor', 'tenant']
+    const capturedRoles = new Set(
+      manifest
+        .filter((target) => target.profilePath !== null)
+        .map((target) => target.role),
+    )
+    const missingRoles = requiredRoles.filter((role) => !capturedRoles.has(role))
+    const interactionBarrierComplete =
+      !interactionBarrierEnabled ||
+      (cpuProfileInteractionBarrierValid(
+        interactionBarrier,
+        captureWindowStartedAtEpochMs,
+        captureWindowEndedAtEpochMs,
+      ) &&
+        cpuProfileActionsWithinWindow(
+          workloadActionEpochMs,
+          captureWindowStartedAtEpochMs,
+          captureWindowEndedAtEpochMs,
+        ))
+    const complete =
+      missingRoles.length === 0 &&
+      interactionBarrierComplete &&
+      manifest.length > 0 &&
+      manifest.every(
+        (target) =>
+          target.profilePath !== null &&
+          target.error === null &&
+          target.coverageRatio >= 0.99,
+      )
+    const manifestPath = outputPath.replace(/(\.[^.]+)?$/, '.manifest.json')
+    const executableSha256 = IS_STANDALONE
+      ? createHash('sha256').update(readFileSync(process.execPath)).digest('hex')
+      : null
+    writeFileSync(
+      manifestPath,
+      JSON.stringify(
+        {
+          cli: {
+            version: getCliVersion(),
+            standalone: IS_STANDALONE,
+            executablePath: process.execPath,
+            executableSha256,
+            argv: process.argv.slice(1),
+          },
+          page: page.url,
+          complete,
+          missingRoles,
+          requestedDurationMs: duration * 1000,
+          captureWindowStartedAt: new Date(captureWindowStartedAtEpochMs).toISOString(),
+          captureWindowEndedAt: new Date(captureWindowEndedAtEpochMs).toISOString(),
+          interactionBarrier,
+          workloadActionEpochMs,
+          manifest,
+        },
+        null,
+        2,
+      ),
+    )
+    console.log(`  manifest → ${manifestPath}`)
+    if (!complete) {
+      console.error(
+        `  incomplete attribution capture${missingRoles.length ? ` — missing ${missingRoles.join(', ')}` : ''}`,
+      )
+      if (!interactionBarrierComplete) {
+        console.error(
+          '  workload actions did not fall inside the interaction profile window',
+        )
+      }
+    }
     console.log('  open in chrome devtools → Performance → Load profile to inspect.')
-    return 0
+    return complete ? 0 : 1
   } finally {
+    if (interactionBarrierInstalled) {
+      await releaseInteractionBarrier('cleanup').catch(() => {})
+    }
     cdp.close()
   }
 }
@@ -242,6 +735,19 @@ function shortUrl(url: string): string {
     .slice(-50)
 }
 
+export function cpuProfileTargetRole(url: string, title = ''): string {
+  const identity = `${title} ${url}`.toLowerCase()
+  if (identity.includes('compositor-worker') || identity.includes('sootsim-compositor')) {
+    return 'compositor'
+  }
+  if (identity.includes('shell-worker')) return 'shell'
+  if (identity.includes('named-worklet')) return 'worklet'
+  if (identity.includes('render-worker') || identity.includes('tenant-worker')) {
+    return 'tenant'
+  }
+  return 'worker'
+}
+
 function topSelfTime(profile: any, topN: number) {
   const total = profile.samples.length || 1
   const byFn = new Map<string, { self: number; name: string; url: string }>()