@playfast/reform-remote 0.1.0 → 1.0.2

package/src/remote-server.ts

@@ -0,0 +1,109 @@
+import { Effect, Layer, ManagedRuntime, Option, PubSub, Queue } from 'effect'
+import {
+  Bus,
+  type CompositionService,
+  forceSync,
+  publish,
+  type Scene,
+  type SlotChild,
+  Triggers,
+  type TriggerRegistryApi,
+  Wire,
+  type WirePatch,
+  type WireTree,
+  type WireNode,
+} from '@playfast/reform'
+import { renderSceneToWire } from './server'
+
+type RuntimeServices = CompositionService | SlotChild | Bus
+const SETTLE_DRAIN = 30
+const settleDrain: Effect.Effect<void> = Effect.yieldNow().pipe(Effect.repeatN(SETTLE_DRAIN))
+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
+  >
+const handlesOf = (node: WireNode): ReadonlyArray<string> =>
+  node.props.flatMap((prop) => (prop._tag === 'Event' ? [prop.handle] : []))
+
+export interface RemoteServer {
+  readonly render: () => Promise<WireTree>
+  readonly renderDiff: () => Promise<ReadonlyArray<WirePatch>>
+  readonly invoke: (handle: string, encodedPayload: unknown) => Promise<void>
+  readonly subscribe: (listener: () => void) => () => void
+  readonly currentTree: () => WireTree
+  readonly dispose: () => Promise<void>
+}
+
+export const makeRemoteServer = (scene: Scene): RemoteServer => {
+  const runtime = ManagedRuntime.make(closedSceneLayer(scene))
+  const registry: TriggerRegistryApi = forceSync(() => runtime.runSync(Triggers.make))
+  const renderEffect = settleDrain.pipe(
+    Effect.zipRight(renderSceneToWire(scene, { register: registry.register })),
+  )
+  const changeListeners = new Set<() => void>()
+  const notifyChange = (): void => {
+    changeListeners.forEach((listener) => listener())
+  }
+  runtime.runFork(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const bus = yield* Bus
+        const subscription = yield* PubSub.subscribe(bus)
+        yield* Queue.take(subscription).pipe(
+          Effect.zipRight(Effect.sync(notifyChange)),
+          Effect.forever,
+        )
+      }),
+    ),
+  )
+  runtime.runSync(
+    Effect.forEach(
+      Option.getOrElse(Option.fromNullable(scene.boot), () => []),
+      (event) => publish('High', event),
+    ),
+  )
+  const frame: { tree: WireTree } = { tree: [] }
+  const render = (): Promise<WireTree> =>
+    runtime.runPromise(
+      renderEffect.pipe(
+        Effect.tap((tree) =>
+          Effect.sync(() => {
+            frame.tree = tree
+          }),
+        ),
+      ),
+    )
+  const renderDiff = (): Promise<ReadonlyArray<WirePatch>> =>
+    runtime.runPromise(
+      Effect.gen(function* () {
+        const next = yield* renderEffect
+        const previous = frame.tree
+        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)
+        yield* Effect.forEach(staleHandles, (handle) => registry.revoke(handle))
+        return patches
+      }),
+    )
+  return {
+    render,
+    renderDiff,
+    invoke: (handle, encodedPayload) =>
+      runtime.runPromise(
+        Effect.gen(function* () {
+          yield* registry.invoke(handle, encodedPayload)
+          yield* settleDrain
+        }),
+      ),
+    subscribe: (listener) => {
+      changeListeners.add(listener)
+      return () => void changeListeners.delete(listener)
+    },
+    currentTree: () => frame.tree,
+    dispose: () => runtime.dispose(),
+  }
+}

package/src/remote-view.typecheck.ts

@@ -3,21 +3,11 @@ import { Schema as S } from 'effect'
 import { Composition, slot, ui, Ui } from '@playfast/reform'
 import { remoteContract, remoteViews } from './client'
 
