@playfast/reform 1.2.1 → 1.4.0

package/src/runtime/feature-mount-ownership.test.ts

@@ -0,0 +1,539 @@
+import { Context, Deferred, Effect, Function as Fn, Layer, Option, Schema as S } from 'effect'
+import { expect, it } from '@effect/vitest'
+import * as Calc from '../calc/calc'
+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 { profiledScene, scene } from '../scene/scene'
+import * as State from '../state/state'
+import { flush, until } from '../testkit/flight.testkit'
+import { Engine } from './loop'
+import { makeAppRuntime } from './appRuntime'
+import type { Instrumentation } from './instrumentation'
+import type { RuntimeHandle } from './runtimeHandle'
+
+// ===========================================================================
+// A hunt over the mount/teardown lifecycle of `makeAppRuntime`.
+//
+// Two defects, each with a PASSING control in the same test:
+//
+//   1. A feature mounted through a `RuntimeHandle` gets a standalone `Scope`
+//      that nothing owns. `mountScoped` registers its disposer in
+//      `activationDisposers` and `app.dispose()` runs them; the three feature
+//      mount paths register nothing, so the runtime (and a parent feature) tear
+//      down while every feature mounted on them keeps its finalizers unrun.
+//
+//   2. `profiledScene` publishes its `Instrumentation` through the
+//      `CurrentInstrumentation` FiberRef, set by `Layer.locally` over the scene's
+//      layers. A feature layer is built later, on a fiber forked from the
+//      ManagedRuntime, which never carried that local — so a mounted feature's
+//      state/calc spans are credited to the no-op sink while the very same
+//      frame's reducer spans (recorded by the scene-level drain loop) land.
+// ===========================================================================
+
+// 200 rounds x 10ms is `until`'s default; a shorter budget keeps a failing arm
+// quick while staying far above the microtask cost of a real release.
+const settledCount = (read: () => number, count: number): Effect.Effect<number> =>
+  until(read, (seen) => seen >= count, 40)
+
+// ---------------------------------------------------------------------------
+// Shared definitions
+// ---------------------------------------------------------------------------
+
+interface LifecycleProbeService {
+  readonly acquired: Array<string>
+  readonly released: Array<string>
+}
+
+const LifecycleProbeBase: Context.TagClass<
+  LifecycleProbe,
+  'hunt.LifecycleProbe',
+  LifecycleProbeService
+> = Context.Tag('hunt.LifecycleProbe')<LifecycleProbe, LifecycleProbeService>()
+class LifecycleProbe extends LifecycleProbeBase {}
+
+const makeProbe = (): LifecycleProbeService => ({ acquired: [], released: [] })
+
+interface ParentValueService {
+  readonly label: string
+}
+
+const ParentValueBase: Context.TagClass<ParentValue, 'hunt.ParentValue', ParentValueService> =
+  Context.Tag('hunt.ParentValue')<ParentValue, ParentValueService>()
+class ParentValue extends ParentValueBase {}
+
+class HuntUi extends ui('hunt.HuntUi')<{ props: {} }>() {}
+class HuntComp extends Composition.make('hunt.HuntComp', {
+  title: 'Hunt',
+  ui: HuntUi,
+})<HuntComp>() {}
+const HuntLive = Composition.live(HuntComp, function* () {
+  return mount({ props: {}, slots: {} })
+})
+
+class RootUi extends ui('hunt.RootUi')<{ props: {} }>() {}
+class RootComp extends Composition.make('hunt.RootComp', {
+  title: 'Root',
+  ui: RootUi,
+})<RootComp>() {}
+const RootLive = Composition.live(RootComp, function* () {
+  return mount({ props: {}, slots: {} })
+})
+
+const rootViews = RootLive.pipe(
+  Layer.provideMerge(
+    provide(
+      RootUi,
+      Ui.make(RootUi, () => null),
+    ),
+  ),
+)
+
+// A scoped marker: a mount whose scope is never closed leaves no `released` entry.
+const scopedMark = (label: string): Layer.Layer<never, never, LifecycleProbe> =>
+  Layer.scopedDiscard(
+    Effect.gen(function* () {
+      const probe = yield* LifecycleProbe
+      yield* Effect.acquireRelease(
+        Effect.sync(() => probe.acquired.push(label)),
+        () => Effect.sync(() => probe.released.push(label)),
+      )
+    }),
+  )
+
+// ---------------------------------------------------------------------------
+// 1a. `app.dispose()` and the feature mounted on it
+// ---------------------------------------------------------------------------
+
+class LeakFeature extends Feature.make('hunt.leak', {
+  composition: HuntComp,
+  module: featureModule([LifecycleProbe], Layer.merge(HuntLive, scopedMark('leak'))),
+}) {}
+
+class ControlFeature extends Feature.make('hunt.control', {
+  composition: HuntComp,
+  module: featureModule([LifecycleProbe], Layer.merge(HuntLive, scopedMark('control'))),
+}) {}
+
+const LeakNative = Feature.tree<typeof LeakFeature>(LeakFeature.token)
+const ControlNative = Feature.tree<typeof ControlFeature>(ControlFeature.token)
+
+const probeScene = (probe: LifecycleProbeService) =>
+  scene(RootComp, {
+    provide: [
+      rootViews.pipe(
+        Layer.provideMerge(Layer.succeed(LifecycleProbe, probe)),
+        Layer.provideMerge(Engine),
+      ),
+    ],
+  })
+
+it.scopedLive('app.dispose() closes the scope of a feature mounted on that runtime', () =>
+  Effect.gen(function* () {
+    const probe = makeProbe()
+    const app = makeAppRuntime(probeScene(probe))
+    yield* Effect.addFinalizer(() => Effect.sync(() => app.dispose()))
+
+    const seen = { leak: 0, control: 0, failed: 0 }
+    app.mountFeature(LeakNative.binding, {
+      onLive: () => {
+        seen.leak += 1
+      },
+      onFailed: () => {
+        seen.failed += 1
+      },
+    })
+    const disposeControl = app.mountFeature(ControlNative.binding, {
+      onLive: () => {
+        seen.control += 1
+      },
+      onFailed: () => {
+        seen.failed += 1
+      },
+    })
+
+    yield* settledCount(() => seen.leak + seen.control, 2)
+    expect(seen).toEqual({ leak: 1, control: 1, failed: 0 })
+    expect(probe.acquired.slice().sort()).toEqual(['control', 'leak'])
+
+    // CONTROL — same mount path, same scope shape: the mount's OWN disposer
+    // closes its scope and the release lands.
+    disposeControl()
+    yield* settledCount(() => probe.released.length, 1)
+    expect(probe.released).toEqual(['control'])
+
+    // The runtime is torn down while `leak` is still mounted. Its scope was
+    // created and forked by this runtime, so disposing the runtime must close it
+    // — `mountScoped`'s disposers are collected and run for exactly that reason.
+    app.dispose()
+    yield* settledCount(() => probe.released.length, 2)
+    yield* flush()
+    expect(probe.released.slice().sort()).toEqual(['control', 'leak'])
+  }),
+)
+
+// ---------------------------------------------------------------------------
+// 1b. A nested feature outlives the parent it was built against
+// ---------------------------------------------------------------------------
+
+class NestParentFeature extends Feature.make('hunt.nestParent', {
+  composition: HuntComp,
+  module: featureModule(
+    [LifecycleProbe],
+    Layer.mergeAll(
+      HuntLive,
+      Layer.succeed(ParentValue, { label: 'parent' }),
+      scopedMark('nest-parent'),
+    ),
+  ),
+}) {}
+
+class NestChildFeature extends Feature.make('hunt.nestChild', {
+  composition: HuntComp,
+  module: featureModule(
+    [LifecycleProbe, ParentValue],
+    Layer.merge(
+      HuntLive,
+      Layer.scopedDiscard(
+        Effect.gen(function* () {
+          const probe = yield* LifecycleProbe
+          const parent = yield* ParentValue
+          yield* Effect.acquireRelease(
+            Effect.sync(() => probe.acquired.push(`nest-child-of-${parent.label}`)),
+            () => Effect.sync(() => probe.released.push(`nest-child-of-${parent.label}`)),
+          )
+        }),
+      ),
+    ),
+  ),
+}) {}
+
+const NestParentNative = Feature.tree<typeof NestParentFeature>(NestParentFeature.token)
+const NestChildNative = Feature.tree<typeof NestChildFeature>(NestChildFeature.token)
+
+it.scopedLive('disposing a parent feature closes the child mounted through its handle', () =>
+  Effect.gen(function* () {
+    const probe = makeProbe()
+    const app = makeAppRuntime(probeScene(probe))
+    yield* Effect.addFinalizer(() => Effect.sync(() => app.dispose()))
+
+    const failures: Array<string> = []
+    const disposeParent = app.mountFeature(NestParentNative.binding, {
+      onFailed: () => failures.push('parent'),
+      onLive: (parent) => {
+        // The child is mounted through the parent's handle and its layer reads a
+        // service the parent's scope owns, so it is built against the parent.
+        parent.mountFeature(NestChildNative.binding, {
+          onFailed: () => failures.push('child'),
+          onLive: () => undefined,
+        })
+      },
+    })
+
+    yield* settledCount(() => probe.acquired.length, 2)
+    expect(failures).toEqual([])
+    expect(probe.acquired.slice().sort()).toEqual(['nest-child-of-parent', 'nest-parent'])
+
+    disposeParent()
+
+    // CONTROL — the parent's own disposer closes the parent's scope.
+    yield* until(
+      () => probe.released.includes('nest-parent'),
+      (found) => found,
+      40,
+    )
+    expect(probe.released).toContain('nest-parent')
+
+    // The child's layer was built against services the parent's scope has now
+    // finalized. It must not survive the parent it was mounted on.
+    yield* settledCount(() => probe.released.length, 2)
+    yield* flush()
+    expect(probe.released.slice().sort()).toEqual(['nest-child-of-parent', 'nest-parent'])
+  }),
+)
+
+// ---------------------------------------------------------------------------
+// 2. A runtime-mounted feature escapes the scene's instrumentation
+// ---------------------------------------------------------------------------
+
+interface Recorder {
+  readonly instrumentation: Instrumentation
+  readonly reducers: Array<string>
+  readonly states: Array<string>
+  readonly calcs: Array<string>
+}
+
+const makeRecorder = (): Recorder => {
+  const reducers: Array<string> = []
+  const states: Array<string> = []
+  const calcs: Array<string> = []
+  return {
+    reducers,
+    states,
+    calcs,
+    instrumentation: {
+      eventDispatched: () => {},
+      reducerRun: (name) => {
+        reducers.push(name)
+        return () => {}
+      },
+      stateUpdated: (name) => {
+        states.push(name)
+      },
+      calcRecomputed: (name) => {
+        calcs.push(name)
+        return () => {}
+      },
+      queryRun: () => () => {},
+      procedureRun: () => () => {},
+      uiRendered: () => () => {},
+      frame: () => () => {},
+    },
+  }
+}
+
+class HuntBumped extends Event.make('hunt.Bumped', S.Struct({})) {}
+
+class HuntSceneCount extends State.make('huntSceneCount', S.Number) {}
+class HuntSceneFold extends Reducer.make('hunt.SceneFold', {
+  states: [HuntSceneCount],
+  events: [HuntBumped],
+}) {}
+class HuntSceneDouble extends Calc.make('huntSceneDouble', {
+  inputs: [HuntSceneCount],
+  output: S.Number,
+}) {}
+
+class HuntFeatCount extends State.make('huntFeatCount', S.Number) {}
+class HuntFeatFold extends Reducer.make('hunt.FeatFold', {
+  states: [HuntFeatCount],
+  events: [HuntBumped],
+}) {}
+class HuntFeatDouble extends Calc.make('huntFeatDouble', {
+  inputs: [HuntFeatCount],
+  output: S.Number,
+}) {}
+
+class ProfiledFeature extends Feature.make('hunt.profiled', {
+  composition: HuntComp,
+  module: featureModule(
+    [],
+    Layer.merge(
+      HuntLive,
+      Calc.live(HuntFeatDouble, ({ huntFeatCount }) => huntFeatCount * 2).pipe(
+        Layer.provideMerge(Reducer.live(HuntFeatFold, (n) => n + 1)),
+        Layer.provideMerge(State.live(HuntFeatCount, 0)),
+      ),
+    ),
+  ),
+}) {}
+
+const ProfiledNative = Feature.tree<typeof ProfiledFeature>(ProfiledFeature.token)
+
+const profiledBase = scene(RootComp, {
+  provide: [
+    rootViews.pipe(
+      Layer.provideMerge(
+        Calc.live(HuntSceneDouble, ({ huntSceneCount }) => huntSceneCount * 2).pipe(
+          Layer.provideMerge(Reducer.live(HuntSceneFold, (n) => n + 1)),
+          Layer.provideMerge(State.live(HuntSceneCount, 0)),
+        ),
+      ),
+      Layer.provideMerge(Engine),
+    ),
+  ],
+})
+
+it.scopedLive("a profiled scene records a runtime-mounted feature's state and calc spans", () =>
+  Effect.gen(function* () {
+    const recorder = makeRecorder()
+    const app = makeAppRuntime(profiledScene(profiledBase, recorder.instrumentation))
+    yield* Effect.addFinalizer(() => Effect.sync(() => app.dispose()))
+
+    const seen = { live: 0, failed: 0 }
+    app.mountFeature(ProfiledNative.binding, {
+      onLive: () => {
+        seen.live += 1
+      },
+      onFailed: () => {
+        seen.failed += 1
+      },
+    })
+    yield* settledCount(() => seen.live + seen.failed, 1)
+    expect(seen).toEqual({ live: 1, failed: 0 })
+
+    // Both derived stores exist before the event, so both are subscribed to it.
+    const sceneDouble = app.read(HuntSceneDouble.store)
+    expect(sceneDouble.get()).toBe(0)
+
+    // ONE event, folded by BOTH reducers in the SAME frame of the SAME loop.
+    app.dispatch('High', Event.construct(HuntBumped, {}))
+    yield* settledCount(() => recorder.reducers.length, 2)
+    yield* until(
+      () => sceneDouble.get(),
+      (value) => value === 2,
+      40,
+    )
+    yield* flush()
+
+    // CONTROL — the recorder is live and the feature really folded on this
+    // runtime: the drain loop (a scene-level layer) reports BOTH reducer spans.
+    expect(recorder.reducers.slice().sort()).toEqual(['hunt.FeatFold', 'hunt.SceneFold'])
+    // CONTROL — state and calc spans are reported at all, for the scene's slices.
+    expect(recorder.states).toContain('huntSceneCount')
+    expect(recorder.calcs).toContain('huntSceneDouble')
+
+    // The feature's fold provably wrote its state and moved its calc in that same
+    // frame, but neither span reaches the scene's instrumentation.
+    expect(recorder.states).toContain('huntFeatCount')
+    expect(recorder.calcs).toContain('huntFeatDouble')
+  }),
+)
+
+// ---------------------------------------------------------------------------
+// 3. A composition activation still building when its owner feature is disposed
+//
+// `mountActivation` forks the activation's scope from the owner and then builds it
+// on a deferred `runFork`. Nothing registers that fiber with the scope, so an owner
+// that closes after the fork does not stop the build — it acquires against an
+// already-closed scope, releasing at the instant of acquisition, and the host is
+// handed an activation whose services are gone. Same shape as `forkFeatureMount`.
+// ---------------------------------------------------------------------------
+
+interface ActivationGateService {
+  readonly open: Deferred.Deferred<void>
+}
+
+const ActivationGateBase: Context.TagClass<
+  ActivationGate,
+  'hunt.ActivationGate',
+  ActivationGateService
+> = Context.Tag('hunt.ActivationGate')<ActivationGate, ActivationGateService>()
+class ActivationGate extends ActivationGateBase {}
+
+class ParkedUi extends ui('hunt.ParkedUi')<{ props: {} }>() {}
+class ParkedComp extends Composition.make('hunt.ParkedComp', {
+  title: 'Parked',
+  ui: ParkedUi,
+})<ParkedComp>() {}
+
+const ParkedLive = Composition.liveScoped(ParkedComp, {
+  render: function* () {
+    return mount({ props: {}, slots: {} })
+  },
+  activate: function* () {
+    const gate = yield* ActivationGate
+    const probe = yield* LifecycleProbe
+    // Parked before anything is acquired: a lazy import, a socket, a config read.
+    yield* Deferred.await(gate.open)
+    yield* Effect.acquireRelease(
+      Effect.sync(() => probe.acquired.push('parked-activation')),
+      () => Effect.sync(() => probe.released.push('parked-activation')),
+    )
+  },
+})
+
+class ActivationHostFeature extends Feature.make('hunt.activationHost', {
+  composition: HuntComp,
+  module: featureModule(
+    [LifecycleProbe, ActivationGate],
+    Layer.merge(
+      HuntLive,
+      ParkedLive.pipe(
+        Layer.provideMerge(
+          provide(
+            ParkedUi,
+            Ui.make(ParkedUi, () => null),
+          ),
+        ),
+      ),
+    ),
+  ),
+}) {}
+
+const ActivationHostNative = Feature.tree<typeof ActivationHostFeature>(ActivationHostFeature.token)
+
+// `RuntimeHandle<never>.read` cannot be spelled for a tag the erased handle does not
+// carry, so the read is coerced once, here, rather than at every call site.
+type ParkedService = Composition.CompositionService<{}, Ui.UiContract>
+const readParked = (handle: RuntimeHandle<never>): ParkedService => {
+  const read: (tag: typeof ParkedComp.tag) => ParkedService = Fn.unsafeCoerce(handle.read)
+  return read(ParkedComp.tag)
+}
+
+const gateScene = (probe: LifecycleProbeService, gate: ActivationGateService) =>
+  scene(RootComp, {
+    provide: [
+      rootViews.pipe(
+        Layer.provideMerge(Layer.succeed(LifecycleProbe, probe)),
+        Layer.provideMerge(Layer.succeed(ActivationGate, gate)),
+        Layer.provideMerge(Engine),
+      ),
+    ],
+  })
+
+it.scopedLive('an activation still building when its owner feature is disposed is stopped', () =>
+  Effect.gen(function* () {
+    const probe = makeProbe()
+    const gate = { open: yield* Deferred.make<void>() }
+    const app = makeAppRuntime(gateScene(probe, gate))
+    yield* Effect.addFinalizer(() => Effect.sync(() => app.dispose()))
+
+    const mounted = { handle: Option.none<RuntimeHandle<never>>() }
+    const disposeHost = app.mountFeature(ActivationHostNative.binding, {
+      onFailed: () => undefined,
+      onLive: (child) => {
+        mounted.handle = Option.some(Fn.unsafeCoerce(child))
+      },
+    })
+    yield* until(
+      () => Option.isSome(mounted.handle),
+      (ready) => ready,
+      40,
+    )
+    const child: RuntimeHandle<never> = Option.getOrThrow(mounted.handle)
+
+    // CONTROL — the same activation, on a live owner, acquires once the gate opens.
+    const controlGate = { open: yield* Deferred.make<void>() }
+    const controlProbe = makeProbe()
+    const controlApp = makeAppRuntime(gateScene(controlProbe, controlGate))
+    yield* Effect.addFinalizer(() => Effect.sync(() => controlApp.dispose()))
+    const controlMounted = { handle: Option.none<RuntimeHandle<never>>() }
+    controlApp.mountFeature(ActivationHostNative.binding, {
+      onFailed: () => undefined,
+      onLive: (childRuntime) => {
+        controlMounted.handle = Option.some(Fn.unsafeCoerce(childRuntime))
+      },
+    })
+    yield* until(
+      () => Option.isSome(controlMounted.handle),
+      (ready) => ready,
+      40,
+    )
+    const controlChild: RuntimeHandle<never> = Option.getOrThrow(controlMounted.handle)
+    controlChild.mountScoped(
+      Option.getOrThrow(Composition.activation(readParked(controlChild), {})),
+    )
+    yield* Deferred.succeed(controlGate.open, undefined)
+    yield* settledCount(() => controlProbe.acquired.length, 1)
+    expect(controlProbe.acquired).toEqual(['parked-activation'])
+    expect(controlProbe.released).toEqual([])
+
+    // SUBJECT — mount the parked activation, dispose the owner feature while it is
+    // still in flight, then let it finish.
+    child.mountScoped(Option.getOrThrow(Composition.activation(readParked(child), {})))
+    disposeHost()
+    yield* flush()
+    yield* Deferred.succeed(gate.open, undefined)
+    yield* flush()
+    yield* flush()
+
+    expect(probe.acquired).toEqual([])
+  }).pipe(Effect.provide(Layer.empty)),
+)

