@playfast/reform-proof 1.1.1 → 1.2.1

package/src/index.ts

@@ -1,25 +1,28 @@
-import { Effect, type Schema } from 'effect'
-import type { YieldWrap } from 'effect/Utils'
+import { Effect, Layer, TestContext, type TestServices } from 'effect'
 import { ProofRunner, type ProofRunnerApi, proofRunnerLayer, withProofRunner } from './runner'
-import { type ProductClass, type RequirementClass } from './product'
-import type { ProofDriver } from './driverTypes'
+import { isRecord } from './assert'
+import type { ContractOf, Facade, SlotsOf } from './facade'
 import type {
-  CompositionClass,
-  CompositionService,
+  AnyRequirementClass,
+  ProductClass,
+  ProductComposition,
+  RequirementClass,
+} from './product'
+import type { ProofCapture, ProofCase, ProofGenerator, SuiteResult } from './proofCase'
+import type {
+  CapturedScene,
   Scene,
-  SlotInstance,
-  Trigger,
+  SlotComposition as ReformSlotComposition,
   UiContract,
 } from '@playfast/reform'
-
-type AnyValue = Schema.Schema.Type<Schema.Schema.Any>
-type AnyComposition = CompositionClass<AnyValue, AnyValue>
+import type { AnyScene, CapturedRender } from '@playfast/reform/internal'
 
 export { ProofRunner, proofRunnerLayer, withProofRunner }
 export type { ProofRunnerApi }
 
 export {
   makeFacade,
+  makeProofFacade,
   makeRuntimeHandleFacade,
   makeRuntimeTreeFacade,
   makeSink,
@@ -28,72 +31,37 @@ export {
 export type {
   MountedFacade,
   MountedSlotFacade,
-  RuntimeServices,
+  MountedSlotFacadesOf,
   RuntimeTreeFacade,
   Sink,
 } from './engine'
 
-export {
-  Product,
-  type ProductClass,
-  type ProductManifest,
-  ProductRequirement,
-  type RequirementClass,
-  type RequirementManifest,
+export { Product, ProductRequirement } from './product'
+export type {
+  AnyRequirementClass,
+  ProductClass,
+  ProductComposition,
+  ProductManifest,
+  RequirementCapture,
+  RequirementClass,
+  RequirementManifest,
 } from './product'
-
-export { expect, matchProps } from './assertions'
-
-export type EventsOf<C extends UiContract> = C extends { events: infer E } ? E : Record<never, never>
-type SlotsOf<C extends UiContract> = C extends { slots: infer S } ? S : Record<never, never>
-type PayloadOf<T> = T extends Trigger<infer P> ? P : never
-export type ContractOf<Comp> = Comp extends CompositionClass<AnyValue, infer C> ? C : never
-type ContractOfSlot<S> = S extends SlotInstance<infer Comp> ? ContractOf<Comp> : never
-
-export type ActionsOf<C extends UiContract> = {
-  readonly [K in keyof EventsOf<C>]: (
-    payload: PayloadOf<EventsOf<C>[K]>,
-  ) => Effect.Effect<C['props'], never, CompositionService>
-}
-export type SlotFacadesOf<C extends UiContract> = {
-  readonly [K in keyof SlotsOf<C>]: SlotFacade<ContractOfSlot<SlotsOf<C>[K]>>
-}
-
-export type Action = (payload: unknown) => Effect.Effect<unknown, never, CompositionService>
-
-export interface Facade<C extends UiContract> {
-  readonly props: Effect.Effect<C['props'], never, CompositionService>
-  readonly expectProps: (partial: Partial<C['props']>) => Effect.Effect<void, never, CompositionService>
-  readonly actions: ActionsOf<C>
-  readonly slots: SlotFacadesOf<C>
-  readonly frame: Effect.Effect<void, never, CompositionService>
-}
-
-export interface SlotFacade<C extends UiContract> extends Facade<C> {
-  readonly first: Effect.Effect<Facade<C>, never, CompositionService>
-  readonly at: (index: number) => Effect.Effect<Facade<C>, never, CompositionService>
-  readonly all: Effect.Effect<ReadonlyArray<Facade<C>>, never, CompositionService>
-  readonly byKey: (key: string) => Effect.Effect<Facade<C>, never, CompositionService>
-  readonly where: (
-    predicate: (props: C['props']) => boolean,
-  ) => Effect.Effect<ReadonlyArray<Facade<C>>, never, CompositionService>
-  readonly count: Effect.Effect<number, never, CompositionService>
-}
-
-type ProofGenerator = Generator<
-  YieldWrap<Effect.Effect<unknown, unknown, CompositionService>>,
-  void,
-  unknown
->
-
-type AnyFacade = Facade<UiContract>
-
-export type ProofBody = (app: AnyFacade) => ProofGenerator
+export { expect, matchProps } from './assert'
+export type {
+  Action,
+  ActionsOf,
+  ContractOf,
+  EventsOf,
+  Facade,
+  SlotFacade,
+  SlotFacadesOf,
+} from './facade'
+export type { ProofCapture, ProofCase, ProofResult, SuiteResult } from './proofCase'
 
 export interface Proof {
-  readonly requirement: RequirementClass<AnyComposition, string>
-  readonly scene: Scene
-  readonly body: ProofBody
+  readonly requirement: AnyRequirementClass
+  readonly scene: AnyScene
+  readonly capture: <Result>(visit: ProofCapture<Result>) => Result
 }
 
 export interface ProofSuite {
@@ -102,45 +70,78 @@ export interface ProofSuite {
   readonly proofs: ReadonlyArray<Proof>
 }
 
-const isRecord = (candidate: unknown): candidate is Record<string, unknown> =>
-  typeof candidate === 'object' && candidate !== null
-
-export interface ProofResult {
-  readonly requirement: string
-  readonly ok: boolean
-  // oxlint-disable-next-line reform-rules/no-optional-fields -- serialized result DTO read as `error ?? …` by the vitest adapter (external); optional kept for wire compat
-  readonly error?: string
-}
-
-export interface SuiteResult {
-  readonly product: string
-  readonly results: ReadonlyArray<ProofResult>
-  readonly ok: boolean
-}
-
-const implement = <Comp extends AnyComposition>(
+const implement = <Comp extends ProductComposition>(
   requirement: RequirementClass<Comp, string>,
-  scene: Scene<ContractOf<Comp>>,
-  body: (app: Facade<ContractOf<Comp>>) => ProofGenerator,
-): Proof => {
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- contract erasure seam: Facade<C> → AnyFacade is contravariant, sound by construction
-  const erased = body as ProofBody
-  return { requirement, scene, body: erased }
+  scene: Scene<ContractOf<NoInfer<Comp>>, NoInfer<Comp>['States']>,
+  body: (app: Facade<ContractOf<Comp>, never>) => ProofGenerator,
+): Proof =>
+  scene.capture(
+    <Services, P, N extends string, Identity>(
+      exactScene: CapturedScene<ContractOf<Comp>, Comp['States'], Services, P, N, Identity>,
+    ): Proof => {
+      const proofCase: ProofCase<
+        Comp,
+        ContractOf<Comp>,
+        Comp['States'],
+        Services,
+        P,
+        N,
+        Identity
+      > = {
+        requirement,
+        scene: exactScene,
+        placement: 'Root',
+        body,
+      }
+      return {
+        requirement,
+        scene: exactScene,
+        capture: (visit) =>
+          visit<Comp, ContractOf<Comp>, Comp['States'], Services, P, N, Identity>(proofCase),
+      }
+    },
+  )
+
+type SlotsHolding<C extends UiContract, Target extends ProductComposition> = C extends {
+  readonly slots: NonNullable<UiContract['slots']>
 }
-
-type SlotsHolding<C extends UiContract, Target> = {
-  [K in keyof SlotsOf<C>]: ContractOfSlot<SlotsOf<C>[K]> extends Target ? K : never
-}[keyof SlotsOf<C>]
-
-const implementVia = <Comp extends AnyComposition, C extends UiContract>(
+  ? {
+      [K in keyof SlotsOf<C>]: [ReformSlotComposition<SlotsOf<C>[K]>] extends [Target] ? K : never
+    }[keyof SlotsOf<C>]
+  : never
+
+type SceneHolding<
+  Comp extends ProductComposition,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+> = [SlotsHolding<C, Comp>] extends [never] ? never : Scene<C, S>
+
+const implementVia = <
+  Comp extends ProductComposition,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+>(
   requirement: RequirementClass<Comp, string>,
-  scene: Scene<C> & ([SlotsHolding<C, ContractOf<Comp>>] extends [never] ? never : unknown),
-  body: (app: Facade<C>) => ProofGenerator,
-): Proof => {
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- contract erasure seam: Facade<C> → AnyFacade is contravariant, sound by construction
-  const erased = body as ProofBody
-  return { requirement, scene, body: erased }
-}
+  scene: SceneHolding<NoInfer<Comp>, C, S>,
+  body: (app: Facade<C, never>) => ProofGenerator,
+): Proof =>
+  scene.capture(
+    <Services, P, N extends string, Identity>(
+      exactScene: CapturedScene<C, S, Services, P, N, Identity>,
+    ): Proof => {
+      const proofCase: ProofCase<Comp, C, S, Services, P, N, Identity> = {
+        requirement,
+        scene: exactScene,
+        placement: 'Slot',
+        body,
+      }
+      return {
+        requirement,
+        scene: exactScene,
+        capture: (visit) => visit<Comp, C, S, Services, P, N, Identity>(proofCase),
+      }
+    },
+  )
 
 interface MakeSuiteConfig {
   readonly proofs: ReadonlyArray<Proof>
@@ -156,28 +157,77 @@ export const isProofSuite = (candidate: unknown): candidate is ProofSuite =>
   isRecord(candidate) && candidate['kind'] === 'ProofSuite' && Array.isArray(candidate['proofs'])
 
 const run = (proofSuite: ProofSuite): Promise<SuiteResult> =>
-  withProofRunner(async (runner: ProofRunnerApi) => {
-    const reports = await Effect.runPromise(
-      Effect.forEach(proofSuite.proofs, (proof) => Effect.promise(() => runner.executeProof(proof))),
-    )
-    return {
+  Effect.runPromise(runEffect(proofSuite))
+
+const runEffect = (proofSuite: ProofSuite): Effect.Effect<SuiteResult, never, never> =>
+  ProofRunner.pipe(
+    Effect.flatMap((runner) =>
+      Effect.forEach(proofSuite.proofs, (proof) => runner.executeProofEffect(proof)),
+    ),
+    Effect.map((reports) => ({
       product: proofSuite.product.manifest.name,
       results: reports,
       ok: reports.every((report) => report.ok),
-    }
-  })
+    })),
+    Effect.provide(proofRunnerLayer),
+  )
+
+export interface StepFrame {
+  readonly index: number
+  readonly captures: ReadonlyArray<CapturedRender>
+}
+
+export interface DriveResult {
+  readonly requirement: string
+  readonly frames: ReadonlyArray<StepFrame>
+  readonly ok: boolean
+  readonly error: string | undefined
+}
+
+export interface ProofDriver {
+  readonly requirement: string
+  readonly run: () => Promise<DriveResult>
+}
 
-export type { DriveResult, ProofDriver, StepFrame } from './driverTypes'
 const driver = (proofSuite: ProofSuite): ReadonlyArray<ProofDriver> =>
   proofSuite.proofs.map((proof) => ({
     requirement: proof.requirement.manifest.statement,
     run: () => withProofRunner((runner: ProofRunnerApi) => runner.driveProof(proof)),
   }))
 
+/**
+ * Wrap a scene's layers in a virtual clock, so every `Effect.sleep`, `Schedule` and
+ * `Clock` read its procedures make elapses only when the proof says so via
+ * `app.advance(...)`:
+ *
+ * ```ts
+ * const MyScene = scene(MyComposition, { provide: [Proof.withTestClock(App)] })
+ * ```
+ *
+ * It has to WRAP the scene's layers, never sit beside them in `provide`. The engine
+ * forks its loop while its layer is being built, and a forked fiber inherits the
+ * clock in scope at that moment — so a clock merged as a sibling reaches the proof
+ * body but not the procedures whose timers it is meant to control. That mis-wiring
+ * is silent (`app.advance(...)` finds a clock, adjusts it, and no product timer
+ * moves), which is why the clock is exposed as this combinator, not a bare layer.
+ *
+ * Opt-in per scene rather than on by default: a scene without it keeps the real
+ * clock, so proofs that observe product timers by waiting stay correct. Once a scene
+ * has it, a product timer NEVER fires on its own — an unadvanced proof sees the
+ * pre-timer state, which is the point.
+ */
+const withTestClock = <ROut, E, RIn>(
+  layer: Layer.Layer<ROut, E, RIn>,
+): Layer.Layer<ROut | TestServices.TestServices, E, RIn> =>
+  layer.pipe(Layer.provideMerge(TestContext.TestContext))
+
 export const Proof: {
   readonly implement: typeof implement
   readonly implementVia: typeof implementVia
   readonly suite: typeof suite
   readonly run: typeof run
+  readonly runEffect: typeof runEffect
   readonly driver: typeof driver
-} = { implement, implementVia, suite, run, driver }
+  readonly withTestClock: typeof withTestClock
+} = { implement, implementVia, suite, run, runEffect, driver, withTestClock }
+

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/product.ts

@@ -1,40 +1,65 @@
-import { Option, type Schema } from 'effect'
-import type { CompositionClass } from '@playfast/reform'
-import type { ContractOf, EventsOf } from './index'
+import { Option } from 'effect'
+import type { AnyComposition } from '@playfast/reform/internal'
+import type { ContractOf, EventNamesOf } from './facade'
 
-type AnyValue = Schema.Schema.Type<Schema.Schema.Any>
-type AnyComposition = CompositionClass<AnyValue, AnyValue>
+export type ProductComposition = AnyComposition & { readonly identity: symbol }
 
-export interface RequirementManifest<Comp extends AnyComposition, Statement extends string> {
+const RequirementCompositionTypeId: unique symbol = Symbol.for(
+  'reform-proof/RequirementComposition',
+)
+
+export interface AnyRequirementClass {
+  new (): {}
+  readonly manifest: {
+    readonly kind: 'ProductRequirement'
+    readonly name: string
+    readonly statement: string
+    readonly composition: ProductComposition
+    readonly events: Option.Option<ReadonlyArray<PropertyKey>>
+  }
+  readonly capture: <Result>(visit: RequirementCapture<Result>) => Result
+}
+
+export type RequirementCapture<Result> = <
+  Comp extends ProductComposition,
+  Statement extends string,
+>(
+  requirement: RequirementClass<Comp, Statement>,
+) => Result
+
+export interface RequirementManifest<Comp extends ProductComposition, Statement extends string> {
   readonly kind: 'ProductRequirement'
   readonly name: Statement
   readonly statement: Statement
   readonly composition: Comp
-  readonly events: Option.Option<ReadonlyArray<keyof EventsOf<ContractOf<Comp>>>>
+  readonly events: Option.Option<ReadonlyArray<EventNamesOf<ContractOf<Comp>>>>
 }
 
-export interface RequirementClass<Comp extends AnyComposition, Statement extends string> {
-  new (): {}
+export interface RequirementClass<
+  Comp extends ProductComposition,
+  Statement extends string,
+> extends AnyRequirementClass {
   readonly manifest: RequirementManifest<Comp, Statement>
+  readonly [RequirementCompositionTypeId]: (composition: Comp) => Comp
 }
 
-export interface ProductManifest<Comp extends AnyComposition> {
+export interface ProductManifest<Comp extends ProductComposition> {
   readonly kind: 'Product'
   readonly name: string
   readonly composition: Comp
-  readonly requirements: ReadonlyArray<RequirementClass<Comp, string>>
+  readonly requirements: ReadonlyArray<AnyRequirementClass>
 }
 
-export interface ProductClass<Comp extends AnyComposition = AnyComposition> {
+export interface ProductClass<Comp extends ProductComposition = ProductComposition> {
   new (): {}
   readonly manifest: ProductManifest<Comp>
 }
 
-interface MakeRequirementOptionsExternalApi<Comp extends AnyComposition> {
-  readonly events?: ReadonlyArray<keyof EventsOf<ContractOf<Comp>>>
+interface MakeRequirementOptionsExternalApi<Comp extends ProductComposition> {
+  readonly events?: ReadonlyArray<EventNamesOf<ContractOf<Comp>>>
 }
 
-const makeRequirement = <Comp extends AnyComposition, const Statement extends string>(
+const makeRequirement = <Comp extends ProductComposition, const Statement extends string>(
   composition: Comp,
   statement: Statement,
   options?: MakeRequirementOptionsExternalApi<Comp>,
@@ -46,20 +71,24 @@ const makeRequirement = <Comp extends AnyComposition, const Statement extends st
     composition,
     events: Option.fromNullable(options?.events),
   }
-  return class {
+  class Requirement {
     static readonly manifest = manifest
+    static readonly [RequirementCompositionTypeId] = (exact: Comp): Comp => exact
+    static readonly capture = <Result>(visit: RequirementCapture<Result>): Result =>
+      visit(Requirement)
   }
+  return Requirement
 }
 
 export const ProductRequirement: { readonly make: typeof makeRequirement } = {
   make: makeRequirement,
 }
 
-interface MakeProductConfig<Comp extends AnyComposition> {
+interface MakeProductConfig<Comp extends ProductComposition> {
   readonly requirements: ReadonlyArray<RequirementClass<Comp, string>>
 }
 
-const makeProduct = <Comp extends AnyComposition>(
+const makeProduct = <Comp extends ProductComposition>(
   composition: Comp,
   config: MakeProductConfig<Comp>,
 ): ProductClass<Comp> => {
@@ -74,4 +103,6 @@ const makeProduct = <Comp extends AnyComposition>(
   }
 }
 
-export const Product: { readonly make: typeof makeProduct } = { make: makeProduct }
+export const Product: { readonly make: typeof makeProduct } = {
+  make: makeProduct,
+}

package/src/proofCase.ts

@@ -0,0 +1,46 @@
+import type { Effect } from 'effect'
+import type { YieldWrap } from 'effect/Utils'
+import type { CapturedScene, UiContract } from '@playfast/reform'
+import type { Facade } from './facade'
+import type { ProductComposition, RequirementClass } from './product'
+
+export type ProofGenerator = Generator<YieldWrap<Effect.Effect<unknown, unknown, never>>, void, unknown>
+
+export interface ProofCase<
+  Comp extends ProductComposition,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+> {
+  readonly requirement: RequirementClass<Comp, string>
+  readonly scene: CapturedScene<C, S, Services, P, N, Identity>
+  readonly placement: 'Root' | 'Slot'
+  readonly body: (app: Facade<C, never>) => ProofGenerator
+}
+
+export type ProofCapture<Result> = <
+  Comp extends ProductComposition,
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+>(
+  proof: ProofCase<Comp, C, S, Services, P, N, Identity>,
+) => Result
+
+export interface ProofResult {
+  readonly requirement: string
+  readonly ok: boolean
+  readonly error: string | undefined
+}
+
+export interface SuiteResult {
+  readonly product: string
+  readonly results: ReadonlyArray<ProofResult>
+  readonly ok: boolean
+}