@playfast/reform-proof 1.2.1 → 1.4.0

package/dist/index.js

@@ -0,0 +1,73 @@
+import { Effect, Layer, TestContext } from 'effect';
+import { ProofRunner, proofRunnerLayer, withProofRunner } from './runner.js';
+import { isRecord } from './assert.js';
+export { ProofRunner, proofRunnerLayer, withProofRunner };
+export { makeFacade, makeProofFacade, makeRuntimeHandleFacade, makeRuntimeTreeFacade, makeSink, proofLayer, } from './engine.js';
+export { Product, ProductRequirement } from './product.js';
+export { expect, matchProps } from './assert.js';
+const implement = (requirement, scene, body) => scene.capture((exactScene) => {
+    const proofCase = {
+        requirement,
+        scene: exactScene,
+        placement: 'Root',
+        body,
+    };
+    return {
+        requirement,
+        scene: exactScene,
+        capture: (visit) => visit(proofCase),
+    };
+});
+const implementVia = (requirement, scene, body) => scene.capture((exactScene) => {
+    const proofCase = {
+        requirement,
+        scene: exactScene,
+        placement: 'Slot',
+        body,
+    };
+    return {
+        requirement,
+        scene: exactScene,
+        capture: (visit) => visit(proofCase),
+    };
+});
+const suite = (product, config) => ({
+    kind: 'ProofSuite',
+    product,
+    proofs: config.proofs,
+});
+export const isProofSuite = (candidate) => isRecord(candidate) && candidate['kind'] === 'ProofSuite' && Array.isArray(candidate['proofs']);
+const run = (proofSuite) => Effect.runPromise(runEffect(proofSuite));
+const runEffect = (proofSuite) => ProofRunner.pipe(Effect.flatMap((runner) => Effect.forEach(proofSuite.proofs, (proof) => runner.executeProofEffect(proof))), Effect.map((reports) => ({
+    product: proofSuite.product.manifest.name,
+    results: reports,
+    ok: reports.every((report) => report.ok),
+})), Effect.provide(proofRunnerLayer));
+const driver = (proofSuite) => proofSuite.proofs.map((proof) => ({
+    requirement: proof.requirement.manifest.statement,
+    run: () => withProofRunner((runner) => runner.driveProof(proof)),
+}));
+/**
+ * Wrap a scene's layers in a virtual clock, so every `Effect.sleep`, `Schedule` and
+ * `Clock` read its procedures make elapses only when the proof says so via
+ * `app.advance(...)`:
+ *
+ * ```ts
+ * const MyScene = scene(MyComposition, { provide: [Proof.withTestClock(App)] })
+ * ```
+ *
+ * It has to WRAP the scene's layers, never sit beside them in `provide`. The engine
+ * forks its loop while its layer is being built, and a forked fiber inherits the
+ * clock in scope at that moment — so a clock merged as a sibling reaches the proof
+ * body but not the procedures whose timers it is meant to control. That mis-wiring
+ * is silent (`app.advance(...)` finds a clock, adjusts it, and no product timer
+ * moves), which is why the clock is exposed as this combinator, not a bare layer.
+ *
+ * Opt-in per scene rather than on by default: a scene without it keeps the real
+ * clock, so proofs that observe product timers by waiting stay correct. Once a scene
+ * has it, a product timer NEVER fires on its own — an unadvanced proof sees the
+ * pre-timer state, which is the point.
+ */
+const withTestClock = (layer) => layer.pipe(Layer.provideMerge(TestContext.TestContext));
+export const Proof = { implement, implementVia, suite, run, runEffect, driver, withTestClock };
+//# 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/product.d.ts