package/src/runtime/featureMount.ts

@@ -1,6 +1,17 @@
-import { Cause, Context, Effect, Exit, Fiber, Option, Scope } from 'effect'
+import {
+  Cause,
+  Context,
+  Effect,
+  ExecutionStrategy,
+  Exit,
+  Fiber,
+  MutableRef,
+  Option,
+  Scope,
+} from 'effect'
 import type { FeatureRequirement } from '../feature/feature'
 import { FeatureLoadFailed } from '../internal/errors'
+import { CurrentInstrumentation, type Instrumentation } from './instrumentation'
 import { EngineRequirements, type EngineServices } from './loop'
 
 const isObjectLike = (candidate: unknown): candidate is object =>
@@ -48,11 +59,101 @@ export const hasFeatureRequirements = <
 export const featureMountFailure = (message: string): FeatureLoadFailed =>
   new FeatureLoadFailed({ cause: message })
 
+export const missingHostServices = (name: string): Effect.Effect<never, FeatureLoadFailed> =>
+  Effect.fail(
+    featureMountFailure(`Feature ${name} requires services missing from the host runtime`),
+  )
+
+export const invalidMountProps = (name: string): Effect.Effect<never, FeatureLoadFailed> =>
+  Effect.fail(featureMountFailure(`Feature ${name} received invalid props`))
+
+/**
+ * `ManagedRuntime.make` captures its runtime outside `profiledScene`'s
+ * `Layer.locally`, so anything forked onto it later would build against the no-op
+ * sink and its state, calc, query and render spans would vanish from the report.
+ */
+export const withInstrumentation =
+  (instrumentation: Instrumentation) =>
+  <A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>
+    Effect.locally(effect, CurrentInstrumentation, instrumentation)
+
 export interface FeatureMountHost {
-  readonly runFork: (effect: Effect.Effect<void, never, never>) => Fiber.RuntimeFiber<void, never>
+  readonly runFork: <A>(effect: Effect.Effect<A, never, never>) => Fiber.RuntimeFiber<A, never>
   readonly isDisposed: () => boolean
 }
 
