@playfast/reform-remote 1.0.1 → 1.1.0

package/src/server.ts

@@ -1,5 +1,6 @@
 import {
   Array as Arr,
+  Context,
   Effect,
   Layer,
   Match,
@@ -12,102 +13,71 @@ import {
   Schema,
 } from 'effect'
 import {
-  Bus,
+  type CapturedScene,
   Composition,
   type CompositionClass,
-  type CompositionService,
   forceSync,
   isFeatureBinding,
+  isSlot,
   isStructure,
   publish,
-  type RenderEnv,
-  type Scene,
-  type SlotChild,
-  type SlotClass,
   type SlotFill,
   type Structure,
-  Triggers,
   type Trigger,
-  type TriggerRegistryApi,
   type UiContract,
+} from '@playfast/reform'
+import {
+  type AnyComposition,
+  type AnyScene,
+  type AnySlot,
+  type AnySlotChild,
+  Bus,
+  Triggers,
+  type TriggerRegistryApi,
   type UiManifest,
   Wire,
   type WireNode,
   type WirePatch,
   type WireProp,
   type WireTree,
-} from '@playfast/reform'
-
-/**
- * The server side of the remote transport (REMOTE_UI.md §5): render a closed
- * `Scene` to a serializable `WireTree`, registering each trigger behind a handle.
- * Reads each composition's returned `Structure` value directly — props, per-slot
- * fills, and event triggers are all DATA — so the server imports no React and never
- * evaluates a view. The render walk is breadth-first over the structure tree,
- * assigning stable ids and encoding props via each contract's own wire schema
- * (`WiredUiManifest`, Phase 1).
- *
- * The render walk (`renderSceneToWire`) is a free-standing effect that requires only
- * `CompositionService | SlotChild` — so any runtime that supplies a scene's services
- * can render a frame, not just `makeRemoteServer`'s own. `@playfast/reform-driver-shot`
- * runs it against `@playfast/reform-drive`'s runtime to screenshot a driven state.
- */
-
-// The runtime services a closed scene exposes (mirrors proof's erasure boundary:
-// the scene's `provide` is typed to `MountedServices`, but slot tags resolve
-// `SlotChild` from the same closed layer).
-type RuntimeServices = CompositionService | SlotChild | Bus
+} from '@playfast/reform/internal'
 
 const SETTLE_DRAIN = 30
 const settleDrain = Effect.yieldNow().pipe(Effect.repeatN(SETTLE_DRAIN))
 
-// The event triggers a `Structure` frame carries (plan 03b). A composition's logic
-// returns its acquired triggers ON the structure value (it never evaluates a view),
-// so the server reads them straight from there. At the erased `UiContract` boundary the contract's event map
-// is `Record<never, never>`, so each value is `never` — assignable to
-// `Trigger<unknown>` without a cast — and an omitted `events` defaults to empty.
+// The erased event map's never values remain assignable to Trigger<unknown> without a cast.
 const eventsOf = (structure: Structure<UiContract>): Record<string, Trigger<unknown>> =>
   Option.match(Option.fromNullable(structure.events), {
     onNone: () => ({}),
     onSome: (events) => events,
   })
 
-const closedSceneLayer = (scene: Scene): Layer.Layer<RuntimeServices, never, never> =>
-  // oxlint-disable-next-line reform-rules/no-type-assertion -- closed-scene erasure: scene.provide is typed to MountedServices, recovered structurally as RuntimeServices
-  scene.provide.reduce((acc, layer) => Layer.merge(acc, layer)) as unknown as Layer.Layer<
-    RuntimeServices,
-    never,
-    never
-  >
-
-/** A composition queued to render, with the props its parent handed it and its place in the tree. */
 interface Mounted {
-  readonly comp: CompositionClass<unknown>
+  readonly comp: AnyComposition
   readonly props: unknown
   readonly id: string
   readonly parentId: Option.Option<string>
   readonly slot: Option.Option<string>
   readonly childIndex: number
-  /** The React `key` the parent gave this slot child, if any — the keyed-slot selector. */
   readonly key: Option.Option<string>
 }
 