@@ -0,0 +1,56 @@
+import { Option } from 'effect';
+import type { AnyComposition } from '@playfast/reform/internal';
+import type { ContractOf, EventNamesOf } from './facade.js';
+export type ProductComposition = AnyComposition & {
+    readonly identity: symbol;
+};
+declare const RequirementCompositionTypeId: unique symbol;
+export interface AnyRequirementClass {
+    new (): {};
+    readonly manifest: {
+        readonly kind: 'ProductRequirement';
+        readonly name: string;
+        readonly statement: string;
+        readonly composition: ProductComposition;
+        readonly events: Option.Option<ReadonlyArray<PropertyKey>>;
+    };
+    readonly capture: <Result>(visit: RequirementCapture<Result>) => Result;
+}
+export type RequirementCapture<Result> = <Comp extends ProductComposition, Statement extends string>(requirement: RequirementClass<Comp, Statement>) => Result;
+export interface RequirementManifest<Comp extends ProductComposition, Statement extends string> {
+    readonly kind: 'ProductRequirement';
+    readonly name: Statement;
+    readonly statement: Statement;
+    readonly composition: Comp;
+    readonly events: Option.Option<ReadonlyArray<EventNamesOf<ContractOf<Comp>>>>;
+}
+export interface RequirementClass<Comp extends ProductComposition, Statement extends string> extends AnyRequirementClass {
+    readonly manifest: RequirementManifest<Comp, Statement>;
+    readonly [RequirementCompositionTypeId]: (composition: Comp) => Comp;
+}
+export interface ProductManifest<Comp extends ProductComposition> {
+    readonly kind: 'Product';
+    readonly name: string;
+    readonly composition: Comp;
+    readonly requirements: ReadonlyArray<AnyRequirementClass>;
+}
+export interface ProductClass<Comp extends ProductComposition = ProductComposition> {
+    new (): {};
+    readonly manifest: ProductManifest<Comp>;
+}
+interface MakeRequirementOptionsExternalApi<Comp extends ProductComposition> {
+    readonly events?: ReadonlyArray<EventNamesOf<ContractOf<Comp>>>;
+}
+declare const makeRequirement: <Comp extends ProductComposition, const Statement extends string>(composition: Comp, statement: Statement, options?: MakeRequirementOptionsExternalApi<Comp>) => RequirementClass<Comp, Statement>;
+export declare const ProductRequirement: {
+    readonly make: typeof makeRequirement;
+};
+interface MakeProductConfig<Comp extends ProductComposition> {
+    readonly requirements: ReadonlyArray<RequirementClass<Comp, string>>;
+}
+declare const makeProduct: <Comp extends ProductComposition>(composition: Comp, config: MakeProductConfig<Comp>) => ProductClass<Comp>;
+export declare const Product: {
+    readonly make: typeof makeProduct;
+};
+export {};
+//# sourceMappingURL=product.d.ts.map

package/dist/product.d.ts.map

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

package/dist/product.js

@@ -0,0 +1,35 @@
+import { Option } from 'effect';
+const RequirementCompositionTypeId = Symbol.for('reform-proof/RequirementComposition');
+const makeRequirement = (composition, statement, options) => {
+    const manifest = {
+        kind: 'ProductRequirement',
+        name: statement,
+        statement,
+        composition,
+        events: Option.fromNullable(options?.events),
+    };
+    class Requirement {
+        static manifest = manifest;
+        static [RequirementCompositionTypeId] = (exact) => exact;
+        static capture = (visit) => visit(Requirement);
+    }
+    return Requirement;
+};
+export const ProductRequirement = {
+    make: makeRequirement,
+};
+const makeProduct = (composition, config) => {
+    const manifest = {
+        kind: 'Product',
+        name: composition.manifest.name,
+        composition,
+        requirements: config.requirements,
+    };
+    return class {
+        static manifest = manifest;
+    };
+};
+export const Product = {
+    make: makeProduct,
+};
+//# sourceMappingURL=product.js.map

