@playfast/reform 1.0.1 → 1.2.0

package/README.md

@@ -13,7 +13,7 @@ State, events, reducers, derived values, async & remote data, and compositions
 
 ---
 
-reform is an application framework built on [Effect](https://effect.website). You describe your app as **definitions** — state, events, reducers, calculations, compositions — and provide their behavior **separately** as Effect layers. The core renders nothing: a host package ([`@playfast/reform-react`](https://www.npmjs.com/package/@playfast/reform-react), [`@playfast/reform-react-native`](https://www.npmjs.com/package/@playfast/reform-react-native)) turns a closed *scene* into a live tree, and [`@playfast/reform-proof`](https://www.npmjs.com/package/@playfast/reform-proof) drives that same scene headlessly in tests. One model, three consumers, no seam between them.
+reform is an application framework built on [Effect](https://effect.website). You describe your app as **definitions** — state, events, reducers, calculations, compositions — and provide their behavior **separately** as Effect layers. The core renders nothing: a host package ([`@playfast/reform-react`](https://www.npmjs.com/package/@playfast/reform-react), [`@playfast/reform-react-native`](https://www.npmjs.com/package/@playfast/reform-react-native)) turns a closed _scene_ into a live tree, and [`@playfast/reform-proof`](https://www.npmjs.com/package/@playfast/reform-proof) drives that same scene headlessly in tests. One model, three consumers, no seam between them.
 
 ## Install
 
@@ -62,24 +62,24 @@ class Bump extends Reducer.make('Bump', { states: [Count], events: [Bumped] }) {
 const BumpLive = Reducer.live(Bump, (n, e) => n + e.by)
 ```
 
-A `State` lives in a plain reactive store; reducers only *return* values, so by construction they are the **only** writers. Reads return the current snapshot through Effect.
+A `State` lives in a plain reactive store; reducers only _return_ values, so by construction they are the **only** writers. Reads return the current snapshot through Effect.
 
 ### The primitives at a glance
 
-| primitive | definition | implementation |
-| --- | --- | --- |
-| [`State` / `StateGroup` / `StateFamily`](#state) | `State.make(name, schema, opts?)` | `.live(initial)` |
-| [`Event` / `EventGroup`](#event) | `Event.make(name, schema)` | — (pure data) |
-| [`Reducer`](#reducer) | `Reducer.make(name, { states / family, events })` | `.live(fold)` |
-| [`Calc` / `CalcFamily`](#calc) | `Calc.make(name, { inputs, output })` | `.live(fn)` |
-| [`AsyncCalc`](#asynccalc) | `AsyncCalc.make(name, { inputs, output, error?, alwaysOn? })` | `.live({ query, … })` |
-| [`RemoteState`](#remotestate) | `RemoteState.make(name, { inputs, output, error?, alwaysOn?, intents })` | `.live({ query, send, apply, … })` |
-| [`Boundary`](#boundary) | `Boundary.make(name, { over })` | `.live({ once? })` |
-| [`Procedure`](#procedure) | `Procedure.make(name, { events, channel })` | `.live(fn*)` |
-| [`Channel`](#procedure) | `Channel.make(name, { policy })` | `.live()` |
-| [`Composition`](#composition) | `Composition.make(name, manifest)` | `.live(fn*)` |
-| [`ui` / `slot`](#composition) | `ui(name)<C>()` / `slot(name)<Comp>()` | `Ui.make` / `provide` |
-| [`Feature`](#feature) | `Feature.make(name, config)` | (eager `module` / lazy `load`) |
+| primitive                                        | definition                                                               | implementation                     |
+| ------------------------------------------------ | ------------------------------------------------------------------------ | ---------------------------------- |
+| [`State` / `StateGroup` / `StateFamily`](#state) | `State.make(name, schema, opts?)`                                        | `.live(initial)`                   |
+| [`Event` / `EventGroup`](#event)                 | `Event.make(name, schema)`                                               | — (pure data)                      |
+| [`Reducer`](#reducer)                            | `Reducer.make(name, { states / family, events })`                        | `.live(fold)`                      |
+| [`Calc` / `CalcFamily`](#calc)                   | `Calc.make(name, { inputs, output })`                                    | `.live(fn)`                        |
+| [`AsyncCalc`](#asynccalc)                        | `AsyncCalc.make(name, { inputs, output, error?, alwaysOn? })`            | `.live({ query, … })`              |
+| [`RemoteState`](#remotestate)                    | `RemoteState.make(name, { inputs, output, error?, alwaysOn?, intents })` | `.live({ query, send, apply, … })` |
+| [`Boundary`](#boundary)                          | `Boundary.make(name, { over })`                                          | `.live({ once? })`                 |
+| [`Procedure`](#procedure)                        | `Procedure.make(name, { events, channel })`                              | `.live(fn*)`                       |
+| [`Channel`](#procedure)                          | `Channel.make(name, { policy })`                                         | `.live()`                          |
+| [`Composition`](#composition)                    | `Composition.make(name, manifest)`                                       | `.live(fn*)`                       |
+| [`ui` / `slot`](#composition)                    | `ui(name)<C>()` / `slot(name, identity)<Comp>()`                         | `Ui.make` / `provide`              |
+| [`Feature`](#feature)                            | `Feature.make(name, config)`                                             | (eager `module` / lazy `load`)     |
 
 ## The model
 
@@ -98,6 +98,7 @@ procedure  ──► Bus (Normal)┘                          │
 ---
 
 <a name="state"></a>
+
 ## State · StateGroup · StateFamily
 
 Reactive stores held outside Effect. Reducers are the sole writers; everything else reads.
@@ -119,13 +120,13 @@ A bundle of related states provided together. `StateGroup.select(Group, 'name')`
 import { State, StateGroup } from '@playfast/reform'
 
 class Count extends State.make('count', S.Number) {}
-class Step  extends State.make('step',  S.Number) {}
+class Step extends State.make('step', S.Number) {}
 class Counter extends StateGroup.make(Count, Step) {}
 
 const CounterLive = StateGroup.live(Counter, { count: 0, step: 1 }) // all members required
 
 // read inside any Effect / composition:
-const count = yield* StateGroup.select(Counter, 'count')
+const count = yield * StateGroup.select(Counter, 'count')
 ```
 
 ### `StateFamily`
@@ -149,13 +150,14 @@ const item = yield* StateFamily.read(Items, id)
 ---
 
 <a name="event"></a>
+
 ## Event · EventGroup
 
 Events are pure tagged data — definitions only, no `.live`.
 
 ```ts
-Event.make(name, schema)        // → EventClass; EventOf<N, P> = { _tag: N } & P
-EventGroup.make(...events)      // → bundle, used in Reducer/Composition manifests
+Event.make(name, schema) // → EventClass; EventOf<N, P> = { _tag: N } & P
+EventGroup.make(...events) // → bundle, used in Reducer/Composition manifests
 
 class LoadedTodos extends Event.make('LoadedTodos', S.Struct({ todos: S.Array(Todo) })) {}
 ```
@@ -164,11 +166,11 @@ class LoadedTodos extends Event.make('LoadedTodos', S.Struct({ todos: S.Array(To
 
 ```ts
 // From a UI view — High priority, synchronous:
-const toggle = yield* Event.trigger(ToggledTodo)   // toggle: (payload) => void
+const toggle = yield * Event.trigger(ToggledTodo) // toggle: (payload) => void
 // ...later: <input onChange={() => toggle({ id })} />
 
 // From a procedure — Normal priority:
-yield* Event.dispatch(TodoUpserted, { todo })
+yield * Event.dispatch(TodoUpserted, { todo })
 ```
 
 `Event.trigger` returns a plain callback (`Trigger<P>`) you hand to the view; `Event.dispatch` returns an `Effect` you yield inside logic.
@@ -176,6 +178,7 @@ yield* Event.dispatch(TodoUpserted, { todo })
 ---
 
 <a name="reducer"></a>
+
 ## Reducer
 
 The only writers of state. A fold is a **pure, synchronous** `(value, event) => value` (async values throw at startup).
@@ -195,9 +198,13 @@ const FeedReducerLive = Reducer.live(FeedReducer, (feed, event) =>
   Match.value(event).pipe(
     Match.tags({
       StartedLoading: (): Feed => ({ _tag: 'Loading' }),
-      LoadedTodos:   ({ todos }): Feed => ({ _tag: 'Ok', todos }),
-      FailedTodos:   ({ message }): Feed => ({ _tag: 'Error', message }),
-      TodoRemoved:   ({ id }) => onOk(feed, Array.filter((t) => t.id !== id)),
+      LoadedTodos: ({ todos }): Feed => ({ _tag: 'Ok', todos }),
+      FailedTodos: ({ message }): Feed => ({ _tag: 'Error', message }),
+      TodoRemoved: ({ id }) =>
+        onOk(
+          feed,
+          Array.filter((t) => t.id !== id),
+        ),
     }),
     Match.exhaustive,
   ),
@@ -209,6 +216,7 @@ An event outside the reducer's declared `events` never reaches the fold; the dra
 ---
 
 <a name="calc"></a>
+
 ## Calc · CalcFamily
 
 Synchronous derived values — memoized projections over one or more sources.
@@ -231,15 +239,26 @@ const positive = yield* IsPositive          // read the memoized value
 **`CalcFamily`** parameterizes a calc by key, one memoized store per key over shared inputs — each member notifies only its own subscribers:
 
 ```ts
-class GroupView extends CalcFamily.make('GroupView', { key: GroupId, inputs: [Board], output: GroupSchema }) {}
-const GroupViewLive = CalcFamily.live(GroupView, (id) => ({ Board }) => project(Board, id), { evictWhenUnused: true })
+class GroupView extends CalcFamily.make('GroupView', {
+  key: GroupId,
+  inputs: [Board],
+  output: GroupSchema,
+}) {}
+const GroupViewLive = CalcFamily.live(
+  GroupView,
+  (id) =>
+    ({ Board }) =>
+      project(Board, id),
+  { evictWhenUnused: true },
+)
 
-const view = yield* CalcFamily.read(GroupView, groupId)
+const view = yield * CalcFamily.read(GroupView, groupId)
 ```
 
 ---
 
 <a name="asynccalc"></a>
+
 ## AsyncCalc & AsyncData
 
 Server reads with a stale-while-revalidate lifecycle. The query re-runs reactively from its inputs.
@@ -259,12 +278,12 @@ AsyncCalc.live(AsyncCalc, {
 - `error` omitted ⇒ the query is infallible (no `Error` arm). `alwaysOn: true` ⇒ no `Idle` arm and `disabled` is rejected.
 - Reading `yield* MyAsyncCalc` yields an **`AsyncData<A, E, Gated>`**:
 
-| arm | `_tag` | fields | when |
-| --- | --- | --- | --- |
-| `AsyncIdle` | `'Idle'` | — | gated query is `disabled` |
-| `AsyncLoading` | `'Loading'` | — | first fetch, no value yet |
+| arm            | `_tag`      | fields                | when                                             |
+| -------------- | ----------- | --------------------- | ------------------------------------------------ |
+| `AsyncIdle`    | `'Idle'`    | —                     | gated query is `disabled`                        |
+| `AsyncLoading` | `'Loading'` | —                     | first fetch, no value yet                        |
 | `AsyncSuccess` | `'Success'` | `value`, `refetching` | succeeded (`refetching: true` while re-fetching) |
-| `AsyncError` | `'Error'` | `error`, `refetching` | failed |
+| `AsyncError`   | `'Error'`   | `error`, `refetching` | failed                                           |
 
 ```ts
 class Doubled extends AsyncCalc.make('Doubled', {
@@ -276,7 +295,7 @@ const DoubledLive = AsyncCalc.live(Doubled, {
   query: ({ count }) => Effect.succeed(count * 2),
 })
 
-const data = yield* Doubled
+const data = yield * Doubled
 Match.value(data).pipe(
   Match.tag('Loading', () => spinner),
   Match.tag('Success', ({ value }) => render(value)),
@@ -287,9 +306,10 @@ Match.value(data).pipe(
 ---
 
 <a name="remotestate"></a>
+
 ## RemoteState
 
-Server-owned state with optimistic mutations, fused into one primitive. **Remote state is derived-only:** the only writer is the server, the only write surface is dispatching a declared *intent*, and the visible value is `pending.reduce(apply, serverTruth)`.
+Server-owned state with optimistic mutations, fused into one primitive. **Remote state is derived-only:** the only writer is the server, the only write surface is dispatching a declared _intent_, and the visible value is `pending.reduce(apply, serverTruth)`.
 
 ```ts
 RemoteState.make(name, { inputs, output, error?, alwaysOn?, intents })   // intents: Event definitions
@@ -318,23 +338,25 @@ class Board extends RemoteState.make('Board', {
 }) {}
 
 const BoardLive = RemoteState.live(Board, {
-  query:  ({ route }) => loadBoard(route.boardId),
-  send:   (intent) => Match.value(intent).pipe(
-            Match.tag('ItemAddIntent',    ({ groupId, name }) => client.AddItem({ groupId, name })),
-            Match.tag('ItemRenameIntent', ({ itemId, name })  => client.RenameItem({ id: itemId, name })),
-            Match.exhaustive,
-          ),
-  apply:  (snapshot, intent) => applyIntent(snapshot, intent),   // idempotent
+  query: ({ route }) => loadBoard(route.boardId),
+  send: (intent) =>
+    Match.value(intent).pipe(
+      Match.tag('ItemAddIntent', ({ groupId, name }) => client.AddItem({ groupId, name })),
+      Match.tag('ItemRenameIntent', ({ itemId, name }) => client.RenameItem({ id: itemId, name })),
+      Match.exhaustive,
+    ),
+  apply: (snapshot, intent) => applyIntent(snapshot, intent), // idempotent
   invalidateOn: [BoardChanged],
   coalesce: 'trailing',
 })
 ```
 
-**Semantics.** A dispatched intent appends to the queue and appears in the overlay in the same flush. On send failure the intent settles immediately and `Board.Failed` fires — there is **no rollback machinery**, the derivation just converges. The **generation rule** guarantees an optimistic change never flickers out between the RPC confirming and the refetch landing: an intent acked at query generation *g* is settled only by a later-generation `Success` run.
+**Semantics.** A dispatched intent appends to the queue and appears in the overlay in the same flush. On send failure the intent settles immediately and `Board.Failed` fires — there is **no rollback machinery**, the derivation just converges. The **generation rule** guarantees an optimistic change never flickers out between the RPC confirming and the refetch landing: an intent acked at query generation _g_ is settled only by a later-generation `Success` run.
 
 ---
 
 <a name="boundary"></a>
+
 ## Boundary
 
 Merges the lifecycle arms of several async sources into one first-load signal, so a subtree shows a single fallback instead of per-query spinners.
@@ -360,6 +382,7 @@ const boot = yield* BootBoundary   // BoundaryState
 ---
 
 <a name="procedure"></a>
+
 ## Procedure & Channel
 
 Procedures are side-effecting reactions to events, running on forked fibers. A **channel** is the named concurrency lane they run on.
@@ -377,14 +400,17 @@ The generator body receives the matched event, can read services from context, a
 ```ts
 class ActionsChannel extends Channel.make('Actions', { policy: { _tag: 'merge' } }) {}
 
-class CreateTodo extends Procedure.make('CreateTodo', { events: [SubmittedNewTodo], channel: ActionsChannel }) {}
+class CreateTodo extends Procedure.make('CreateTodo', {
+  events: [SubmittedNewTodo],
+  channel: ActionsChannel,
+}) {}
 const CreateTodoLive = Procedure.live(CreateTodo, function* (event) {
   const client = yield* TodosClient
   const result = yield* Effect.either(client.AddTodo({ text: event.text }))
   yield* Match.value(result).pipe(
     Match.tags({
       Right: ({ right }) => Event.dispatch(TodoUpserted, { todo: right }),
-      Left:  ({ left })  => Event.dispatch(FailedTodos, { message: String(left) }),
+      Left: ({ left }) => Event.dispatch(FailedTodos, { message: String(left) }),
     }),
     Match.exhaustive,
   )
@@ -396,6 +422,7 @@ Policies: `merge` (unbounded concurrency), `latest` (new event cancels the in-fl
 ---
 
 <a name="composition"></a>
+
 ## Composition · ui · slot · provide
 
 A **composition** is a unit of logic that reads state and renders a typed UI contract. The contract (`ui`) and its presentation are authored separately, so logic stays renderer-neutral.
@@ -426,12 +453,13 @@ const CounterView = provide(CounterUi, Ui.make(CounterUi, ({ count }, _slots, {
 
 - **`Composition.make(name, manifest)`** — manifest declares `ui` plus the `states` / `calcs` / `events` / `slots` it touches (all reflectable).
 - **`Composition.live(comp, fn*)`** — the generator reads sources and returns a `Node` (the view applied to props/events).
-- **`slot(name)<Comp>()`** — a hole a parent composition declares (`slots: { body: BodySlot }`) and fills with `provide(BodySlot, ChildComposition)` (or a `Feature`). Children render through the host.
+- **`slot(name, identity)<Comp>()`** — a hole a parent composition declares (`slots: { body: BodySlot }`) and fills with `provide(BodySlot, ChildComposition)` (or a `Feature`). Declare `identity` as a named module-level unique symbol (`const BodySlotIdentity: unique symbol = Symbol('BodySlot')`); `Symbol.for(...)` and inline `Symbol(...)` arguments are forbidden. Reform generates a separate runtime key for every slot definition, while `name` remains a display label, so independently authored same-name slots remain distinct. Children render through the host.
 - **`provide(...)`** — binds a UI presentation to a contract, or fills a slot with a composition / feature. Returns a `Layer`.
 
 ---
 
 <a name="feature"></a>
+
 ## Feature
 
 The lazy/eager code-split unit. Definitions stay eager and reflectable; the heavy implementation can load on demand as an **Effect** (never a bare Promise), so code-splitting composes with the rest of the layer graph.
@@ -449,22 +477,36 @@ class Counter extends Feature.make('counter', {
 // lazy: defer the module behind an import
 class Reports extends Feature.make('reports', {
   loadingStrategy: 'lazy',
+  composition: ReportsComp,
   load: lazyImport(() => import('./reports.module')),
+  eager: featureModule([], PlaceholderLive),
   placeholder: { loading: SpinnerComp, failed: RetryComp },
 }) {}
 ```
 
-A feature shares the app's engine but gets its own scope — `mountFeature(binding, engineContext)` loads it, builds its layer, dispatches its boot events, and disposes everything when the scope closes. Fill a slot with one via `provide(SomeSlot, Reports)`; the host paints the placeholders while it loads.
+A feature's `requires` tuple accepts shared State/Calc carriers, StateGroups, and
+ordinary Effect `Context.Tag`s. A lazy feature shares the app's engine but gets
+its own scope — `mountFeature(binding, parentContext)` loads it, builds its layer
+against the immediate parent, dispatches its boot events, and disposes everything
+when the scope closes. Fill a slot with one via `provide(SomeSlot, Reports)`;
+`provide` merges its optional eager placeholder module automatically while the
+host paints the placeholders and loads the main module.
+
+Default Features retain their binding identity too. Their module is merged by
+`provide`, their composition renders synchronously from the parent runtime, and
+their boot events run once for each keyed activation.
 
 ---
 
 <a name="scene"></a>
+
 ## Scene
 
 A scene bundles a root composition with the closed wiring that runs it — the single handle the React host, React Native host, and proofs all consume.
 
 ```ts
 scene(composition, { provide: [...layers], boot?: [...events] })   // → Scene
+featureScene(eagerFeature, { provide: closedEnvironment })         // → Scene
 seedScene(base, seeds)                                             // tooling: override seed values
 isScene(value)                                                     // reflection guard
 
@@ -476,9 +518,14 @@ const AppScene = scene(AppRoot, {
 
 `provide` is the list of layers that close the app (they must resolve to `MountedServices` — every composition's render service plus the `Bus`). Hand the scene to [`@playfast/reform-react`](https://www.npmjs.com/package/@playfast/reform-react) to mount or to [`@playfast/reform-proof`](https://www.npmjs.com/package/@playfast/reform-proof) to assert. `seedScene` overlays seed values onto already-closed layers (used by the dev tool to preview alternative initial state).
 
+`featureScene` is the typed root helper for a default/eager Feature. Its `provide`
+layer closes the engine plus the Feature's declared requirements; lazy Features
+are rejected because an application root must be immediately available.
+
 ---
 
 <a name="engine"></a>
+
 ## Engine & runtime surface
 
 `Engine` is the layer that ties a runtime together: it provides the `Bus` (one `PubSub`), the `Reducers` / `Channels` / `Procedures` registries, and forks the single drain loop. Merge it at the root of your app's layers:
@@ -547,15 +594,15 @@ Mount it with [`@playfast/reform-react`](https://www.npmjs.com/package/@playfast
 
 ## The reform family
 
-| Package | Role |
-| --- | --- |
-| **`@playfast/reform`** | Renderer-neutral core (this package) |
-| [`@playfast/reform-react`](https://www.npmjs.com/package/@playfast/reform-react) | React / DOM host |
-| [`@playfast/reform-react-native`](https://www.npmjs.com/package/@playfast/reform-react-native) | React Native host |
-| [`@playfast/reform-forms`](https://www.npmjs.com/package/@playfast/reform-forms) | Headless form state |
-| [`@playfast/reform-forms-react`](https://www.npmjs.com/package/@playfast/reform-forms-react) | Typed JSX mapping for forms |
-| [`@playfast/reform-proof`](https://www.npmjs.com/package/@playfast/reform-proof) | Headless testing toolkit |
-| [`@playfast/reform-eslint-plugin`](https://www.npmjs.com/package/@playfast/reform-eslint-plugin) | Lint rules for reform conventions |
+| Package                                                                                          | Role                                 |
+| ------------------------------------------------------------------------------------------------ | ------------------------------------ |
+| **`@playfast/reform`**                                                                           | Renderer-neutral core (this package) |
+| [`@playfast/reform-react`](https://www.npmjs.com/package/@playfast/reform-react)                 | React / DOM host                     |
+| [`@playfast/reform-react-native`](https://www.npmjs.com/package/@playfast/reform-react-native)   | React Native host                    |
+| [`@playfast/reform-forms`](https://www.npmjs.com/package/@playfast/reform-forms)                 | Headless form state                  |
+| [`@playfast/reform-forms-react`](https://www.npmjs.com/package/@playfast/reform-forms-react)     | Typed JSX mapping for forms          |
+| [`@playfast/reform-proof`](https://www.npmjs.com/package/@playfast/reform-proof)                 | Headless testing toolkit             |
+| [`@playfast/reform-eslint-plugin`](https://www.npmjs.com/package/@playfast/reform-eslint-plugin) | Lint rules for reform conventions    |
 
 ## License
 

package/package.json

@@ -1,36 +1,38 @@
 {
   "name": "@playfast/reform",
-  "playbook": "./playbook",
-  "version": "1.0.1",
-  "type": "module",
+  "version": "1.2.0",
   "description": "The renderer-neutral core of the reform framework — typed, headless state, events, reducers, derived values, async/remote data, and compositions built on Effect.",
   "keywords": [
-    "reform",
     "effect",
-    "state-management",
-    "headless",
     "framework",
-    "reactive"
+    "headless",
+    "reactive",
+    "reform",
+    "state-management"
   ],
+  "bugs": {
+    "url": "https://github.com/playfast/reform/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/playfast/reform.git",
     "directory": "packages/reform"
   },
-  "bugs": {
-    "url": "https://github.com/playfast/reform/issues"
-  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "type": "module",
   "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
     ".": "./src/index.ts",
     "./*": "./src/*.ts"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "clean": "rm -rf dist .tsbuildinfo",
     "check": "tsc --noEmit",
@@ -50,7 +52,5 @@
       "optional": true
     }
   },
-  "publishConfig": {
-    "access": "public"
-  }
+  "playbook": "./playbook"
 }

package/src/boundary/boundary.test.ts

@@ -2,12 +2,6 @@ import { expect, it } from '@effect/vitest'
 import { Data, Duration, Effect, Layer, Schema as S } from 'effect'
 import { AsyncCalc, Boundary, Calc, Engine, Event, State, StateGroup } from '../index'
 
-// Boundary merges several async lifecycles into one Pending/Errored/Ready value
-// — the Suspense-boundary analog, value-level. The behaviours under test: the
-// arm mapping (Loading pends, Idle and SWR-refetching count Ready, Error
-// surfaces), the chained-gate settle-gap pin, the `once` latch, and the
-// notification economy (arm-stable churn wakes nobody).
-
 const tick = (ms = 10) => Effect.sleep(Duration.millis(ms))
 
 const until = <A>(read: () => A, pred: (a: A) => boolean, rounds = 200): Effect.Effect<A> =>
@@ -37,8 +31,12 @@ it.live('pending while ANY covered query is on its first load; one Ready when al
   const TestLayer = Boundary.live(Gate).pipe(
     Layer.provideMerge(
       Layer.merge(
-        AsyncCalc.live(Fast, { query: ({ seed }) => Effect.succeed(seed).pipe(Effect.delay('10 millis')) }),
-        AsyncCalc.live(Slow, { query: ({ seed }) => Effect.succeed(seed).pipe(Effect.delay('40 millis')) }),
+        AsyncCalc.live(Fast, {
+          query: ({ seed }) => Effect.succeed(seed).pipe(Effect.delay('10 millis')),
+        }),
+        AsyncCalc.live(Slow, {
+          query: ({ seed }) => Effect.succeed(seed).pipe(Effect.delay('40 millis')),
+        }),
       ),
     ),
     Layer.provideMerge(StateGroup.live(Inputs, { seed: 1 })),
@@ -51,13 +49,13 @@ it.live('pending while ANY covered query is on its first load; one Ready when al
     })
     expect(store.get()._tag).toBe('Pending')
 
-    // The fast query settles first — still Pending (the slow one holds it).
     yield* tick(20)
     expect(store.get()._tag).toBe('Pending')
 
-    yield* until(() => store.get()._tag, (t) => t === 'Ready')
-    // Exactly ONE notification fired across the whole boot: Pending→Pending
-    // churn (Fast settling) was absorbed by the stable arm reference.
+    yield* until(
+      () => store.get()._tag,
+      (t) => t === 'Ready',
+    )
     expect(observed).toEqual(['Ready'])
   }).pipe(Effect.provide(TestLayer))
 })
@@ -86,9 +84,10 @@ it.live('a gated query that is OFF counts Ready — the off arm must not hold th
   )
   return Effect.gen(function* () {
     const store = yield* Gate.store
-    // The gated query is Idle (deliberately off): only the always-on first
-    // load pends, and Ready arrives without ever waiting on the Idle arm.
-    yield* until(() => store.get()._tag, (t) => t === 'Ready')
+    yield* until(
+      () => store.get()._tag,
+      (t) => t === 'Ready',
+    )
     expect(store.get()._tag).toBe('Ready')
   }).pipe(Effect.provide(TestLayer))
 })
@@ -114,13 +113,21 @@ it.live('an SWR refetch never re-pends — Success with refetching: true is Read
     const seed = yield* StateGroup.select(Inputs, 'seed').store
     const qStore = yield* Q.store
     const store = yield* Gate.store
-    yield* until(() => store.get()._tag, (t) => t === 'Ready')
+    yield* until(
+      () => store.get()._tag,
+      (t) => t === 'Ready',
+    )
 
-    // Move the input: the query goes Success+refetching (SWR) — Ready holds.
     seed.set(2)
-    yield* until(() => qStore.get(), (q) => q._tag === 'Success' && q.refetching)
+    yield* until(
+      () => qStore.get(),
+      (q) => q._tag === 'Success' && q.refetching,
+    )
     expect(store.get()._tag).toBe('Ready')
-    yield* until(() => qStore.get(), (q) => q._tag === 'Success' && !q.refetching)
+    yield* until(
+      () => qStore.get(),
+      (q) => q._tag === 'Success' && !q.refetching,
+    )
     expect(store.get()._tag).toBe('Ready')
   }).pipe(Effect.provide(TestLayer))
 })
@@ -150,28 +157,27 @@ it.live('a first-load failure surfaces as Errored with the failure, and a retry
   )
   return Effect.gen(function* () {
     const store = yield* Gate.store
-    const errored = yield* until(() => store.get(), (s) => s._tag === 'Errored')
+    const errored = yield* until(
+      () => store.get(),
+      (s) => s._tag === 'Errored',
+    )
     if (errored._tag === 'Errored') {
       expect(errored.errors).toHaveLength(1)
       const failure = errored.errors[0]
       expect(failure instanceof Boom && failure.message).toBe('server down')
     }
 
-    // The retry path: the server heals, a listed fact refetches, Ready lands.
     healthy.now = true
     yield* Event.dispatch(Poke, {})
-    yield* until(() => store.get()._tag, (t) => t === 'Ready')
+    yield* until(
+      () => store.get()._tag,
+      (t) => t === 'Ready',
+    )
     expect(store.get()._tag).toBe('Ready')
   }).pipe(Effect.provide(TestLayer))
 })
 
 it.live('settle-gap pin: a chained gate never leaks Ready between hops', () => {
-  // B enables only when A has succeeded — the app's Session → Bootstrap shape.
-  // The dangerous instant: A flips Success while B is still Idle (Idle counts
-  // Ready), so a naive merge could notify Ready before B's driver flips it to
-  // Loading. Layer dependency order (B's driver subscribes to A's store before
-  // the boundary does) plus the one-microtask fixpoint flush close the gap;
-  // this records every notification to prove no intermediate Ready escapes.
   class Seed extends State.make('seed', S.Number) {}
   class Inputs extends StateGroup.make(Seed) {}
   class A extends AsyncCalc.make('A', {
@@ -204,20 +210,16 @@ it.live('settle-gap pin: a chained gate never leaks Ready between hops', () => {
     })
     expect(store.get()._tag).toBe('Pending')
 
-    yield* until(() => store.get()._tag, (t) => t === 'Ready')
-    yield* tick(30) // let any straggler notification land before judging
-    // ONE Ready, at the end — never a Ready while B's hop was still pending.
+    yield* until(
+      () => store.get()._tag,
+      (t) => t === 'Ready',
+    )
+    yield* tick(30)
     expect(observed).toEqual(['Ready'])
   }).pipe(Effect.provide(TestLayer))
 })
 
 it.live('once + a Calc hop in the chain: the latch never freezes a mid-flush Ready', () => {
-  // The app's boot shape: AsyncCalc A → plain Calc projecting it → AsyncCalc B
-  // gated on the projection. Propagation crosses TWO scheduler-flush rounds,
-  // so when A settles there is a mid-flush frame where B has not yet flipped
-  // to Loading — a recompute-time latch would freeze that intermediate Ready
-  // and the boundary would abandon B's whole first load (caught live by the
-  // boot-frames walk: nav in, boards card still spinning).
   class Seed extends State.make('seed', S.Number) {}
   class Inputs extends StateGroup.make(Seed) {}
   class A extends AsyncCalc.make('A', {
@@ -247,20 +249,24 @@ it.live('once + a Calc hop in the chain: the latch never freezes a mid-flush Rea
   return Effect.gen(function* () {
     const bStore = yield* B.store
     const store = yield* Gate.store
-    // While B's first load is in flight the boundary MUST still be Pending —
-    // a poisoned latch would already report Ready here.
-    yield* until(() => bStore.get()._tag, (t) => t === 'Loading')
+    yield* until(
+      () => bStore.get()._tag,
+      (t) => t === 'Loading',
+    )
     expect(store.get()._tag).toBe('Pending')
-    yield* until(() => bStore.get()._tag, (t) => t === 'Success')
-    yield* until(() => store.get()._tag, (t) => t === 'Ready')
+    yield* until(
+      () => bStore.get()._tag,
+      (t) => t === 'Success',
+    )
+    yield* until(
+      () => store.get()._tag,
+      (t) => t === 'Ready',
+    )
     expect(store.get()._tag).toBe('Ready')
   }).pipe(Effect.provide(TestLayer))
 })
 
 it.live('once: a covered gate enabling AFTER the latch never re-pends the boundary', () => {
-  // The boot-boundary semantics: a route-gated query (the board) first loads
-  // on a later navigation — its own screen owns that loading state, the shell
-  // splash must not come back.
   class Route extends State.make('routeFlag', S.Boolean) {}
   class Inputs extends StateGroup.make(Route) {}
   class Always extends AsyncCalc.make('Always', {
@@ -289,13 +295,21 @@ it.live('once: a covered gate enabling AFTER the latch never re-pends the bounda
     const route = yield* StateGroup.select(Inputs, 'routeFlag').store
     const routedStore = yield* Routed.store
     const store = yield* Gate.store
-    yield* until(() => store.get()._tag, (t) => t === 'Ready')
+    yield* until(
+      () => store.get()._tag,
+      (t) => t === 'Ready',
+    )
 
-    // "Navigate": the routed query enables and goes Loading — latched Ready holds.
     route.set(true)
-    yield* until(() => routedStore.get()._tag, (t) => t === 'Loading')
+    yield* until(
+      () => routedStore.get()._tag,
+      (t) => t === 'Loading',
+    )
     expect(store.get()._tag).toBe('Ready')
-    yield* until(() => routedStore.get()._tag, (t) => t === 'Success')
+    yield* until(
+      () => routedStore.get()._tag,
+      (t) => t === 'Success',
+    )
     expect(store.get()._tag).toBe('Ready')
   }).pipe(Effect.provide(TestLayer))
 })