@playfast/reform-remote 1.0.2 → 1.2.0

package/src/remote-server.ts

@@ -1,109 +0,0 @@
-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/transport.types.ts

@@ -1,29 +0,0 @@
-import type { WirePatch, WireTree } from '@playfast/reform'
-
-export interface SnapshotMessage {
-  readonly _tag: 'Snapshot'
-  readonly tree: WireTree
-}
-
-export interface PatchesMessage {
-  readonly _tag: 'Patches'
-  readonly patches: ReadonlyArray<WirePatch>
-}
-
-export type ServerMessage = SnapshotMessage | PatchesMessage
-
-export interface InvokeMessage {
-  readonly _tag: 'Invoke'
-  readonly handle: string
-  readonly payload: unknown
-}
-
-export interface RemoteTransport<Out, In> {
-  readonly send: (message: Out) => void
-  readonly onMessage: (handler: (message: In) => void) => () => void
-}
-
-export interface ServerBinding {
-  readonly start: () => Promise<void>
-  readonly dispose: () => Promise<void>
-}