@playfast/reform 0.1.0 → 1.1.1

package/src/remote/remoteState.typecheck.ts

@@ -1,7 +1,3 @@
-// Type-level proofs enforced by `tsc --noEmit` over `src` (not a vitest file).
-// These guard the cast-free seam: if a guarantee regresses, a `@ts-expect-error`
-// goes unused or an assignment fails, and `tsc` breaks.
-
 import { Context, Effect, Layer, Match, Schema as S } from 'effect'
 import * as Boundary from '../boundary/boundary'
 import type { AsyncData } from '../calc/asyncData'
@@ -25,8 +21,6 @@ const RenameIntentBase: Event.EventClass<
 > = Event.make('TRenameIntent', S.Struct({ id: S.String, name: S.String }))
 class RenameIntent extends RenameIntentBase {}
 type Intent = Event.EventType<typeof AddIntent> | Event.EventType<typeof RenameIntent>
-// An undeclared intent tag, named so the negative `apply` below avoids an inline
-// object-type parameter.
 type DeleteIntentTag = { readonly _tag: 'TDeleteIntent' }
 
 const PageBase: State.StateClass<'tcPage', number> = State.make('tcPage', S.Number)
@@ -63,10 +57,6 @@ const ItemsBase: RemoteState.RemoteStateClass<
 })
 class Items extends ItemsBase {}
 
-// --- intent-union inference: apply/send receive exactly the declared union ---
-
-// POSITIVE: a Match.exhaustive fold over the declared intents compiles, `send`'s
-// R2 flows from its body, and gated `disabled` is accepted.
 export const okLive: Layer.Layer<
   | Store<AsyncData<ReadonlyArray<Row>, string, true>>
   | Store<ReadonlyArray<RemoteState.PendingIntent<Intent>>>,
@@ -87,7 +77,6 @@ export const okLive: Layer.Layer<
   disabled: ({ tcPage }) => tcPage < 0,
 })
 
-// NEGATIVE: a handler typed for an undeclared tag does not fit the union.
 export const badIntent: Layer.Layer<
   | Store<AsyncData<ReadonlyArray<Row>, string, true>>
   | Store<ReadonlyArray<RemoteState.PendingIntent<Intent>>>,
@@ -100,18 +89,12 @@ export const badIntent: Layer.Layer<
   apply: (rows: ReadonlyArray<Row>, intent: DeleteIntentTag) => rows,
 })
 
-// --- layer requirement honesty: RIn is complete and exact ---
-
-// POSITIVE: the layer's RIn is exactly the input stores, the query/send context,
-// and the engine registries — and its ROut names the overlay + pending stores.
 export const okLayer: Layer.Layer<
   Store<AsyncData<ReadonlyArray<Row>, string, true>> | Store<ReadonlyArray<RemoteState.PendingIntent<Intent>>>,
   never,
   Store<number> | SendDep | Reducers | Procedures | Channels | Bus
 > = okLive
 
-// NEGATIVE: dropping the send dependency (R2) from the annotation fails —
-// requirements cannot be silently widened away.
 // @ts-expect-error the send body's R2 must appear in the layer's requirements
 export const badLayer: Layer.Layer<
   Store<AsyncData<ReadonlyArray<Row>, string, true>> | Store<ReadonlyArray<RemoteState.PendingIntent<Intent>>>,
@@ -119,8 +102,6 @@ export const badLayer: Layer.Layer<
   Store<number> | Reducers | Procedures | Channels | Bus
 > = okLive
 
-// --- alwaysOn / error narrowing: the read carries exactly the possible arms ---
-
 const AlwaysItemsBase: RemoteState.RemoteStateClass<
   'TAlwaysItems',
   readonly [typeof page],
@@ -136,7 +117,6 @@ const AlwaysItemsBase: RemoteState.RemoteStateClass<
 })
 class AlwaysItems extends AlwaysItemsBase {}
 
