@playfast/reform-profiler 1.0.2 → 1.1.0

package/package.json

@@ -1,25 +1,28 @@
 {
   "name": "@playfast/reform-profiler",
-  "playbook": "./playbook",
-  "version": "1.0.2",
-  "type": "module",
+  "version": "1.1.0",
   "description": "Performance profiler for reform scenes — a recording Instrumentation, Chrome DevTools trace export, terminal reports, and a React overlay. Dev builds get the real recorder; prod builds resolve to no-op stubs.",
   "keywords": [
-    "reform",
+    "devtools",
     "effect",
-    "profiler",
     "performance",
-    "devtools"
+    "profiler",
+    "reform"
   ],
+  "bugs": {
+    "url": "https://github.com/playfast/reform/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/playfast/reform.git",
     "directory": "packages/reform-profiler"
   },
-  "bugs": {
-    "url": "https://github.com/playfast/reform/issues"
-  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "type": "module",
   "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
@@ -33,10 +36,9 @@
     },
     "./recorder": "./src/index.ts"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "clean": "rm -rf dist .tsbuildinfo",
     "check": "tsc --noEmit",
@@ -48,8 +50,8 @@
     "lint:fix": "oxlint --fix src"
   },
   "peerDependencies": {
-    "effect": "*",
     "@playfast/reform": "*",
+    "effect": "*",
     "react": "^19.0.0"
   },
   "peerDependenciesMeta": {
@@ -57,7 +59,5 @@
       "optional": true
     }
   },
-  "publishConfig": {
-    "access": "public"
-  }
+  "playbook": "./playbook"
 }

package/src/index.ts

@@ -7,7 +7,7 @@ export {
   type ProfileSnapshot,
   type ProfileStat,
 } from './recorder'
