@playfast/reform-profiler 1.0.2 → 1.2.0

package/src/profiler.test.ts

@@ -1,4 +1,4 @@
-import { Schema as S } from 'effect'
+import { Effect, Option, Schema as S } from 'effect'
 import { expect, test } from 'vitest'
 import {
   Composition,
@@ -16,13 +16,19 @@ import {
   ui,
 } from '@playfast/reform'
 import { Layer } from 'effect'
+import { until } from '@playfast/reform/testkit/flight.testkit'
 import { makeProfiler } from './recorder'
 import { profileScene } from './profileScene'
 import { listProfilers } from './registry'
 import { toChromeTrace, traceJson } from './trace'
 import { formatReport } from './report'
 
-const settle = (ms = 20) => new Promise((resolve) => setTimeout(resolve, ms))
+// The recorder coalesces on the reform scheduler's queueMicrotask; a microtask
+// queued after it therefore runs once every pending flush has drained.
+const flushed = (): Promise<void> => new Promise((resolve) => queueMicrotask(() => resolve()))
+
+const reaches = <A>(read: () => A, predicate: (value: A) => boolean): Promise<A> =>
+  Effect.runPromise(until(read, predicate))
 
 test('aggregates count and time per name, per kind', () => {
   const profiler = makeProfiler({ label: 'agg' })
@@ -76,11 +82,11 @@ test('subscribers are notified once per burst (coalesced)', async () => {
   profiler.eventDispatched('a', 'High')
   profiler.eventDispatched('b', 'High')
   profiler.eventDispatched('c', 'High')
-  await settle(0)
+  await flushed()
   expect(calls.count).toBe(1)
   unsubscribe()
   profiler.eventDispatched('d', 'High')
-  await settle(0)
+  await flushed()
   expect(calls.count).toBe(1)
 })
 
@@ -114,19 +120,25 @@ class Bump extends Reducer.make('ProfilerBump', { states: [Count], events: [Bump
 const BumpLive = Reducer.live(Bump, (n) => n + 1)
 
 class RootUi extends ui('ProfilerRoot')<{ props: { count: number } }>() {}
+
 class Root extends Composition.make('ProfilerRoot', {
   title: 'ProfilerRoot',
   states: [States],
   events: [Bumped],
   ui: RootUi,
-}) {}
+})<Root>() {}
 const RootLive = Composition.live(Root, function* () {
   const count = yield* StateGroup.select(States, 'profiler-count')
   return mount({ props: { count }, slots: {} })
 })
 
 const app = RootLive.pipe(
-  Layer.provideMerge(provide(RootUi, Ui.make(RootUi, () => null))),
+  Layer.provideMerge(
+    provide(
+      RootUi,
+      Ui.make(RootUi, () => null),
+    ),
+  ),
   Layer.provideMerge(
     Layer.mergeAll(BumpLive).pipe(
       Layer.provideMerge(Layer.mergeAll(Engine, StateGroup.live(States, { 'profiler-count': 0 }))),
@@ -145,9 +157,15 @@ test('profileScene records engine activity through makeAppRuntime and registers
 
   runtime.boot()
   runtime.dispatch('High', Event.construct(Bumped, {}))
-  await settle()
 
-  const snapshot = profiler.snapshot()
+  const snapshot = await reaches(
+    () => profiler.snapshot(),
+    (taken) =>
+      (taken.events.get('ProfilerBumped')?.count ?? 0) >= 2 &&
+      (taken.reducers.get('ProfilerBump')?.count ?? 0) >= 2 &&
+      (taken.states.get('profiler-count')?.count ?? 0) >= 2 &&
+      taken.frames.count >= 1,
+  )
   expect(snapshot.events.get('ProfilerBumped')?.count).toBe(2)
   expect(snapshot.reducers.get('ProfilerBump')?.count).toBe(2)
   expect(snapshot.states.get('profiler-count')?.count).toBe(2)
@@ -158,13 +176,23 @@ test('profileScene records engine activity through makeAppRuntime and registers
   expect(report).toContain('ProfilerBump')
 
   runtime.dispose()
-  await settle()
+  await reaches(
+    () => listProfilers().map((entry) => entry.handle),
+    (handles) => !handles.includes(profiler),
+  )
   expect(listProfilers().map((entry) => entry.handle)).not.toContain(profiler)
 
   const before = profiler.snapshot().events.get('ProfilerBumped')?.count
   const plain = makeAppRuntime(baseScene)
+  // The plain runtime's own count landing proves its frame ran; the profiler must not have seen it.
+  const plainCount = Option.getOrThrow(
+    plain.readOption(StateGroup.select(States, 'profiler-count').store),
+  )
   plain.dispatch('High', Event.construct(Bumped, {}))
-  await settle()
+  await reaches(
+    () => plainCount.get(),
+    (count) => count === 1,
+  )
   expect(profiler.snapshot().events.get('ProfilerBumped')?.count).toBe(before)
   plain.dispose()
 })

package/src/react/overlay.tsx

@@ -97,7 +97,9 @@ const DroppedNote = ({ count }: DroppedNoteProps): ReactNode => {
   if (count === 0) {
     return null
   }
-  return <div style={{ color: palette.dim }}>({count} early records evicted from the ring buffer)</div>
+  return (
+    <div style={{ color: palette.dim }}>({count} early records evicted from the ring buffer)</div>
+  )
 }
 
 interface ProfilerBodyProps {

package/src/recorder.ts

@@ -1,4 +1,4 @@
-import { type Instrumentation, makeScheduler, type SpanEnd } from '@playfast/reform'
+import { type Instrumentation, makeScheduler, type SpanEnd } from '@playfast/reform/internal'
 
 export type ProfileKind =
   | 'event'
@@ -93,8 +93,7 @@ export const makeProfiler = (options: ProfilerOptionsExternalApi = {}): Profiler
     readonly detail: string
   }
 
-  const instant = (site: Site): void =>
-    record({ ...site, start: performance.now(), dur: 0 })
+  const instant = (site: Site): void => record({ ...site, start: performance.now(), dur: 0 })
 
   const span = (site: Site): SpanEnd => {
     const start = performance.now()

package/src/registry.ts

@@ -10,7 +10,10 @@ export interface ProfilerRegistration {
 
 interface RegistryState {
   // Refcount: StrictMode double-build shares one entry.
-  readonly entries: Map<ProfilerHandle, { readonly registration: ProfilerRegistration; readonly count: number }>
+  readonly entries: Map<
+    ProfilerHandle,
+    { readonly registration: ProfilerRegistration; readonly count: number }
+  >
   readonly listeners: Set<() => void>
   readonly version: { current: number }
   readonly overlay: { owner: Option.Option<object> }

package/src/trace.ts

@@ -54,7 +54,14 @@ const US_PER_MS = 1000
 export const toChromeTrace = (profiler: ProfilerHandle): ChromeTrace => {
   const { records } = profiler.snapshot()
   const meta: ReadonlyArray<ChromeTraceEvent> = [
-    { ph: 'M', name: 'process_name', ts: 0, pid, tid: 0, args: { name: `reform: ${profiler.label}` } },
+    {
+      ph: 'M',
+      name: 'process_name',
+      ts: 0,
+      pid,
+      tid: 0,
+      args: { name: `reform: ${profiler.label}` },
+    },
     ...Object.values(lanes).map(
       (lane): ChromeTraceEvent => ({
         ph: 'M',
@@ -71,9 +78,19 @@ export const toChromeTrace = (profiler: ProfilerHandle): ChromeTrace => {
     const cat = record.kind
     const tid = lanes[record.kind].tid
     const args = record.detail === '' ? {} : { detail: record.detail }
+    const complete: ChromeTraceEvent = {
+      ph: 'X',
+      name: record.name,
+      cat,
+      ts: startUs,
+      dur: record.dur * US_PER_MS,
+      pid,
+      tid,
+      args,
+    }
     return instantKinds.has(record.kind)
       ? { ph: 'i', name: record.name, cat, ts: startUs, pid, tid, s: 't', args }
-      : { ph: 'X', name: record.name, cat, ts: startUs, dur: record.dur * US_PER_MS, pid, tid, args }
+      : complete
   })
   return { traceEvents: [...meta, ...body], displayTimeUnit: 'ms' }
 }