@playfast/reform 0.0.8 → 0.0.10

package/src/scene/seedScene.test.ts

@@ -1,11 +1,11 @@
 import { Effect, Layer, ManagedRuntime, Schema as S } from 'effect'
 import { expect, test } from 'vitest'
 import {
-  type CaptureSinkApi,
-  CaptureSink,
   Composition,
   Engine,
   Event,
+  isStructure,
+  mount,
   provide,
   publish,
   Reducer,
@@ -18,13 +18,14 @@ import {
   Ui,
   ui,
 } from '../index'
+import { CurrentSeedOverrides } from '../internal/seeds'
 
 // `seedScene` is the tooling seam over CLOSED scenes: the app bundle below seeds
 // `count: 1` itself (no open store), and the overlay must reach the nested
 // `State.live` through `Layer.locally(CurrentSeedOverrides, …)` on the scene's
 // pre-composed layers. The harness mirrors the dev-tool preview: merge the
 // scene's `provide`, mount it in a ManagedRuntime, and read the root
-// composition's rendered props through the headless CaptureSink.
+// composition's rendered props through the headless Structure.
 
 class CountState extends State.make('count', S.Number) {}
 class MiniStates extends StateGroup.make(CountState) {}
@@ -46,8 +47,7 @@ class Counter extends Composition.make('Counter', {
 }) {}
 const CounterLive = Composition.live(Counter, function* () {
   const count = yield* StateGroup.select(MiniStates, 'count')
-  const view = yield* CounterUi
-  return view({ count })
+  return mount({ props: { count }, slots: {} })
 })
 
 // The closed app layer a scene provides: views + logic + Engine, with the state
@@ -61,37 +61,44 @@ const MiniApp = Views.pipe(Layer.provideMerge(Logic))
 
 const CounterScene = scene(Counter, { provide: [MiniApp] })
 
+// The dev-tool inspector overlays raw, user-typed seeds (`Record<string, unknown>`)
+// — the untyped seam that `seedScene` wraps once a composition's state tuple is
+// known. These two cases (absent key / schema-invalid value) are compile errors
+// through the now-typed `seedScene`, so they're exercised here at the raw overlay
+// to prove `resolveSeed`'s runtime defensiveness still falls back to the seed.
+const overlayRawSeeds = (base: Scene, seeds: Readonly<Record<string, unknown>>): Scene => ({
+  ...base,
+  provide: base.provide.map(Layer.locally(CurrentSeedOverrides, seeds)),
+})
+
 const headlessEnv: RenderEnv = {
   props: {},
   tracker: { add: () => {} },
-  slots: { slot: () => () => null },
 }
 
-// One ManagedRuntime per scene under test, with its own capture cell so two
-// runtimes in the same test (the no-leakage case) cannot bleed into each other.
-// Each `read` re-renders the root composition, repopulating the cell from the
-// stores that runtime actually built.
+const isCountProps = (props: unknown): props is { readonly count: number } =>
+  typeof props === 'object' &&
+  props !== null &&
+  'count' in props &&
+  typeof props.count === 'number'
+
+// One ManagedRuntime per scene under test. Each `read` re-renders the root
+// composition and reads the Structure built from the stores that runtime actually
+// constructed.
 const makeHarness = (s: Scene) => {
-  const captured: { count: number } = { count: -1 }
-  const sink: CaptureSinkApi = {
-    record: (capture) => {
-      const props = capture.props
-      if (
-        typeof props === 'object' &&
-        props !== null &&
-        'count' in props &&
-        typeof props.count === 'number'
-      ) {
-        captured.count = props.count
-      }
-    },
-  }
-  const layer = s.provide
-    .reduce((a, b) => Layer.merge(a, b))
-    .pipe(Layer.provideMerge(Layer.succeed(CaptureSink, sink)))
+  const layer = s.provide.reduce((a, b) => Layer.merge(a, b))
   const runtime = ManagedRuntime.make(layer)
   const read = Effect.flatMap(Counter.tag, (c) =>
-    Composition.render(c, headlessEnv).pipe(Effect.map(() => captured.count)),
+    Composition.render(c, headlessEnv).pipe(
+      Effect.flatMap((frame) => {
+        if (!isStructure(frame)) {
+          return Effect.dieMessage('Counter must render a Structure')
+        }
+        return isCountProps(frame.props)
+          ? Effect.succeed(frame.props.count)
+          : Effect.dieMessage('Counter Structure props must include numeric count')
+      }),
+    ),
   )
   return { runtime, read }
 }
@@ -134,7 +141,7 @@ test('the live reducer drives the SAME overridden store', async () => {
 })
 
 test('an absent key leaves the authored seed in place', async () => {
-  const { runtime, read } = makeHarness(seedScene(CounterScene, { other: 1 }))
+  const { runtime, read } = makeHarness(overlayRawSeeds(CounterScene, { other: 1 }))
   try {
     expect(await runtime.runPromise(read)).toBe(1)
   } finally {
@@ -143,7 +150,7 @@ test('an absent key leaves the authored seed in place', async () => {
 })
 
 test('a schema-invalid override falls back to the authored seed', async () => {
-  const { runtime, read } = makeHarness(seedScene(CounterScene, { count: 'not-a-number' }))
+  const { runtime, read } = makeHarness(overlayRawSeeds(CounterScene, { count: 'not-a-number' }))
   try {
     expect(await runtime.runPromise(read)).toBe(1)
   } finally {

package/src/state/stateGroup.ts

@@ -51,6 +51,26 @@ export type GroupSeeds<G extends AnyStateGroup> =
     ? { readonly [N in StateName<Members[number]>]: ValueForName<Members, N> }
     : never
 
+// Collapse a union of records into their intersection — merges every group's
+// seed record into one. (The classic contravariant-position trick.)
+type UnionToIntersection<U> = (U extends unknown ? (k: U) => void : never) extends (
+  k: infer I,
+) => void
+  ? I
+  : never
+
+/** The seed record for one tuple entry: a group's `GroupSeeds`, else nothing. */
+type EntrySeeds<G> = G extends AnyStateGroup ? GroupSeeds<G> : never
+
+/**
+ * The optional seed overrides for a composition's whole `states` tuple, keyed by
+ * member name and typed to each member's value. Every key is optional (seeds are
+ * overrides over the authored initial). Tuple entries that aren't state groups
+ * contribute no keys, so a partially-grouped `states` still types its groups.
+ * Powers `seedScene` — a typo'd key or mistyped value is a compile error.
+ */
+export type SeedsOf<St extends ReadonlyArray<unknown>> = Partial<UnionToIntersection<EntrySeeds<St[number]>>>
+
 /** Compose atomic States into a group provided (and addressed) as a unit. */
 export const make = <const Members extends ReadonlyArray<AnyState>>(
   ...members: Members & NoDuplicateNames<Members>