-export { type ProfiledScene, profileScene } from './profileScene'
+export { type CapturedProfiledScene, type ProfiledScene, profileScene } from './profileScene'
 export { type ChromeTrace, type ChromeTraceEvent, toChromeTrace, traceJson } from './trace'
 export { formatReport } from './report'
 export {

package/src/noop.ts

@@ -1,10 +1,7 @@
-import { noopInstrumentation, type Scene, type UiContract } from '@playfast/reform'
-import type { ProfiledScene } from './profileScene'
-import type {
-  ProfilerHandle,
-  ProfilerOptionsExternalApi,
-  ProfileSnapshot,
-} from './recorder'
+import { type CapturedScene, type Scene, type UiContract } from '@playfast/reform'
+import { noopInstrumentation } from '@playfast/reform/internal'
+import type { CapturedProfiledScene, ProfiledScene } from './profileScene'
+import type { ProfilerHandle, ProfilerOptionsExternalApi, ProfileSnapshot } from './recorder'
 import type { ProfilerRegistration } from './registry'
 import type { ChromeTrace } from './trace'
 
@@ -18,7 +15,7 @@ export type {
   ProfileSnapshot,
   ProfileStat,
 } from './recorder'
-export type { ProfiledScene } from './profileScene'
+export type { CapturedProfiledScene, ProfiledScene } from './profileScene'
 export type { ChromeTrace, ChromeTraceEvent } from './trace'
 export type { ProfilerRegistration } from './registry'
 
@@ -47,10 +44,45 @@ export const noopProfiler: ProfilerHandle = {
 export const makeProfiler = (_options: ProfilerOptionsExternalApi = {}): ProfilerHandle =>
   noopProfiler
 
-export const profileScene = <C extends UiContract, S extends ReadonlyArray<unknown>>(
+const profileCapturedScene = <
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+>(
+  base: CapturedScene<C, S, Services, P, N, Identity>,
+): CapturedProfiledScene<C, S, Services, P, N, Identity> => ({
+  scene: base,
+  profiler: noopProfiler,
+})
+
+export function profileScene<
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+>(
+  base: CapturedScene<C, S, Services, P, N, Identity>,
+  _options?: ProfilerOptionsExternalApi,
+): CapturedProfiledScene<C, S, Services, P, N, Identity>
+export function profileScene<C extends UiContract, S extends ReadonlyArray<unknown>>(
+  base: Scene<C, S>,
+  _options?: ProfilerOptionsExternalApi,
+): ProfiledScene<C, S>
+export function profileScene<C extends UiContract, S extends ReadonlyArray<unknown>>(
   base: Scene<C, S>,
   _options: ProfilerOptionsExternalApi = {},
-): ProfiledScene<C, S> => ({ scene: base, profiler: noopProfiler })
+): ProfiledScene<C, S> {
+  return base.capture<ProfiledScene<C, S>>(
+    <Services, P, N extends string, Identity>(
+      exactScene: CapturedScene<C, S, Services, P, N, Identity>,
+    ): ProfiledScene<C, S> => profileCapturedScene(exactScene),
+  )
+}
 
 const emptyTrace: ChromeTrace = { traceEvents: [], displayTimeUnit: 'ms' }
 
@@ -61,11 +93,15 @@ export const traceJson = (_profiler: ProfilerHandle): string =>
 
 export const formatReport = (_profiler: ProfilerHandle): string => ''
 
-export const registerProfiler = (_registration: ProfilerRegistration): (() => void) => () => {}
+export const registerProfiler =
+  (_registration: ProfilerRegistration): (() => void) =>
+  () => {}
 
 export const listProfilers = (): ReadonlyArray<ProfilerRegistration> => []
 
-export const subscribeProfilers = (_listener: () => void): (() => void) => () => {}
+export const subscribeProfilers =
+  (_listener: () => void): (() => void) =>
+  () => {}
 
 export const profilersVersion = (): number => 0
 

package/src/profileScene.ts

@@ -1,5 +1,6 @@
 import { Effect, Layer } from 'effect'
-import { profiledScene, type Scene, type UiContract } from '@playfast/reform'
+import { type CapturedScene, profiledScene, type Scene, type UiContract } from '@playfast/reform'
+import { type AnySceneCapture, type SceneCapture } from '@playfast/reform/internal'
 import { makeProfiler, type ProfilerHandle, type ProfilerOptionsExternalApi } from './recorder'
 import { registerProfiler } from './registry'
 
@@ -11,29 +12,94 @@ export interface ProfiledScene<
   readonly profiler: ProfilerHandle
 }
 
-export const profileScene = <C extends UiContract, S extends ReadonlyArray<unknown>>(
+export interface CapturedProfiledScene<
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+> extends ProfiledScene<C, S> {
+  readonly scene: CapturedScene<C, S, Services, P, N, Identity>
+}
+
+const makeLifecycle = (profiler: ProfilerHandle) =>
+  Layer.scopedDiscard(
+    Effect.acquireRelease(
+      Effect.sync(() => registerProfiler({ label: profiler.label, handle: profiler })),
+      (unregister) => Effect.sync(unregister),
+    ),
+  )
+
+const withLifecycle = <
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+>(
+  base: CapturedScene<C, S, Services, P, N, Identity>,
+  lifecycle: ReturnType<typeof makeLifecycle>,
+): CapturedScene<C, S, Services, P, N, Identity> => {
+  const captured: CapturedScene<C, S, Services, P, N, Identity> = {
+    kind: 'Scene',
+    composition: base.composition,
+    // Lifecycle on the first provide layer tracks the runtime's build/dispose scope.
+    provide: base.provide.map((layer, index) =>
+      index === 0 ? Layer.merge(layer, lifecycle) : layer,
+    ),
+    ...(base.boot === undefined ? {} : { boot: base.boot }),
+    ...(base.instrumentation === undefined ? {} : { instrumentation: base.instrumentation }),
+    capture: <Result>(capture: SceneCapture<C, S, Result>): Result => capture(captured),
+    captureAny: <Result>(capture: AnySceneCapture<Result>): Result => capture(captured),
+  }
+  return captured
+}
+
+const profileCapturedScene = <
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+>(
+  base: CapturedScene<C, S, Services, P, N, Identity>,
+  profiler: ProfilerHandle,
+  lifecycle: ReturnType<typeof makeLifecycle>,
+): CapturedProfiledScene<C, S, Services, P, N, Identity> => ({
+  scene: withLifecycle(profiledScene(base, profiler), lifecycle),
+  profiler,
+})
+
+export function profileScene<
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+>(
+  base: CapturedScene<C, S, Services, P, N, Identity>,
+  options?: ProfilerOptionsExternalApi,
+): CapturedProfiledScene<C, S, Services, P, N, Identity>
+export function profileScene<C extends UiContract, S extends ReadonlyArray<unknown>>(
+  base: Scene<C, S>,
+  options?: ProfilerOptionsExternalApi,
+): ProfiledScene<C, S>
+export function profileScene<C extends UiContract, S extends ReadonlyArray<unknown>>(
   base: Scene<C, S>,
   options: ProfilerOptionsExternalApi = {},
-): ProfiledScene<C, S> => {
+): ProfiledScene<C, S> {
   const profiler = makeProfiler({
     label: options.label ?? base.composition.manifest.title,
     ...(options.capacity !== undefined ? { capacity: options.capacity } : {}),
   })
-  const lifecycle = Layer.scopedDiscard(
-    Effect.acquireRelease(
-      Effect.sync(() => registerProfiler({ label: profiler.label, handle: profiler })),
-      (unregister) => Effect.sync(unregister),
-    ),
+  const lifecycle = makeLifecycle(profiler)
+  return base.capture<ProfiledScene<C, S>>(
+    <Services, P, N extends string, Identity>(
+      exactScene: CapturedScene<C, S, Services, P, N, Identity>,
+    ): ProfiledScene<C, S> => profileCapturedScene(exactScene, profiler, lifecycle),
   )
-  const wrapped = profiledScene(base, profiler)
-  return {
-    // Lifecycle on first provide layer so register/unregister track runtime build/dispose.
-    scene: {
-      ...wrapped,
-      provide: wrapped.provide.map((layer, index) =>
-        index === 0 ? Layer.merge(layer, lifecycle) : layer,
-      ),
-    },
-    profiler,
-  }
 }

package/src/profiler.test.ts

@@ -114,19 +114,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 }))),

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' }
 }