package/dist/product.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"product.js","sourceRoot":"","sources":["../src/product.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAM/B,MAAM,4BAA4B,GAAkB,MAAM,CAAC,GAAG,CAC5D,qCAAqC,CACtC,CAAA;AAqDD,MAAM,eAAe,GAAG,CACtB,WAAiB,EACjB,SAAoB,EACpB,OAAiD,EACd,EAAE;IACrC,MAAM,QAAQ,GAAyC;QACrD,IAAI,EAAE,oBAAoB;QAC1B,IAAI,EAAE,SAAS;QACf,SAAS;QACT,WAAW;QACX,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,OAAO,EAAE,MAAM,CAAC;KAC7C,CAAA;IACD,MAAM,WAAW;QACf,MAAM,CAAU,QAAQ,GAAG,QAAQ,CAAA;QACnC,MAAM,CAAU,CAAC,4BAA4B,CAAC,GAAG,CAAC,KAAW,EAAQ,EAAE,CAAC,KAAK,CAAA;QAC7E,MAAM,CAAU,OAAO,GAAG,CAAS,KAAiC,EAAU,EAAE,CAC9E,KAAK,CAAC,WAAW,CAAC,CAAA;;IAEtB,OAAO,WAAW,CAAA;AACpB,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,kBAAkB,GAA8C;IAC3E,IAAI,EAAE,eAAe;CACtB,CAAA;AAMD,MAAM,WAAW,GAAG,CAClB,WAAiB,EACjB,MAA+B,EACX,EAAE;IACtB,MAAM,QAAQ,GAA0B;QACtC,IAAI,EAAE,SAAS;QACf,IAAI,EAAE,WAAW,CAAC,QAAQ,CAAC,IAAI;QAC/B,WAAW;QACX,YAAY,EAAE,MAAM,CAAC,YAAY;KAClC,CAAA;IACD,OAAO;QACL,MAAM,CAAU,QAAQ,GAAG,QAAQ,CAAA;KACpC,CAAA;AACH,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,OAAO,GAA0C;IAC5D,IAAI,EAAE,WAAW;CAClB,CAAA"}

package/dist/proofCase.d.ts

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

package/dist/proofCase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proofCase.d.ts","sourceRoot":"","sources":["../src/proofCase.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AACpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AACjE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AACtC,OAAO,KAAK,EAAE,kBAAkB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAA;AAErE,MAAM,MAAM,cAAc,GAAG,SAAS,CAAC,SAAS,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,CAAA;AAExG,MAAM,WAAW,SAAS,CACxB,IAAI,SAAS,kBAAkB,EAC/B,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,EAChC,QAAQ,EACR,CAAC,EACD,CAAC,SAAS,MAAM,EAChB,QAAQ;IAER,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAA;IACpD,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,CAAA;IAC7D,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;IACnC,QAAQ,CAAC,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,EAAE,KAAK,CAAC,KAAK,cAAc,CAAA;CACzD;AAED,MAAM,MAAM,YAAY,CAAC,MAAM,IAAI,CACjC,IAAI,SAAS,kBAAkB,EAC/B,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,aAAa,CAAC,OAAO,CAAC,EAChC,QAAQ,EACR,CAAC,EACD,CAAC,SAAS,MAAM,EAChB,QAAQ,EAER,KAAK,EAAE,SAAS,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,KACnD,MAAM,CAAA;AAEX,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAA;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAA;CACnC;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"}

package/dist/proofCase.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=proofCase.js.map

package/dist/proofCase.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"proofCase.js","sourceRoot":"","sources":["../src/proofCase.ts"],"names":[],"mappings":""}

package/dist/runner.d.ts

@@ -0,0 +1,15 @@
+import { Context, Effect, Layer } from 'effect';
+import type { DriveResult, Proof, ProofResult } from './index.js';
+export interface ProofRunnerApi {
+    readonly executeProofEffect: (proof: Proof) => Effect.Effect<ProofResult, never, never>;
+    readonly driveProofEffect: (proof: Proof) => Effect.Effect<DriveResult, never, never>;
+    readonly executeProof: (proof: Proof) => Promise<ProofResult>;
+    readonly driveProof: (proof: Proof) => Promise<DriveResult>;
+}
+declare const ProofRunnerBase: Context.TagClass<ProofRunner, 'reform-proof/ProofRunner', ProofRunnerApi>;
+export declare class ProofRunner extends ProofRunnerBase {
+}
+export declare const proofRunnerLayer: Layer.Layer<ProofRunner>;
+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,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAE/C,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAE9D,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,kBAAkB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,CAAA;IACvF,QAAQ,CAAC,gBAAgB,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,KAAK,EAAE,KAAK,CAAC,CAAA;IACrF,QAAQ,CAAC,YAAY,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,OAAO,CAAC,WAAW,CAAC,CAAA;IAC7D,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,qBAAa,WAAY,SAAQ,eAAe;CAAG;AAEnD,eAAO,MAAM,gBAAgB,EAAE,KAAK,CAAC,KAAK,CAAC,WAAW,CAKpD,CAAA;AAEF,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,13 @@
+import { Context, Effect, Layer } from 'effect';
+import { driveProof, driveProofEffect, executeProof, executeProofEffect } from './engine.js';
+const ProofRunnerBase = Context.Tag('reform-proof/ProofRunner')();
+export class ProofRunner extends ProofRunnerBase {
+}
+export const proofRunnerLayer = Layer.succeed(ProofRunner, {
+    executeProofEffect,
+    driveProofEffect,
+    executeProof,
+    driveProof,
+});
+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,gBAAgB,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAUzF,MAAM,eAAe,GACnB,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,EAA+B,CAAA;AAExE,MAAM,OAAO,WAAY,SAAQ,eAAe;CAAG;AAEnD,MAAM,CAAC,MAAM,gBAAgB,GAA6B,KAAK,CAAC,OAAO,CAAC,WAAW,EAAE;IACnF,kBAAkB;IAClB,gBAAgB;IAChB,YAAY;IACZ,UAAU;CACX,CAAC,CAAA;AAEF,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

