@playfast/reform-proof 0.0.7

package/README.md

@@ -0,0 +1,87 @@
+<div align="center">
+
+# `@playfast/proof`
+
+**A headless testing toolkit for [reform](https://www.npmjs.com/package/@playfast/reform).**
+Drive a scene's compositions and assert on what they compute — deterministically, with no DOM, no timers, and no text matching.
+
+[![npm](https://img.shields.io/npm/v/@playfast/proof.svg)](https://www.npmjs.com/package/@playfast/proof)
+[![license](https://img.shields.io/npm/l/@playfast/proof.svg)](#license)
+[![built with Effect](https://img.shields.io/badge/built%20with-Effect-5a67d8.svg)](https://effect.website)
+
+</div>
+
+---
+
+A reform *scene* is renderer-neutral, so it can be exercised without a host. `@playfast/proof` runs that same scene against a capturing UI: it dispatches typed events, settles the engine, and lets you assert on the **props a composition computed** — pure data, never rendered markup. The scene you prove is the exact scene `@playfast/react` mounts, so there is no seam between a passing test and production behavior.
+
+## Install
+
+```sh
+bun add -d @playfast/proof @playfast/reform effect react
+```
+
+Peers: `effect`, `react` (`^19`), and `@playfast/reform`.
+
+## Quick start
+
+A proof binds a human-readable **requirement** to a composition, then implements it as a generator that drives the scene's `app` facade:
+
+```ts
+import { Layer } from 'effect'
+import { scene } from '@playfast/reform'
+import { Product, Proof, ProductRequirement, expect } from '@playfast/reform-proof'
+import { Counter } from './counter.compose'
+import { CounterLive } from './counter.layer'
+
+const CounterScene = scene(Counter, { provide: [CounterLive] })
+
+class Bumps extends ProductRequirement.make(Counter, 'bumps the count') {}
+
+const bumps = Proof.implement(Bumps, CounterScene, function* (app) {
+  yield* app.actions.bump({})         // dispatch a contract event, settle
+  const props = yield* app.props      // read what the composition computed
+  yield* expect(props.count).toBe(1)
+})
+
+const product = Product.make(Counter, { requirements: [Bumps] })
+const suite = Proof.suite(product, { proofs: [bumps] })
+
+const result = await Proof.run(suite)  // { product, results, ok }
+```
+
+## The workflow
+
+| step | API |
+| --- | --- |
+| Declare a requirement | `ProductRequirement.make(composition, statement)` |
+| Group requirements | `Product.make(composition, { requirements })` |
+| Implement a proof | `Proof.implement(requirement, scene, function* (app) { … })` |
+| Compose a suite | `Proof.suite(product, { proofs })` |
+| Run it | `Proof.run(suite) → Promise<SuiteResult>` |
+| Step it (for tooling) | `Proof.driver(suite) → ProofDriver[]` |
+
+The `statement` is a string-literal type, matched at `Proof.implement` so a requirement's name and its proof can never drift apart.
+
+## The facade
+
+Inside a proof body, `app` is a typed handle derived from the composition's UI contract:
+
+- `yield* app.actions.<event>(payload)` — dispatch a contract event and settle.
+- `yield* app.props` — re-render and return the latest computed props struct.
+- `yield* app.slots.<name>.first` / `.at(i)` / `.all` — descend into child composition facades; a slot used directly defaults to its first instance.
+- `yield* app.frame` — force a settle (re-render and wait for engine stability).
+
+Assertions are Effects: `expect(actual).toBe(…)`, `.toEqual(…)`, `.toContain(…)`. Mis-targeting a contract surfaces as a tagged failure — `UnknownAction`, `UnknownSlot`, or `AssertionFailed` — rather than an undefined read.
+
+## Why it's deterministic
+
+There is no real clock. `settle` cooperatively drains forked fibers and loops until the render tree reaches a two-frame fixpoint, so genuinely async flows (queries, procedures, remote state) resolve without flakiness from timing races. `Proof.driver` exposes the same run one frame at a time, capturing what each step saw — which is what powers the editor's test-play timeline.
+
+## The reform family
+
+Core [`@playfast/reform`](https://www.npmjs.com/package/@playfast/reform) · hosts [`@playfast/react`](https://www.npmjs.com/package/@playfast/react) / [`@playfast/react-native`](https://www.npmjs.com/package/@playfast/react-native) · forms [`@playfast/forms`](https://www.npmjs.com/package/@playfast/forms) + [`@playfast/forms-react`](https://www.npmjs.com/package/@playfast/forms-react)
+
+## License
+
+MIT

package/dist/engine.d.ts

@@ -0,0 +1,18 @@
+import type { DriveResult, Proof, ProofResult } from './index';
+/**
+ * Run one proof against a fresh runtime, returning its pass/fail result. Each
+ * proof gets its own isolated environment, so nothing leaks between proofs. Boots
+ * the scene as the host would, settles, then runs the proof body to completion.
+ */
+export declare const executeProof: (proof: Proof) => Promise<ProofResult>;
+/**
+ * Drive one proof a step at a time, recording a `StepFrame` after each yielded
+ * effect settles. Reuses the same makeFacade runtime/facade/settle as
+ * `executeProof`, but instead of handing the body to `Effect.gen` (which runs it
+ * to completion), it pumps the generator by hand — `gen.next(value)` yields the
+ * next effect, we run it on the live runtime, snapshot the sink, and feed the
+ * result back. So the editor gets the per-step timeline with no change to the
+ * proof authoring API.
+ */
+export declare const driveProof: (proof: Proof) => Promise<DriveResult>;
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.d.ts","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAU,WAAW,EAAU,KAAK,EAAE,WAAW,EAAyB,MAAM,SAAS,CAAA;AA0PrG;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAU,OAAO,KAAK,KAAG,OAAO,CAAC,WAAW,CAqBpE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,GAAU,OAAO,KAAK,KAAG,OAAO,CAAC,WAAW,CAkClE,CAAA"}

package/dist/engine.js

@@ -0,0 +1,259 @@
+import { Effect, Layer, ManagedRuntime } from 'effect';
+import { yieldWrapGet } from 'effect/Utils';
+import { isValidElement } from 'react';
+import { UnknownAction, UnknownSlot } from './errors';
+import { Bus, CaptureSink, Composition, isFeatureBinding, publish, } from '@playfast/reform';
+// The drain loop, channels, RPC, and reducers run on forked fibers, so a
+// dispatched event takes an unknown number of ticks to flow through. Each poll
+// first drains COOPERATIVELY — a burst of `yieldNow` lets those forked fibers
+// cascade (event → channel → procedure → in-memory RPC → fact → reducer) with no
+// real time — so a synchronous flow reaches its final state within one poll. A
+// real-time `sleep` is still paid each poll to remain the correctness authority
+// for a genuinely time-delayed client (the cooperative drain alone could read a
+// flow waiting on a real timer as falsely "stable" and settle early). The render
+// then re-runs until the captured tree stops changing, bounded so a stuck flow
+// fails fast instead of hanging.
+const SETTLE_DRAIN = 30;
+const SETTLE_STEP = '1 milli';
+const SETTLE_MAX_RENDERS = 100;
+/** Cooperatively run forked engine fibers to a fixpoint without advancing real time. */
+const settleDrain = Effect.yieldNow().pipe(Effect.repeatN(SETTLE_DRAIN));
+// A keyed view backed by a getter — the only place dynamic keys are needed.
+const keyed = (get) => {
+    const target = Object.create(null);
+    return new Proxy(target, { get: (_t, key) => get(String(key)) });
+};
+const uiNameOf = (comp) => comp.manifest.ui.manifest.name;
+const makeSink = () => {
+    // A const holder whose array we swap on reset (no reassigned binding).
+    const state = { captures: [] };
+    return {
+        api: { record: (capture) => state.captures.push(capture) },
+        get captures() {
+            return state.captures;
+        },
+        reset: () => {
+            state.captures = [];
+        },
+    };
+};
+/**
+ * Build a proof's runtime layer: the scene's closed wiring with the capture sink
+ * merged in, so `Ui`'s `serviceOption(CaptureSink)` finds it and records each
+ * render (absent in production, the same layer renders to React). The scene's
+ * `provide` is typed to the host-read subset (`MountedServices`); a proof also
+ * resolves slot-binding tags (`CompositionClass`), which the same closed layer
+ * supplies at runtime — restate that broader `RuntimeServices` surface here. This
+ * is the one erasure boundary, the same seam the react host crosses when it reads
+ * a slot tag with the requirement erased.
+ */
+const proofLayer = (scene, sink) => {
+    const sceneLayer = scene.provide.reduce((a, b) => Layer.merge(a, b));
+    return Layer.provideMerge(sceneLayer, Layer.succeed(CaptureSink, sink.api));
+};
+/**
+ * Walk a rendered node tree and invoke any slot components it contains (JSX
+ * defers them to the host; headless we drive them ourselves), enqueuing the
+ * child each stands for. Slot components are matched by identity, so this never
+ * calls — and never needs hooks from — ordinary components.
+ */
+const drive = (node, enqueueBy) => {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            drive(child, enqueueBy);
+        return;
+    }
+    if (!isValidElement(node))
+        return;
+    if (node.type instanceof Function) {
+        const enqueue = enqueueBy.get(node.type);
+        if (enqueue !== undefined) {
+            enqueue(node.props);
+            return;
+        }
+    }
+    drive(node.props.children, enqueueBy);
+};
+const makeFacade = (runtime, root, sink) => {
+    // Slot bindings (`provide(slot, composition)`) are static, so resolve the
+    // whole child tree once, up front — keeping `renderTree` and slot navigation
+    // synchronous (no nested runtime drive).
+    const bindings = new Map();
+    // A slot's child is a plain composition or a `FeatureBinding`. A proof drives the
+    // composition the feature mounts; for a `default` feature that composition's logic
+    // is already live (its eager `.live` was merged into the scene by `provide`), so
+    // unwrapping is all that's needed. (Driving a `lazy` feature — load gap +
+    // placeholders — is the proof host's Part B increment; until then a scene wires
+    // features as `default`, the eagerly-resolvable form.)
+    const childComposition = (child) => isFeatureBinding(child) ? child.composition : child;
+    const collect = (comp) => Effect.gen(function* () {
+        for (const slotClass of Object.values(comp.manifest.slots ?? {})) {
+            if (bindings.has(slotClass))
+                continue;
+            const child = childComposition(yield* slotClass.tag);
+            bindings.set(slotClass, child);
+            yield* collect(child);
+        }
+    });
+    runtime.runSync(collect(root));
+    // One breadth-first render of the whole tree. Each view reports its
+    // `(props, events)` to the sink; each slot it renders enqueues a child (built
+    // on the next level), so a single sweep renders everything.
+    const renderLevel = (frontier) => Effect.gen(function* () {
+        if (frontier.length === 0)
+            return;
+        const next = [];
+        for (const { comp, props } of frontier) {
+            const service = yield* comp.tag;
+            // A slot renders to a deferred component (JSX `<slots.Item/>`); map each
+            // back to the child it stands for so the tree walk can enqueue it.
+            const enqueueBy = new Map();
+            const slots = {
+                slot: (name) => {
+                    const slotClass = comp.manifest.slots?.[name];
+                    const child = slotClass && bindings.get(slotClass);
+                    const component = () => null;
+                    if (child)
+                        enqueueBy.set(component, (childProps) => next.push({ comp: child, props: childProps }));
+                    return component;
+                },
+            };
+            const env = { props, tracker: { add: () => { } }, slots };
+            const node = yield* Composition.render(service, env);
+            drive(node, enqueueBy);
+        }
+        yield* renderLevel(next);
+    });
+    const renderTree = Effect.gen(function* () {
+        sink.reset();
+        yield* renderLevel([{ comp: root, props: {} }]);
+    });
+    const capturesFor = (name) => sink.captures.filter((capture) => capture.name === name);
+    // A cheap fingerprint of the rendered tree; when two successive renders match,
+    // the engine has stopped producing new state and the read is safe.
+    const fingerprint = () => JSON.stringify(sink.captures.map((capture) => [capture.name, capture.props]));
+    // Re-render until the tree is stable for two consecutive renders, or give up.
+    const settleFrom = (previous, remaining) => Effect.gen(function* () {
+        if (remaining === 0)
+            return;
+        yield* settleDrain;
+        yield* Effect.sleep(SETTLE_STEP);
+        yield* renderTree;
+        const current = fingerprint();
+        if (current === previous)
+            return;
+        yield* settleFrom(current, remaining - 1);
+    });
+    const settle = Effect.gen(function* () {
+        yield* settleDrain;
+        yield* renderTree;
+        yield* settleFrom(fingerprint(), SETTLE_MAX_RENDERS);
+    });
+    const triggerOf = (name, index, event) => {
+        const trigger = capturesFor(name)[index]?.events[event];
+        if (trigger === undefined) {
+            throw new UnknownAction({ composition: name, action: event, rendered: capturesFor(name).length });
+        }
+        return trigger;
+    };
+    const nodeFacade = (name, index, comp) => ({
+        props: Effect.map(renderTree, () => capturesFor(name)[index]?.props),
+        // `keyed` resolves event/slot names at runtime; cast the string-keyed proxy
+        // to the contract-typed surface. This is the one reflection boundary, the
+        // same seam as `definitionClass` — every name the proxy serves is a real
+        // contract member, so the cast is sound.
+        actions: keyed((event) => (payload) => renderTree.pipe(Effect.flatMap(() => Effect.sync(() => triggerOf(name, index, event)(payload))), Effect.flatMap(() => settle))),
+        slots: keyed((slotName) => slotFacade(comp, slotName)),
+        frame: settle,
+    });
+    const slotFacade = (parent, slotName) => {
+        const slotClass = parent.manifest.slots?.[slotName];
+        const child = slotClass && bindings.get(slotClass);
+        if (child === undefined) {
+            throw new UnknownSlot({ parent: uiNameOf(parent), slot: slotName });
+        }
+        const childName = uiNameOf(child);
+        const at = (index) => Effect.as(renderTree, nodeFacade(childName, index, child));
+        const first = nodeFacade(childName, 0, child);
+        return {
+            first: at(0),
+            at,
+            all: Effect.map(renderTree, () => capturesFor(childName).map((_capture, index) => nodeFacade(childName, index, child))),
+            // Used directly, a slot behaves as its first instance.
+            props: first.props,
+            actions: first.actions,
+            slots: first.slots,
+            frame: first.frame,
+        };
+    };
+    return { facade: nodeFacade(uiNameOf(root), 0, root), settle };
+};
+/**
+ * Run one proof against a fresh runtime, returning its pass/fail result. Each
+ * proof gets its own isolated environment, so nothing leaks between proofs. Boots
+ * the scene as the host would, settles, then runs the proof body to completion.
+ */
+export const executeProof = async (proof) => {
+    const sink = makeSink();
+    const runtime = ManagedRuntime.make(proofLayer(proof.scene, sink));
+    try {
+        const { facade, settle } = makeFacade(runtime, proof.scene.composition, sink);
+        await runtime.runPromise(Effect.forEach(proof.scene.boot ?? [], (event) => publish('High', event)).pipe(Effect.flatMap(() => settle)));
+        await runtime.runPromise(Effect.gen(() => proof.body(facade)));
+        return { requirement: proof.requirement.manifest.statement, ok: true };
+    }
+    catch (error) {
+        return {
+            requirement: proof.requirement.manifest.statement,
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    finally {
+        await runtime.dispose();
+    }
+};
+/**
+ * Drive one proof a step at a time, recording a `StepFrame` after each yielded
+ * effect settles. Reuses the same makeFacade runtime/facade/settle as
+ * `executeProof`, but instead of handing the body to `Effect.gen` (which runs it
+ * to completion), it pumps the generator by hand — `gen.next(value)` yields the
+ * next effect, we run it on the live runtime, snapshot the sink, and feed the
+ * result back. So the editor gets the per-step timeline with no change to the
+ * proof authoring API.
+ */
+export const driveProof = async (proof) => {
+    const sink = makeSink();
+    const runtime = ManagedRuntime.make(proofLayer(proof.scene, sink));
+    const frames = [];
+    const statement = proof.requirement.manifest.statement;
+    try {
+        const { facade, settle } = makeFacade(runtime, proof.scene.composition, sink);
+        await runtime.runPromise(Effect.forEach(proof.scene.boot ?? [], (event) => publish('High', event)).pipe(Effect.flatMap(() => settle)));
+        frames.push({ index: 0, captures: [...sink.captures] });
+        const generator = proof.body(facade);
+        // Pump the generator: run each yielded effect on the runtime, snapshot, recur.
+        const pump = async (input, index) => {
+            const step = generator.next(input);
+            if (step.done === true)
+                return;
+            const value = await runtime.runPromise(yieldWrapGet(step.value));
+            frames.push({ index, captures: [...sink.captures] });
+            await pump(value, index + 1);
+        };
+        await pump(undefined, 1);
+        return { requirement: statement, frames, ok: true };
+    }
+    catch (error) {
+        return {
+            requirement: statement,
+            frames,
+            ok: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+    finally {
+        await runtime.dispose();
+    }
+};
+//# sourceMappingURL=engine.js.map

package/dist/engine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.js","sourceRoot":"","sources":["../src/engine.ts"],"names":[],"mappings":"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"}

package/dist/errors.d.ts

@@ -0,0 +1,40 @@
+import { type Cause } from 'effect';
+/**
+ * Tagged errors for the proof harness. A failed assertion or a malformed proof
+ * navigation throws one of these — tagged and structured, never a bare `Error` —
+ * so a runner can distinguish an assertion failure from a harness misuse.
+ */
+/**
+ * The constructor shape `Data.TaggedError(tag)<A>` produces, named so the
+ * generated `.d.ts` can describe the `extends` base under `isolatedDeclarations`
+ * (which forbids an inferred expression in an extends clause).
+ */
+type TaggedErrorClass<Tag extends string, A extends Record<string, unknown>> = new (args: A) => Cause.YieldableError & {
+    readonly _tag: Tag;
+} & Readonly<A>;
+declare const AssertionFailedBase: TaggedErrorClass<'reform-proof/AssertionFailed', {
+    readonly detail: string;
+}>;
+/** An `expect(...)` matcher did not hold. */
+export declare class AssertionFailed extends AssertionFailedBase {
+    get message(): string;
+}
+declare const UnknownActionBase: TaggedErrorClass<'reform-proof/UnknownAction', {
+    readonly composition: string;
+    readonly action: string;
+    readonly rendered: number;
+}>;
+/** A proof referenced an action the rendered composition never exposed. */
+export declare class UnknownAction extends UnknownActionBase {
+    get message(): string;
+}
+declare const UnknownSlotBase: TaggedErrorClass<'reform-proof/UnknownSlot', {
+    readonly parent: string;
+    readonly slot: string;
+}>;
+/** A proof navigated into a slot the parent composition does not declare. */
+export declare class UnknownSlot extends UnknownSlotBase {
+    get message(): string;
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,KAAK,EAAQ,MAAM,QAAQ,CAAA;AAEzC;;;;GAIG;AAEH;;;;GAIG;AACH,KAAK,gBAAgB,CAAC,GAAG,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,KAC7E,IAAI,EAAE,CAAC,KACJ,KAAK,CAAC,cAAc,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAA;CAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAA;AAEhE,QAAA,MAAM,mBAAmB,EAAE,gBAAgB,CACzC,8BAA8B,EAC9B;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CACoD,CAAA;AAEjF,6CAA6C;AAC7C,qBAAa,eAAgB,SAAQ,mBAAmB;IACtD,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;AAED,QAAA,MAAM,iBAAiB,EAAE,gBAAgB,CACvC,4BAA4B,EAC5B;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAKpF,CAAA;AAEF,2EAA2E;AAC3E,qBAAa,aAAc,SAAQ,iBAAiB;IAClD,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;AAED,QAAA,MAAM,eAAe,EAAE,gBAAgB,CACrC,0BAA0B,EAC1B;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CACgD,CAAA;AAEpG,6EAA6E;AAC7E,qBAAa,WAAY,SAAQ,eAAe;IAC9C,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}

package/dist/errors.js

@@ -0,0 +1,23 @@
+import { Data } from 'effect';
+const AssertionFailedBase = (Data.TaggedError('reform-proof/AssertionFailed'));
+/** An `expect(...)` matcher did not hold. */
+export class AssertionFailed extends AssertionFailedBase {
+    get message() {
+        return `reform-proof: assertion failed — ${this.detail}`;
+    }
+}
+const UnknownActionBase = (Data.TaggedError('reform-proof/UnknownAction'));
+/** A proof referenced an action the rendered composition never exposed. */
+export class UnknownAction extends UnknownActionBase {
+    get message() {
+        return `reform-proof: '${this.composition}' has no action '${this.action}' (rendered ${this.rendered} instance(s))`;
+    }
+}
+const UnknownSlotBase = (Data.TaggedError('reform-proof/UnknownSlot'));
+/** A proof navigated into a slot the parent composition does not declare. */
+export class UnknownSlot extends UnknownSlotBase {
+    get message() {
+        return `reform-proof: '${this.parent}' has no slot '${this.slot}'`;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,IAAI,EAAE,MAAM,QAAQ,CAAA;AAiBzC,MAAM,mBAAmB,GAGrB,CAAA,IAAI,CAAC,WAAW,CAAC,8BAA8B,CAA8B,CAAA,CAAA;AAEjF,6CAA6C;AAC7C,MAAM,OAAO,eAAgB,SAAQ,mBAAmB;IACtD,IAAa,OAAO;QAClB,OAAO,oCAAoC,IAAI,CAAC,MAAM,EAAE,CAAA;IAC1D,CAAC;CACF;AAED,MAAM,iBAAiB,GAGnB,CAAA,IAAI,CAAC,WAAW,CAAC,4BAA4B,CAI/C,CAAA,CAAA;AAEF,2EAA2E;AAC3E,MAAM,OAAO,aAAc,SAAQ,iBAAiB;IAClD,IAAa,OAAO;QAClB,OAAO,kBAAkB,IAAI,CAAC,WAAW,oBAAoB,IAAI,CAAC,MAAM,eAAe,IAAI,CAAC,QAAQ,eAAe,CAAA;IACrH,CAAC;CACF;AAED,MAAM,eAAe,GAGjB,CAAA,IAAI,CAAC,WAAW,CAAC,0BAA0B,CAAqD,CAAA,CAAA;AAEpG,6EAA6E;AAC7E,MAAM,OAAO,WAAY,SAAQ,eAAe;IAC9C,IAAa,OAAO;QAClB,OAAO,kBAAkB,IAAI,CAAC,MAAM,kBAAkB,IAAI,CAAC,IAAI,GAAG,CAAA;IACpE,CAAC;CACF"}

package/dist/index.d.ts

@@ -0,0 +1,176 @@
+import { Effect } from 'effect';
+import type { YieldWrap } from 'effect/Utils';
+import { ProofRunner, type ProofRunnerApi, proofRunnerLayer, withProofRunner } from './runner';
+import type { CompositionClass, CompositionService, Scene, SlotInstance, Trigger, UiCapture, UiContract } from '@playfast/reform';
+export { ProofRunner, proofRunnerLayer, withProofRunner };
+export type { ProofRunnerApi };
+/** Any composition, used where the contract type is irrelevant. */
+type AnyComposition = CompositionClass<any, any>;
+export interface RequirementManifest<Comp extends AnyComposition, Statement extends string> {
+    readonly kind: 'ProductRequirement';
+    readonly name: Statement;
+    /** The human-readable behavioural statement; doubles as the manifest name. */
+    readonly statement: Statement;
+    /** The composition this requirement specifies — its contract types the facade. */
+    readonly composition: Comp;
+}
+export interface RequirementClass<Comp extends AnyComposition, Statement extends string> {
+    new (): {};
+    readonly manifest: RequirementManifest<Comp, Statement>;
+}
+export interface ProductManifest<Comp extends AnyComposition> {
+    readonly kind: 'Product';
+    readonly name: string;
+    readonly composition: Comp;
+    readonly requirements: ReadonlyArray<RequirementClass<Comp, string>>;
+}
+export interface ProductClass<Comp extends AnyComposition = AnyComposition> {
+    new (): {};
+    readonly manifest: ProductManifest<Comp>;
+}
+/**
+ * A named, human-readable behavioural statement bound to the composition it
+ * specifies. The composition types the proof facade; the statement's literal
+ * type is re-stated (and enforced) at `Proof.implement`.
+ */
+declare const makeRequirement: <Comp extends AnyComposition, const Statement extends string>(composition: Comp, statement: Statement) => RequirementClass<Comp, Statement>;
+export declare const ProductRequirement: {
+    readonly make: typeof makeRequirement;
+};
+/**
+ * Group a composition with the full list of requirements that specify it. The
+ * shared `Comp` type-checks that every requirement targets this composition.
+ */
+declare const makeProduct: <Comp extends AnyComposition>(composition: Comp, config: {
+    readonly requirements: ReadonlyArray<RequirementClass<Comp, string>>;
+}) => ProductClass<Comp>;
+export declare const Product: {
+    readonly make: typeof makeProduct;
+};
+export declare const expect: <A>(actual: A) => {
+    toBe: (expected: A) => Effect.Effect<void>;
+    toEqual: (expected: A) => Effect.Effect<void>;
+    toContain: (expected: A extends ReadonlyArray<infer E> ? E : unknown) => Effect.Effect<void>;
+};
+/** The event payloads of a contract, keyed by event name. */
+type EventsOf<C extends UiContract> = C extends {
+    events: infer E;
+} ? E : Record<never, never>;
+/** The slot instances of a contract, keyed by slot name. */
+type SlotsOf<C extends UiContract> = C extends {
+    slots: infer S;
+} ? S : Record<never, never>;
+/** The payload a trigger accepts. */
+type PayloadOf<T> = T extends Trigger<infer P> ? P : never;
+/** The UI contract a composition resolves. */
+export type ContractOf<Comp> = Comp extends CompositionClass<any, infer C> ? C : never;
+/** The child contract a slot stands for — the contract of the composition it holds. */
+type ContractOfSlot<S> = S extends SlotInstance<infer Comp> ? ContractOf<Comp> : never;
+/** The contract's events as facade actions: payload in, dispatch-and-settle Effect out. */
+export type ActionsOf<C extends UiContract> = {
+    readonly [K in keyof EventsOf<C>]: (payload: PayloadOf<EventsOf<C>[K]>) => Effect.Effect<void, never, CompositionService>;
+};
+/** The contract's slots as child facades, each typed by the child's own contract. */
+export type SlotFacadesOf<C extends UiContract> = {
+    readonly [K in keyof SlotsOf<C>]: SlotFacade<ContractOfSlot<SlotsOf<C>[K]>>;
+};
+/** The Effect a facade action returns: dispatch the event, then settle. */
+export type Action = (payload: unknown) => Effect.Effect<void, never, CompositionService>;
+/**
+ * The handle a proof drives — the same surface the production UI receives, fully
+ * typed from the composition's contract `C`: read state (`props`), trigger events
+ * (`actions`), reach children (`slots`), and wait for the next frame (`frame`).
+ * Each access yields a real Effect/SlotFacade against the running engine.
+ */
+export interface Facade<C extends UiContract> {
+    /** Re-render the tree and read the props this node last computed. */
+    readonly props: Effect.Effect<C['props'], never, CompositionService>;
+    /** The contract's events as callables; calling one dispatches and settles. */
+    readonly actions: ActionsOf<C>;
+    /** Child composition facades, keyed by slot name. */
+    readonly slots: SlotFacadesOf<C>;
+    /** Settle the engine and re-render — wait for the next stable frame. */
+    readonly frame: Effect.Effect<void, never, CompositionService>;
+}
+/** A slot may hold many instances (a list); it is also usable as its first one. */
+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>;
+}
+/** The generator a proof body produces — its yielded effects run on the engine. */
+type ProofGenerator = Generator<YieldWrap<Effect.Effect<unknown, unknown, CompositionService>>, void, unknown>;
+/** An erased facade — the runtime shape before the contract type is re-attached. */
+type AnyFacade = Facade<UiContract>;
+/** The erased body stored on a `Proof` value; `implement` types the contract in. */
+export type ProofBody = (app: AnyFacade) => ProofGenerator;
+export interface Proof {
+    readonly requirement: RequirementClass<AnyComposition, string>;
+    /** The scene this proof runs against: its closed wiring + boot events. */
+    readonly scene: Scene;
+    readonly body: ProofBody;
+}
+export interface ProofSuite {
+    /** Brand so adapters can duck-type a suite among a module's exports. */
+    readonly kind: 'ProofSuite';
+    readonly product: ProductClass;
+    readonly proofs: ReadonlyArray<Proof>;
+}
+export interface ProofResult {
+    readonly requirement: string;
+    readonly ok: boolean;
+    readonly error?: string;
+}
+export interface SuiteResult {
+    readonly product: string;
+    readonly results: ReadonlyArray<ProofResult>;
+    readonly ok: boolean;
+}
+/**
+ * Implement (prove) a requirement by driving the facade against a scene. A proof
+ * is a VALUE. The scene supplies the runtime (its closed `provide` + `boot`) and
+ * the composition that types the facade; its contract must equal the
+ * requirement's composition contract, so a scene for the wrong composition — or
+ * one whose contract has drifted — is a compile error. The `app` facade is fully
+ * typed from that contract.
+ */
+declare const implement: <Comp extends AnyComposition>(requirement: RequirementClass<Comp, string>, scene: Scene<ContractOf<Comp>>, body: (app: Facade<ContractOf<Comp>>) => ProofGenerator) => Proof;
+/** Compose proofs with the product whose requirements they prove. */
+declare const suite: (product: ProductClass, config: {
+    readonly proofs: ReadonlyArray<Proof>;
+}) => ProofSuite;
+/** Duck-type a `ProofSuite` among arbitrary module exports (the adapter's seam). */
+export declare const isProofSuite: (value: unknown) => value is ProofSuite;
+/**
+ * Run every proof against a fresh runtime, returning per-requirement results.
+ * Each proof gets its own environment, so nothing leaks between proofs. Execution
+ * goes through the injected `ProofRunner` (the headless engine by default).
+ */
+declare const run: (proofSuite: ProofSuite) => Promise<SuiteResult>;
+/** One step of a driven proof: the rendered tree captured right after the
+ *  proof's i-th yielded effect settled. Index 0 is the booted, pre-drive tree. */
+export interface StepFrame {
+    readonly index: number;
+    readonly captures: ReadonlyArray<UiCapture>;
+}
+export interface DriveResult {
+    readonly requirement: string;
+    readonly frames: ReadonlyArray<StepFrame>;
+    readonly ok: boolean;
+    readonly error?: string;
+}
+export interface ProofDriver {
+    readonly requirement: string;
+    /** Run the proof, snapshotting the captured tree after each yielded step. */
+    readonly run: () => Promise<DriveResult>;
+}
+/** A driver per proof in the suite — the editor's Test-play entry point. Each
+ *  `run` resolves the same `ProofRunner` layer and steps that proof. */
+declare const driver: (proofSuite: ProofSuite) => ReadonlyArray<ProofDriver>;
+export declare const Proof: {
+    readonly implement: typeof implement;
+    readonly suite: typeof suite;
+    readonly run: typeof run;
+    readonly driver: typeof driver;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C,OAAO,EAAE,WAAW,EAAE,KAAK,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAC9F,OAAO,KAAK,EACV,gBAAgB,EAChB,kBAAkB,EAClB,KAAK,EACL,YAAY,EACZ,OAAO,EACP,SAAS,EACT,UAAU,EACX,MAAM,kBAAkB,CAAA;AAazB,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,eAAe,EAAE,CAAA;AACzD,YAAY,EAAE,cAAc,EAAE,CAAA;AAM9B,mEAAmE;AACnE,KAAK,cAAc,GAAG,gBAAgB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;AAEhD,MAAM,WAAW,mBAAmB,CAAC,IAAI,SAAS,cAAc,EAAE,SAAS,SAAS,MAAM;IACxF,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAA;IACnC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,8EAA8E;IAC9E,QAAQ,CAAC,SAAS,EAAE,SAAS,CAAA;IAC7B,kFAAkF;IAClF,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAA;CAC3B;AAED,MAAM,WAAW,gBAAgB,CAAC,IAAI,SAAS,cAAc,EAAE,SAAS,SAAS,MAAM;IACrF,QAAQ,EAAE,CAAA;IACV,QAAQ,CAAC,QAAQ,EAAE,mBAAmB,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;CACxD;AAED,MAAM,WAAW,eAAe,CAAC,IAAI,SAAS,cAAc;IAC1D,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,EAAE,IAAI,CAAA;IAC1B,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAA;CACrE;AAED,MAAM,WAAW,YAAY,CAAC,IAAI,SAAS,cAAc,GAAG,cAAc;IACxE,QAAQ,EAAE,CAAA;IACV,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC,IAAI,CAAC,CAAA;CACzC;AAED;;;;GAIG;AACH,QAAA,MAAM,eAAe,GAAI,IAAI,SAAS,cAAc,EAAE,KAAK,CAAC,SAAS,SAAS,MAAM,EAClF,aAAa,IAAI,EACjB,WAAW,SAAS,KACnB,gBAAgB,CAAC,IAAI,EAAE,SAAS,CAG/B,CAAA;AAEJ,eAAO,MAAM,kBAAkB,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,eAAe,CAAA;CAEvE,CAAA;AAED;;;GAGG;AACH,QAAA,MAAM,WAAW,GAAI,IAAI,SAAS,cAAc,EAC9C,aAAa,IAAI,EACjB,QAAQ;IAAE,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAA;CAAE,KAC/E,YAAY,CAAC,IAAI,CAQhB,CAAA;AAEJ,eAAO,MAAM,OAAO,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,WAAW,CAAA;CAA0B,CAAA;AAcnF,eAAO,MAAM,MAAM,GAAI,CAAC,EAAE,QAAQ,CAAC;qBAChB,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;wBAIpB,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;0BAIrB,CAAC,SAAS,aAAa,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;CAI1F,CAAA;AAQF,6DAA6D;AAC7D,KAAK,QAAQ,CAAC,CAAC,SAAS,UAAU,IAAI,CAAC,SAAS;IAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;AAC9F,4DAA4D;AAC5D,KAAK,OAAO,CAAC,CAAC,SAAS,UAAU,IAAI,CAAC,SAAS;IAAE,KAAK,EAAE,MAAM,CAAC,CAAA;CAAE,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,EAAE,KAAK,CAAC,CAAA;AAC5F,qCAAqC;AACrC,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AAC1D,8CAA8C;AAC9C,MAAM,MAAM,UAAU,CAAC,IAAI,IAAI,IAAI,SAAS,gBAAgB,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;AACtF,uFAAuF;AACvF,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS,YAAY,CAAC,MAAM,IAAI,CAAC,GAAG,UAAU,CAAC,IAAI,CAAC,GAAG,KAAK,CAAA;AAEtF,2FAA2F;AAC3F,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,UAAU,IAAI;IAC5C,QAAQ,EAAE,CAAC,IAAI,MAAM,QAAQ,CAAC,CAAC,CAAC,GAAG,CACjC,OAAO,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAC/B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,kBAAkB,CAAC;CACpD,CAAA;AACD,qFAAqF;AACrF,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,UAAU,IAAI;IAChD,QAAQ,EAAE,CAAC,IAAI,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC5E,CAAA;AAED,2EAA2E;AAC3E,MAAM,MAAM,MAAM,GAAG,CAAC,OAAO,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAAA;AAEzF;;;;;GAKG;AACH,MAAM,WAAW,MAAM,CAAC,CAAC,SAAS,UAAU;IAC1C,qEAAqE;IACrE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAAA;IACpE,8EAA8E;IAC9E,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,CAAA;IAC9B,qDAAqD;IACrD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAA;IAChC,wEAAwE;IACxE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAAA;CAC/D;AAED,mFAAmF;AACnF,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,UAAU,CAAE,SAAQ,MAAM,CAAC,CAAC,CAAC;IACjE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAAA;IACnE,QAAQ,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAAA;IACnF,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,kBAAkB,CAAC,CAAA;CACjF;AAMD,mFAAmF;AACnF,KAAK,cAAc,GAAG,SAAS,CAC7B,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,kBAAkB,CAAC,CAAC,EAC9D,IAAI,EACJ,OAAO,CACR,CAAA;AAED,oFAAoF;AACpF,KAAK,SAAS,GAAG,MAAM,CAAC,UAAU,CAAC,CAAA;AAEnC,oFAAoF;AACpF,MAAM,MAAM,SAAS,GAAG,CAAC,GAAG,EAAE,SAAS,KAAK,cAAc,CAAA;AAE1D,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC,cAAc,EAAE,MAAM,CAAC,CAAA;IAC9D,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAA;IAC3B,QAAQ,CAAC,OAAO,EAAE,YAAY,CAAA;IAC9B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAA;CACtC;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,WAAW,CAAC,CAAA;IAC5C,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;CACrB;AAED;;;;;;;GAOG;AACH,QAAA,MAAM,SAAS,GAAI,IAAI,SAAS,cAAc,EAC5C,aAAa,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,EAC3C,OAAO,KAAK,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,EAC9B,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,KAAK,cAAc,KACtD,KAA0D,CAAA;AAE7D,qEAAqE;AACrE,QAAA,MAAM,KAAK,GACT,SAAS,YAAY,EACrB,QAAQ;IAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,KAAK,CAAC,CAAA;CAAE,KAChD,UAAsE,CAAA;AAKzE,oFAAoF;AACpF,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,UAC8B,CAAA;AAErF;;;;GAIG;AACH,QAAA,MAAM,GAAG,GAAI,YAAY,UAAU,KAAG,OAAO,CAAC,WAAW,CAOrD,CAAA;AAMJ;kFACkF;AAClF,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;CAC5C;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;IACzC,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,6EAA6E;IAC7E,QAAQ,CAAC,GAAG,EAAE,MAAM,OAAO,CAAC,WAAW,CAAC,CAAA;CACzC;AAED;wEACwE;AACxE,QAAA,MAAM,MAAM,GAAI,YAAY,UAAU,KAAG,aAAa,CAAC,WAAW,CAI7D,CAAA;AAEL,eAAO,MAAM,KAAK,EAAE;IAClB,QAAQ,CAAC,SAAS,EAAE,OAAO,SAAS,CAAA;IACpC,QAAQ,CAAC,KAAK,EAAE,OAAO,KAAK,CAAA;IAC5B,QAAQ,CAAC,GAAG,EAAE,OAAO,GAAG,CAAA;IACxB,QAAQ,CAAC,MAAM,EAAE,OAAO,MAAM,CAAA;CACK,CAAA"}

package/dist/index.js

@@ -0,0 +1,92 @@
+import { Effect } from 'effect';
+import { AssertionFailed } from './errors';
+import { ProofRunner, proofRunnerLayer, withProofRunner } from './runner';
+// reform-proof — the stability story for AI authorship. Product behaviour is
+// declared as human-readable requirements (the definition) and proven by tests
+// (the implementation), the same split as the rest of reform. A proof drives the
+// real reduce loop through a headless FACADE: no DOM, no text matching. It reads
+// the props each composition computed and calls the contract's events as
+// callbacks — exactly what the production UI receives. HOW a proof runs is the
+// injectable `ProofRunner` layer (./runner); the headless engine (./engine) is its
+// default. `Proof.run`/`Proof.driver` resolve that layer, so the vitest adapter
+// can drive the very same proofs as native tests.
+// The injectable execution seam is re-exported so adapters can resolve it.
+export { ProofRunner, proofRunnerLayer, withProofRunner };
+/**
+ * A named, human-readable behavioural statement bound to the composition it
+ * specifies. The composition types the proof facade; the statement's literal
+ * type is re-stated (and enforced) at `Proof.implement`.
+ */
+const makeRequirement = (composition, statement) => Object.assign(class {
+}, {
+    manifest: { kind: 'ProductRequirement', name: statement, statement, composition },
+});
+export const ProductRequirement = {
+    make: makeRequirement,
+};
+/**
+ * Group a composition with the full list of requirements that specify it. The
+ * shared `Comp` type-checks that every requirement targets this composition.
+ */
+const makeProduct = (composition, config) => Object.assign(class {
+}, {
+    manifest: {
+        kind: 'Product',
+        name: composition.manifest.name,
+        composition,
+        requirements: config.requirements,
+    },
+});
+export const Product = { make: makeProduct };
+// ---------------------------------------------------------------------------
+// Assertions — Effect-returning matchers; a failed match fails the proof.
+// ---------------------------------------------------------------------------
+const deepEqual = (a, b) => Object.is(a, b) || JSON.stringify(a) === JSON.stringify(b);
+const fail = (message) => Effect.sync(() => {
+    throw new AssertionFailed({ detail: message });
+});
+export const expect = (actual) => ({
+    toBe: (expected) => Object.is(actual, expected)
+        ? Effect.void
+        : fail(`expected ${JSON.stringify(actual)} to be ${JSON.stringify(expected)}`),
+    toEqual: (expected) => deepEqual(actual, expected)
+        ? Effect.void
+        : fail(`expected ${JSON.stringify(actual)} to equal ${JSON.stringify(expected)}`),
+    toContain: (expected) => Array.isArray(actual) && actual.some((item) => deepEqual(item, expected))
+        ? Effect.void
+        : fail(`expected ${JSON.stringify(actual)} to contain ${JSON.stringify(expected)}`),
+});
+/**
+ * Implement (prove) a requirement by driving the facade against a scene. A proof
+ * is a VALUE. The scene supplies the runtime (its closed `provide` + `boot`) and
+ * the composition that types the facade; its contract must equal the
+ * requirement's composition contract, so a scene for the wrong composition — or
+ * one whose contract has drifted — is a compile error. The `app` facade is fully
+ * typed from that contract.
+ */
+const implement = (requirement, scene, body) => ({ requirement, scene, body: body });
+/** Compose proofs with the product whose requirements they prove. */
+const suite = (product, config) => ({ kind: 'ProofSuite', product, proofs: config.proofs });
+const isRecord = (value) => typeof value === 'object' && value !== null;
+/** Duck-type a `ProofSuite` among arbitrary module exports (the adapter's seam). */
+export const isProofSuite = (value) => isRecord(value) && value['kind'] === 'ProofSuite' && Array.isArray(value['proofs']);
+/**
+ * Run every proof against a fresh runtime, returning per-requirement results.
+ * Each proof gets its own environment, so nothing leaks between proofs. Execution
+ * goes through the injected `ProofRunner` (the headless engine by default).
+ */
+const run = (proofSuite) => withProofRunner(async (runner) => {
+    const results = [];
+    for (const proof of proofSuite.proofs) {
+        results.push(await runner.executeProof(proof));
+    }
+    return { product: proofSuite.product.manifest.name, results, ok: results.every((r) => r.ok) };
+});
+/** A driver per proof in the suite — the editor's Test-play entry point. Each
+ *  `run` resolves the same `ProofRunner` layer and steps that proof. */
+const driver = (proofSuite) => proofSuite.proofs.map((proof) => ({
+    requirement: proof.requirement.manifest.statement,
+    run: () => withProofRunner((runner) => runner.driveProof(proof)),
+}));
+export const Proof = { implement, suite, run, driver };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/runner.d.ts

@@ -0,0 +1,22 @@
+import { Context, Layer } from 'effect';
+import type { DriveResult, Proof, ProofResult } from './index';
+export interface ProofRunnerApi {
+    /** Run a proof to completion, returning its pass/fail result. */
+    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>;
+}
+declare const ProofRunnerBase: Context.TagClass<ProofRunner, 'reform-proof/ProofRunner', ProofRunnerApi>;
+/** The service identity for the proof execution strategy. */
+export declare class ProofRunner extends ProofRunnerBase {
+}
+/** The default runner: the headless engine that drives the real reduce loop. */
+export declare const proofRunnerLayer: Layer.Layer<ProofRunner>;
+/**
+ * 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 declare const withProofRunner: <A>(use: (runner: ProofRunnerApi) => Promise<A>) => Promise<A>;
+export {};
+//# sourceMappingURL=runner.d.ts.map

package/dist/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAU,KAAK,EAAE,MAAM,QAAQ,CAAA;AAE/C,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAS9D,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,WAAW,CAAC,CAAA;IAC7D,wEAAwE;IACxE,QAAQ,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,WAAW,CAAC,CAAA;CAC5D;AAED,QAAA,MAAM,eAAe,EAAE,OAAO,CAAC,QAAQ,CAAC,WAAW,EAAE,0BAA0B,EAAE,cAAc,CACvB,CAAA;AAExE,6DAA6D;AAC7D,qBAAa,WAAY,SAAQ,eAAe;CAAG;AAEnD,gFAAgF;AAChF,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAGpD,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,KAAK,CAAC,MAAM,EAAE,cAAc,KAAK,OAAO,CAAC,CAAC,CAAC,KAAG,OAAO,CAAC,CAAC,CAMvF,CAAA"}

package/dist/runner.js

@@ -0,0 +1,18 @@
+import { Context, Effect, Layer } from 'effect';
+import { driveProof, executeProof } from './engine';
+const ProofRunnerBase = Context.Tag('reform-proof/ProofRunner')();
+/** 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.succeed(ProofRunner, {
+    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 = (use) => Effect.runPromise(ProofRunner.pipe(Effect.flatMap((runner) => Effect.promise(() => use(runner))), Effect.provide(proofRunnerLayer)));
+//# sourceMappingURL=runner.js.map

package/dist/runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.js","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAiBnD,MAAM,eAAe,GACnB,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,EAA+B,CAAA;AAExE,6DAA6D;AAC7D,MAAM,OAAO,WAAY,SAAQ,eAAe;CAAG;AAEnD,gFAAgF;AAChF,MAAM,CAAC,MAAM,gBAAgB,GAA6B,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE;IACnF,YAAY;IACZ,UAAU;CACX,CAAC,CAAA;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAI,GAA2C,EAAc,EAAE,CAC5F,MAAM,CAAC,UAAU,CACf,WAAW,CAAC,IAAI,CACd,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAC7D,MAAM,CAAC,OAAO,CAAC,gBAAgB,CAAC,CACjC,CACF,CAAA"}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@playfast/reform-proof",
+  "playbook": "./playbook",
+  "version": "0.0.7",
+  "type": "module",
+  "description": "Headless testing toolkit for reform — drive a scene's compositions and assert on the props they compute, with no DOM, timers, or text matching.",
+  "keywords": [
+    "reform",
+    "effect",
+    "testing",
+    "headless",
+    "proof"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/playfast/reform.git",
+    "directory": "packages/proof"
+  },
+  "bugs": {
+    "url": "https://github.com/playfast/reform/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./src/index.ts",
+    "./*": "./src/*.ts"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist .tsbuildinfo",
+    "check": "tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "lint": "oxlint src",
+    "lint:fix": "oxlint --fix src"
+  },
+  "peerDependencies": {
+    "effect": "*",
+    "react": "^19.0.0",
+    "@playfast/reform": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}