@playfast/reform-remote-node 1.0.1 → 1.0.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@playfast/reform-remote-node",
   "playbook": "./playbook",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "type": "module",
   "description": "Node WebSocket server adapter for reform-remote — serves a reform scene's UI over the `ws` package, one isolated runtime per connection.",
   "keywords": [

package/src/index.ts

@@ -8,31 +8,15 @@ import {
   serveShared,
 } from '@playfast/reform-remote'
 
-/**
- * @playfast/reform-remote-node — serve a reform scene's UI over WebSocket from a
- * Node process, using the `ws` package. The scene runs ONCE as a single shared
- * runtime (`serveShared`); every connection attaches to it via `addClient`, so all
- * clients see and drive the same state. Sockets are wrapped with JSON framing: the
- * already-`_tag`-discriminated wire messages need no envelope. The Bun-native
- * equivalent is `@playfast/reform-remote-bun`; the browser/web client is
- * `@playfast/reform-remote-web`.
- */
-
 export interface NodeWebSocketOptionsExternalApi {
-  /** The scene to run — ONE shared runtime that every connection attaches to. */
   readonly scene: Scene
-  /** Listen on this port (use `0` for an ephemeral port; read it back from `wss.address()`). */
   readonly port?: number
-  /** Attach to an existing HTTP server instead of opening a port. */
   readonly server?: Server
-  /** Restrict upgrades to this path. */
   readonly path?: string
 }
 
 export interface NodeWebSocketServer {
-  /** The underlying `ws` server — for reading the bound address, or further config. */
   readonly wss: WebSocketServer
-  /** Dispose the shared runtime and close the server. */
   readonly stop: () => Promise<void>
 }
 
@@ -46,7 +30,6 @@ export const serveNodeWebSocket = (options: NodeWebSocketOptionsExternalApi): No
       ? new WebSocketServer({ server: options.server, path: options.path })
       : new WebSocketServer({ port: options.port === undefined ? 0 : options.port, path: options.path })
 
-  // One shared runtime for the whole server; every socket attaches to it.
   const shared = serveShared({ scene: options.scene })
 
   wss.on('connection', (socket) => {
@@ -72,8 +55,7 @@ export const serveNodeWebSocket = (options: NodeWebSocketOptionsExternalApi): No
     wss,
     stop: async (): Promise<void> => {
       await shared.dispose()
-      // Terminate live sockets so `wss.close` doesn't block waiting for them to
-      // drain on their own — `close` only fires its callback once all are gone.
+      // Terminate live sockets so `wss.close` doesn't block waiting for drain.
       wss.clients.forEach((client) => client.terminate())
       await new Promise<void>((resolve, reject) =>
         wss.close((error) => (error === undefined ? resolve() : reject(error))),

package/src/server.test.ts

@@ -2,8 +2,7 @@ import type { AddressInfo } from 'node:net'
 import { afterEach, expect, test, vi } from 'vitest'
 import { Layer, Schema as S } from 'effect'
 
-// Real loopback socket I/O: headroom so the full parallel suite can't starve it past
-// the 5s default (passes fast in isolation; 30s still fails a genuine hang).
+// Real loopback I/O: headroom so parallel suite can't starve past 5s default.
 vi.setConfig({ testTimeout: 30_000, hookTimeout: 30_000 })
 import {
   Composition,
@@ -23,8 +22,6 @@ import type { WireNode, WireProp } from '@playfast/reform'
 import type { ServerMessage } from '@playfast/reform-remote'
 import { type NodeWebSocketServer, serveNodeWebSocket } from './index'
 
-// A self-contained counter scene (the adapter packages stay independent of the
-// core package's test fixtures, which aren't part of its public surface).
 class Count extends State.make('count', S.Number) {}
 class Counters extends StateGroup.make(Count) {}
 class Bumped extends Event.make('Bumped', S.Struct({ by: S.Number })) {}
@@ -111,9 +108,7 @@ test('every connection shares ONE runtime — a bump on one socket reaches the o
   open.add(host)
   const port = await listening(host)
 
-  // Attach every listener BEFORE awaiting: the shared server snapshots a new client
-  // off its pre-rendered baseline immediately, so a lazily-attached listener could miss
-  // the frame (a real `connect()` client registers its handler synchronously).
+  // Attach listeners before await: shared server snapshots immediately; lazy attach can miss the frame.
   const a = new WebSocket(`ws://localhost:${port}`)
   const snapAP = nextMessage(a, (m) => m._tag === 'Snapshot')
   const b = new WebSocket(`ws://localhost:${port}`)
@@ -122,7 +117,6 @@ test('every connection shares ONE runtime — a bump on one socket reaches the o
     const snapA = await snapAP
     const snapB = await snapBP
 
-    // a bumps; BOTH a and b receive the broadcast diff off the shared runtime.
     const frameAP = nextMessage(a, (m) => m._tag === 'Patches')
     const frameBP = nextMessage(b, (m) => m._tag === 'Patches')
     a.send(JSON.stringify({ _tag: 'Invoke', handle: '0:bump', payload: { by: 4 } }))
@@ -139,7 +133,6 @@ test('every connection shares ONE runtime — a bump on one socket reaches the o
     )
     expect(countOf(treeA[0]!)).toBe(4)
     expect(countOf(treeB[0]!)).toBe(4)
-    // A late joiner snapshots the CURRENT shared count (4), not a fresh 0.
     const c = new WebSocket(`ws://localhost:${port}`)
     const snapC = await nextMessage(c, (m) => m._tag === 'Snapshot')
     expect(countOf((snapC._tag === 'Snapshot' ? snapC.tree : [])[0]!)).toBe(4)