@playfast/reform-remote 1.0.1 → 1.1.0

package/src/server.test.ts

@@ -2,8 +2,14 @@ import { createElement, Fragment, type ReactNode } from 'react'
 import { renderToStaticMarkup } from 'react-dom/server'
 import { expect, test } from 'vitest'
 import { Option } from 'effect'
-import { Ui, Wire } from '@playfast/reform'
-import type { WireNode, WirePatch, WireProp, WireTree } from '@playfast/reform'
+import { Ui } from '@playfast/reform'
+import {
+  Wire,
+  type WireNode,
+  type WirePatch,
+  type WireProp,
+  type WireTree,
+} from '@playfast/reform/internal'
 import { makeRemoteServer } from './server'
 import { remoteViews, renderWireTree } from './client'
 import {
@@ -17,17 +23,20 @@ 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 draw = (node: ReactNode): void =>
+  void renderToStaticMarkup(createElement(Fragment, null, node))
 
 const dataOf = (node: WireNode, name: string): WireProp | undefined =>
   node.props.find((prop) => prop._tag === 'Data' && prop.name === name)
 
 const eventOf = (node: WireNode, name: string): Extract<WireProp, { _tag: 'Event' }> | undefined =>
-  node.props.find((prop): prop is Extract<WireProp, { _tag: 'Event' }> => prop._tag === 'Event' && prop.name === name)
+  node.props.find(
+    (prop): prop is Extract<WireProp, { _tag: 'Event' }> =>
+      prop._tag === 'Event' && prop.name === name,
+  )
 
-const byId = (tree: WireTree, id: string): WireNode | undefined => tree.find((node) => node.id === id)
+const byId = (tree: WireTree, id: string): WireNode | undefined =>
+  tree.find((node) => node.id === id)
 
 const upsertIds = (patches: ReadonlyArray<WirePatch>): ReadonlyArray<string> =>
   patches.flatMap((patch) => (patch._tag === 'Upsert' ? [patch.node.id] : []))
@@ -35,8 +44,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,16 +73,12 @@ 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())
   try {
     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' })
 
@@ -117,7 +120,10 @@ test('renderDiff streams patches a client folds back to the current tree', async
 
 test('end to end: client reconstructs props + event callbacks that drive the server', async () => {
   const server = makeRemoteServer(counterScene())
-  const captured: { props?: Record<string, unknown>; events?: Record<string, (p: { by: number }) => void> } = {}
+  const captured: {
+    props?: Record<string, unknown>
+    events?: Record<string, (p: { by: number }) => void>
+  } = {}
   const sent: Array<[string, unknown]> = []
   try {
     const tree = await server.render()
@@ -156,8 +162,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())
   try {
@@ -205,22 +209,23 @@ test('two events on one node register distinct handles and each fires independen
     expect(eventOf(before, 'clear')?.handle).toBe('0.Main.0:clear')
 
     await server.invoke('0.Main.0:greet', { text: 'hello' })
-    expect(dataOf(byId(await server.render(), '0.Main.0')!, 'greeting')).toMatchObject({ value: 'hello' })
+    expect(dataOf(byId(await server.render(), '0.Main.0')!, 'greeting')).toMatchObject({
+      value: 'hello',
+    })
 
     await server.invoke('0.Main.0:clear', {})
-    expect(dataOf(byId(await server.render(), '0.Main.0')!, 'greeting')).toMatchObject({ value: '' })
+    expect(dataOf(byId(await server.render(), '0.Main.0')!, 'greeting')).toMatchObject({
+      value: '',
+    })
   } finally {
     await server.dispose()
   }
 })
 
-// ── 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 +243,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 +262,19 @@ 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 +287,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 +319,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 {