-/**
- * Type-level proof that a remote client view — authored with the SAME `Ui.make`
- * the local renderer uses and registered with `remoteViews` — is strict: props,
- * event payloads, and slot names are all derived from the contract, so a wrong
- * access fails to compile. Compiled by `tsc` (the `@ts-expect-error`s would
- * themselves error if the line below them ever stopped being an error); not
- * bundled, not a runtime test.
- */
-
 class FooUi extends ui('Foo', {
   props: S.Struct({ n: S.Number }),
   events: { go: S.Struct({ x: S.String }) },
 }) {}
 
-// ✓ props and event payloads are inferred from the contract.
 const fooView = Ui.make(FooUi, (props, _slots, events) => {
   events.go({ x: String(props.n) })
   return null
@@ -41,12 +31,10 @@ Ui.make(FooUi, (_props, _slots, events) => {
   return null
 })
 
-// A local contract with a slot.
 class FooComp extends Composition.make('FooComp', { title: 'Foo', ui: FooUi }) {}
 class FooSlot extends slot('Foo')<typeof FooComp>() {}
 class ShellUi extends ui('Shell', { props: S.Struct({}), slots: { Main: FooSlot } }) {}
 
-// ✓ slot components are keyed by the contract's slot names.
 const shellView = Ui.make(ShellUi, (_props, slots) => createElement(slots.Main, {}))
 
 Ui.make(ShellUi, (_props, slots) =>
@@ -54,12 +42,9 @@ Ui.make(ShellUi, (_props, slots) =>
   createElement(slots.Other, {}),
 )
 
-// The server declares its shape ONCE and exports `typeof` it; the client implements that
-// type with `remoteViews<AppContract>(…)` — importing only the TYPE, never the value.
 const AppContractValue = remoteContract({ Foo: FooUi, Shell: ShellUi })
 type AppContract = typeof AppContractValue
 
-// ✓ a view per contract, each recovering its own name + schema; implements the full shape.
 remoteViews<AppContract>({ Foo: fooView, Shell: shellView })
 
 // @ts-expect-error — a view set MISSING `Shell` does not implement the server's shape.

package/src/server.test.ts

@@ -17,8 +17,6 @@ import {
   structureCounterScene,
 } from './fixtures'
 
-// The client renders views as React components, so a test runs them by RENDERING
-// `renderWireTree`'s output (node, no DOM needed) — the views capture as they render.
 const draw = (node: ReactNode): void => void renderToStaticMarkup(createElement(Fragment, null, node))
 
 const dataOf = (node: WireNode, name: string): WireProp | undefined =>
@@ -35,8 +33,6 @@ const upsertIds = (patches: ReadonlyArray<WirePatch>): ReadonlyArray<string> =>
 const deleteIds = (patches: ReadonlyArray<WirePatch>): ReadonlyArray<string> =>
   patches.flatMap((patch) => (patch._tag === 'Delete' ? [patch.id] : []))
 
-// ── flat counter ──────────────────────────────────────────────────────────────
-
 test('a scene renders to a wire tree with schema-encoded props and a trigger handle', async () => {
   const server = makeRemoteServer(counterScene())
   try {
@@ -66,7 +62,6 @@ test('invoking a trigger handle dispatches into the runtime and the next render
   }
 })
 
-// ── structure-path counter: events ride ON the structure (plan 03b) ─────────────
 
 test('a mount(...)-returning body registers its event from structure.events and invoking it dispatches', async () => {
   const server = makeRemoteServer(structureCounterScene())
@@ -74,8 +69,6 @@ test('a mount(...)-returning body registers its event from structure.events and
     const tree = await server.render()
     const root = tree[0]!
     expect(root.name).toBe('Counter')
-    // Props come from the structure value; the `bump` trigger rode on
-    // `structure.events` and was registered behind the standard handle.
     expect(dataOf(root, 'count')).toEqual({ _tag: 'Data', name: 'count', value: 0 })
     expect(eventOf(root, 'bump')).toEqual({ _tag: 'Event', name: 'bump', handle: '0:bump' })
 
@@ -156,7 +149,6 @@ test('boot events are applied before the first render', async () => {
   }
 })
 
-// ── nested slot: a child with its own state, two events ─────────────────────────
 
 test('a slotted child renders nested with its own encoded props and handle', async () => {
   const server = makeRemoteServer(slottedScene())
@@ -214,13 +206,11 @@ test('two events on one node register distinct handles and each fires independen
   }
 })
 
-// ── dynamic list: add (upsert), remove (delete + handle revocation) ─────────────
 
 test('a list renders one child per item under a single slot, in order', async () => {
   const server = makeRemoteServer(listScene())
   try {
     const tree = await server.render()
-    // List + Bar + two items.
     expect(tree).toHaveLength(4)
     expect(byId(tree, '0')!.name).toBe('List')
     expect(byId(tree, '0.Bar.0')!.slot).toBe('Bar')
@@ -238,14 +228,13 @@ test('a list renders one child per item under a single slot, in order', async ()
 test('adding an item emits an Upsert for the new node; removing emits a Delete', async () => {
   const server = makeRemoteServer(listScene())
   try {
-    await server.renderDiff() // first frame (snapshot baseline)
+    await server.renderDiff()
 
     await server.invoke('0.Bar.0:add', { id: 'c', label: 'C' })
     const added = await server.renderDiff()
     expect(deleteIds(added)).toEqual([])
     expect(upsertIds(added)).toContain('0.Item.2')
 
-    // Remove the last item — exactly its node leaves the tree.
     await server.invoke('0.Item.2:remove', {})
     const removed = await server.renderDiff()
     expect(deleteIds(removed)).toEqual(['0.Item.2'])
@@ -258,25 +247,20 @@ test("a removed node's handle is revoked — a stale client invocation rejects",
   const server = makeRemoteServer(listScene())
   try {
     await server.renderDiff()
-    // The handle works while the item is mounted…
     await server.invoke('0.Item.1:remove', {})
-    await server.renderDiff() // item 'b' gone → its handle revoked
-    // …and fails cleanly once the node has been unmounted.
+    await server.renderDiff()
     await expect(server.invoke('0.Item.1:remove', {})).rejects.toBeDefined()
   } finally {
     await server.dispose()
   }
 })
 
-// ── Option props: Effect-native values survive the wire as real instances ───────
 
 test('an Option prop round-trips through JSON as a real Option (symmetric schema decode)', async () => {
   const server = makeRemoteServer(optionScene(Option.some('hi')))
   const captured: { label?: unknown } = {}
   try {
     const tree = await server.render()
-    // Round-trip the tree through JSON exactly as the real WebSocket transport does —
-    // the Option's `toJSON` flattens it to a plain `{_tag,value}` shape on the way out.
     const wire: WireTree = JSON.parse(JSON.stringify(tree))
     draw(
       renderWireTree(wire, {
@@ -289,7 +273,6 @@ test('an Option prop round-trips through JSON as a real Option (symmetric schema
         invoke: () => undefined,
       }),
     )
-    // The client decoded it back through the contract schema → a REAL Option instance.
     expect(Option.isOption(captured.label)).toBe(true)
     expect(captured.label).toStrictEqual(Option.some('hi'))
   } finally {
@@ -322,7 +305,6 @@ test('a data-only change upserts only the changed node, leaving siblings untouch
     await server.renderDiff()
     await server.invoke('0.Main.0:greet', { text: 'changed' })
     const patches = await server.renderDiff()
-    // Only the panel changed; the shell is unchanged, so no patch for it.
     expect(upsertIds(patches)).toEqual(['0.Main.0'])
     expect(deleteIds(patches)).toEqual([])
   } finally {

package/src/server.ts

@@ -1,86 +1,40 @@
 import {
   Array as Arr,
   Effect,
-  Layer,
   Match,
-  ManagedRuntime,
   Option,
   type ParseResult,
-  PubSub,
-  Queue,
   Record as Rec,
   Schema,
 } from 'effect'
 import {
-  Bus,
   Composition,
   type CompositionClass,
   type CompositionService,
-  forceSync,
   isFeatureBinding,
   isStructure,
-  publish,
   type RenderEnv,
   type Scene,
   type SlotChild,
   type SlotClass,
   type SlotFill,
   type Structure,
-  Triggers,
   type Trigger,
   type TriggerRegistryApi,
   type UiContract,
   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
-
-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.
+// At erased UiContract boundary, event map is Record<never, never> → assignable to Trigger<unknown> without 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 props: unknown
@@ -88,26 +42,15 @@ interface Mounted {
   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 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 render (screenshot): wire still has Event handles; registrar is no-op.
 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,8 +59,6 @@ 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.
   const encodedProps = yield* Option.match(Option.fromNullable(manifest.props), {
     onNone: () => Effect.succeed({}),
     onSome: (schema) => Schema.encodeUnknown(schema)(structure.props),
@@ -151,18 +92,13 @@ 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]) =>
@@ -170,10 +106,6 @@ const structureFills = (structure: Structure<UiContract>): Record<string, SlotFi
     ),
   )
 
-// 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), () => ({}))
 
@@ -216,7 +148,7 @@ 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.
+  // Explicit type so recursive walk references 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> {
@@ -235,8 +167,7 @@ const collect = Effect.fn('collect')(function* (
   return bindings
 })
 
-// `renderLevel` recurses level by level, so it carries an explicit type so its body can
-// reference itself cast-free.
+// Explicit type so recursive renderLevel references itself cast-free.
 const renderLevel: (
   frontier: ReadonlyArray<Mounted>,
   bindings: ReadonlyMap<SlotClass, CompositionClass<unknown>>,
@@ -256,9 +187,6 @@ const renderLevel: (
       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`,
@@ -286,16 +214,6 @@ const renderLevel: (
   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. */
 export interface RenderSceneToWireOptions {
   readonly register: TriggerRegistryApi['register']
 }
@@ -320,125 +238,4 @@ export const renderSceneToWire = (
     return yield* renderLevel([root], bindings, register)
   })
 
-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 registry: TriggerRegistryApi = forceSync(() => runtime.runSync(Triggers.make))
-
-  // 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 })),
-  )
-
-  // 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())
-  }
-  runtime.runFork(
-    Effect.scoped(
-      Effect.gen(function* () {
-        const bus = yield* Bus
-        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.
-        yield* Queue.take(subscription).pipe(
-          Effect.zipRight(Effect.sync(notifyChange)),
-          Effect.forever,
-        )
-      }),
-    ),
-  )
-
-  runtime.runSync(
-    Effect.forEach(
-      Option.getOrElse(Option.fromNullable(scene.boot), () => []),
-      (event) => publish('High', event),
-    ),
-  )
-
-  // 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> =>
-    runtime.runPromise(
-      renderEffect.pipe(
-        Effect.tap((tree) =>
-          Effect.sync(() => {
-            frame.tree = tree
-          }),
-        ),
-      ),
-    )
-
-  const renderDiff = (): Promise<ReadonlyArray<WirePatch>> =>
-    runtime.runPromise(
-      Effect.gen(function* () {
-        const next = yield* renderEffect
-        const previous = frame.tree
-        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)
-        yield* Effect.forEach(staleHandles, (handle) => registry.revoke(handle))
-        return patches
-      }),
-    )
-
-  return {
-    render,
-    renderDiff,
-    invoke: (handle, encodedPayload) =>
-      runtime.runPromise(
-        Effect.gen(function* () {
-          yield* registry.invoke(handle, encodedPayload)
-          yield* settleDrain
-        }),
-      ),
-    subscribe: (listener) => {
-      changeListeners.add(listener)
-      return () => void changeListeners.delete(listener)
-    },
-    currentTree: () => frame.tree,
-    dispose: () => runtime.dispose(),
-  }
-}
+export { makeRemoteServer, type RemoteServer } from './remote-server'