+/**
+ * Every scope a runtime mints for something it mounts is forked from an owner, so
+ * closing the owner closes the mount. A forked scope deregisters itself from its
+ * owner when it closes first, so mount churn does not accumulate finalizers.
+ *
+ * Forking a *closed* owner is not an error in Effect — it hands back an already-closed
+ * scope, against which a layer builds successfully while releasing everything at the
+ * instant it is acquired. A mount reported live over finalized services is worse than
+ * no mount, so that case is refused. A finalizer added to a closed scope runs
+ * immediately, which is how the state is read without reaching into Effect's internals.
+ */
+export const forkMountScope = (owner: Scope.Scope): Option.Option<Scope.CloseableScope> =>
+  Effect.runSync(
+    Effect.gen(function* () {
+      const scope = yield* Scope.fork(owner, ExecutionStrategy.sequential)
+      const alive = MutableRef.make(true)
+      yield* Scope.addFinalizer(
+        scope,
+        Effect.sync(() => MutableRef.set(alive, false)),
+      )
+      return MutableRef.get(alive) ? Option.some(scope) : Option.none()
+    }),
+  )
+
+/**
+ * Build a composition activation into a scope forked from `ownerScope` and hand back
+ * its disposer, which is also registered with `disposers` so the host's own teardown
+ * reaches it.
+ */
+/**
+ * Guard shared by every mount path: a runtime that is going away, or an owner scope
+ * that has already closed, refuses the mount rather than reporting a dead one live.
+ */
+export const startMount = (
+  host: FeatureMountHost,
+  ownerScope: Scope.Scope,
+  start: (scope: Scope.CloseableScope) => () => void,
+): (() => void) =>
+  host.isDisposed()
+    ? () => {}
+    : Option.match(forkMountScope(ownerScope), { onNone: () => () => {}, onSome: start })
+
+export const mountActivation = (
+  host: FeatureMountHost,
+  disposers: Set<() => void>,
+  build: Effect.Effect<unknown, never, Scope.Scope>,
+  ownerScope: Scope.Scope,
+): (() => void) =>
+  startMount(host, ownerScope, (scope) => {
+    const liveness = { active: true }
+    // Same ordering as `forkFeatureMount`: forked first so it finalizes last, and the
+    // fiber registered with `scope` so an owner closing mid-build stops it rather than
+    // letting it acquire against a scope that is already gone.
+    const buildScope = Effect.runSync(Scope.fork(scope, ExecutionStrategy.sequential))
+    const fiber = host.runFork(Effect.provideService(build, Scope.Scope, buildScope))
+    Effect.runSync(Scope.addFinalizer(scope, Fiber.interrupt(fiber)))
+    const dispose = (): void => {
+      if (!liveness.active) {
+        return
+      }
+      liveness.active = false
+      fiber.unsafeInterruptAsFork(fiber.id())
+      const close = Fiber.await(fiber).pipe(
+        Effect.zipRight(Scope.close(scope, Exit.succeed(undefined))),
+        Effect.ensuring(Effect.sync(() => disposers.delete(dispose))),
+      )
+      Effect.runFork(close)
+    }
+    disposers.add(dispose)
+    return dispose
+  })
+
 /**
  * Fork a feature mount onto the host runtime and hand back its disposer. Both
  * the typed and captured mount paths settle failures and tear down identically.
@@ -63,9 +164,14 @@ export const forkFeatureMount = (
   mount: Effect.Effect<void, FeatureLoadFailed, Scope.Scope>,
   onFailed: (error: FeatureLoadFailed) => void,
 ): (() => void) => {
+  // Forked before the mount fiber so it finalizes after it. Closing `scope` — which the
+  // owner does when it closes — must interrupt a mount still in flight before releasing
+  // what it has already built; the mount runs on a deferred `runFork`, so an owner that
+  // closes after the fork would otherwise let it go live against finalized services.
+  const buildScope = Effect.runSync(Scope.fork(scope, ExecutionStrategy.sequential))
   const fiber = host.runFork(
     mount.pipe(
-      Effect.provideService(Scope.Scope, scope),
+      Effect.provideService(Scope.Scope, buildScope),
       Effect.matchCause({
         onFailure: (cause) => {
           // Disposer interruption is cancellation, not a failed feature.
@@ -79,6 +185,7 @@ export const forkFeatureMount = (
       }),
     ),
   )
+  Effect.runSync(Scope.addFinalizer(scope, Fiber.interrupt(fiber)))
   return () => {
     // Interrupt first, then await finalizer registration before closing the scope.
     fiber.unsafeInterruptAsFork(fiber.id())