@playfast/reform-proof 1.0.1 → 1.2.0

package/src/nested-feature.test.ts

@@ -0,0 +1,174 @@
+import { expect, it } from '@effect/vitest'
+import { Effect, Layer, Schema as S } from 'effect'
+import {
+  Composition,
+  Engine,
+  Feature,
+  type FeatureSlotTarget,
+  featureModule,
+  mount,
+  one,
+  provide,
+  scene,
+  slot,
+  State,
+  ui,
+} from '@playfast/reform'
+import { FeatureInput, featureModuleFromInput } from '@playfast/reform/internal'
+import { Product, Proof, ProductRequirement } from './index'
+
+const NestedFeatureInput = S.Struct({ value: S.Number })
+
+class NestedFeatureValue extends State.make('proof.nestedFeature.value', S.Number) {}
+
+class NestedUi extends ui('ProofNestedFeature')<{
+  props: { mountValue: number; featureValue: number }
+}>() {}
+
+class Nested extends Composition.make('ProofNestedFeature', {
+  title: 'Nested feature',
+  props: NestedFeatureInput,
+  states: [NestedFeatureValue],
+  ui: NestedUi,
+})<Nested>() {}
+
+const NestedLive = Composition.live(Nested, function* () {
+  const props = yield* Nested.props
+  const featureValue = yield* NestedFeatureValue
+  return mount({
+    props: { mountValue: props.value, featureValue },
+    slots: {},
+  })
+})
+
+const NestedModule = featureModuleFromInput(
+  NestedFeatureInput,
+  [],
+  NestedLive.pipe(
+    Layer.provideMerge(
+      Layer.unwrapEffect(
+        Effect.map(FeatureInput, (input) =>
+          State.live(NestedFeatureValue, S.decodeUnknownSync(NestedFeatureInput)(input).value),
+        ),
+      ),
+    ),
+  ),
+)
+
+class PlaceholderUi extends ui('ProofNestedFeaturePlaceholder')<{
+  props: { phase: string }
+}>() {}
+
+class Placeholder extends Composition.make('ProofNestedFeaturePlaceholder', {
+  title: 'Nested feature placeholder',
+  ui: PlaceholderUi,
+})<Placeholder>() {}
+
+const PlaceholderLive = Composition.live(Placeholder, function* () {
+  return mount({ props: { phase: 'loading' }, slots: {} })
+})
+
+class NestedFeature extends Feature.make('proof.nestedFeature', {
+  loadingStrategy: 'lazy',
+  input: NestedFeatureInput,
+  composition: Nested,
+  load: Effect.succeed(NestedModule),
+  placeholder: { loading: Placeholder, failed: Placeholder },
+}) {}
+
+class NestedSlot extends slot('ProofNestedFeatureSlot')<
+  NestedSlot,
+  FeatureSlotTarget<typeof NestedFeature>
+>() {}
+
+class RootUi extends ui('ProofNestedFeatureRoot')<{
+  props: { ready: boolean }
+  slots: { Nested: NestedSlot }
+}>() {}
+
+class Root extends Composition.make('ProofNestedFeatureRoot', {
+  title: 'Nested feature root',
+  slots: { Nested: NestedSlot },
+  ui: RootUi,
+})<Root>() {}
+
+const RootLive = Composition.live(Root, function* () {
+  return mount({
+    props: { ready: true },
+    slots: { Nested: one({ value: 42 }) },
+  })
+})
+
+const RootModule = featureModule(
+  [],
+  Layer.mergeAll(RootLive, PlaceholderLive, provide(NestedSlot, NestedFeature)),
+)
+
+class RootFeature extends Feature.make('proof.rootFeature', {
+  composition: Root,
+  module: RootModule,
+}) {}
+
+class HarnessRootSlot extends slot('ProofHarnessRootSlot')<
+  HarnessRootSlot,
+  FeatureSlotTarget<typeof RootFeature>
+>() {}
+
+class HarnessUi extends ui('ProofNestedFeatureHarness')<{
+  props: { ready: boolean }
+  slots: { Root: HarnessRootSlot }
+}>() {}
+
+class Harness extends Composition.make('ProofNestedFeatureHarness', {
+  title: 'Nested feature harness',
+  slots: { Root: HarnessRootSlot },
+  ui: HarnessUi,
+})<Harness>() {}
+
+const HarnessLive = Composition.live(Harness, function* () {
+  return mount({
+    props: { ready: true },
+    slots: { Root: one({}) },
+  })
+})
+
+const RootScene = scene(Harness, {
+  provide: [
+    Layer.mergeAll(HarnessLive, provide(HarnessRootSlot, RootFeature)).pipe(
+      Layer.provideMerge(Engine),
+    ),
+  ],
+})
+
+class MountsNestedFeature extends ProductRequirement.make(
+  Root,
+  'mounts a nested native Feature with its slot input',
+) {}
+
+class RootProduct extends Product.make(Root, {
+  requirements: [MountsNestedFeature],
+}) {}
+
+const mountsNestedFeature = Proof.implementVia(MountsNestedFeature, RootScene, function* (app) {
+  const root = yield* app.slots.Root.first
+  const nested = yield* root.slots.Nested.first
+  yield* nested.expectProps({ mountValue: 42, featureValue: 42 })
+})
+
+const NestedFeatureProofs = Proof.suite(RootProduct, {
+  proofs: [mountsNestedFeature],
+})
+
+it.live('proves a Feature that mounts a nested native Feature', () =>
+  Effect.gen(function* () {
+    const result = yield* Proof.runEffect(NestedFeatureProofs)
+    expect(result.results).toEqual([
+      {
+        requirement: 'mounts a nested native Feature with its slot input',
+        ok: true,
+        error: undefined,
+      },
+    ])
+    expect(result.ok).toBe(true)
+  }),
+)

