@playfast/proof 0.0.1

package/dist/cjs/errors.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownSlot = exports.UnknownAction = exports.AssertionFailed = void 0;
+const effect_1 = require("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.
+ */
+/** An `expect(...)` matcher did not hold. */
+class AssertionFailed extends effect_1.Data.TaggedError('reform-proof/AssertionFailed') {
+    get message() {
+        return `reform-proof: assertion failed — ${this.detail}`;
+    }
+}
+exports.AssertionFailed = AssertionFailed;
+/** A proof referenced an action the rendered composition never exposed. */
+class UnknownAction extends effect_1.Data.TaggedError('reform-proof/UnknownAction') {
+    get message() {
+        return `reform-proof: '${this.composition}' has no action '${this.action}' (rendered ${this.rendered} instance(s))`;
+    }
+}
+exports.UnknownAction = UnknownAction;
+/** A proof navigated into a slot the parent composition does not declare. */
+class UnknownSlot extends effect_1.Data.TaggedError('reform-proof/UnknownSlot') {
+    get message() {
+        return `reform-proof: '${this.parent}' has no slot '${this.slot}'`;
+    }
+}
+exports.UnknownSlot = UnknownSlot;

package/dist/cjs/index.js

@@ -0,0 +1,324 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Proof = exports.expect = exports.Product = exports.ProductRequirement = void 0;
+const effect_1 = require("effect");
+const Utils_1 = require("effect/Utils");
+const react_1 = require("react");
+const errors_js_1 = require("./errors.js");
+const reform_1 = require("reform");
+/**
+ * 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 },
+});
+exports.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,
+    },
+});
+exports.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_1.Effect.sync(() => {
+    throw new errors_js_1.AssertionFailed({ detail: message });
+});
+const expect = (actual) => ({
+    toBe: (expected) => Object.is(actual, expected)
+        ? effect_1.Effect.void
+        : fail(`expected ${JSON.stringify(actual)} to be ${JSON.stringify(expected)}`),
+    toEqual: (expected) => deepEqual(actual, expected)
+        ? effect_1.Effect.void
+        : fail(`expected ${JSON.stringify(actual)} to equal ${JSON.stringify(expected)}`),
+    toContain: (expected) => Array.isArray(actual) && actual.some((item) => deepEqual(item, expected))
+        ? effect_1.Effect.void
+        : fail(`expected ${JSON.stringify(actual)} to contain ${JSON.stringify(expected)}`),
+});
+exports.expect = expect;
+// 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_1.Effect.yieldNow().pipe(effect_1.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) => effect_1.Layer.merge(a, b));
+    return effect_1.Layer.provideMerge(sceneLayer, effect_1.Layer.succeed(reform_1.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 (!(0, react_1.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) => (0, reform_1.isFeatureBinding)(child) ? child.composition : child;
+    const collect = (comp) => effect_1.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_1.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* reform_1.Composition.render(service, env);
+            drive(node, enqueueBy);
+        }
+        yield* renderLevel(next);
+    });
+    const renderTree = effect_1.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_1.Effect.gen(function* () {
+        if (remaining === 0)
+            return;
+        yield* settleDrain;
+        yield* effect_1.Effect.sleep(SETTLE_STEP);
+        yield* renderTree;
+        const current = fingerprint();
+        if (current === previous)
+            return;
+        yield* settleFrom(current, remaining - 1);
+    });
+    const settle = effect_1.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 errors_js_1.UnknownAction({ composition: name, action: event, rendered: capturesFor(name).length });
+        }
+        return trigger;
+    };
+    const nodeFacade = (name, index, comp) => ({
+        props: effect_1.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_1.Effect.flatMap(() => effect_1.Effect.sync(() => triggerOf(name, index, event)(payload))), effect_1.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 errors_js_1.UnknownSlot({ parent: uiNameOf(parent), slot: slotName });
+        }
+        const childName = uiNameOf(child);
+        const at = (index) => effect_1.Effect.as(renderTree, nodeFacade(childName, index, child));
+        const first = nodeFacade(childName, 0, child);
+        return {
+            first: at(0),
+            at,
+            all: effect_1.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 };
+};
+/**
+ * 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) => ({ product, proofs: config.proofs });
+/**
+ * Run every proof against a fresh runtime, returning per-requirement results.
+ * Each proof gets its own environment, so nothing leaks between proofs.
+ */
+const run = async (proofSuite) => {
+    const results = [];
+    for (const proof of proofSuite.proofs) {
+        const sink = makeSink();
+        const runtime = effect_1.ManagedRuntime.make(proofLayer(proof.scene, sink));
+        try {
+            const { facade, settle } = makeFacade(runtime, proof.scene.composition, sink);
+            // Boot the scene as the host would, then settle before the proof drives.
+            await runtime.runPromise(effect_1.Effect.forEach(proof.scene.boot ?? [], (event) => (0, reform_1.publish)('High', event)).pipe(effect_1.Effect.flatMap(() => settle)));
+            await runtime.runPromise(effect_1.Effect.gen(() => proof.body(facade)));
+            results.push({ requirement: proof.requirement.manifest.statement, ok: true });
+        }
+        catch (error) {
+            results.push({
+                requirement: proof.requirement.manifest.statement,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            await runtime.dispose();
+        }
+    }
+    return { product: proofSuite.product.manifest.name, results, ok: results.every((r) => r.ok) };
+};
+/**
+ * Drive one proof a step at a time, recording a `StepFrame` after each yielded
+ * effect settles. Reuses the same makeFacade runtime/facade/settle as `run`,
+ * 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.
+ */
+const driveProof = async (proof) => {
+    const sink = makeSink();
+    const runtime = effect_1.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_1.Effect.forEach(proof.scene.boot ?? [], (event) => (0, reform_1.publish)('High', event)).pipe(effect_1.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((0, Utils_1.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();
+    }
+};
+/** A driver per proof in the suite — the editor's Test-play entry point. */
+const driver = (proofSuite) => proofSuite.proofs.map((proof) => ({
+    requirement: proof.requirement.manifest.statement,
+    run: () => driveProof(proof),
+}));
+exports.Proof = { implement, suite, run, driver };

package/dist/cjs/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "sideEffects": []
+}

package/dist/dts/errors.d.ts

@@ -0,0 +1,37 @@
+declare const AssertionFailed_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "reform-proof/AssertionFailed";
+} & Readonly<A>;
+/**
+ * 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.
+ */
+/** An `expect(...)` matcher did not hold. */
+export declare class AssertionFailed extends AssertionFailed_base<{
+    readonly detail: string;
+}> {
+    get message(): string;
+}
+declare const UnknownAction_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "reform-proof/UnknownAction";
+} & Readonly<A>;
+/** A proof referenced an action the rendered composition never exposed. */
+export declare class UnknownAction extends UnknownAction_base<{
+    readonly composition: string;
+    readonly action: string;
+    readonly rendered: number;
+}> {
+    get message(): string;
+}
+declare const UnknownSlot_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "reform-proof/UnknownSlot";
+} & Readonly<A>;
+/** A proof navigated into a slot the parent composition does not declare. */
+export declare class UnknownSlot extends UnknownSlot_base<{
+    readonly parent: string;
+    readonly slot: string;
+}> {
+    get message(): string;
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/dts/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":";;;AAEA;;;;GAIG;AAEH,6CAA6C;AAC7C,qBAAa,eAAgB,SAAQ,qBAAiD;IACpF,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,2EAA2E;AAC3E,qBAAa,aAAc,SAAQ,mBAA+C;IAChF,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF;;;;AAED,6EAA6E;AAC7E,qBAAa,WAAY,SAAQ,iBAA6C;IAC5E,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CACtB,CAAC;IACA,IAAa,OAAO,IAAI,MAAM,CAE7B;CACF"}

package/dist/dts/index.d.ts

@@ -0,0 +1,139 @@
+import { Effect } from 'effect';
+import { type YieldWrap } from 'effect/Utils';
+import { type CompositionClass, type CompositionService, type Scene, type SlotInstance, type Trigger, type UiCapture, type UiContract } from 'reform';
+/** 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>;
+}
+export declare const ProductRequirement: {
+    make: <Comp extends AnyComposition, const Statement extends string>(composition: Comp, statement: Statement) => RequirementClass<Comp, Statement>;
+};
+export declare const Product: {
+    make: <Comp extends AnyComposition>(composition: Comp, config: {
+        readonly requirements: ReadonlyArray<RequirementClass<Comp, string>>;
+    }) => ProductClass<Comp>;
+};
+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>;
+}
+/** An erased facade — the runtime shape before the contract type is re-attached. */
+type AnyFacade = Facade<UiContract>;
+/** The generator a proof body produces — its yielded effects run on the engine. */
+type ProofGenerator = Generator<YieldWrap<Effect.Effect<unknown, unknown, CompositionService>>, void, unknown>;
+/** 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 {
+    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;
+}
+/** 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>;
+}
+export declare const Proof: {
+    implement: <Comp extends AnyComposition>(requirement: RequirementClass<Comp, string>, scene: Scene<ContractOf<Comp>>, body: (app: Facade<ContractOf<Comp>>) => ProofGenerator) => Proof;
+    suite: (product: ProductClass, config: {
+        readonly proofs: ReadonlyArray<Proof>;
+    }) => ProofSuite;
+    run: (proofSuite: ProofSuite) => Promise<SuiteResult>;
+    driver: (proofSuite: ProofSuite) => ReadonlyArray<ProofDriver>;
+};
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/dts/index.d.ts.map

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

package/dist/esm/errors.js

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

package/dist/esm/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAA;AAE7B;;;;GAIG;AAEH,6CAA6C;AAC7C,MAAM,OAAO,eAAgB,SAAQ,IAAI,CAAC,WAAW,CAAC,8BAA8B,CAElF;IACA,IAAa,OAAO;QAClB,OAAO,oCAAoC,IAAI,CAAC,MAAM,EAAE,CAAA;IAC1D,CAAC;CACF;AAED,2EAA2E;AAC3E,MAAM,OAAO,aAAc,SAAQ,IAAI,CAAC,WAAW,CAAC,4BAA4B,CAI9E;IACA,IAAa,OAAO;QAClB,OAAO,kBAAkB,IAAI,CAAC,WAAW,oBAAoB,IAAI,CAAC,MAAM,eAAe,IAAI,CAAC,QAAQ,eAAe,CAAA;IACrH,CAAC;CACF;AAED,6EAA6E;AAC7E,MAAM,OAAO,WAAY,SAAQ,IAAI,CAAC,WAAW,CAAC,0BAA0B,CAG1E;IACA,IAAa,OAAO;QAClB,OAAO,kBAAkB,IAAI,CAAC,MAAM,kBAAkB,IAAI,CAAC,IAAI,GAAG,CAAA;IACpE,CAAC;CACF"}

package/dist/esm/index.js

@@ -0,0 +1,321 @@
+import { Effect, Layer, ManagedRuntime } from 'effect';
+import { yieldWrapGet } from 'effect/Utils';
+import { isValidElement } from 'react';
+import { AssertionFailed, UnknownAction, UnknownSlot } from './errors.js';
+import { Bus, CaptureSink, Composition, isFeatureBinding, publish, } from 'reform';
+/**
+ * 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)}`),
+});
+// 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 };
+};
+/**
+ * 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) => ({ product, proofs: config.proofs });
+/**
+ * Run every proof against a fresh runtime, returning per-requirement results.
+ * Each proof gets its own environment, so nothing leaks between proofs.
+ */
+const run = async (proofSuite) => {
+    const results = [];
+    for (const proof of proofSuite.proofs) {
+        const sink = makeSink();
+        const runtime = ManagedRuntime.make(proofLayer(proof.scene, sink));
+        try {
+            const { facade, settle } = makeFacade(runtime, proof.scene.composition, sink);
+            // Boot the scene as the host would, then settle before the proof drives.
+            await runtime.runPromise(Effect.forEach(proof.scene.boot ?? [], (event) => publish('High', event)).pipe(Effect.flatMap(() => settle)));
+            await runtime.runPromise(Effect.gen(() => proof.body(facade)));
+            results.push({ requirement: proof.requirement.manifest.statement, ok: true });
+        }
+        catch (error) {
+            results.push({
+                requirement: proof.requirement.manifest.statement,
+                ok: false,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            await runtime.dispose();
+        }
+    }
+    return { product: proofSuite.product.manifest.name, results, ok: results.every((r) => r.ok) };
+};
+/**
+ * Drive one proof a step at a time, recording a `StepFrame` after each yielded
+ * effect settles. Reuses the same makeFacade runtime/facade/settle as `run`,
+ * 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.
+ */
+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();
+    }
+};
+/** A driver per proof in the suite — the editor's Test-play entry point. */
+const driver = (proofSuite) => proofSuite.proofs.map((proof) => ({
+    requirement: proof.requirement.manifest.statement,
+    run: () => driveProof(proof),
+}));
+export const Proof = { implement, suite, run, driver };
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

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

package/dist/esm/package.json

@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "sideEffects": []
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@playfast/proof",
+  "version": "0.0.1",
+  "type": "module",
+  "sideEffects": [],
+  "license": "MIT",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/dts/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/dts/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "default": "./dist/cjs/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "effect": "*",
+    "react": "^19.0.0",
+    "@playfast/reform": "^0.0.1"
+  }
+}