@@ -1,6 +1,6 @@
 {
   "name": "@playfast/reform-proof",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "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": [
     "effect",
@@ -19,15 +19,26 @@
     "directory": "packages/proof"
   },
   "files": [
+    "dist",
     "src",
     "README.md"
   ],
   "type": "module",
   "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     "./package.json": "./package.json",
-    ".": "./src/index.ts",
-    "./*": "./src/*.ts"
+    ".": {
+      "playfast-src": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": {
+      "playfast-src": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
   },
   "publishConfig": {
     "access": "public"
@@ -35,12 +46,13 @@
   "scripts": {
     "clean": "rm -rf dist .tsbuildinfo",
     "check": "tsc --noEmit",
-    "build": "tsc -p tsconfig.build.json",
+    "build": "rm -rf dist .tsbuildinfo && tsc -p tsconfig.build.json && bun ../../scripts/fix-esm-extensions.ts dist",
     "test": "vitest run",
     "test:watch": "vitest",
     "coverage": "vitest run --coverage",
     "lint": "oxlint src",
-    "lint:fix": "oxlint --fix src"
+    "lint:fix": "oxlint --fix src",
+    "prepack": "bun run build"
   },
   "peerDependencies": {
     "@playfast/reform": "*",

package/src/engine.ts

@@ -1,4 +1,4 @@
-import { Cause, Effect, Option, Record as Rec, Ref } from 'effect'
+import { Array as Arr, Cause, Effect, Option, Record as Rec, Ref } from 'effect'
 import { yieldWrapGet } from 'effect/Utils'
 import {
   type CapturedScene,
@@ -9,6 +9,7 @@ import {
 } from '@playfast/reform'
 import { type AnyComposition, type AnyScene } from '@playfast/reform/internal'
 import {
+  type DispatchedAction,
   invalidCompositionProps,
   type HostRuntime,
   makeSink,
@@ -26,14 +27,10 @@ import type { ProductComposition } from './product'
 import type { Proof } from './index'
 
 export { makeSink } from './engineSink'
-export type { Sink } from './engineSink'
+export type { DispatchedAction, Sink } from './engineSink'
 export { proofLayer } from './engineTree'
 export { makeFacade, makeProofFacade, makeRuntimeHandleFacade } from './engineMounted'
-export type {
-  MountedFacade,
-  MountedSlotFacade,
-  MountedSlotFacadesOf,
-} from './engineSink'
+export type { MountedFacade, MountedSlotFacade, MountedSlotFacadesOf } from './engineSink'
 export { makeRuntimeTreeFacade } from './engineTreeFacade'
 export type { RuntimeTreeFacade } from './engineTreeTypes'
 
@@ -63,7 +60,7 @@ const withProofRuntimeTree = <
 >(
   scene: CapturedScene<C, S, Services, P, N, Identity>,
   sink: Sink,
-  dispatched: Set<string>,
+  dispatched: Set<DispatchedAction>,
   use: (runtime: HostRuntime, tree: RuntimeTreeFacade<C>) => Effect.Effect<A, E, never>,
 ): Effect.Effect<A, E, never> =>
   Effect.acquireUseRelease(
@@ -83,11 +80,19 @@ const withProofRuntimeTree = <
 
 const missingCoverage = (
   proof: Pick<Proof, 'requirement'>,
-  dispatched: Set<string>,
+  dispatched: Set<DispatchedAction>,
 ): ReadonlyArray<string> =>
   Option.match(proof.requirement.manifest.events, {
     onNone: () => [],
-    onSome: (declared) => declared.map(String).filter((event) => !dispatched.has(event)),
+    onSome: (declared) => {
+      const owner = compositionIdentity(proof.requirement.manifest.composition)
+      const covered = new Set(
+        Arr.filterMap(Arr.fromIterable(dispatched), (action) =>
+          Object.is(action.identity, owner) ? Option.some(action.event) : Option.none(),
+        ),
+      )
+      return declared.map(String).filter((event) => !covered.has(event))
+    },
   })
 
 interface ProofPlacement {
@@ -144,7 +149,7 @@ const executeProofWithSink = Effect.fn('executeProofWithSink')(function* <
   scene: CapturedScene<C, S, Services, P, N, Identity>,
   sink: Sink,
 ): Effect.fn.Return<ProofResult, never, never> {
-  const dispatched = new Set<string>()
+  const dispatched = new Set<DispatchedAction>()
   const statement = proof.requirement.manifest.statement
   const runGenerator = Effect.fn('runProofGenerator')(function* (
     generator: ReturnType<typeof proof.body>,
@@ -218,7 +223,7 @@ const driveProofWithSink = Effect.fn('driveProofWithSink')(function* <
   const frames = yield* Ref.make<ReadonlyArray<StepFrame>>([])
   const statement = proof.requirement.manifest.statement
   // Driving tracks dispatches for the facade without enforcing coverage.
-  const dispatched = new Set<string>()
+  const dispatched = new Set<DispatchedAction>()
   const record = (index: number): Effect.Effect<void> =>
     Ref.update(frames, (current) => [...current, { index, captures: [...sink.captures] }])
   const pump = Effect.fn('pump')(function* (
@@ -282,4 +287,3 @@ export const driveProofEffect = (proof: Proof): Effect.Effect<DriveResult, never
 
 export const driveProof = (proof: Proof): Promise<DriveResult> =>
   Effect.runPromise(driveProofEffect(proof))
-

package/src/engineMounted.ts

@@ -10,7 +10,9 @@ import {
 import { type AnyComposition, CaptureSink } from '@playfast/reform/internal'
 import type { Facade } from './facade'
 import {
+  compositionIdentityOf,
   directSettle,
+  type DispatchedAction,
   expectMatchingProps,
   keyed,
   type MountedFacade,
@@ -32,11 +34,7 @@ import {
   slotCapturesFor,
   slotsOf,
 } from './engineTree'
-import {
-  collectRuntimeBindings,
-  renderTreeRuntime,
-  settleTreeRuntime,
-} from './engineRender'
+import { collectRuntimeBindings, renderTreeRuntime, settleTreeRuntime } from './engineRender'
 
 export function makeFacade<
   C extends UiContract,
@@ -49,7 +47,7 @@ export function makeFacade<
   runtime: ManagedRuntime.ManagedRuntime<Services | CaptureSink, never>,
   scene: CapturedScene<C, S, Services, P, N, Identity>,
   sink: Sink,
-  dispatched: Set<string>,
+  dispatched: Set<DispatchedAction>,
 ): {
   readonly facade: Facade<C, never>
   readonly settle: Effect.Effect<void, never, never>
@@ -74,7 +72,7 @@ function makeMountedFacade<
   runtime: RenderRuntime,
   root: CompositionClass<P, C, S, N, Identity>,
   sink: Sink,
-  dispatched: Set<string>,
+  dispatched: Set<DispatchedAction>,
   settleBoundary: SettleBoundary,
 ): {
   readonly facade: MountedFacade<C>
@@ -84,14 +82,14 @@ function makeMountedFacade(
   runtime: RenderRuntime,
   root: AnyComposition,
   sink: Sink,
-  dispatched: Set<string>,
+  dispatched: Set<DispatchedAction>,
   settleBoundary: SettleBoundary,
 ): MountedFacadeHandleErasure
 function makeMountedFacade(
   runtime: RenderRuntime,
   root: AnyComposition,
   sink: Sink,
-  dispatched: Set<string>,
+  dispatched: Set<DispatchedAction>,
   settleBoundary: SettleBoundary,
 ): MountedFacadeHandleErasure {
   const bindings = collectRuntimeBindings(root, runtime)
@@ -146,7 +144,7 @@ function makeMountedFacade(
           Effect.flatMap(() => triggerOf(ref, event)),
           Effect.flatMap((trigger) =>
             Effect.sync(() => {
-              dispatched.add(event)
+              dispatched.add({ identity: compositionIdentityOf(comp), event })
               trigger(payload)
             }),
           ),
@@ -244,7 +242,7 @@ export const makeProofFacade = <
   runtime: ManagedRuntime.ManagedRuntime<Services | CaptureSink, never>,
   scene: CapturedScene<C, S, Services, P, N, Identity>,
   sink: Sink,
-  dispatched: Set<string>,
+  dispatched: Set<DispatchedAction>,
 ): {
   readonly facade: Facade<C, never>
   readonly settle: Effect.Effect<void, never, never>
@@ -264,7 +262,7 @@ export const makeRuntimeHandleFacade = <
   runtime: RuntimeHandle<Services>,
   root: RuntimeRootComposition<RootIdentifier, P, C, S, N, Identity>,
   sink: Sink,
-  dispatched: Set<string>,
+  dispatched: Set<DispatchedAction>,
 ): {
   readonly facade: MountedFacade<C>
   readonly settle: Effect.Effect<void, never, never>

package/src/engineSink.ts

@@ -91,7 +91,9 @@ export const settleDrain: Effect.Effect<void> = Effect.yieldNow().pipe(Effect.re
 // settle loop would never make progress. Pinning it to a real clock is what lets the
 // two clocks coexist: the harness keeps advancing while the product's timers hold
 // still until `app.advance(...)` moves them.
-export const settleStep: Effect.Effect<void> = Effect.sleep(SETTLE_STEP).pipe(Effect.withClock(Clock.make()))
+export const settleStep: Effect.Effect<void> = Effect.sleep(SETTLE_STEP).pipe(
+  Effect.withClock(Clock.make()),
+)
 
 export const keyed = <V>(get: (key: string) => V): Record<string, V> => {
   const target: Record<string, V> = Object.create(null)
@@ -101,6 +103,18 @@ export const keyed = <V>(get: (key: string) => V): Record<string, V> => {
 export const messageOf = (error: unknown): string =>
   error instanceof Error ? error.message : String(error)
 
+// An action credited to the composition that actually raised it. A bare event name
+// is not enough: two contracts in one tree can expose the same action name, and a
+// requirement's coverage must be answered by *its* composition's action, not by a
+// child that happens to spell its own action the same way.
+export interface DispatchedAction {
+  readonly identity: symbol
+  readonly event: string
+}
+
+export const compositionIdentityOf = (composition: AnyComposition): symbol =>
+  composition.capture<symbol>((exact) => exact.identity)
+
 export const uiNameOf = (comp: AnyComposition): string => comp.manifest.ui.manifest.name
 
 // UiContract erases event values to never, so this boundary needs no assertion.

package/src/engineTreeFacade.ts

@@ -1,9 +1,11 @@
-import { Array as Arr, type Duration, Effect, Option, TestClock } from 'effect'
+import { Array as Arr, type Duration, Effect, MutableRef, Option, TestClock } from 'effect'
 import { AssertionFailed, NoTestClock, UnknownAction, UnknownSlot } from './errors'
 import { matchProps } from './assert'
 import { type RuntimeHandle, type UiContract } from '@playfast/reform'
 import type { AnyComposition } from '@playfast/reform/internal'
 import {
+  compositionIdentityOf,
+  type DispatchedAction,
   type HostRuntime,
   keyed,
   type MountedFacadeErasure,
@@ -28,14 +30,14 @@ export function makeRuntimeTreeFacade<
   root: RuntimeRootComposition<RootIdentifier, P, C, S, N, Identity>,
   rootProps: P,
   sink: Sink,
-  dispatched: Set<string>,
+  dispatched: Set<DispatchedAction>,
 ): RuntimeTreeFacade<C>
 export function makeRuntimeTreeFacade(
   runtime: HostRuntime,
   root: AnyComposition,
   rootProps: unknown,
   sink: Sink,
-  dispatched: Set<string>,
+  dispatched: Set<DispatchedAction>,
 ): RuntimeTreeFacadeErasure {
   const driver = makeTreeDriver(runtime, root, rootProps, sink)
   const currentRoot = (): TreeNode => driver.render().root
@@ -49,10 +51,12 @@ export function makeRuntimeTreeFacade(
     })
 
   // `peek` is the non-dying half of `resolve`: None once the node has left the
-  // tree, so an action that removed its own node can still report a result.
+  // tree, so an action that removed its own node can still report a result. It is
+  // given the node as it stood before the dispatch, because "is this still the node
+  // I acted on" cannot be answered from a bare index.
   const nodeFacade = (
     resolve: () => TreeNode,
-    peek: () => Option.Option<TreeNode>,
+    peek: (before: TreeNode) => Option.Option<TreeNode>,
   ): MountedFacadeErasure => ({
     props: Effect.sync(() => resolve().props),
     expectProps: (partial) =>
@@ -81,12 +85,12 @@ export function makeRuntimeTreeFacade(
               }).message,
             )
           }
-          dispatched.add(event)
+          dispatched.add({ identity: compositionIdentityOf(node.comp), event })
           trigger(payload)
           yield* driver.settle
           // A self-removing action leaves nothing to re-read; report what the
           // node last rendered instead of dying on the vanished child.
-          return Option.match(peek(), {
+          return Option.match(peek(node), {
             onNone: () => node.props,
             onSome: (settled) => settled.props,
           })
@@ -113,15 +117,46 @@ export function makeRuntimeTreeFacade(
       }
       return resolved
     }
-    const peekAt = (index: number): Option.Option<TreeNode> =>
-      Option.fromNullable(children()[index])
     const peekByKey = (key: string): Option.Option<TreeNode> =>
       Arr.findFirst(children(), (candidate) => Option.contains(candidate.key, key))
-    const childAt = (index: number): MountedFacadeErasure =>
-      nodeFacade(
-        () => children()[index] ?? missingChild(index),
-        () => peekAt(index),
+
+    // Which node an index still refers to, after the slot may have changed under it.
+    // Three outcomes, in order: the same node (it survived, wherever it moved to); a
+    // node that took its place (a slot of unchanged length swapped one child for
+    // another — a placeholder giving way to the real thing); or nothing, because the
+    // slot shrank and whatever sits at the index now is a *different row* that slid
+    // down. Reporting that neighbour's props is the bug this ordering exists to stop.
+    interface PeekAt {
+      readonly index: number
+      readonly before: TreeNode
+      readonly siblingsBefore: number
+    }
+
+    const peekAt = ({ index, before, siblingsBefore }: PeekAt): Option.Option<TreeNode> => {
+      const now = children()
+      const survived = Arr.findFirst(now, (candidate) =>
+        Option.match(before.key, {
+          onNone: () => candidate.path === before.path,
+          onSome: (key) => Option.contains(candidate.key, key),
+        }),
       )
+      if (Option.isSome(survived)) {
+        return survived
+      }
+      return now.length === siblingsBefore ? Option.fromNullable(now[index]) : Option.none()
+    }
+
+    const childAt = (index: number): MountedFacadeErasure => {
+      const siblings = MutableRef.make(0)
+      return nodeFacade(
+        () => {
+          const now = children()
+          MutableRef.set(siblings, now.length)
+          return now[index] ?? missingChild(index)
+        },
+        (before) => peekAt({ index, before, siblingsBefore: MutableRef.get(siblings) }),
+      )
+    }
     const childByKey = (key: string): MountedFacadeErasure =>
       nodeFacade(
         () => Option.getOrElse(peekByKey(key), () => missingKey(key)),