package/src/runner.ts

@@ -1,38 +1,26 @@
 import { Context, Effect, Layer } from 'effect'
-import { driveProof, executeProof } from './engine'
+import { driveProof, driveProofEffect, executeProof, executeProofEffect } from './engine'
 import type { DriveResult, Proof, ProofResult } from './index'
 
-// reform-proof runner — the injectable seam HOW a proof is executed. The proof
-// system depends on this layer rather than calling the engine directly, so the
-// execution strategy can be swapped (the vitest adapter resolves the same layer to
-// run each proof as a native test). The default layer is the headless engine in
-// ./engine; mirrors the Tag + Layer house style of reform's `CaptureSink` and
-// `Notifications` services.
-
 export interface ProofRunnerApi {
-  /** Run a proof to completion, returning its pass/fail result. */
+  readonly executeProofEffect: (proof: Proof) => Effect.Effect<ProofResult, never, never>
+  readonly driveProofEffect: (proof: Proof) => Effect.Effect<DriveResult, never, never>
   readonly executeProof: (proof: Proof) => Promise<ProofResult>
-  /** Step a proof a frame at a time (the editor's Test-play timeline). */
   readonly driveProof: (proof: Proof) => Promise<DriveResult>
 }
 
 const ProofRunnerBase: Context.TagClass<ProofRunner, 'reform-proof/ProofRunner', ProofRunnerApi> =
   Context.Tag('reform-proof/ProofRunner')<ProofRunner, ProofRunnerApi>()
 
-/** The service identity for the proof execution strategy. */
 export class ProofRunner extends ProofRunnerBase {}
 
-/** The default runner: the headless engine that drives the real reduce loop. */
 export const proofRunnerLayer: Layer.Layer<ProofRunner> = Layer.succeed(ProofRunner, {
+  executeProofEffect,
+  driveProofEffect,
   executeProof,
   driveProof,
 })
 