-const childComposition = (child: SlotChild): CompositionClass<unknown> =>
-  isFeatureBinding(child) ? child.composition : child
+const childComposition = (child: AnySlotChild): AnyComposition => {
+  if (!isFeatureBinding(child)) {
+    return child
+  }
+  return child.capture<AnyComposition>((binding): AnyComposition => binding.composition)
+}
+
+const isRecord = (candidate: unknown): candidate is Record<string, unknown> =>
+  typeof candidate === 'object' && candidate !== null && !Array.isArray(candidate)
 
 const handlesOf = (node: WireNode): ReadonlyArray<string> =>
   node.props.flatMap((prop) => (prop._tag === 'Event' ? [prop.handle] : []))
 
-// A static render (a screenshot) has no client to receive trigger handles, so the
-// default registrar is a no-op: the wire node still carries its `Event` props (with
-// deterministic handles), they're just never registered for invocation.
+// One-shot renders still emit deterministic handles but have no client registry.
 const noRegister: TriggerRegistryApi['register'] = () => Effect.void
 
-// Structure → wire encoding (plan 02 + 03b). Props come straight from the
-// `Structure` value (data, never a view render). Event triggers ride ON the
-// structure (`structure.events`) and are registered through `register` (the live
-// registry for a streaming server, a no-op for a one-shot render). Produces the
-// wire shape the transport and `Wire.diff` consume.
 const toWireNodeFromStructure = Effect.fn('toWireNodeFromStructure')(function* (
   mounted: Mounted,
   structure: Structure<UiContract>,
@@ -116,28 +86,47 @@ const toWireNodeFromStructure = Effect.fn('toWireNodeFromStructure')(function* (
   const manifest: UiManifest = mounted.comp.manifest.ui.manifest
   const name = manifest.name
 
-  // `manifest.props` is `Schema.Schema<any, any>`, so the encoded shape is `any` — a record
-  // of wire-encoded prop values keyed by name (no view eval). Absent on the type-only form.
+  // The manifest stores schema AST only; reconstruct an unknown-safe schema at this wire seam.
   const encodedProps = yield* Option.match(Option.fromNullable(manifest.props), {
     onNone: () => Effect.succeed({}),
-    onSome: (schema) => Schema.encodeUnknown(schema)(structure.props),
+    onSome: (reflection) =>
+      Schema.encodeUnknown(Schema.make<unknown, unknown>(reflection.ast))(structure.props).pipe(
+        Effect.flatMap((encoded) => {
+          if (isRecord(encoded)) {
+            return Effect.succeed(encoded)
+          }
+          return Effect.dieMessage(
+            `reform-remote: ${manifest.name} props did not encode to a record`,
+          )
+        }),
+      ),
   })
   const dataProps: ReadonlyArray<WireProp> = Rec.toEntries(encodedProps).map(
-    ([propName, propValue]): WireProp => ({ _tag: 'Data', name: propName, value: propValue }),
+    ([propName, propValue]): WireProp => ({
+      _tag: 'Data',
+      name: propName,
+      value: propValue,
+    }),
   )
 
   const eventSchemas = Option.fromNullable(manifest.events)
   const events = eventsOf(structure)
-  const eventProps: ReadonlyArray<WireProp> = yield* Effect.forEach(Rec.toEntries(events), ([eventName, trigger]) =>
-    Effect.gen(function* () {
-      const schema = Option.flatMap(eventSchemas, (schemas) => Rec.get(schemas, eventName))
-      if (Option.isNone(schema)) {
-        return Option.none<WireProp>()
-      }
-      const handle = `${mounted.id}:${eventName}`
-      yield* register(handle, trigger, schema.value)
-      return Option.some<WireProp>({ _tag: 'Event', name: eventName, handle })
-    }),
+  const eventProps: ReadonlyArray<WireProp> = yield* Effect.forEach(
+    Rec.toEntries(events),
+    ([eventName, trigger]) =>
+      Effect.gen(function* () {
+        const schema = Option.flatMap(eventSchemas, (schemas) => Rec.get(schemas, eventName))
+        if (Option.isNone(schema)) {
+          return Option.none<WireProp>()
+        }
+        const handle = `${mounted.id}:${eventName}`
+        yield* register(handle, trigger, Schema.make<unknown, unknown>(schema.value.ast))
+        return Option.some<WireProp>({
+          _tag: 'Event',
+          name: eventName,
+          handle,
+        })
+      }),
   ).pipe(Effect.map(Arr.getSomes))
 
   return {
@@ -151,36 +140,102 @@ const toWireNodeFromStructure = Effect.fn('toWireNodeFromStructure')(function* (
   }
 })
 
-// Narrow an erased slot value to a `SlotFill` by its discriminant. `Structure<
-// UiContract>` erases its per-slot fill types at this boundary (the strict typing
-// lives on the concrete contract), so the runtime fills arrive as `unknown` and
-// are recovered structurally — no `as`.
+// Structure erases per-slot fill types; recover SlotFill structurally without `as`.
 const isSlotFill = (candidate: unknown): candidate is SlotFill<unknown> =>
   typeof candidate === 'object' &&
   candidate !== null &&
   '_tag' in candidate &&
   (candidate._tag === 'Each' || candidate._tag === 'One' || candidate._tag === 'Absent')
 
-// Read a structure's fills by slot name, recovering each erased value via the
-// discriminant guard. Returns a plain record keyed by declared slot name.
 const structureFills = (structure: Structure<UiContract>): Record<string, SlotFill<unknown>> =>
   Rec.fromEntries(
-    Rec.toEntries(structure.slots).flatMap(([slotName, fillValue]) =>
-      isSlotFill(fillValue) ? [[slotName, fillValue] as const] : [],
+    Rec.toEntries(structure.slots).flatMap(
+      ([slotName, fillValue]): ReadonlyArray<readonly [string, SlotFill<unknown>]> =>
+        isSlotFill(fillValue) ? [[slotName, fillValue]] : [],
+    ),
+  )
+
+const slotsOf = (comp: AnyComposition): Record<string, AnySlot> =>
+  comp.capture<Record<string, AnySlot>>((exact) => {
+    if (!('slots' in exact.manifest)) {
+      return {}
+    }
+    const candidate: unknown = exact.manifest.slots
+    if (!isRecord(candidate)) {
+      return {}
+    }
+    return Rec.fromEntries(
+      Rec.toEntries(candidate).flatMap(
+        ([name, slotDefinition]): ReadonlyArray<readonly [string, AnySlot]> =>
+          isSlot(slotDefinition) ? [[name, slotDefinition]] : [],
+      ),
+    )
+  })
+
+const serviceFromContext = <Services, Identifier, Service>(
+  context: Context.Context<Services>,
+  tag: Context.Tag<Identifier, Service>,
+  missing: string,
+): Effect.Effect<Service, never, never> =>
+  Option.match(Context.getOption(context, tag), {
+    onNone: () => Effect.dieMessage(missing),
+    onSome: Effect.succeed,
+  })
+
+const capturedSlotProvider = <Services>(
+  context: Context.Context<Services>,
+  slotDefinition: AnySlot,
+): Effect.Effect<AnySlotChild, never, never> =>
+  slotDefinition.capture((exact) =>
+    serviceFromContext(
+      context,
+      exact.provider,
+      'reform-remote: scene does not provide a declared slot',
     ),
   )
 
-// Enqueue the children a single declared slot is filled with, reading the fill
-// (Each / One / Absent) from the returned `Structure`. Multiplicity, per-item
-// `key`, and props are carried as data — no view walk, no reconstruction.
-/** A composition's declared slot map, defaulting to an empty record when it declares none. */
-const slotsOf = (comp: CompositionClass<unknown>): Record<string, SlotClass> =>
-  Option.getOrElse(Option.fromNullable(comp.manifest.slots), () => ({}))
+const renderCapturedComposition = <Services>(
+  context: Context.Context<Services>,
+  composition: AnyComposition,
+  props: unknown,
+): Effect.Effect<Structure<UiContract>, never, never> =>
+  composition.capture<Effect.Effect<Structure<UiContract>, never, never>>(
+    <P, C extends UiContract, S extends ReadonlyArray<unknown>, N extends string, Identity>(
+      exact: CompositionClass<P, C, S, N, Identity>,
+    ): Effect.Effect<Structure<UiContract>, never, never> =>
+      Option.match(exact.parseProps(props), {
+        onNone: () =>
+          Effect.dieMessage(
+            `reform-remote: invalid props for composition ${composition.manifest.name}`,
+          ),
+        onSome: (parsed) =>
+          serviceFromContext(
+            context,
+            exact.tag,
+            `reform-remote: scene does not provide composition ${composition.manifest.name}`,
+          ).pipe(
+            Effect.flatMap((service) =>
+              Composition.render<P, C>(service, {
+                props: parsed,
+                tracker: { add: () => {} },
+              }),
+            ),
+            Effect.flatMap((frame) => {
+              if (isStructure(frame)) {
+                return Effect.succeed(frame)
+              }
+              return Effect.dieMessage(
+                `reform-remote: composition ${composition.manifest.name} did not return a Structure`,
+              )
+            }),
+          ),
+      }),
+  )
 
 const enqueueStructureSlot = (
   parent: Mounted,
   slotName: string,
-  child: CompositionClass<unknown>,
+  child: AnyComposition,
   fill: SlotFill<unknown>,
 ): ReadonlyArray<Mounted> =>
   Match.value(fill).pipe(
@@ -212,58 +267,60 @@ const enqueueStructureSlot = (
     Match.exhaustive,
   )
 
-const collect = Effect.fn('collect')(function* (
-  root: CompositionClass<unknown>,
-): Effect.fn.Return<Map<SlotClass, CompositionClass<unknown>>, never, SlotChild> {
-  const bindings = new Map<SlotClass, CompositionClass<unknown>>()
-  // `walk` recurses, so it carries an explicit type so its body can reference itself cast-free.
-  const walk: (comp: CompositionClass<unknown>) => Effect.Effect<void, never, SlotChild> = Effect.fn(
-    'walk',
-  )(function* (comp: CompositionClass<unknown>): Effect.fn.Return<void, never, SlotChild> {
-    yield* Effect.forEach(Rec.values(slotsOf(comp)), (slotClass) =>
-      Effect.gen(function* () {
-        if (bindings.has(slotClass)) {
-          return
-        }
-        const child = childComposition(yield* slotClass.tag)
-        bindings.set(slotClass, child)
-        yield* walk(child)
-      }),
-    )
-  })
+type SlotProvider<Services> = (
+  slotDefinition: AnySlot,
+) => Effect.Effect<AnySlotChild, never, Services>
+
+const collect = Effect.fn('collect')(function* <Services>(
+  root: AnyComposition,
+  provideSlot: SlotProvider<Services>,
+): Effect.fn.Return<Map<AnySlot, AnyComposition>, never, Services> {
+  const bindings = new Map<AnySlot, AnyComposition>()
+  // Explicit type keeps the recursive reference cast-free.
+  const walk: (comp: AnyComposition) => Effect.Effect<void, never, Services> = Effect.fn('walk')(
+    function* (comp: AnyComposition): Effect.fn.Return<void, never, Services> {
+      yield* Effect.forEach(Rec.values(slotsOf(comp)), (slotClass) =>
+        Effect.gen(function* () {
+          if (bindings.has(slotClass)) {
+            return
+          }
+          const child = childComposition(yield* provideSlot(slotClass))
+          bindings.set(slotClass, child)
+          yield* walk(child)
+        }),
+      )
+    },
+  )
   yield* walk(root)
   return bindings
 })
 
-// `renderLevel` recurses level by level, so it carries an explicit type so its body can
-// reference itself cast-free.
-const renderLevel: (
-  frontier: ReadonlyArray<Mounted>,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
-  register: TriggerRegistryApi['register'],
-) => Effect.Effect<ReadonlyArray<WireNode>, ParseResult.ParseError, CompositionService> = Effect.fn(
-  'renderLevel',
-)(function* (
+type CompositionRenderer<Services> = (
+  composition: AnyComposition,
+  props: unknown,
+) => Effect.Effect<Structure<UiContract>, never, Services>
+
+interface RenderLevel {
+  <Services>(
+    frontier: ReadonlyArray<Mounted>,
+    bindings: ReadonlyMap<AnySlot, AnyComposition>,
+    register: TriggerRegistryApi['register'],
+    render: CompositionRenderer<Services>,
+  ): Effect.Effect<ReadonlyArray<WireNode>, ParseResult.ParseError, Services>
+}
+
+const renderLevel: RenderLevel = Effect.fn('renderLevel')(function* <Services>(
   frontier: ReadonlyArray<Mounted>,
-  bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
+  bindings: ReadonlyMap<AnySlot, AnyComposition>,
   register: TriggerRegistryApi['register'],
-): Effect.fn.Return<ReadonlyArray<WireNode>, ParseResult.ParseError, CompositionService> {
+  render: CompositionRenderer<Services>,
+): Effect.fn.Return<ReadonlyArray<WireNode>, ParseResult.ParseError, Services> {
   if (frontier.length === 0) {
     return []
   }
   const rendered = yield* Effect.forEach(frontier, (mounted) =>
     Effect.gen(function* () {
-      const service = yield* mounted.comp.tag
-      const env: RenderEnv = { props: mounted.props, tracker: { add: () => {} } }
-      const frame = yield* Composition.render(service, env)
-      // Every composition returns a `Structure` (the Node render path is gone): its
-      // wire node's props come from `frame.props`, event triggers from `frame.events`,
-      // and children are enqueued by reading each declared slot's fill — no view eval.
-      if (!isStructure(frame)) {
-        return yield* Effect.dieMessage(
-          `reform-remote server: composition ${mounted.comp.manifest.name} did not return a Structure`,
-        )
-      }
+      const frame = yield* render(mounted.comp, mounted.props)
       const node = yield* toWireNodeFromStructure(mounted, frame, register)
       const fills = structureFills(frame)
       const children = Rec.toEntries(slotsOf(mounted.comp)).flatMap(([slotName, slotClass]) => {
@@ -282,90 +339,96 @@ const renderLevel: (
   )
   const nodes = rendered.map((entry) => entry.node)
   const next = rendered.flatMap((entry) => entry.children)
-  const rest = yield* renderLevel(next, bindings, register)
+  const rest = yield* renderLevel(next, bindings, register, render)
   return [...nodes, ...rest]
 })
 
-/**
- * Render the scene's CURRENT frame to a serializable `WireTree`, breadth-first from
- * the root composition. Requires only the scene's render services
- * (`CompositionService | SlotChild`), so it runs on any runtime built from the same
- * closed scene — `makeRemoteServer`'s, or `@playfast/reform-drive`'s (the screenshot
- * path). `register` defaults to a no-op: a one-shot render needs no live trigger
- * registry, while `makeRemoteServer` passes its connection registry so the streamed
- * client can invoke handles.
- */
-/** Options for {@link renderSceneToWire}; the registrar defaults to a no-op for one-shot renders. */
+const renderSceneWith = Effect.fn('renderSceneWith')(function* <SlotServices, CompositionServices>(
+  scene: AnyScene,
+  options: RenderSceneToWireOptions | undefined,
+  provideSlot: SlotProvider<SlotServices>,
+  render: CompositionRenderer<CompositionServices>,
+): Effect.fn.Return<WireTree, ParseResult.ParseError, SlotServices | CompositionServices> {
+  const register = options?.register ?? noRegister
+  const bindings = yield* collect(scene.composition, provideSlot)
+  const root: Mounted = {
+    comp: scene.composition,
+    props: {},
+    id: '0',
+    parentId: Option.none(),
+    slot: Option.none(),
+    childIndex: 0,
+    key: Option.none(),
+  }
+  return yield* renderLevel([root], bindings, register, render)
+})
 export interface RenderSceneToWireOptions {
   readonly register: TriggerRegistryApi['register']
 }
 
 // oxlint-disable-next-line reform-rules/prefer-effect-fn -- exported binding: Effect.fn's inferred type isn't portable under isolatedDeclarations
-export const renderSceneToWire = (
-  scene: Scene,
+export const renderSceneToWire = <
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+>(
+  scene: CapturedScene<C, S, Services, P, N, Identity>,
   options?: RenderSceneToWireOptions,
-): Effect.Effect<WireTree, ParseResult.ParseError, CompositionService | SlotChild> =>
-  Effect.gen(function* () {
-    const register = options?.register ?? noRegister
-    const bindings = yield* collect(scene.composition)
-    const root: Mounted = {
-      comp: scene.composition,
-      props: {},
-      id: '0',
-      parentId: Option.none(),
-      slot: Option.none(),
-      childIndex: 0,
-      key: Option.none(),
-    }
-    return yield* renderLevel([root], bindings, register)
-  })
+): Effect.Effect<WireTree, ParseResult.ParseError, Services> =>
+  Effect.context<Services>().pipe(
+    Effect.flatMap((context) =>
+      renderSceneWith(
+        scene,
+        options,
+        (slotDefinition) => capturedSlotProvider(context, slotDefinition),
+        (composition, props) => renderCapturedComposition(context, composition, props),
+      ),
+    ),
+  )
 
 export interface RemoteServer {
-  /** Render the current frame to a full wire tree; triggers are (re-)registered behind stable handles. */
   readonly render: () => Promise<WireTree>
-  /**
-   * Render and return only the patches since the previous frame (the streaming
-   * form). Handles of deleted nodes are revoked, so a stale client invocation
-   * fails cleanly rather than firing a dangling trigger.
-   */
   readonly renderDiff: () => Promise<ReadonlyArray<WirePatch>>
-  /** Fire a trigger the client referenced by handle, then settle the runtime. */
   readonly invoke: (handle: string, encodedPayload: unknown) => Promise<void>
-  /**
-   * Observe SERVER-INITIATED state changes. The listener fires (after the drain
-   * settles) whenever an event flows on the engine bus — i.e. when an async procedure
-   * resolves, a boot loader completes, or a scheduler ticks — NOT just in response to a
-   * client invoke. `serve` registers a `renderDiff`-and-push listener here so the client
-   * sees background updates (a repo list that finishes loading, a reconcile sweep) that
-   * no user interaction triggered. Returns an unsubscribe handle.
-   */
   readonly subscribe: (listener: () => void) => () => void
-  /**
-   * The last emitted frame — the baseline every `renderDiff` diffs against. A new
-   * client attaching to a SHARED server snapshots off this (rather than a fresh
-   * `render()`, which would re-key the baseline and desync clients mid-stream).
-   */
   readonly currentTree: () => WireTree
-  /** Tear down the runtime and its forked fibers. */
   readonly dispose: () => Promise<void>
 }
 
-export const makeRemoteServer = (scene: Scene): RemoteServer => {
-  const runtime = ManagedRuntime.make(closedSceneLayer(scene))
+const makeCapturedRemoteServer = <
+  C extends UiContract,
+  S extends ReadonlyArray<unknown>,
+  Services,
+  P,
+  N extends string,
+  Identity,
+>(
+  scene: CapturedScene<C, S, Services, P, N, Identity>,
+): RemoteServer => {
+  const layer = scene.provide.reduce((acc, provided) => Layer.merge(acc, provided))
+  const runtime = ManagedRuntime.make(layer)
   const registry: TriggerRegistryApi = forceSync(() => runtime.runSync(Triggers.make))
+  const context = forceSync(() => runtime.runSync(Effect.context<Services>()))
+  const busFromContext = serviceFromContext(
+    context,
+    Bus,
+    'reform-remote: scene does not provide Bus',
+  )
 
-  // The shared render walk, registering triggers in this connection's registry so the
-  // client can invoke them. `settleDrain` first so an in-flight batch folds into state.
   const renderEffect = settleDrain.pipe(
-    Effect.zipRight(renderSceneToWire(scene, { register: registry.register })),
+    Effect.zipRight(
+      renderSceneWith(
+        scene,
+        { register: registry.register },
+        (slotDefinition) => capturedSlotProvider(context, slotDefinition),
+        (composition, props) => renderCapturedComposition(context, composition, props),
+      ),
+    ),
   )
 
-  // Server-initiated change notification: a forked daemon subscribes to the engine bus
-  // and, after each batch settles, fans out to registered listeners. This is what lets a
-  // streaming binding push frames the client never asked for — a background load resolving
-  // long after connect. Forked BEFORE the boot publish below so nothing is missed (the
-  // listener set is empty until `subscribe` runs, so early ticks are harmless no-ops; the
-  // binding's opening snapshot captures all state up to `start`).
   const changeListeners = new Set<() => void>()
   const notifyChange = (): void => {
     changeListeners.forEach((listener) => listener())
@@ -373,11 +436,9 @@ export const makeRemoteServer = (scene: Scene): RemoteServer => {
   runtime.runFork(
     Effect.scoped(
       Effect.gen(function* () {
-        const bus = yield* Bus
+        const bus = yield* busFromContext
         const subscription = yield* PubSub.subscribe(bus)
-        // Notify on each event; the consumer (`serve`) debounces, so the render it triggers
-        // runs a tick later — after the drain has folded this event into state. No settle
-        // here: it would only perturb the drain's own scheduling for no benefit.
+        // The transport debounces; settling here would perturb the drain's scheduling.
         yield* Queue.take(subscription).pipe(
           Effect.zipRight(Effect.sync(notifyChange)),
           Effect.forever,
@@ -389,12 +450,13 @@ export const makeRemoteServer = (scene: Scene): RemoteServer => {
   runtime.runSync(
     Effect.forEach(
       Option.getOrElse(Option.fromNullable(scene.boot), () => []),
-      (event) => publish('High', event),
+      (event) =>
+        busFromContext.pipe(
+          Effect.flatMap((bus) => publish('High', event).pipe(Effect.provideService(Bus, bus))),
+        ),
     ),
   )
 
-  // The last emitted frame, to diff against. A const holder whose field we swap
-  // (no reassigned binding — house rule), not a `let`.
   const frame: { tree: WireTree } = { tree: [] }
 
   const render = (): Promise<WireTree> =>
@@ -416,9 +478,7 @@ export const makeRemoteServer = (scene: Scene): RemoteServer => {
         const patches = Wire.diff(previous, next)
         frame.tree = next
         const nextIds = new Set(next.map((node) => node.id))
-        const staleHandles = previous
-          .filter((node) => !nextIds.has(node.id))
-          .flatMap(handlesOf)
+        const staleHandles = previous.filter((node) => !nextIds.has(node.id)).flatMap(handlesOf)
         yield* Effect.forEach(staleHandles, (handle) => registry.revoke(handle))
         return patches
       }),
@@ -442,3 +502,17 @@ export const makeRemoteServer = (scene: Scene): RemoteServer => {
     dispose: () => runtime.dispose(),
   }
 }
+
+export const makeRemoteServer = (scene: AnyScene): RemoteServer =>
+  scene.captureAny<RemoteServer>(
+    <
+      C extends UiContract,
+      S extends ReadonlyArray<unknown>,
+      Services,
+      P,
+      N extends string,
+      Identity,
+    >(
+      exactScene: CapturedScene<C, S, Services, P, N, Identity>,
+    ) => makeCapturedRemoteServer(exactScene),
+  )