@playfast/reform-proof 0.0.7 → 0.0.8

package/src/index.ts

@@ -0,0 +1,301 @@
+import { Effect } from 'effect'
+import type { YieldWrap } from 'effect/Utils'
+import { AssertionFailed } from './errors'
+import { ProofRunner, type ProofRunnerApi, proofRunnerLayer, withProofRunner } from './runner'
+import type {
+  CompositionClass,
+  CompositionService,
+  Scene,
+  SlotInstance,
+  Trigger,
+  UiCapture,
+  UiContract,
+} from '@playfast/reform'
+
+// 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 }
+export type { ProofRunnerApi }
+
+// ---------------------------------------------------------------------------
+// Definitions: ProductRequirement + Product
+// ---------------------------------------------------------------------------
+
+/** 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`.
+ */
+const makeRequirement = <Comp extends AnyComposition, const Statement extends string>(
+  composition: Comp,
+  statement: Statement,
+): RequirementClass<Comp, Statement> =>
+  Object.assign(class {}, {
+    manifest: { kind: 'ProductRequirement' as const, name: statement, statement, composition },
+  })
+
+export const ProductRequirement: { readonly make: typeof makeRequirement } = {
+  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 = <Comp extends AnyComposition>(
+  composition: Comp,
+  config: { readonly requirements: ReadonlyArray<RequirementClass<Comp, string>> },
+): ProductClass<Comp> =>
+  Object.assign(class {}, {
+    manifest: {
+      kind: 'Product' as const,
+      name: composition.manifest.name,
+      composition,
+      requirements: config.requirements,
+    },
+  })
+
+export const Product: { readonly make: typeof makeProduct } = { make: makeProduct }
+
+// ---------------------------------------------------------------------------
+// Assertions — Effect-returning matchers; a failed match fails the proof.
+// ---------------------------------------------------------------------------
+
+const deepEqual = (a: unknown, b: unknown): boolean =>
+  Object.is(a, b) || JSON.stringify(a) === JSON.stringify(b)
+
+const fail = (message: string): Effect.Effect<never> =>
+  Effect.sync(() => {
+    throw new AssertionFailed({ detail: message })
+  })
+
+export const expect = <A>(actual: A) => ({
+  toBe: (expected: A): Effect.Effect<void> =>
+    Object.is(actual, expected)
+      ? Effect.void
+      : fail(`expected ${JSON.stringify(actual)} to be ${JSON.stringify(expected)}`),
+  toEqual: (expected: A): Effect.Effect<void> =>
+    deepEqual(actual, expected)
+      ? Effect.void
+      : fail(`expected ${JSON.stringify(actual)} to equal ${JSON.stringify(expected)}`),
+  toContain: (expected: A extends ReadonlyArray<infer E> ? E : unknown): Effect.Effect<void> =>
+    Array.isArray(actual) && actual.some((item) => deepEqual(item, expected))
+      ? Effect.void
+      : fail(`expected ${JSON.stringify(actual)} to contain ${JSON.stringify(expected)}`),
+})
+
+// ---------------------------------------------------------------------------
+// Facade — a headless view over the live composition tree
+// ---------------------------------------------------------------------------
+
+// --- Contract projection: derive the facade's exact shape from a UI contract ---
+
+/** 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>
+}
+
+// ---------------------------------------------------------------------------
+// Proofs + suite
+// ---------------------------------------------------------------------------
+
+/** 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.
+ */
+const implement = <Comp extends AnyComposition>(
+  requirement: RequirementClass<Comp, string>,
+  scene: Scene<ContractOf<Comp>>,
+  body: (app: Facade<ContractOf<Comp>>) => ProofGenerator,
+): Proof => ({ requirement, scene, body: body as ProofBody })
+
+/** Compose proofs with the product whose requirements they prove. */
+const suite = (
+  product: ProductClass,
+  config: { readonly proofs: ReadonlyArray<Proof> },
+): ProofSuite => ({ kind: 'ProofSuite', product, proofs: config.proofs })
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === 'object' && value !== null
+
+/** Duck-type a `ProofSuite` among arbitrary module exports (the adapter's seam). */
+export const isProofSuite = (value: unknown): value is ProofSuite =>
+  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: ProofSuite): Promise<SuiteResult> =>
+  withProofRunner(async (runner: ProofRunnerApi) => {
+    const results: ProofResult[] = []
+    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) }
+  })
+
+// ---------------------------------------------------------------------------
+// Driver: step a proof for the editor's Test-play timeline
+// ---------------------------------------------------------------------------
+
+/** 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. */
+const driver = (proofSuite: ProofSuite): ReadonlyArray<ProofDriver> =>
+  proofSuite.proofs.map((proof) => ({
+    requirement: proof.requirement.manifest.statement,
+    run: () => withProofRunner((runner: ProofRunnerApi) => runner.driveProof(proof)),
+  }))
+
+export const Proof: {
+  readonly implement: typeof implement
+  readonly suite: typeof suite
+  readonly run: typeof run
+  readonly driver: typeof driver
+} = { implement, suite, run, driver }

package/src/runner.ts

@@ -0,0 +1,42 @@
+import { Context, Effect, Layer } from 'effect'
+import { driveProof, executeProof } from './engine'
+import type { DriveResult, Proof, ProofResult } from './index'
+
+// reform-proof runner — the injectable seam HOW a proof is executed. The proof
+// system depends on this layer rather than calling the engine directly, so the
+// execution strategy can be swapped (the vitest adapter resolves the same layer to
+// run each proof as a native test). The default layer is the headless engine in
+// ./engine; mirrors the Tag + Layer house style of reform's `CaptureSink` and
+// `Notifications` services.
+
+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>
+}
+
+const ProofRunnerBase: Context.TagClass<ProofRunner, 'reform-proof/ProofRunner', ProofRunnerApi> =
+  Context.Tag('reform-proof/ProofRunner')<ProofRunner, ProofRunnerApi>()
+
+/** 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.Layer<ProofRunner> = 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 = <A>(use: (runner: ProofRunnerApi) => Promise<A>): Promise<A> =>
+  Effect.runPromise(
+    ProofRunner.pipe(
+      Effect.flatMap((runner) => Effect.promise(() => use(runner))),
+      Effect.provide(proofRunnerLayer),
+    ),
+  )

package/dist/engine.d.ts

@@ -1,18 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,259 +0,0 @@
-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

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