-/**
- * Resolve the `ProofRunner` from `proofRunnerLayer` and use it — the single seam
- * the proof system (`Proof.run`/`Proof.driver`) and the vitest adapter both run
- * through, so every proof executes via the same injectable engine.
- */
 export const withProofRunner = <A>(use: (runner: ProofRunnerApi) => Promise<A>): Promise<A> =>
   Effect.runPromise(
     ProofRunner.pipe(

package/src/structure-events.test.ts

@@ -16,19 +16,13 @@ import {
 import { describe, expect, test } from 'vitest'
 import { Product, Proof, ProductRequirement, expect as proofExpect } from './index'
 
-// Plan 03b — events ride ON the structure. A composition whose `live` body returns
-// `mount({ props, events })` never calls its view, so the event triggers it acquires
-// (`yield* Event.trigger(Bumped)`) are NOT captured by a view's CaptureSink — they
-// travel with the frame on `structure.events`. The proof engine's `driveStructure`
-// records them into the same capture the view path uses, so `app.actions.bump()`
-// resolves and settles identically for a Structure frame. This file is the only
-// runtime exercise of the structure EVENT path; the view path stays covered by
-// typed-seams.test.ts.
-
 class CountState extends State.make('scount', S.Number) {}
 class MiniStates extends StateGroup.make(CountState) {}
 class Bumped extends Event.make('SBumped', S.Struct({})) {}
-class BumpReducer extends Reducer.make('SBumpReducer', { states: [CountState], events: [Bumped] }) {}
+class BumpReducer extends Reducer.make('SBumpReducer', {
+  states: [CountState],
+  events: [Bumped],
+}) {}
 const BumpReducerLive = Reducer.live(BumpReducer, (n) => n + 1)
 
 class CounterUi extends ui('SCounter')<{
@@ -40,16 +34,17 @@ class Counter extends Composition.make('SCounter', {
   states: [MiniStates],
   events: [Bumped],
   ui: CounterUi,
-}) {}
-// Body returns a STRUCTURE carrying the bump trigger on `events` — the view is never
-// called, so the trigger must ride on the frame for the proof to resolve it.
+})<Counter>() {}
 const CounterLive = Composition.live(Counter, function* () {
   const count = yield* StateGroup.select(MiniStates, 'scount')
   const bump = yield* Event.trigger(Bumped)
   return mount({ props: { count }, slots: {}, events: { bump } })
 })
 
-const presentations = provide(CounterUi, Ui.make(CounterUi, () => null))
+const presentations = provide(
+  CounterUi,
+  Ui.make(CounterUi, () => null),
+)
 const Views = CounterLive.pipe(Layer.provideMerge(presentations))
 const Logic = BumpReducerLive.pipe(
   Layer.provideMerge(Layer.mergeAll(Engine, StateGroup.live(MiniStates, { scount: 5 }))),

package/src/structure-locators.test.ts

@@ -4,7 +4,6 @@ import {
   Engine,
   each,
   mount,
-  Props,
   provide,
   scene,
   slot,
@@ -16,28 +15,21 @@ import {
 import { describe, expect, test } from 'vitest'
 import { type Facade, Product, Proof, ProductRequirement, expect as proofExpect } from './index'
 
-// Plan 06 — typed recursive proof navigation. A list parent returns a STRUCTURE
-// whose `Item` slot is filled with `each`, so each child rides a stable `key` (the
-// SINGLE source of the wire key + family key). The proof facade selects a child by
-// that key (`byKey`), filters by computed props (`where`), and reads the fill length
-// (`count`) — all against the structure tree, no view evaluated. `byKey` returns a
-// facade still typed by the child contract, so `.expectProps` checks the CHILD's
-// props and `.slots` would keep descending type-safely.
-
-// A list of todos lives in state; the parent computes its props + the `each` fill.
 class TodosState extends State.make(
   'locTodos',
   S.Array(S.Struct({ id: S.String, done: S.Boolean })),
 ) {}
 class TodoStates extends StateGroup.make(TodosState) {}
 
-class ItemUi extends ui('LocItem')<{ props: { id: string; done: boolean } }>() {}
+class ItemUi extends ui('LocItem')<{
+  props: { id: string; done: boolean }
+}>() {}
 class Item extends Composition.make('LocItem', {
   title: 'LocItem',
   props: S.Struct({ id: S.String, done: S.Boolean }),
   ui: ItemUi,
-}) {}
-class ItemSlot extends slot('LocItem')<typeof Item>() {}
+})<Item>() {}
+class ItemSlot extends slot('LocItem')<ItemSlot, typeof Item>() {}
 
 class ListUi extends ui('LocList')<{
   props: { total: number }
@@ -48,30 +40,34 @@ class List extends Composition.make('LocList', {
   states: [TodoStates],
   slots: { Item: ItemSlot },
   ui: ListUi,
-}) {}
+})<List>() {}
 
-// The parent body returns pure data: its own props, and the `Item` slot filled with
-// one keyed child per todo. No `.map`, no JSX — `each` owns multiplicity + key.
 const ListLive = Composition.live(List, function* () {
   const todos = yield* StateGroup.select(TodoStates, 'locTodos')
   return mount({
     props: { total: todos.length },
     slots: {
-      Item: each(todos, { key: (t) => t.id, props: (t) => ({ id: t.id, done: t.done }) }),
+      Item: each(todos, {
+        key: (t) => t.id,
+        props: (t) => ({ id: t.id, done: t.done }),
+      }),
     },
   })
 })
-// A leaf child in structure-as-data echoes the props its parent's `each` fed it
-// (read via the `Props` service), so the recorded capture carries the per-item
-// props `byKey`/`where`/`expectProps` assert against. No view, hook-free.
 const ItemLive = Composition.live(Item, function* () {
-  const props: { id: string; done: boolean } = yield* Props
+  const props = yield* Item.props
   return mount({ props, slots: {} })
 })
 
 const presentations = Layer.mergeAll(
-  provide(ListUi, Ui.make(ListUi, () => null)),
-  provide(ItemUi, Ui.make(ItemUi, () => null)),
+  provide(
+    ListUi,
+    Ui.make(ListUi, () => null),
+  ),
+  provide(
+    ItemUi,
+    Ui.make(ItemUi, () => null),
+  ),
 )
 const wiring = provide(ItemSlot, Item)
 const Views = Layer.mergeAll(ListLive, ItemLive, wiring).pipe(Layer.provideMerge(presentations))
@@ -94,18 +90,12 @@ class ListProduct extends Product.make(List, { requirements: [Locates] }) {}
 describe('typed recursive proof navigation (plan 06)', () => {
   test('byKey / where / count resolve children from the structure tree', async () => {
     const proof = Proof.implement(Locates, ListScene, function* (app) {
-      // The parent's computed props.
       yield* proofExpect((yield* app.props).total).toBe(3)
-      // count = the fill length.
       yield* proofExpect(yield* app.slots.Item.count).toBe(3)
-      // byKey selects the one child mounted under that `each` key; the facade is
-      // typed by the CHILD contract, so `expectProps` checks the child's props.
       const second = yield* app.slots.Item.byKey('todo-2')
       yield* second.expectProps({ id: 'todo-2', done: true })
       const first = yield* app.slots.Item.byKey('todo-1')
       yield* first.expectProps({ id: 'todo-1', done: false })
-      // where filters children by their computed props (predicate typed by the
-      // CHILD contract — `p.done` is known).
       const doneItems = yield* app.slots.Item.where((p) => p.done)
       yield* proofExpect(doneItems.length).toBe(1)
       yield* doneItems[0]!.expectProps({ id: 'todo-2' })
@@ -123,9 +113,6 @@ describe('typed recursive proof navigation (plan 06)', () => {
   })
 })
 
-// Type-only: the `byKey`-selected facade is typed by the Item CHILD contract
-// (`{ id, done }`) — recursive typed selection. A wrong prop key in `expectProps`
-// is a compile error. Non-exported, never called; exists only to be typechecked.
 const _negativeTypeCheck = (app: Facade<Ui.Contract<typeof ListUi>>): void => {
   Proof.implement(Locates, ListScene, function* () {
     const child = yield* app.slots.Item.byKey('todo-1')

package/src/typed-seams.test.ts

@@ -18,42 +18,34 @@ import {
 import { describe, expect, test } from 'vitest'
 import { Product, Proof, ProductRequirement, expect as proofExpect } from './index'
 
-// Exercises the four type-safety seams closed in this change, each against a
-// self-contained mini Counter (the same fixture shape as the stepper test):
-//   #1 typed seeds       — seedScene is keyed/valued by the state tuple
-//   #2 action results    — an action resolves to the settled next props
-//   #4 typed assertions  — app.expectProps is a contract-typed subset match
-//   #5 event coverage     — a requirement's declared events must be dispatched
-// Negative cases are compile-time (`@ts-expect-error`) — the whole point is that
-// the bad input never reaches runtime.
-
 class CountState extends State.make('count', S.Number) {}
 class MiniStates extends StateGroup.make(CountState) {}
 class Bumped extends Event.make('Bumped', S.Struct({})) {}
 class BumpReducer extends Reducer.make('BumpReducer', { states: [CountState], events: [Bumped] }) {}
 const BumpReducerLive = Reducer.live(BumpReducer, (n) => n + 1)
 
-// A trivial slot child: a proof runtime resolves slot-bound compositions, so the
-// app needs at least one slot for the suite's provide layer to type-close.
 class LabelUi extends ui('Label')<{ props: { text: string } }>() {}
-class Label extends Composition.make('Label', { title: 'Label', ui: LabelUi }) {}
+
+class Label extends Composition.make('Label', { title: 'Label', ui: LabelUi })<Label>() {}
 const LabelLive = Composition.live(Label, function* () {
   return mount({ props: { text: 'count' }, slots: {} })
 })
-class LabelSlot extends slot('Label')<typeof Label>() {}
+
+class LabelSlot extends slot('Label')<LabelSlot, typeof Label>() {}
 
 class CounterUi extends ui('Counter')<{
   props: { count: number }
   slots: { Label: LabelSlot }
   events: { bump: Trigger<Record<string, never>> }
 }>() {}
+
 class Counter extends Composition.make('Counter', {
   title: 'Counter',
   states: [MiniStates],
   events: [Bumped],
   slots: { Label: LabelSlot },
   ui: CounterUi,
-}) {}
+})<Counter>() {}
 const CounterLive = Composition.live(Counter, function* () {
   const count = yield* StateGroup.select(MiniStates, 'count')
   const bump = yield* Event.trigger(Bumped)