@playfast/reform-proof 1.1.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,8 +1,10 @@
 import { Context, Effect, Layer } from 'effect'
-import { driveProof, executeProof } from './execution'
+import { driveProof, driveProofEffect, executeProof, executeProofEffect } from './engine'
 import type { DriveResult, Proof, ProofResult } from './index'
 
 export interface ProofRunnerApi {
+  readonly executeProofEffect: (proof: Proof) => Effect.Effect<ProofResult, never, never>
+  readonly driveProofEffect: (proof: Proof) => Effect.Effect<DriveResult, never, never>
   readonly executeProof: (proof: Proof) => Promise<ProofResult>
   readonly driveProof: (proof: Proof) => Promise<DriveResult>
 }
@@ -13,6 +15,8 @@ const ProofRunnerBase: Context.TagClass<ProofRunner, 'reform-proof/ProofRunner',
 export class ProofRunner extends ProofRunnerBase {}
 
 export const proofRunnerLayer: Layer.Layer<ProofRunner> = Layer.succeed(ProofRunner, {
+  executeProofEffect,
+  driveProofEffect,
   executeProof,
   driveProof,
 })

package/src/structure-events.test.ts

@@ -19,7 +19,10 @@ import { Product, Proof, ProductRequirement, expect as proofExpect } from './ind
 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')<{
@@ -31,14 +34,17 @@ class Counter extends Composition.make('SCounter', {
   states: [MiniStates],
   events: [Bumped],
   ui: CounterUi,
-}) {}
+})<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,
@@ -22,13 +21,15 @@ class TodosState extends State.make(
 ) {}
 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 }
@@ -39,25 +40,34 @@ class List extends Composition.make('LocList', {
   states: [TodoStates],
   slots: { Item: ItemSlot },
   ui: ListUi,
-}) {}
+})<List>() {}
 
 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 }),
+      }),
     },
   })
 })
 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))

package/src/typed-seams.test.ts

