@playfast/reform-remote 1.0.2 → 1.1.0

package/src/server.ts

@@ -1,34 +1,51 @@
 import {
   Array as Arr,
+  Context,
   Effect,
+  Layer,
   Match,
+  ManagedRuntime,
   Option,
   type ParseResult,
+  PubSub,
+  Queue,
   Record as Rec,
   Schema,
 } from 'effect'
 import {
+  type CapturedScene,
   Composition,
   type CompositionClass,
-  type CompositionService,
+  forceSync,
   isFeatureBinding,
+  isSlot,
   isStructure,
-  type RenderEnv,
-  type Scene,
-  type SlotChild,
-  type SlotClass,
+  publish,
   type SlotFill,
   type Structure,
   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'
+} from '@playfast/reform/internal'
+
+const SETTLE_DRAIN = 30
+const settleDrain = Effect.yieldNow().pipe(Effect.repeatN(SETTLE_DRAIN))
 
-// At erased UiContract boundary, event map is Record<never, never> → assignable to Trigger<unknown> without cast.
+// 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: () => ({}),
@@ -36,7 +53,7 @@ const eventsOf = (structure: Structure<UiContract>): Record<string, Trigger<unkn
   })
 
 interface Mounted {
-  readonly comp: CompositionClass<unknown>
+  readonly comp: AnyComposition
   readonly props: unknown
   readonly id: string
   readonly parentId: Option.Option<string>
@@ -45,10 +62,20 @@ interface Mounted {
   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)
 
-// One-shot render (screenshot): wire still has Event handles; registrar is no-op.
+const handlesOf = (node: WireNode): ReadonlyArray<string> =>
+  node.props.flatMap((prop) => (prop._tag === 'Event' ? [prop.handle] : []))
+
+// One-shot renders still emit deterministic handles but have no client registry.
 const noRegister: TriggerRegistryApi['register'] = () => Effect.void
 
 const toWireNodeFromStructure = Effect.fn('toWireNodeFromStructure')(function* (
@@ -59,26 +86,47 @@ const toWireNodeFromStructure = Effect.fn('toWireNodeFromStructure')(function* (
   const manifest: UiManifest = mounted.comp.manifest.ui.manifest
   const name = manifest.name
 
+  // 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 {
@@ -101,18 +149,93 @@ const isSlotFill = (candidate: unknown): candidate is SlotFill<unknown> =>
 
 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: CompositionClass<unknown>): Record<string, SlotClass> =>
-  Option.getOrElse(Option.fromNullable(comp.manifest.slots), () => ({}))
+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',
+    ),
+  )
+
+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(
@@ -144,54 +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>>()
-  // 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> {
-    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
 })
 
-// Explicit type so recursive renderLevel references 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)
-      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]) => {
@@ -210,32 +339,180 @@ 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]
 })
 
+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 {
+  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>
+}
+
+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',
+  )
+
+  const renderEffect = settleDrain.pipe(
+    Effect.zipRight(
+      renderSceneWith(
+        scene,
+        { register: registry.register },
+        (slotDefinition) => capturedSlotProvider(context, slotDefinition),
+        (composition, props) => renderCapturedComposition(context, composition, props),
+      ),
+    ),
+  )
+
+  const changeListeners = new Set<() => void>()
+  const notifyChange = (): void => {
+    changeListeners.forEach((listener) => listener())
+  }
+  runtime.runFork(
+    Effect.scoped(
+      Effect.gen(function* () {
+        const bus = yield* busFromContext
+        const subscription = yield* PubSub.subscribe(bus)
+        // The transport debounces; settling here would perturb the drain's scheduling.
+        yield* Queue.take(subscription).pipe(
+          Effect.zipRight(Effect.sync(notifyChange)),
+          Effect.forever,
+        )
+      }),
+    ),
+  )
+
+  runtime.runSync(
+    Effect.forEach(
+      Option.getOrElse(Option.fromNullable(scene.boot), () => []),
+      (event) =>
+        busFromContext.pipe(
+          Effect.flatMap((bus) => publish('High', event).pipe(Effect.provideService(Bus, bus))),
+        ),
+    ),
+  )
 
-export { makeRemoteServer, type RemoteServer } from './remote-server'
+  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 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),
+  )

package/src/transport.test.ts

@@ -9,7 +9,8 @@ import { inMemoryTransportPair } from './memory'
 import { remoteViews } from './client'
 import { asyncCounterScene, CounterUi, counterScene } from './fixtures'
 
-const draw = (node: ReactNode): void => void renderToStaticMarkup(createElement(Fragment, null, node))
+const draw = (node: ReactNode): void =>
+  void renderToStaticMarkup(createElement(Fragment, null, node))
 
 interface Probe {
   props?: Record<string, unknown>