@playfast/reform-remote 1.1.0 → 1.2.0

package/src/server.ts

@@ -1,370 +1,32 @@
 import {
-  Array as Arr,
-  Context,
   Effect,
   Layer,
-  Match,
   ManagedRuntime,
   Option,
   type ParseResult,
   PubSub,
   Queue,
-  Record as Rec,
-  Schema,
 } from 'effect'
+import { type CapturedScene, forceSync, publish, type UiContract } from '@playfast/reform'
 import {
-  type CapturedScene,
-  Composition,
-  type CompositionClass,
-  forceSync,
-  isFeatureBinding,
-  isSlot,
-  isStructure,
-  publish,
-  type SlotFill,
-  type Structure,
-  type Trigger,
-  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/internal'
-
-const SETTLE_DRAIN = 30
-const settleDrain = Effect.yieldNow().pipe(Effect.repeatN(SETTLE_DRAIN))
-
-// 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,
-  })
-
-interface Mounted {
-  readonly comp: AnyComposition
-  readonly props: unknown
-  readonly id: string
-  readonly parentId: Option.Option<string>
-  readonly slot: Option.Option<string>
-  readonly childIndex: number
-  readonly key: Option.Option<string>
-}
-
-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] : []))
-
-// One-shot renders still emit deterministic handles but have no client registry.
-const noRegister: TriggerRegistryApi['register'] = () => Effect.void
-
-const toWireNodeFromStructure = Effect.fn('toWireNodeFromStructure')(function* (
-  mounted: Mounted,
-  structure: Structure<UiContract>,
-  register: TriggerRegistryApi['register'],
-): Effect.fn.Return<WireNode, ParseResult.ParseError> {
-  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: (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,
-    }),
-  )
-
-  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.make<unknown, unknown>(schema.value.ast))
-        return Option.some<WireProp>({
-          _tag: 'Event',
-          name: eventName,
-          handle,
-        })
-      }),
-  ).pipe(Effect.map(Arr.getSomes))
-
-  return {
-    id: mounted.id,
-    name,
-    parentId: Option.getOrNull(mounted.parentId),
-    childIndex: mounted.childIndex,
-    slot: Option.getOrNull(mounted.slot),
-    key: Option.getOrNull(mounted.key),
-    props: [...dataProps, ...eventProps],
-  }
-})
-
-// 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')
-
-const structureFills = (structure: Structure<UiContract>): Record<string, SlotFill<unknown>> =>
-  Rec.fromEntries(
-    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',
-    ),
-  )
-
-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: AnyComposition,
-  fill: SlotFill<unknown>,
-): ReadonlyArray<Mounted> =>
-  Match.value(fill).pipe(
-    Match.tag('Each', (each) =>
-      each.items.map(
-        (entry, index): Mounted => ({
-          comp: child,
-          props: entry.props,
-          id: `${parent.id}.${slotName}.${index}`,
-          parentId: Option.some(parent.id),
-          slot: Option.some(slotName),
-          childIndex: index,
-          key: Option.fromNullable(entry.key),
-        }),
-      ),
-    ),
-    Match.tag('One', (single) => [
-      {
-        comp: child,
-        props: single.props,
-        id: `${parent.id}.${slotName}.0`,
-        parentId: Option.some(parent.id),
-        slot: Option.some(slotName),
-        childIndex: 0,
-        key: Option.none(),
-      } satisfies Mounted,
-    ]),
-    Match.tag('Absent', () => []),
-    Match.exhaustive,
-  )
-
-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
-})
-
-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<AnySlot, AnyComposition>,
-  register: TriggerRegistryApi['register'],
-  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 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]) => {
-        const child = bindings.get(slotClass)
-        if (child === undefined) {
-          return []
-        }
-        const fill = fills[slotName]
-        if (fill === undefined) {
-          return []
-        }
-        return enqueueStructureSlot(mounted, slotName, child, fill)
-      })
-      return { node, children }
-    }),
-  )
-  const nodes = rendered.map((entry) => entry.node)
-  const next = rendered.flatMap((entry) => entry.children)
-  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']
-}
+import {
+  capturedSlotProvider,
+  renderCapturedComposition,
+  type RenderSceneToWireOptions,
+  renderSceneWith,
+  serviceFromContext,
+} from './wireRender'
+import { handlesOf, settleDrain } from './wireNode'
+
+export type { RenderSceneToWireOptions } from './wireRender'
 
 // oxlint-disable-next-line reform-rules/prefer-effect-fn -- exported binding: Effect.fn's inferred type isn't portable under isolatedDeclarations
 export const renderSceneToWire = <