-// NEGATIVE: an alwaysOn remote state rejects `disabled` (erased to never).
 export const badDisabled: Layer.Layer<
   | Store<AsyncData<ReadonlyArray<Row>, never, false>>
   | Store<ReadonlyArray<RemoteState.PendingIntent<Event.EventType<typeof AddIntent>>>>,
@@ -156,40 +136,27 @@ declare const idleArm: 'Idle'
 declare const errorArm: 'Error'
 declare const fourArms: 'Idle' | 'Loading' | 'Success' | 'Error'
 
-// POSITIVE: alwaysOn + no `error` schema ⇒ at most Loading | Success…
 export const alwaysExact: 'Loading' | 'Success' = alwaysArms
-// …and gated + `error` schema ⇒ exactly all four arms (both directions).
 export const gatedSubset: 'Idle' | 'Loading' | 'Success' | 'Error' = gatedArms
 export const gatedAll: Effect.Effect.Success<typeof Items>['_tag'] = fourArms
 
-// NEGATIVE: the excluded arms really are gone from the read type.
 // @ts-expect-error an alwaysOn remote state has no Idle arm
 export const noIdle: Effect.Effect.Success<typeof AlwaysItems>['_tag'] = idleArm
 // @ts-expect-error no `error` schema ⇒ no Error arm
 export const noError: Effect.Effect.Success<typeof AlwaysItems>['_tag'] = errorArm
 
-// --- surface shape: Sources where expected, never a reducer target ---
-
-// POSITIVE: the class itself is a `Source` (a calc input / boundary coverage),
-// valued at the overlaid lifecycle.
 export const classAsSource: Source<'TItems', AsyncData<ReadonlyArray<Row>, string, true>> = Items
 export const classAsAnySource: AnySource = Items
 
-// POSITIVE: `pending` is an ordinary read-only `Source` (badges, "saving…" chrome).
 export const pendingAsSource: Source<'TItems/pending', ReadonlyArray<RemoteState.PendingIntent<Intent>>> =
   Items.pending
 
-// POSITIVE: `truth` is the un-overlaid lifecycle under the same arms.
 export const truthAsSource: Source<'TItems/truth', AsyncData<ReadonlyArray<Row>, string, true>> =
   Items.truth
 
-// POSITIVE: a boundary covers the remote state like any lifecycle source.
 export const covered: Boundary.BoundaryClass<'TItemsBoundary', readonly [typeof Items]> =
   Boundary.make('TItemsBoundary', { over: [Items] })
 