@@ -25,24 +25,27 @@ class BumpReducer extends Reducer.make('BumpReducer', { states: [CountState], ev
 const BumpReducerLive = Reducer.live(BumpReducer, (n) => n + 1)
 
 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)

package/src/assertions.ts

@@ -1,65 +0,0 @@
-import { Array as Arr, Effect, Option, Record as Rec } from 'effect'
-import { AssertionFailed } from './errors'
-
-interface ComparePair {
-  readonly left: unknown
-  readonly right: unknown
-}
-
-// oxlint-disable-next-line reform-rules/no-json-parse-stringify -- arbitrary unknown assertion values, not Schema-typed data
-const show = (subject: unknown): string => JSON.stringify(subject)
-
-const deepEqual = ({ left, right }: ComparePair): boolean =>
-  Object.is(left, right) || show(left) === show(right)
-
-const fail = (message: string): Effect.Effect<never> =>
-  Effect.dieMessage(new AssertionFailed({ detail: message }).message)
-
-export const expect = <A>(actual: A) => ({
-  toBe: (expected: A): Effect.Effect<void> =>
-    Object.is(actual, expected)
-      ? Effect.void
-      : fail(`expected ${show(actual)} to be ${show(expected)}`),
-  toEqual: (expected: A): Effect.Effect<void> =>
-    deepEqual({ left: actual, right: expected })
-      ? Effect.void
-      : fail(`expected ${show(actual)} to equal ${show(expected)}`),
-  toContain: (expected: A extends ReadonlyArray<infer E> ? E : unknown): Effect.Effect<void> =>
-    Array.isArray(actual) && actual.some((element) => deepEqual({ left: element, right: expected }))
-      ? Effect.void
-      : fail(`expected ${show(actual)} to contain ${show(expected)}`),
-  toMatchObject: (expected: Partial<A>): Effect.Effect<void> => {
-    const mismatch = matchPartial({ actual, expected })
-    return mismatch === undefined ? Effect.void : fail(mismatch)
-  },
-})
-
-const isRecord = (candidate: unknown): candidate is Record<string, unknown> =>
-  typeof candidate === 'object' && candidate !== null
-
-interface MatchInput {
-  readonly actual: unknown
-  readonly expected: unknown
-}
-
-const matchPartial = ({ actual, expected }: MatchInput): string | undefined => {
-  if (!isRecord(expected)) {
-    return deepEqual({ left: actual, right: expected })
-      ? undefined
-      : `expected ${show(actual)} to match ${show(expected)}`
-  }
-  if (!isRecord(actual)) {
-    return `expected ${show(actual)} to be an object matching ${show(expected)}`
-  }
-  const mismatch = Arr.findFirst(
-    Rec.keys(expected),
-    (key) => !deepEqual({ left: actual[key], right: expected[key] }),
-  )
-  return Option.match(mismatch, {
-    onNone: () => undefined,
-    onSome: (key) =>
-      `expected key ${show(key)} to match ${show(expected[key])}, got ${show(actual[key])}`,
-  })
-}
-
-export const matchProps: (input: MatchInput) => string | undefined = matchPartial

package/src/driverTypes.ts

@@ -1,19 +0,0 @@
-import type { UiCapture } from '@playfast/reform'
-
-export interface StepFrame {
-  readonly index: number
-  readonly captures: ReadonlyArray<UiCapture>
-}
-
-export interface DriveResult {
-  readonly requirement: string
-  readonly frames: ReadonlyArray<StepFrame>
-  readonly ok: boolean
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- serialized result DTO read as `error ?? …` by the editor timeline (external); optional kept for wire compat
-  readonly error?: string
-}
-
-export interface ProofDriver {
-  readonly requirement: string
-  readonly run: () => Promise<DriveResult>
-}

package/src/execution.ts

@@ -1,100 +0,0 @@
-import { Cause, Effect, Option, Ref } from 'effect'
-import { yieldWrapGet } from 'effect/Utils'
-import {
-  Bus,
-  type CompositionService,
-  publish,
-  type Scene,
-  sceneInstrumentation,
-} from '@playfast/reform'
-import type { DriveResult, Proof, ProofResult, StepFrame } from './index'
-import { makeFacadeEffect } from './facade'
-import { makeSink, messageOf, proofLayer, type RuntimeServices, type Sink } from './sink'
-import type { PumpStep } from './treeBindings'
-
-const missingCoverage = (proof: Proof, dispatched: Set<string>): ReadonlyArray<string> =>
-  Option.match(proof.requirement.manifest.events, {
-    onNone: () => [],
-    onSome: (declared) => declared.map(String).filter((event) => !dispatched.has(event)),
-  })
-
-const bootScene = (scene: Scene): Effect.Effect<void, never, Bus> =>
-  Effect.forEach(
-    Option.getOrElse(Option.fromNullable(scene.boot), () => []),
-    (event) => publish('High', event),
-  ).pipe(Effect.asVoid)
-
-const executeProofEffect = Effect.fn('executeProofEffect')(function* (
-  proof: Proof,
-  sink: Sink,
-): Effect.fn.Return<ProofResult, never, RuntimeServices> {
-  const dispatched = new Set<string>()
-  const statement = proof.requirement.manifest.statement
-  return yield* Effect.gen(function* () {
-    const { facade, settle } = yield* makeFacadeEffect(proof.scene.composition, sink, dispatched)
-    yield* bootScene(proof.scene)
-    yield* settle
-    yield* Effect.gen(() => proof.body(facade))
-    const missing = missingCoverage(proof, dispatched)
-    const coverageError = `requirement declares events never dispatched: ${missing.join(', ')}`
-    return missing.length > 0
-      ? { requirement: statement, ok: false, error: coverageError }
-      : { requirement: statement, ok: true }
-  }).pipe(
-    Effect.catchAllCause((cause) =>
-      Effect.succeed({ requirement: statement, ok: false, error: messageOf(Cause.squash(cause)) }),
-    ),
-  )
-})
-
-export const executeProof = async (proof: Proof): Promise<ProofResult> => {
-  const sink = makeSink(sceneInstrumentation(proof.scene))
-  return Effect.runPromise(executeProofEffect(proof, sink).pipe(Effect.provide(proofLayer(proof.scene, sink))))
-}
-
-const driveProofEffect = Effect.fn('driveProofEffect')(function* (
-  proof: Proof,
-  sink: Sink,
-): Effect.fn.Return<DriveResult, never, RuntimeServices> {
-  const frames = yield* Ref.make<ReadonlyArray<StepFrame>>([])
-  const statement = proof.requirement.manifest.statement
-  const dispatched = new Set<string>()
-  const record = (index: number): Effect.Effect<void> =>
-    Ref.update(frames, (current) => [...current, { index, captures: [...sink.captures] }])
-  const pump = Effect.fn('pump')(function* (
-    generator: ReturnType<Proof['body']>,
-    step: PumpStep,
-  ): Effect.fn.Return<void, unknown, CompositionService> {
-    const next = generator.next(step.input)
-    if (next.done === true) {
-      return
-    }
-    const output = yield* yieldWrapGet(next.value)
-    yield* record(step.index)
-    yield* pump(generator, { input: output, index: step.index + 1 })
-  })
-  return yield* Effect.gen(function* () {
-    const { facade, settle } = yield* makeFacadeEffect(proof.scene.composition, sink, dispatched)
-    yield* bootScene(proof.scene)
-    yield* settle
-    yield* record(0)
-    yield* pump(proof.body(facade), { input: undefined, index: 1 })
-    return { requirement: statement, frames: yield* Ref.get(frames), ok: true }
-  }).pipe(
-    Effect.catchAllCause((cause) =>
-      Ref.get(frames).pipe(
-        Effect.map((collected) => ({
-          requirement: statement,
-          frames: collected,
-          ok: false,
-          error: messageOf(Cause.squash(cause)),
-        })),
-      ),
-    ),
-  )
-})
-
-export const driveProof = async (proof: Proof): Promise<DriveResult> => {
-  const sink = makeSink(sceneInstrumentation(proof.scene))
-  return Effect.runPromise(driveProofEffect(proof, sink).pipe(Effect.provide(proofLayer(proof.scene, sink))))
-}