package/src/slottedFixtures.ts

@@ -0,0 +1,120 @@
+import { createElement } from 'react'
+import { Effect, Layer, Schema as S } from 'effect'
+import {
+  Composition,
+  Engine,
+  Event,
+  Reducer,
+  State,
+  Ui,
+  mount,
+  one,
+  provide,
+  scene,
+  slot,
+  type CapturedScene,
+  type DerivedContract,
+  type SlotService,
+  ui,
+} from '@playfast/reform'
+import { type CompositionChildSummary, type EngineServices, type WiredUi } from '@playfast/reform/internal'
+
+const GreetingBase: State.StateDefinition<'greeting', string, typeof S.String> = State.make(
+  'greeting',
+  S.String,
+)
+class Greeting extends GreetingBase {}
+class Greeted extends Event.make('Greeted', S.Struct({ text: S.String })) {}
+class Cleared extends Event.make('Cleared', S.Struct({})) {}
+class SetGreeting extends Reducer.make('SetGreeting', {
+  states: [Greeting],
+  events: [Greeted],
+}) {}
+class ClearGreeting extends Reducer.make('ClearGreeting', {
+  states: [Greeting],
+  events: [Cleared],
+}) {}
+const PanelUiBase: WiredUi<
+  DerivedContract<{
+    props: S.Struct<{ greeting: typeof S.String }>
+    events: {
+      greet: S.Struct<{ text: typeof S.String }>
+      clear: S.Struct<{}>
+    }
+  }>,
+  'Panel'
+> = ui('Panel', {
+  props: S.Struct({ greeting: S.String }),
+  events: { greet: S.Struct({ text: S.String }), clear: S.Struct({}) },
+})
+class PanelUi extends PanelUiBase {}
+
+class Panel extends Composition.make('Panel', {
+  title: 'Panel',
+  ui: PanelUi,
+  states: [Greeting],
+})<Panel>() {}
+
+class MainSlot extends slot('Main')<MainSlot, typeof Panel>() {}
+const ShellUiBase: Ui.UiClass<{ props: {}; slots: { Main: MainSlot } }, 'Shell'> = ui('Shell')<{
+  props: {}
+  slots: { Main: MainSlot }
+}>()
+class ShellUi extends ShellUiBase {}
+
+class Shell extends Composition.make('Shell', {
+  title: 'Shell',
+  slots: { Main: MainSlot },
+  ui: ShellUi,
+})<Shell>() {}
+
+type SlottedScene = CapturedScene<
+  typeof ShellUi.Contract,
+  readonly [],
+  | EngineServices
+  | State.StateStore<'greeting', string>
+  | Ui.UiService<'Panel'>
+  | Ui.UiService<'Shell'>
+  | Composition.CompositionId<'Shell', Shell, MainSlot>
+  | Composition.CompositionId<'Panel', Panel, never>
+  | SlotService<'Main', MainSlot, CompositionChildSummary<Panel>>,
+  unknown,
+  'Shell',
+  Shell
+>
+
+const makeSlottedScene = (): SlottedScene => {
+  const presentation = Layer.mergeAll(
+    provide(
+      ShellUi,
+      Ui.make(ShellUi, (_props, slots) => createElement(slots.Main, {})),
+    ),
+    provide(
+      PanelUi,
+      Ui.make(PanelUi, ({ greeting }) => greeting),
+    ),
+    provide(MainSlot, Panel),
+    State.live(Greeting, 'hi'),
+  )
+  const app = Layer.mergeAll(
+    Composition.live(Shell, function* () {
+      yield* Effect.void
+      return mount({ props: {}, slots: { Main: one({}) } })
+    }),
+    Composition.live(Panel, function* () {
+      const greeting = yield* Greeting
+      const greet = yield* Event.trigger(Greeted)
+      const clearTrigger = yield* Event.trigger(Cleared)
+      const clear = (): void => clearTrigger({})
+      return mount({
+        props: { greeting },
+        slots: {},
+        events: { greet, clear },
+      })
+    }),
+    Reducer.live(SetGreeting, (_greeting, event) => event.text),
+    Reducer.live(ClearGreeting, () => ''),
+  ).pipe(Layer.provideMerge(presentation), Layer.provideMerge(Engine))
+  return scene(Shell, { provide: [app] })
+}
+export const slottedScene: typeof makeSlottedScene = makeSlottedScene