-// NEGATIVE: the pending queue is NOT user state — `Reducer.make` cannot target
-// it (it is a `StateToken`, not a `StateClass`; the hidden queue reducer is the
-// sole writer).
 export const badReducerTarget: Reducer.StateReducerClass<State.AnyState, readonly [typeof AddIntent]> =
   // @ts-expect-error the pending queue is not a reducible state
   Reducer.make('TBadReducer', {

package/src/remote/remoteStateDefinition.ts

@@ -0,0 +1,135 @@
+import { Context, Effect, Schema } from 'effect'
+import type { Effect as EffectType } from 'effect/Effect'
+import { type Manifest, yieldableClass } from '../definition/definition'
+import * as Event from '../event/event'
+import { readTracked } from '../internal/track'
+import type { AnySchema } from '../internal/variance'
+import type { GatedOf } from '../internal/queryDriver'
+import { gatedFlag } from '../internal/queryDriver'
+import type { AnySource } from '../state/token'
+import { StateToken } from '../state/token'
+import type { Store } from '../internal/store'
+import type { AsyncData, AsyncError, AsyncSuccess } from '../calc/asyncData'
+
+export interface PendingIntent<I> {
+  readonly opId: string
+  readonly intent: I
+  readonly status: 'sending' | 'confirmed'
+}
+
+export interface FailedIntent<I> {
+  readonly intent: I
+  readonly error: unknown
+}
+
+export type RemoteStateSettled<A, E> = AsyncSuccess<A> | AsyncError<E>
+
+// ExternalApi: optional `intent` only on Queued envelopes
+export interface QueueFoldEventExternalApi<I> {
+  readonly _tag: string
+  readonly opId: string
+  readonly intent?: I
+}
+
+export interface RemoteStateManifestExternalApi<N extends string, A, E> extends Manifest {
+  readonly kind: 'RemoteState'
+  readonly name: N
+  readonly output: AnySchema<A>
+  readonly error?: AnySchema<E>
+  readonly gated: boolean
+  readonly intents: ReadonlyArray<string>
+}
+
+export interface RemoteStateClass<
+  out N extends string,
+  out Inputs extends ReadonlyArray<AnySource>,
+  in out Intents extends ReadonlyArray<Event.AnyEvent>,
+  in out A,
+  in out E,
+  in out Gated extends boolean,
+> extends EffectType<AsyncData<A, E, Gated>, never, Store<AsyncData<A, E, Gated>>> {
+  new (): {}
+  readonly manifest: RemoteStateManifestExternalApi<N, A, E>
+  readonly store: Context.Tag<Store<AsyncData<A, E, Gated>>, Store<AsyncData<A, E, Gated>>>
+  readonly name: N
+  readonly inputs: Inputs
+  readonly intents: Intents
+  readonly gated: Gated
+  readonly truth: StateToken<`${N}/truth`, AsyncData<A, E, Gated>>
+  // pending is a Source (not StateClass) so user reducers cannot target it
+  readonly pending: StateToken<
+    `${N}/pending`,
+    ReadonlyArray<PendingIntent<Event.EventType<Intents[number]>>>
+  >
+  readonly Failed: Event.EventClass<`${N}/Failed`, FailedIntent<Event.EventType<Intents[number]>>>
+}
+
+export interface RemoteStateConfigExternalApi<
+  Inputs extends ReadonlyArray<AnySource>,
+  Intents extends ReadonlyArray<Event.AnyEvent>,
+  A,
+  E,
+  AlwaysOn extends boolean,
+> {
+  readonly inputs: Inputs
+  readonly output: AnySchema<A>
+  readonly error?: AnySchema<E>
+  readonly alwaysOn?: AlwaysOn
+  readonly intents: Intents
+}
+
+// Schema.Unknown in intent slot: Intents is open at make-time; event schemas are reflective only
+export const looseSchema = <P>(schema: Schema.Schema.AnyNoContext): AnySchema<P> => schema
+
+export const make = <
+  const N extends string,
+  const Inputs extends ReadonlyArray<AnySource>,
+  const Intents extends ReadonlyArray<Event.AnyEvent>,
+  A,
+  E = never,
+  const AlwaysOn extends boolean = false,
+>(
+  name: N,
+  config: RemoteStateConfigExternalApi<Inputs, Intents, A, E, AlwaysOn>,
+): RemoteStateClass<N, Inputs, Intents, A, E, GatedOf<AlwaysOn>> => {
+  type I = Event.EventType<Intents[number]>
+  const store = Context.GenericTag<Store<AsyncData<A, E, GatedOf<AlwaysOn>>>>(
+    `reform/remoteState/${name}`,
+  )
+  const truthTag = Context.GenericTag<Store<AsyncData<A, E, GatedOf<AlwaysOn>>>>(
+    `reform/remoteState/${name}/truth`,
+  )
+  const pendingTag = Context.GenericTag<Store<ReadonlyArray<PendingIntent<I>>>>(
+    `reform/remoteState/${name}/pending`,
+  )
+  const gated = gatedFlag(config.alwaysOn)
+  const manifest: RemoteStateManifestExternalApi<N, A, E> = {
+    kind: 'RemoteState',
+    name,
+    output: config.output,
+    gated,
+    intents: config.intents.map((event) => event.tag),
+    ...(config.error !== undefined ? { error: config.error } : {}),
+  }
+  // Annotated consts preserve template-literal types for interface matching
+  const truthName: `${N}/truth` = `${name}/truth`
+  const pendingName: `${N}/pending` = `${name}/pending`
+  const failedName: `${N}/Failed` = `${name}/Failed`
+  const read = Effect.flatMap(store, readTracked)
+  return yieldableClass(read, {
+    manifest,
+    store,
+    name,
+    inputs: config.inputs,
+    intents: config.intents,
+    gated,
+    truth: new StateToken(truthName, truthTag),
+    pending: new StateToken(pendingName, pendingTag),
+    Failed: Event.make(
+      failedName,
+      looseSchema<FailedIntent<I>>(
+        Schema.Struct({ intent: Schema.Unknown, error: Schema.Unknown }),
+      ),
+    ),
+  })
+}

package/src/remote/remoteStateLayers.ts

@@ -0,0 +1,118 @@
+import { Context, Effect, Layer, MutableRef } from 'effect'
+import { type AnyAsyncData, AsyncData, narrowStore, widenStore } from '../calc/asyncData'
+import { reuse as shareStructure } from '../internal/reuse'
+import { resolveScheduler } from '../internal/scheduler'
+import { sameKey } from '../internal/sources'
+import { makeDerivedStore, type Store } from '../internal/store'
+import { narrowHandled } from '../runtime/bus'
+import { type ReducerEntry, Reducers } from '../runtime/loop'
+import type { PendingIntent, QueueFoldEventExternalApi } from './remoteStateDefinition'
+
+interface OverlayLayerOptions<I, A, E, Gated extends boolean> {
+  readonly apply: (current: A, intent: I) => A
+  readonly pendingTag: Context.Tag<Store<ReadonlyArray<PendingIntent<I>>>, Store<ReadonlyArray<PendingIntent<I>>>>
+  readonly reuse: boolean | undefined
+  readonly storeTag: Context.Tag<Store<AsyncData<A, E, Gated>>, Store<AsyncData<A, E, Gated>>>
+  readonly truthTag: Context.Tag<Store<AsyncData<A, E, Gated>>, Store<AsyncData<A, E, Gated>>>
+}
+
+export const makeOverlayLayer = <I, A, E, Gated extends boolean>(
+  options: OverlayLayerOptions<I, A, E, Gated>,
+): Layer.Layer<Store<AsyncData<A, E, Gated>>, never, Store<AsyncData<A, E, Gated>> | Store<ReadonlyArray<PendingIntent<I>>>> =>
+  Layer.scoped(
+    options.storeTag,
+    Effect.gen(function* () {
+      const scheduler = yield* resolveScheduler
+      const feedStore = widenStore<A, E, Gated>(yield* options.truthTag)
+      const queueStore = yield* options.pendingTag
+      const memo = MutableRef.make<
+        { readonly key: ReadonlyArray<unknown>; readonly output: AnyAsyncData<A, E> } | undefined
+      >(undefined)
+      const recompute = (): AnyAsyncData<A, E> => {
+        const feed = feedStore.getSnapshot()
+        const pending = queueStore.getSnapshot()
+        const key = [feed, pending]
+        const previous = MutableRef.get(memo)
+        if (previous !== undefined && sameKey(key, previous.key)) {
+          return previous.output
+        }
+        const applyPending = (base: A): A =>
+          pending.reduce((applied, entry) => options.apply(applied, entry.intent), base)
+        const overlaid: AnyAsyncData<A, E> =
+          feed._tag === 'Success' ? AsyncData.success(applyPending(feed.value), feed.refetching) : feed
+        const output =
+          options.reuse === true &&
+          previous !== undefined &&
+          previous.output._tag === 'Success' &&
+          overlaid._tag === 'Success'
+            ? AsyncData.success(shareStructure(previous.output.value, overlaid.value), overlaid.refetching)
+            : overlaid
+        MutableRef.set(memo, { key, output })
+        return output
+      }
+      const subscribe = (listener: () => void): (() => void) => {
+        const offFeed = feedStore.subscribe(listener)
+        const offQueue = queueStore.subscribe(listener)
+        return () => {
+          offFeed()
+          offQueue()
+        }
+      }
+      const derived = makeDerivedStore(recompute, subscribe, scheduler)
+      yield* Effect.addFinalizer(() => Effect.sync(derived.unsubscribe))
+      return narrowStore<A, E, Gated>(derived.store)
+    }),
+  )
+
+interface QueueReducerOptions<I> {
+  readonly ackedTag: string
+  readonly name: string
+  readonly pendingTag: Context.Tag<Store<ReadonlyArray<PendingIntent<I>>>, Store<ReadonlyArray<PendingIntent<I>>>>
+  readonly queuedTag: string
+  readonly settledTag: string
+}
+
+export const makeQueueReducerLayer = <I>(
+  options: QueueReducerOptions<I>,
+): Layer.Layer<never, never, Reducers | Store<ReadonlyArray<PendingIntent<I>>>> => {
+  const handles: ReadonlySet<string> = new Set([options.queuedTag, options.ackedTag, options.settledTag])
+  const fold = (
+    queue: ReadonlyArray<PendingIntent<I>>,
+    event: QueueFoldEventExternalApi<I>,
+  ): ReadonlyArray<PendingIntent<I>> => {
+    if (event._tag === options.queuedTag) {
+      return event.intent === undefined
+        ? queue
+        : [...queue, { opId: event.opId, intent: event.intent, status: 'sending' }]
+    }
+    if (event._tag === options.ackedTag) {
+      const sending = queue.some((entry) => entry.opId === event.opId && entry.status === 'sending')
+      if (!sending) {
+        return queue
+      }
+      return queue.map((entry) =>
+        entry.opId === event.opId ? { ...entry, status: 'confirmed' as const } : entry,
+      )
+    }
+    return queue.some((entry) => entry.opId === event.opId)
+      ? queue.filter((entry) => entry.opId !== event.opId)
+      : queue
+  }
+  return Layer.scopedDiscard(
+    Effect.gen(function* () {
+      const reducers = yield* Reducers
+      if (reducers.entries.some((entry) => entry.name === options.name)) {
+        yield* Effect.logWarning(`reform: duplicate reducer name '${options.name}' registered`)
+      }
+      const store = yield* options.pendingTag
+      const entry: ReducerEntry = {
+        name: options.name,
+        handles,
+        apply: (event) => store.set(fold(store.get(), narrowHandled(event))),
+      }
+      yield* Effect.acquireRelease(Effect.sync(() => reducers.register(entry)), () =>
+        Effect.sync(() => reducers.unregister(entry)),
+      )
+    }),
+  )
+}

package/src/remote/remoteStateLiveTypes.ts

@@ -0,0 +1,59 @@
+import { Effect } from 'effect'
+import * as Event from '../event/event'
+import * as Channel from '../channel/channel'
+import type { InputsObject, InvalidateBy } from '../internal/sources'
+import type { AnySource } from '../state/token'
+import type { RemoteStateSettled } from './remoteStateDefinition'
+
+type EventPayload<Ev extends Event.AnyEvent> = Ev extends Event.EventClass<string, infer P>
+  ? P
+  : never
+
+export type RemoteStateLiveExternalApi<
+  Inputs extends ReadonlyArray<AnySource>,
+  Intents extends ReadonlyArray<Event.AnyEvent>,
+  A,
+  E,
+  Gated extends boolean,
+  R,
+  R2,
+  SettledEvent extends Event.AnyEvent = never,
+> = {
+  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
+  // Any failure settles + Failed; response value ignored — truth via invalidated query
+  readonly send: (intent: Event.EventType<Intents[number]>) => Effect.Effect<unknown, unknown, R2>
+  // Must be idempotent against truth that already carries the intent
+  readonly apply: (value: A, intent: Event.EventType<Intents[number]>) => A
+  readonly channel?: Channel.ChannelClass
+  readonly invalidateBy?: InvalidateBy<Inputs>
+  readonly invalidateOn?: ReadonlyArray<Event.AnyEvent>
+  readonly coalesce?: 'switch' | 'trailing'
+  readonly reuse?: boolean
+  readonly settled?: {
+    readonly event: SettledEvent
+    readonly payload: (result: RemoteStateSettled<A, E>) => EventPayload<SettledEvent>
+  }
+  // Only settled server truth is persisted (overlay is a separate store)
+  readonly persist?:
+    | boolean
+    | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
+} & (Gated extends true
+  ? { readonly disabled?: (inputs: InputsObject<Inputs>) => boolean }
+  : { readonly disabled?: never })
+
+// Runtime view: `disabled` is `never` at type level for non-gated definitions
+export type RemoteStateLiveRuntimeExternalApi<Inputs extends ReadonlyArray<AnySource>, A, E, R> = {
+  readonly query: (inputs: InputsObject<Inputs>) => Effect.Effect<A, E, R>
+  readonly invalidateBy?: InvalidateBy<Inputs>
+  readonly disabled?: (inputs: InputsObject<Inputs>) => boolean
+  readonly coalesce?: 'switch' | 'trailing'
+  readonly reuse?: boolean
+  readonly persist?:
+    | boolean
+    | { readonly key?: string | ((inputs: InputsObject<Inputs>) => string) }
+}
+
+export interface SettleLink {
+  readonly requested: () => number
+  readonly register: (opId: string, waitFor: number) => void
+}

package/src/remote/remoteStateSend.ts

@@ -0,0 +1,64 @@
+import { Context, Effect, Either, Layer } from 'effect'
+import * as Channel from '../channel/channel'
+import * as Event from '../event/event'
+import { Bus, narrowHandled } from '../runtime/bus'
+import type { SettleLink } from './remoteStateLiveTypes'
+
+interface SendProcedureOptions<I, R> {
+  readonly acked: Event.EventClass<string, { readonly opId: string }>
+  readonly channel: Channel.ChannelClass
+  readonly failed: Event.EventClass<string, { readonly intent: I; readonly error: unknown }>
+  readonly handles: ReadonlySet<string>
+  readonly invalidated: Event.EventClass<string, {}>
+  readonly linkTag: Context.Tag<SettleLink, SettleLink>
+  readonly name: string
+  readonly queued: Event.EventClass<string, { readonly opId: string; readonly intent: I }>
+  readonly send: (intent: I) => Effect.Effect<unknown, unknown, R>
+  readonly settled: Event.EventClass<string, { readonly opId: string }>
+}
+
+export const makeSendProcedureLayer = <I, R>(
+  options: SendProcedureOptions<I, R>,
+): Layer.Layer<never, never, Channel.Procedures | SettleLink | Bus | R> =>
+  Layer.scopedDiscard(
+    Effect.gen(function* () {
+      const procedures = yield* Channel.Procedures
+      if (procedures.entries.some((entry) => entry.name === options.name)) {
+        yield* Effect.logWarning(`reform: duplicate procedure name '${options.name}' registered`)
+      }
+      const link = yield* options.linkTag
+      const runtime = yield* Effect.runtime<Bus | R>()
+      const deliver = Effect.fn('deliver')(
+        function* (intent: I): Effect.fn.Return<void, never, Bus | R> {
+          const opId = yield* Effect.sync(() => crypto.randomUUID())
+          yield* Event.dispatch(options.queued, { opId, intent })
+          const outcome = yield* options.send(intent).pipe(
+            Effect.catchAllDefect((defect) => Effect.fail(defect)),
+            Effect.either,
+            Effect.onInterrupt(() => Event.dispatch(options.settled, { opId })),
+          )
+          yield* Either.match(outcome, {
+            onLeft: (error) =>
+              Effect.zipRight(
+                Event.dispatch(options.failed, { intent, error }),
+                Event.dispatch(options.settled, { opId }),
+              ),
+            onRight: () =>
+              Effect.sync(() => link.register(opId, link.requested() + 1)).pipe(
+                Effect.zipRight(Event.dispatch(options.acked, { opId })),
+                Effect.zipRight(Event.dispatch(options.invalidated, {})),
+              ),
+          })
+        },
+      )
+      const entry: Channel.ProcedureEntry = {
+        name: options.name,
+        channelName: options.channel.manifest.name,
+        handles: options.handles,
+        run: (event) => Effect.provide(deliver(narrowHandled<I>(event)), runtime),
+      }
+      yield* Effect.acquireRelease(Effect.sync(() => procedures.register(entry)), () =>
+        Effect.sync(() => procedures.unregister(entry)),
+      )
+    }),
+  )

package/src/runtime/appRuntime.test.ts

@@ -0,0 +1,197 @@
+import { Context, Duration, Effect, Layer, Schema as S } from "effect";
+import { expect, it } from "@effect/vitest";
+import * as Composition from "../compose/composition";
+import { provide } from "../compose/provide";
+import { mount } from "../compose/structure";
+import * as Ui from "../compose/ui";
+import { ui } from "../compose/ui";
+import * as Event from "../event/event";
+import * as Feature from "../feature/feature";
+import { featureModule } from "../feature/feature";
+import * as Reducer from "../reducer/reducer";
+import { scene } from "../scene/scene";
+import * as State from "../state/state";
+import { Engine, Reducers } from "./loop";
+import { makeAppRuntime } from "./appRuntime";
+
+// The host-level mount lifecycle: `RuntimeHandle.mountFeature` forks the mount,
+// and its disposer must CANCEL a mount whose fiber has not run yet (StrictMode
+// cleanup/setup, fast remounts) — a scope close alone does not interrupt, so a
+// stale mount would still register reducers and dispatch `binding.boot` onto the
+// shared bus.
+
+class Tick extends Event.make("appRuntime.Tick", S.Struct({})) {}
+class Count extends State.make("appRuntime.count", S.Number) {}
+class CountReducer extends Reducer.make("appRuntime.CountReducer", {
+  states: [Count],
+  events: [Tick],
+}) {}
+
+class CtrUi extends ui("appRuntime.CtrUi")<{ props: {} }>() {}
+class CtrComp extends Composition.make("appRuntime.CtrComp", {
+  title: "Counter",
+  ui: CtrUi,
+}) {}
+
+class CounterFeature extends Feature.make("appRuntime.counter", {
+  composition: CtrComp,
+  module: featureModule(
+    [],
+    Reducer.live(CountReducer, (n) => n + 1).pipe(
+      Layer.provideMerge(State.live(Count, 0)),
+    ),
+  ),
+  boot: [Event.construct(Tick, {})],
+}) {}
+
+class RootUi extends ui("appRuntime.RootUi")<{ props: {} }>() {}
+class RootComp extends Composition.make("appRuntime.RootComp", {
+  title: "Root",
+  ui: RootUi,
+}) {}
+const RootLive = Composition.live(RootComp, function* () {
+  return mount({ props: {}, slots: {}, events: {} });
+});
+
+const rootScene = () =>
+  scene(RootComp, {
+    provide: [
+      RootLive.pipe(
+        Layer.provideMerge(
+          provide(
+            RootUi,
+            Ui.make(RootUi, () => null),
+          ),
+        ),
+        Layer.provideMerge(Engine),
+      ),
+    ],
+  });
+
+const settle = Effect.sleep(Duration.millis(50));
+const appRuntime = Effect.acquireRelease(
+  Effect.sync(() => makeAppRuntime(rootScene())),
+  (app) => Effect.sync(() => app.dispose()),
+);
+
+interface ParentValueService {
+  readonly value: string;
+}
+const ParentValueBase: Context.TagClass<
+  ParentValue,
+  "appRuntime.ParentValue",
+  ParentValueService
+> = Context.Tag("appRuntime.ParentValue")<ParentValue, ParentValueService>();
+class ParentValue extends ParentValueBase {}
+
+interface ChildValueService {
+  readonly value: string;
+}
+const ChildValueBase: Context.TagClass<
+  ChildValue,
+  "appRuntime.ChildValue",
+  ChildValueService
+> = Context.Tag("appRuntime.ChildValue")<ChildValue, ChildValueService>();
+class ChildValue extends ChildValueBase {}
+
+class ParentFeature extends Feature.make("appRuntime.parent", {
+  composition: CtrComp,
+  module: featureModule(
+    [],
+    Layer.succeed(ParentValue, { value: "from-parent" }),
+  ),
+}) {}
+
+class ChildFeature extends Feature.make("appRuntime.child", {
+  composition: CtrComp,
+  module: featureModule(
+    [ParentValue],
+    Layer.effect(
+      ChildValue,
+      Effect.map(ParentValue, ({ value }) => ({ value })),
+    ),
+  ),
+}) {}
+
+it.scopedLive(
+  "disposing a mount before its fiber runs cancels it — no registration, no boot, no handler calls",
+  () =>
+    Effect.gen(function* () {
+      const app = yield* appRuntime;
+      const baseline = app.read(Reducers).entries.length;
+      const calls = { live: 0, failed: 0 };
+      const dispose = app.mountFeature(CounterFeature.binding, {
+        onLive: () => {
+          calls.live += 1;
+        },
+        onFailed: () => {
+          calls.failed += 1;
+        },
+      });
+      // Same-tick dispose (the StrictMode cleanup shape): the fork has not run yet.
+      dispose();
+      yield* settle;
+      expect(calls).toEqual({ live: 0, failed: 0 });
+      expect(app.read(Reducers).entries.length).toBe(baseline);
+      expect(app.read(Reducers).byTag.get("appRuntime.Tick")).toBeUndefined();
+    }),
+);
+
+it.scopedLive(
+  "an undisposed mount still goes live, and disposing it after live reclaims the registration",
+  () =>
+    Effect.gen(function* () {
+      const app = yield* appRuntime;
+      const baseline = app.read(Reducers).entries.length;
+      const calls = { live: 0, failed: 0 };
+      const dispose = app.mountFeature(CounterFeature.binding, {
+        onLive: () => {
+          calls.live += 1;
+        },
+        onFailed: () => {
+          calls.failed += 1;
+        },
+      });
+      yield* Effect.sleep(Duration.millis(1)).pipe(
+        Effect.repeat({ until: () => calls.live === 1 }),
+        Effect.timeout(Duration.seconds(2)),
+      );
+      expect(calls).toEqual({ live: 1, failed: 0 });
+      expect(app.read(Reducers).entries.length).toBe(baseline + 1);
+      dispose();
+      yield* settle;
+      expect(app.read(Reducers).entries.length).toBe(baseline);
+    }),
+);
+
+it.scopedLive(
+  "a nested Feature mounts against its immediate parent context",
+  () =>
+    Effect.gen(function* () {
+      const app = yield* appRuntime;
+      const observed: Array<string> = [];
+      const disposers: Array<() => void> = [];
+      yield* Effect.addFinalizer(() =>
+        Effect.sync(() => disposers.reverse().forEach((dispose) => dispose())),
+      );
+      disposers.push(
+        app.mountFeature(ParentFeature.binding, {
+          onFailed: () => observed.push("parent-failed"),
+          onLive: (parent) => {
+            disposers.push(
+              parent.mountFeature(ChildFeature.binding, {
+                onFailed: () => observed.push("child-failed"),
+                onLive: (child) =>
+                  observed.push(child.read(ChildValue).value),
+              }),
+            );
+          },
+        }),
+      );
+      yield* Effect.sleep(Duration.millis(1)).pipe(
+        Effect.repeat({ until: () => observed.length > 0 }),
+        Effect.timeout(Duration.seconds(2)),
+      );
+      expect(observed).toEqual(["from-parent"]);
+    }),
+);