@playfast/reform-proof 1.2.0 → 1.2.1

package/src/index.ts

@@ -1,17 +1,21 @@
-import { Array as Arr, Effect, Option, Record as Rec } from 'effect'
-import type { YieldWrap } from 'effect/Utils'
-import { AssertionFailed } from './errors'
-import { formatFingerprint } from './fingerprint'
+import { Effect, Layer, TestContext, type TestServices } from 'effect'
 import { ProofRunner, type ProofRunnerApi, proofRunnerLayer, withProofRunner } from './runner'
+import { isRecord } from './assert'
+import type { ContractOf, Facade, SlotsOf } from './facade'
+import type {
+  AnyRequirementClass,
+  ProductClass,
+  ProductComposition,
+  RequirementClass,
+} from './product'
+import type { ProofCapture, ProofCase, ProofGenerator, SuiteResult } from './proofCase'
 import type {
   CapturedScene,
   Scene,
   SlotComposition as ReformSlotComposition,
-  SlotContract as ReformSlotContract,
-  Trigger,
   UiContract,
 } from '@playfast/reform'
-import type { AnyComposition, AnyScene, CapturedRender } from '@playfast/reform/internal'
+import type { AnyScene, CapturedRender } from '@playfast/reform/internal'
 
 export { ProofRunner, proofRunnerLayer, withProofRunner }
 export type { ProofRunnerApi }
@@ -32,262 +36,27 @@ export type {
   Sink,
 } from './engine'
 