package/src/wireNode.ts

@@ -0,0 +1,153 @@
+import { Array as Arr, Effect, Option, type ParseResult, Record as Rec, Schema } from 'effect'
+import {
+  isFeatureBinding,
+  isSlot,
+  type SlotFill,
+  type Structure,
+  type Trigger,
+  type UiContract,
+} from '@playfast/reform'
+import {
+  type AnyComposition,
+  type AnySlot,
+  type AnySlotChild,
+  type TriggerRegistryApi,
+  type UiManifest,
+  type WireNode,
+  type WireProp,
+} from '@playfast/reform/internal'
+
+export const SETTLE_DRAIN = 30
+export const settleDrain: Effect.Effect<void> = Effect.yieldNow().pipe(Effect.repeatN(SETTLE_DRAIN))
+
+// The erased event map's never values remain assignable to Trigger<unknown> without a cast.
+export const eventsOf = (structure: Structure<UiContract>): Record<string, Trigger<unknown>> =>
+  Option.match(Option.fromNullable(structure.events), {
+    onNone: () => ({}),
+    onSome: (events) => events,
+  })
+
+export interface Mounted {
+  readonly comp: AnyComposition
+  readonly props: unknown
+  readonly id: string
+  readonly parentId: Option.Option<string>
+  readonly slot: Option.Option<string>
+  readonly childIndex: number
+  readonly key: Option.Option<string>
+}
+
+export const childComposition = (child: AnySlotChild): AnyComposition => {
+  if (!isFeatureBinding(child)) {
+    return child
+  }
+  return child.capture<AnyComposition>((binding): AnyComposition => binding.composition)
+}
+
+export const isRecord = (candidate: unknown): candidate is Record<string, unknown> =>
+  typeof candidate === 'object' && candidate !== null && !Array.isArray(candidate)
+
+export 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.
+export const noRegister: TriggerRegistryApi['register'] = () => Effect.void
+
+export const toWireNodeFromStructure: (
+  mounted: Mounted,
+  structure: Structure<UiContract>,
+  register: TriggerRegistryApi['register'],
+) => Effect.Effect<WireNode, ParseResult.ParseError> = Effect.fn('toWireNodeFromStructure')(
+  function* (
+  mounted: Mounted,
+  structure: Structure<UiContract>,
+  register: TriggerRegistryApi['register'],
+): Effect.fn.Return<WireNode, ParseResult.ParseError> {
+  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: (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,
+    }),
+  )
+
+  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.make<unknown, unknown>(schema.value.ast))
+        return Option.some<WireProp>({
+          _tag: 'Event',
+          name: eventName,
+          handle,
+        })
+      }),
+  ).pipe(Effect.map(Arr.getSomes))
+
+  return {
+    id: mounted.id,
+    name,
+    parentId: Option.getOrNull(mounted.parentId),
+    childIndex: mounted.childIndex,
+    slot: Option.getOrNull(mounted.slot),
+    key: Option.getOrNull(mounted.key),
+    props: [...dataProps, ...eventProps],
+  }
+})
+
+// Structure erases per-slot fill types; recover SlotFill structurally without `as`.
+export 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')
+
+export const structureFills = (structure: Structure<UiContract>): Record<string, SlotFill<unknown>> =>
+  Rec.fromEntries(
+    Rec.toEntries(structure.slots).flatMap(
+      ([slotName, fillValue]): ReadonlyArray<readonly [string, SlotFill<unknown>]> =>
+        isSlotFill(fillValue) ? [[slotName, fillValue]] : [],
+    ),
+  )
+
+export 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]] : [],
+      ),
+    )
+  })