@playfast/reform-remote-node 1.0.2 → 1.1.1

package/package.json

@@ -1,36 +1,38 @@
 {
   "name": "@playfast/reform-remote-node",
-  "playbook": "./playbook",
-  "version": "1.0.2",
-  "type": "module",
+  "version": "1.1.1",
   "description": "Node WebSocket server adapter for reform-remote — serves a reform scene's UI over the `ws` package, one isolated runtime per connection.",
   "keywords": [
-    "reform",
     "effect",
-    "websocket",
-    "remote",
     "node",
-    "server"
+    "reform",
+    "remote",
+    "server",
+    "websocket"
   ],
+  "bugs": {
+    "url": "https://github.com/playfast/reform/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/playfast/reform.git",
     "directory": "packages/reform-remote-node"
   },
-  "bugs": {
-    "url": "https://github.com/playfast/reform/issues"
-  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "type": "module",
   "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
     ".": "./src/index.ts",
     "./*": "./src/*.ts"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "clean": "rm -rf dist .tsbuildinfo",
     "check": "tsc --noEmit",
@@ -44,16 +46,14 @@
   "dependencies": {
     "ws": "^8.18.0"
   },
-  "peerDependencies": {
-    "effect": "*",
-    "react": "^19.0.0",
-    "@playfast/reform": "*",
-    "@playfast/reform-remote": "*"
-  },
   "devDependencies": {
     "@types/ws": "^8.5.13"
   },
-  "publishConfig": {
-    "access": "public"
-  }
+  "peerDependencies": {
+    "@playfast/reform": "*",
+    "@playfast/reform-remote": "*",
+    "effect": "*",
+    "react": "^19.0.0"
+  },
+  "playbook": "./playbook"
 }

package/src/index.ts

@@ -1,6 +1,7 @@
 import type { Server } from 'node:http'
+import { Option, Schema } from 'effect'
 import { type RawData, WebSocketServer } from 'ws'
-import type { Scene } from '@playfast/reform'
+import type { AnyScene } from '@playfast/reform/internal'
 import {
   type InvokeMessage,
   type RemoteTransport,
@@ -9,7 +10,7 @@ import {
 } from '@playfast/reform-remote'
 
 export interface NodeWebSocketOptionsExternalApi {
-  readonly scene: Scene
+  readonly scene: AnyScene
   readonly port?: number
   readonly server?: Server
   readonly path?: string
@@ -20,24 +21,72 @@ export interface NodeWebSocketServer {
   readonly stop: () => Promise<void>
 }
 
-const parseInvoke = (frame: RawData): InvokeMessage =>
-  // oxlint-disable-next-line reform-rules/no-json-parse-stringify, reform-rules/no-type-assertion -- wire frame decode; InvokeMessage is a structural type with no Schema here
-  JSON.parse(frame.toString()) as InvokeMessage
+const WirePropSchema = Schema.Union(
+  Schema.Struct({
+    _tag: Schema.Literal('Data'),
+    name: Schema.String,
+    value: Schema.Unknown,
+  }),
+  Schema.Struct({
+    _tag: Schema.Literal('Event'),
+    name: Schema.String,
+    handle: Schema.String,
+  }),
+)
+const WireNodeSchema = Schema.Struct({
+  id: Schema.String,
+  name: Schema.String,
+  parentId: Schema.NullOr(Schema.String),
+  childIndex: Schema.Number,
+  slot: Schema.NullOr(Schema.String),
+  key: Schema.NullOr(Schema.String),
+  props: Schema.Array(WirePropSchema),
+})
+const WirePatchSchema = Schema.Union(
+  Schema.Struct({ _tag: Schema.Literal('Upsert'), node: WireNodeSchema }),
+  Schema.Struct({ _tag: Schema.Literal('Delete'), id: Schema.String }),
+)
+const InvokeMessageJson: Schema.Schema<InvokeMessage, string, never> = Schema.parseJson(
+  Schema.Struct({
+    _tag: Schema.Literal('Invoke'),
+    handle: Schema.String,
+    payload: Schema.Unknown,
+  }),
+)
+const ServerMessageJson: Schema.Schema<ServerMessage, string, never> = Schema.parseJson(
+  Schema.Union(
+    Schema.Struct({
+      _tag: Schema.Literal('Snapshot'),
+      tree: Schema.Array(WireNodeSchema),
+    }),
+    Schema.Struct({
+      _tag: Schema.Literal('Patches'),
+      patches: Schema.Array(WirePatchSchema),
+    }),
+  ),
+)
+const decodeInvokeMessage: (input: unknown) => InvokeMessage =
+  Schema.decodeUnknownSync(InvokeMessageJson)
+const encodeServerMessage: (message: ServerMessage) => string = Schema.encodeSync(ServerMessageJson)
 
-export const serveNodeWebSocket = (options: NodeWebSocketOptionsExternalApi): NodeWebSocketServer => {
-  const wss =
+const parseInvoke = (frame: RawData): InvokeMessage => decodeInvokeMessage(frame.toString())
+
+export const serveNodeWebSocket = (
+  options: NodeWebSocketOptionsExternalApi,
+): NodeWebSocketServer => {
+  const serverConfig =
     options.server !== undefined
-      ? new WebSocketServer({ server: options.server, path: options.path })
-      : new WebSocketServer({ port: options.port === undefined ? 0 : options.port, path: options.path })
+      ? { server: options.server, path: options.path }
+      : { port: options.port === undefined ? 0 : options.port, path: options.path }
+  const wss = new WebSocketServer(serverConfig)
 
   const shared = serveShared({ scene: options.scene })
 
   wss.on('connection', (socket) => {
     const handlers = new Set<(message: InvokeMessage) => void>()
     const transport: RemoteTransport<ServerMessage, InvokeMessage> = {
-      // oxlint-disable-next-line reform-rules/no-json-parse-stringify -- wire frame encode; ServerMessage is a structural type with no Schema here
-      send: (message) => socket.send(JSON.stringify(message)),
-      onMessage: (handler) => {
+      send: (message: ServerMessage): void => void socket.send(encodeServerMessage(message)),
+      onMessage: (handler: (message: InvokeMessage) => void): (() => void) => {
         handlers.add(handler)
         return () => void handlers.delete(handler)
       },
@@ -55,11 +104,17 @@ 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 drain.
+      // `wss.close` waits for live sockets to drain.
       wss.clients.forEach((client) => client.terminate())
-      await new Promise<void>((resolve, reject) =>
-        wss.close((error) => (error === undefined ? resolve() : reject(error))),
-      )
+      await new Promise<void>((resolve, reject) => {
+        wss.close((error) => (error === undefined ? resolve() : reject(error)))
+        // Bun's `ws` frees the port but never invokes that callback nor emits 'close',
+        // which would hang teardown forever. Both runtimes drop `address()` the moment
+        // the listener is gone, so that fact — not the signal — is what we settle on.
+        if (Option.isNone(Option.fromNullable(wss.address()))) {
+          resolve()
+        }
+      })
     },
   }
 }

package/src/server.test.ts

@@ -12,13 +12,13 @@ import {
   State,
   StateGroup,
   Ui,
-  Wire,
   mount,
   provide,
   scene,
   ui,
 } from '@playfast/reform'
-import type { WireNode, WireProp } from '@playfast/reform'
+import { Wire } from '@playfast/reform/internal'
+import type { WireNode, WireProp } from '@playfast/reform/internal'
 import type { ServerMessage } from '@playfast/reform-remote'
 import { type NodeWebSocketServer, serveNodeWebSocket } from './index'
 
@@ -30,11 +30,19 @@ class CounterUi extends ui('Counter', {
   props: S.Struct({ count: S.Number }),
   events: { bump: S.Struct({ by: S.Number }) },
 }) {}
-class Counter extends Composition.make('Counter', { title: 'Counter', ui: CounterUi, states: [Count] }) {}
+
+class Counter extends Composition.make('Counter', {
+  title: 'Counter',
+  ui: CounterUi,
+  states: [Count],
+})<Counter>() {}
 
 const counterScene = () => {
   const presentation = Layer.mergeAll(
-    provide(CounterUi, Ui.make(CounterUi, ({ count }) => `count:${count}`)),
+    provide(
+      CounterUi,
+      Ui.make(CounterUi, ({ count }) => `count:${count}`),
+    ),
     StateGroup.live(Counters, { count: 0 }),
   )
   const app = Layer.mergeAll(