-export type ProductComposition = AnyComposition & { readonly identity: symbol }
-
-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<EventNamesOf<ContractOf<Comp>>>>
-}
-
-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 ProductComposition> {
-  readonly kind: 'Product'
-  readonly name: string
-  readonly composition: Comp
-  readonly requirements: ReadonlyArray<AnyRequirementClass>
-}
-
-export interface ProductClass<Comp extends ProductComposition = ProductComposition> {
-  new (): {}
-  readonly manifest: ProductManifest<Comp>
-}
-
-interface MakeRequirementOptionsExternalApi<Comp extends ProductComposition> {
-  readonly events?: ReadonlyArray<EventNamesOf<ContractOf<Comp>>>
-}
-
-const makeRequirement = <Comp extends ProductComposition, const Statement extends string>(
-  composition: Comp,
-  statement: Statement,
-  options?: MakeRequirementOptionsExternalApi<Comp>,
-): RequirementClass<Comp, Statement> => {
-  const manifest: RequirementManifest<Comp, Statement> = {
-    kind: 'ProductRequirement',
-    name: statement,
-    statement,
-    composition,
-    events: Option.fromNullable(options?.events),
-  }
-  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 ProductComposition> {
-  readonly requirements: ReadonlyArray<RequirementClass<Comp, string>>
-}
-
-const makeProduct = <Comp extends ProductComposition>(
-  composition: Comp,
-  config: MakeProductConfig<Comp>,
-): ProductClass<Comp> => {
-  const manifest: ProductManifest<Comp> = {
-    kind: 'Product',
-    name: composition.manifest.name,
-    composition,
-    requirements: config.requirements,
-  }
-  return class {
-    static readonly manifest = manifest
-  }
-}
-
-export const Product: { readonly make: typeof makeProduct } = {
-  make: makeProduct,
-}
-
-interface ComparePair {
-  readonly left: unknown
-  readonly right: unknown
-}
-
-const show = (subject: unknown): string => formatFingerprint(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
-
-export type EventsOf<C extends UiContract> = C extends {
-  readonly events: infer E extends NonNullable<UiContract['events']>
-}
-  ? E
-  : Readonly<Record<PropertyKey, never>>
-type EventNamesOf<C extends UiContract> = C extends {
-  readonly events: NonNullable<UiContract['events']>
-}
-  ? keyof EventsOf<C>
-  : never
-type SlotsOf<C extends UiContract> = C extends {
-  readonly slots: infer S extends NonNullable<UiContract['slots']>
-}
-  ? S
-  : Readonly<Record<PropertyKey, never>>
-type PayloadOf<T> = T extends Trigger<infer P> ? P : never
-export type ContractOf<Comp> = Comp extends {
-  readonly Contract: infer C extends UiContract
-}
-  ? C
-  : never
-type ContractOfSlot<S> = ReformSlotContract<S>
-
-export type ActionsOf<C extends UiContract, R = never> = C extends {
-  readonly events: NonNullable<UiContract['events']>
-}
-  ? {
-      readonly [K in keyof EventsOf<C>]: (
-        payload: PayloadOf<EventsOf<C>[K]>,
-      ) => Effect.Effect<C['props'], never, R>
-    }
-  : Readonly<Record<PropertyKey, never>>
-export type SlotFacadesOf<C extends UiContract, R = never> = C extends {
-  readonly slots: NonNullable<UiContract['slots']>
-}
-  ? {
-      readonly [K in keyof SlotsOf<C>]: SlotFacade<ContractOfSlot<SlotsOf<C>[K]>, R>
-    }
-  : Readonly<Record<PropertyKey, never>>
-
-export type Action<R = never> = (payload: unknown) => Effect.Effect<unknown, never, R>
-
-export interface Facade<C extends UiContract, R = never> {
-  readonly props: Effect.Effect<C['props'], never, R>
-  readonly expectProps: (partial: Partial<C['props']>) => Effect.Effect<void, never, R>
-  readonly actions: ActionsOf<C, R>
-  readonly slots: SlotFacadesOf<C, R>
-  readonly frame: Effect.Effect<void, never, R>
-}
-
-export interface SlotFacade<C extends UiContract, R = never> extends Facade<C, R> {
-  readonly first: Effect.Effect<Facade<C, R>, never, R>
-  readonly at: (index: number) => Effect.Effect<Facade<C, R>, never, R>
-  readonly all: Effect.Effect<ReadonlyArray<Facade<C, R>>, never, R>
-  readonly byKey: (key: string) => Effect.Effect<Facade<C, R>, never, R>
-  readonly where: (
-    predicate: (props: C['props']) => boolean,
-  ) => Effect.Effect<ReadonlyArray<Facade<C, R>>, never, R>
-  readonly count: Effect.Effect<number, never, R>
-}
-
-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 { Product, ProductRequirement } from './product'
+export type {
+  AnyRequirementClass,
+  ProductClass,
+  ProductComposition,
+  ProductManifest,
+  RequirementCapture,
+  RequirementClass,
+  RequirementManifest,
+} from './product'
+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: AnyRequirementClass
@@ -301,18 +70,6 @@ export interface ProofSuite {
   readonly proofs: ReadonlyArray<Proof>
 }
 
-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
-}
-
 const implement = <Comp extends ProductComposition>(
   requirement: RequirementClass<Comp, string>,
   scene: Scene<ContractOf<NoInfer<Comp>>, NoInfer<Comp>['States']>,
@@ -438,6 +195,32 @@ const driver = (proofSuite: ProofSuite): ReadonlyArray<ProofDriver> =>
     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
@@ -445,4 +228,6 @@ export const Proof: {
   readonly run: typeof run
   readonly runEffect: typeof runEffect
   readonly driver: typeof driver
-} = { implement, implementVia, suite, run, runEffect, driver }
+  readonly withTestClock: typeof withTestClock
+} = { implement, implementVia, suite, run, runEffect, driver, withTestClock }
+

package/src/product.ts

@@ -0,0 +1,108 @@
+import { Option } from 'effect'
+import type { AnyComposition } from '@playfast/reform/internal'
+import type { ContractOf, EventNamesOf } from './facade'
+
+export type ProductComposition = AnyComposition & { readonly identity: symbol }
+
+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<EventNamesOf<ContractOf<Comp>>>>
+}
+
+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 ProductComposition> {
+  readonly kind: 'Product'
+  readonly name: string
+  readonly composition: Comp
+  readonly requirements: ReadonlyArray<AnyRequirementClass>
+}
+
+export interface ProductClass<Comp extends ProductComposition = ProductComposition> {
+  new (): {}
+  readonly manifest: ProductManifest<Comp>
+}
+
+interface MakeRequirementOptionsExternalApi<Comp extends ProductComposition> {
+  readonly events?: ReadonlyArray<EventNamesOf<ContractOf<Comp>>>
+}
+
+const makeRequirement = <Comp extends ProductComposition, const Statement extends string>(
+  composition: Comp,
+  statement: Statement,
+  options?: MakeRequirementOptionsExternalApi<Comp>,
+): RequirementClass<Comp, Statement> => {
+  const manifest: RequirementManifest<Comp, Statement> = {
+    kind: 'ProductRequirement',
+    name: statement,
+    statement,
+    composition,
+    events: Option.fromNullable(options?.events),
+  }
+  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 ProductComposition> {
+  readonly requirements: ReadonlyArray<RequirementClass<Comp, string>>
+}
+
+const makeProduct = <Comp extends ProductComposition>(
+  composition: Comp,
+  config: MakeProductConfig<Comp>,
+): ProductClass<Comp> => {
+  const manifest: ProductManifest<Comp> = {
+    kind: 'Product',
+    name: composition.manifest.name,
+    composition,
+    requirements: config.requirements,
+  }
+  return class {
+    static readonly manifest = manifest
+  }
+}
+
+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
+}

package/src/test-clock.test.ts

@@ -0,0 +1,135 @@
+import { Duration, Effect, Layer, Schema as S } from 'effect'
+import {
+  Channel,
+  Composition,
+  Engine,
+  Event,
+  mount,
+  Procedure,
+  provide,
+  publish,
+  Reducer,
+  scene,
+  State,
+  StateGroup,
+  type Trigger,
+  Ui,
+  ui,
+} from '@playfast/reform'
+import { describe, expect, test } from 'vitest'
+import { Product, Proof, ProductRequirement, expect as proofExpect } from './index'
+
+// A scene's product timers live inside its procedures, on the real clock: a proof
+// could only observe one by waiting it out, which spends real seconds AND races the
+// runner (a fixed sleep past the timer assumes the woken fiber is scheduled before
+// the next read). `Proof.withTestClock` puts a virtual clock behind the scene so
+// `app.advance(...)` moves that time exactly, instantly, and only on demand.
+
+const FLASH = Duration.millis(1500)
+
+class FlashState extends State.make('flash', S.Boolean) {}
+class FlashStates extends StateGroup.make(FlashState) {}
+
+class Submitted extends Event.make('TCSubmitted', S.Struct({})) {}
+class FlashEnded extends Event.make('TCFlashEnded', S.Struct({})) {}
+
+class EndFlash extends Reducer.make('TCEndFlash', {
+  states: [FlashState],
+  events: [FlashEnded],
+}) {}
+const EndFlashLive = Reducer.live(EndFlash, () => false)
+
+class FlashLane extends Channel.make('TCFlashLane', { policy: { _tag: 'latest' } }) {}
+class FlashTimer extends Procedure.make('TCFlashTimer', {
+  events: [Submitted],
+  channel: FlashLane,
+}) {}
+// The product timer under test: a success flash that clears itself 1500ms later.
+const FlashTimerLive = Procedure.live(FlashTimer, function* () {
+  yield* Effect.sleep(FLASH)
+  yield* publish('Normal', Event.construct(FlashEnded, {}))
+})
+
+class FlashUi extends ui('TCFlash')<{
+  props: { flash: boolean }
+  events: { submit: Trigger<Record<string, never>> }
+}>() {}
+class Flash extends Composition.make('TCFlash', {
+  title: 'TCFlash',
+  states: [FlashStates],
+  events: [Submitted],
+  ui: FlashUi,
+})<Flash>() {}
+const FlashLive = Composition.live(Flash, function* () {
+  const flash = yield* StateGroup.select(FlashStates, 'flash')
+  const submit = yield* Event.trigger(Submitted)
+  return mount({ props: { flash }, slots: {}, events: { submit } })
+})
+
+const presentations = provide(FlashUi, Ui.make(FlashUi, () => null))
+const Views = FlashLive.pipe(Layer.provideMerge(presentations))
+const Logic = Layer.mergeAll(EndFlashLive, FlashTimerLive, Channel.live(FlashLane)).pipe(
+  Layer.provideMerge(Layer.mergeAll(Engine, StateGroup.live(FlashStates, { flash: true }))),
+)
+const App = Views.pipe(Layer.provideMerge(Logic))
+
+const VirtualScene = scene(Flash, { provide: [Proof.withTestClock(App)] })
+const RealScene = scene(Flash, { provide: [App] })
+
+class ClearsFlash extends ProductRequirement.make(Flash, 'clears the flash after the window', {
+  events: ['submit'],
+}) {}
+class FlashProduct extends Product.make(Flash, { requirements: [ClearsFlash] }) {}
+
+describe('Proof.withTestClock', () => {
+  test('app.advance elapses a product timer without spending real time', async () => {
+    const proof = Proof.implement(ClearsFlash, VirtualScene, function* (app) {
+      yield* proofExpect((yield* app.props).flash).toBe(true)
+      yield* app.actions.submit({})
+      // The timer is armed but no virtual time has passed, so the flash still shows.
+      // On the real clock this frame is a race; here it is a fact.
+      yield* proofExpect((yield* app.props).flash).toBe(true)
+      yield* app.advance(FLASH)
+      yield* proofExpect((yield* app.props).flash).toBe(false)
+    })
+
+    const startedAt = performance.now()
+    const result = await Proof.run(Proof.suite(FlashProduct, { proofs: [proof] }))
+    const elapsed = performance.now() - startedAt
+
+    expect(result.results.map((entry) => entry.error)).toEqual([undefined])
+    expect(result.ok).toBe(true)
+    // The assertion that matters: 1500ms of product time cost a fraction of it in
+    // real time. Generous enough not to flake on a loaded runner, tight enough that
+    // a regression to the real clock (>= 1500ms) fails here.
+    expect(elapsed).toBeLessThan(750)
+  })
+
+  test('the timer does not fire on its own — only advancing moves it', async () => {
+    // The complement of the test above: if the virtual clock were a no-op and the
+    // procedure were really sleeping on the wall clock, this proof would go green the
+    // moment the settle loop outlasted the window. It must stay red instead.
+    const proof = Proof.implement(ClearsFlash, VirtualScene, function* (app) {
+      yield* app.actions.submit({})
+      yield* app.frame
+      yield* app.frame
+      yield* proofExpect((yield* app.props).flash).toBe(false)
+    })
+
+    const result = await Proof.run(Proof.suite(FlashProduct, { proofs: [proof] }))
+
+    expect(result.ok).toBe(false)
+  })
+
+  test('app.advance against the real clock dies rather than silently no-opping', async () => {
+    const proof = Proof.implement(ClearsFlash, RealScene, function* (app) {
+      yield* app.actions.submit({})
+      yield* app.advance(FLASH)
+    })
+
+    const result = await Proof.run(Proof.suite(FlashProduct, { proofs: [proof] }))
+
+    expect(result.ok).toBe(false)
+    expect(result.results[0]?.error).toContain('Proof.withTestClock')
+  })
+})