@playfast/reform-remote 0.0.2

package/README.md

@@ -0,0 +1,125 @@
+<div align="center">
+
+# `@playfast/reform-remote`
+
+**Run a reform scene's logic on the server; render its UI on a thin client over a transport.**
+
+</div>
+
+---
+
+A fourth consumer of a reform [`Scene`](https://www.npmjs.com/package/@playfast/reform), alongside
+[`@playfast/react`](https://www.npmjs.com/package/@playfast/react),
+[`@playfast/react-native`](https://www.npmjs.com/package/@playfast/react-native), and
+[`@playfast/proof`](https://www.npmjs.com/package/@playfast/proof). State, events, reducers,
+async/remote data, and compositions all run **server-side**; the client receives a serialized
+tree of rendered UI contracts and renders them with local presentations. The wire carries only
+data — UI-tree patches one way, trigger invocations the other — so there is no API layer to write.
+
+This builds on reform's existing seams: the **`ui` contract** already separates logic from
+presentation, the **`CaptureSink`** already serializes the rendered surface headlessly (the same
+mechanism proofs use), and the **schema-first `ui`** form (`ui(name, { props, events })`) carries
+the wire schemas that make props and trigger payloads typed *and* runtime-validated at the seam.
+See [`REMOTE_UI.md`](../../REMOTE_UI.md) for the design.
+
+## Install
+
+```sh
+npm install @playfast/reform-remote @playfast/reform effect react
+```
+
+Add a transport adapter for the wire you want — `inMemoryTransportPair` ships here; for real
+sockets pair with [`@playfast/reform-remote-node`](https://www.npmjs.com/package/@playfast/reform-remote-node),
+[`@playfast/reform-remote-bun`](https://www.npmjs.com/package/@playfast/reform-remote-bun), or
+[`@playfast/reform-remote-web`](https://www.npmjs.com/package/@playfast/reform-remote-web).
+
+## Key concepts
+
+| Concept | What it does |
+| --- | --- |
+| `makeRemoteServer(scene)` | Renders a `Scene` to a `WireTree`; `render()`/`renderDiff()` emit full tree/patches; `invoke(handle, payload)` fires a trigger. |
+| `renderWireTree(tree, { views, invoke })` | Folds a `WireTree` back into React using local presentations. |
+| `remoteContract({...})` / `remoteViews<C>({...})` | The trpc-style typesafe seam — server declares the contract, client implements exactly it. |
+| `serve({ scene, transport })` / `connect({ transport, views })` | Bind both ends to any `RemoteTransport`. |
+| `inMemoryTransportPair()` | In-process duplex `RemoteTransport` (the simplest concrete adapter). |
+| `<RemoteUI transport views />` / `useRemoteUI` | React binding that owns connect, subscription, re-render, teardown. |
+| `useConnectionStatus(reporter)` | Reads a transport's live `StatusReporter` status. |
+
+## How it fits together
+
+```
+            server                                   client
+  ┌────────────────────────┐                ┌──────────────────────────┐
+  Scene ─► makeRemoteServer ─► WirePatch[] ──►  Wire.apply ─► renderWireTree
+   ▲          (renders,                          (folds tree)   (local views)
+   │           encodes props,                                        │
+   │           registers triggers)                                   ▼
+   └──────────── invoke(handle, payload) ◄──── event callback fires ─┘
+```
+
+- **`makeRemoteServer(scene)`** — renders the scene to a `WireTree`, encoding each contract's
+  props via its schema and registering triggers behind stable `${nodeId}:${event}` handles.
+  `render()` / `renderDiff()` produce a full tree / patches; `invoke(handle, payload)` decodes the
+  payload and fires the trigger (a `High`-priority dispatch into the Bus).
+- **`renderWireTree(tree, { views, invoke })`** — turns a `WireTree` back into React using the
+  presentations in `views` (the bundled vocabulary), reconstituting event props as callbacks.
+- **`remoteContract({...})` / `remoteViews<AppContract>({...})`** — the trpc-style typesafe seam.
+  The SERVER declares its UI shape ONCE and exports `typeof` it; the CLIENT imports only that TYPE
+  and implements it. `remoteViews<AppContract>` type-checks the client's view set to implement
+  EXACTLY the server's contracts — a missing, extra, or wrong-contract view is a compile error.
+  Each view is a plain `Ui.make` (props, slots, events all typed from its contract); the render
+  name + props schema come from the contract, so they can't drift. The result is a branded
+  `RemoteViewSet<AppContract>` that `connect`/`renderWireTree`/`<RemoteUI>` accept (an unbranded
+  `Record` is rejected — the contract check is end-to-end, with no widening):
+  ```ts
+  // server (or shared) — the AppRouter analog:
+  export const AppContract = remoteContract({ TodoApp: TodoAppUi, TodoItem: TodoItemUi })
+  export type AppContract = typeof AppContract
+
+  // client — imports the TYPE only:
+  import type { AppContract } from '…/contracts'
+  const TodoItem = Ui.make(TodoItemUi, (props, _slots, events) => (
+    <li onClick={() => events.toggle({})}>{props.text}</li> // props/events fully typed
+  ))
+  export const views = remoteViews<AppContract>({ TodoApp: /* … */, TodoItem })
+  ```
+- **`serve({ scene, transport })` / `connect({ transport, views })`** — bind both ends to any
+  `RemoteTransport` (WebSocket, postMessage, in-memory). The server sends a `Snapshot` (full tree,
+  replace) on connect and `Patches` (apply) thereafter, so a reconnecting client re-syncs cleanly.
+- **`inMemoryTransportPair()`** — the in-process duplex adapter the tests drive `serve`/`connect`
+  over without a socket; the simplest concrete `RemoteTransport`.
+- **`<RemoteUI transport views />` / `useRemoteUI(transport, views)`** — the React binding. It owns
+  the whole client side — `connect`, the patch subscription, re-render on each frame, and teardown
+  on unmount — so the call site holds no `useSyncExternalStore` or `binding.node()`. Pair it with
+  **`useConnectionStatus(transport)`** to read a transport's live status (e.g. a reconnecting badge):
+  ```tsx
+  const App = () => {
+    const status = useConnectionStatus(transport) // 'connecting' | 'open' | 'reconnecting' | 'closed'
+    return (
+      <>
+        {status !== 'open' ? <div className={`conn ${status}`}>{status}…</div> : null}
+        <RemoteUI transport={transport} views={views} />
+      </>
+    )
+  }
+  ```
+
+## Transport adapters
+
+| Package | Role | Built on |
+| --- | --- | --- |
+| `inMemoryTransportPair` (here) | in-process duplex | — |
+| [`@playfast/reform-remote-node`](https://www.npmjs.com/package/@playfast/reform-remote-node) | WebSocket server | `ws` |
+| [`@playfast/reform-remote-bun`](https://www.npmjs.com/package/@playfast/reform-remote-bun) | WebSocket server | `Bun.serve` |
+| [`@playfast/reform-remote-web`](https://www.npmjs.com/package/@playfast/reform-remote-web) | WebSocket client (factory, auto-reconnect) | global `WebSocket` |
+
+## Status
+
+The full loop — scene → wire tree → diff → client render → trigger → server dispatch → re-render
+— is implemented and proven over the in-memory transport (flat, nested-slot, and dynamic-list
+scenes) and over real WebSockets via the adapter packages above. Remaining: `provideRemote` sugar
+that gates wiring on the `WiredUi` brand per remote.
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,127 @@
+import { type ReactNode } from 'react';
+import { Schema } from 'effect';
+import { type MadeView, Ui, type UiClass, type WireTree } from '@playfast/reform';
+/**
+ * The client side of the remote transport: fold the server's patches with
+ * `Wire.apply`, then render the resulting `WireTree` with locally registered
+ * presentations. The presentations are the SAME `Ui.make` views the local
+ * `@playfast/react` renderer uses — one presentation, many consumers (REMOTE_UI.md):
+ *
+ *  - Each wire node's view runs as a stable React COMPONENT, so a view body's own
+ *    hooks (`useState`, effects) work exactly as under `@playfast/react`.
+ *  - Slots are COMPONENTS that render that slot's wire children, so a view's
+ *    `<slots.Foo/>` / `createElement(slots.Foo, props)` works unchanged (the
+ *    per-slot props were captured server-side; the client component ignores them).
+ *  - Data props are DECODED through the contract's own props schema — the inverse of
+ *    the server's `Schema.encodeUnknown` — so `Option`/`Date`/branded props arrive as
+ *    real instances, not their `{_tag,value}` wire shape.
+ *
+ * A client view is authored with `Ui.make(SomeUi, …)` — exactly like a local view —
+ * and registered with `remoteViews<AppContract>({ Some: SomeView, … })`. There is no
+ * separate `remoteView` call: a `Ui.make` view carries its own contract, so `remoteViews`
+ * recovers each view's wire name + props schema straight from it.
+ */
+/**
+ * The dynamic presentation shape the renderer calls — slots and events erased to
+ * their runtime form. Views are authored with `Ui.make` (contract-typed); this is
+ * only the internal shape `renderWireTree` invokes them through.
+ */
+export type RemoteView = (props: Record<string, unknown>, slots: Record<string, (slotProps?: {
+    readonly slotKey?: string;
+}) => ReactNode>, events: Record<string, (payload: unknown) => void>) => ReactNode;
+/** A contract-bound view paired with the contract name the renderer looks it up by, and
+ *  (for a WIRED contract) the props schema used to DECODE wire props back into their
+ *  decoded domain types — the symmetric inverse of the server's `Schema.encodeUnknown`.
+ *  Without it, an `Option`/`Date`/branded prop would reach the view as its raw encoded
+ *  shape (e.g. `{_tag:'Some',value}`) instead of a real `Option`. */
+export interface RegisteredRemoteView {
+    readonly name: string;
+    readonly view: RemoteView;
+    readonly propsSchema?: Schema.Schema<Record<string, unknown>, unknown>;
+}
+/** The by-name presentation record the renderer walks — the unbranded runtime shape behind
+ *  a `RemoteViewSet`. Internal: it is NOT part of the public API, so a raw record of this
+ *  shape can never be handed to `connect`/`renderWireTree`/`<RemoteUI>` (those demand the
+ *  branded `RemoteViewSet<C>`). A `RemoteViewSet<C>` is structurally `ViewRegistry & brand`,
+ *  so it always widens back to this when the renderer needs the plain lookup. */
+type ViewRegistry = Readonly<Record<string, RegisteredRemoteView>>;
+/** Phantom brand carrying the server `RemoteContract` a view set was checked against. Typed
+ *  as a function OF `C` (never called) so the contract appears in the type WITHOUT needing a
+ *  runtime value of `C` — `remoteViews<C>(views)` can brand the set cast-free even though the
+ *  client imports the contract as a TYPE only (trpc-style), never as a value. */
+declare const ViewSetContract: unique symbol;
+/**
+ * The presentation set the client renders by contract name — the `ViewRegistry` the renderer
+ * walks, BRANDED with the server `RemoteContract` `C` it was checked against. The brand is
+ * what makes the whole client chain typesafe: `connect`, `renderWireTree`, and `<RemoteUI>`
+ * accept only a `RemoteViewSet` *produced by* `remoteViews<C>(…)` — never an arbitrary
+ * `Record`, which lacks the brand — so a view set cannot reach the renderer without having
+ * been type-checked to implement exactly the server's shape. `C` is recovered by inference at
+ * each consumer, so passing a `RemoteViewSet<AppContract>` types the whole chain to that app.
+ *
+ * No default for `C`: a `RemoteViewSet` is ALWAYS bound to a concrete contract (inferred from
+ * `remoteViews<AppContract>(…)`), never silently widened to the `RemoteContract` bound — that
+ * is what keeps the safety end to end.
+ */
+export type RemoteViewSet<C extends RemoteContract> = ViewRegistry & {
+    readonly [ViewSetContract]: (contract: C) => void;
+};
+/**
+ * The shared "shape" the server publishes and the client implements — the trpc `AppRouter`
+ * analog. It is a registry of the server's UI contracts (the `ui(...)` classes the scene's
+ * wire tree can emit) keyed by a label. The SERVER declares it ONCE (`remoteContract({…})`)
+ * and exports `typeof` it; the CLIENT imports THAT TYPE and `remoteViews<AppContract>(…)`
+ * checks its view set against it, so the client is forced to implement exactly the server's
+ * views. The wire name + props schema are read from each view's own contract at runtime, so
+ * the label is only the type-level join key — the contract is never needed as a value here.
+ *
+ * `UiClass<any>` is the registry's *upper bound*; the precise per-contract types are
+ * preserved by inferring `C` narrowly at the `remoteContract` declaration site (so
+ * `Ui.Contract<C[K]>` recovers the real contract, not `any`).
+ */
+export type RemoteContract = Readonly<Record<string, UiClass<any>>>;
+/**
+ * Declare a server's `RemoteContract` with its precise key/contract types inferred (the
+ * `const` type parameter keeps each value's specific `UiClass<…>` instead of widening to
+ * the `UiClass<any>` bound). Define it ONCE next to the scene and export `typeof` it as the
+ * UI requirements the client implements against:
+ *
+ *   export const AppContract = remoteContract({ Shell: ShellUi, Sidebar: SidebarUi })
+ *   export type AppContract = typeof AppContract
+ *
+ * The client then imports only the TYPE and implements it:
+ *
+ *   import type { AppContract } from '…/app-contract'
+ *   export const views = remoteViews<AppContract>({ Shell: ShellView, Sidebar: SidebarView })
+ */
+export declare const remoteContract: <const C extends RemoteContract>(contract: C) => C;
+/**
+ * The client view set a `RemoteContract` demands: exactly one `Ui.make` view per contract,
+ * each typed to THAT contract (`MadeView<Ui.Contract<C[K]>>`). A missing key, an extra key,
+ * or a view authored for the wrong contract is a COMPILE error — the client cannot connect
+ * to the server without implementing precisely its shape, the same guarantee trpc gives a
+ * client built from `AppRouter`.
+ */
+export type RemoteViews<C extends RemoteContract> = {
+    readonly [K in keyof C]: MadeView<Ui.Contract<C[K]>>;
+};
+/**
+ * Implement a server's UI shape: `remoteViews<AppContract>({ … })` takes the server's
+ * `RemoteContract` as a TYPE PARAMETER (the client imports only `typeof AppContract`, never a
+ * value — trpc-style) and a set of `Ui.make` views type-checked to implement EXACTLY that
+ * contract. Each view carries its own contract (`Ui.make(SomeUi, …)`), so the wire name and
+ * props schema are recovered from the view itself — a renamed/retyped contract can never
+ * drift from its presentation, and the SAME view authored for the local renderer is reused.
+ * The result is a `RemoteViewSet<C>` (the branded set `connect`/`renderWireTree`/`<RemoteUI>`
+ * accept); an unbranded `Record` can never be substituted.
+ */
+export declare const remoteViews: <C extends RemoteContract>(views: RemoteViews<C>) => RemoteViewSet<C>;
+export interface ClientConfig<C extends RemoteContract> {
+    /** Presentation (+ optional props schema) per contract name — a contract-checked set. */
+    readonly views: RemoteViewSet<C>;
+    /** Deliver a trigger invocation to the server (the transport's send). */
+    readonly invoke: (handle: string, payload: unknown) => void;
+}
+export declare const renderWireTree: <C extends RemoteContract>(tree: WireTree, config: ClientConfig<C>) => ReactNode;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,KAAK,SAAS,EAAU,MAAM,OAAO,CAAA;AACvE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EACL,KAAK,QAAQ,EACb,EAAE,EACF,KAAK,OAAO,EAIZ,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAQzB;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG,CACvB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAG9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,SAAS,CAAC,EAAE;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,KAAK,SAAS,CAAC,EAC/E,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC,KAC/C,SAAS,CAAA;AAEd;;;;qEAIqE;AACrE,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,OAAO,CAAC,CAAA;CACvE;AAED;;;;iFAIiF;AACjF,KAAK,YAAY,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,CAAC,CAAA;AAElE;;;iFAGiF;AACjF,QAAA,MAAM,eAAe,EAAE,OAAO,MAAsD,CAAA;AAEpF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,cAAc,IAAI,YAAY,GAAG;IACnE,QAAQ,CAAC,CAAC,eAAe,CAAC,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,IAAI,CAAA;CAClD,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,cAAc,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAA;AAEnE;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,cAAc,GAAI,KAAK,CAAC,CAAC,SAAS,cAAc,EAAE,UAAU,CAAC,KAAG,CAAa,CAAA;AAE1F;;;;;;GAMG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,cAAc,IAAI;IAClD,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,GAAG,QAAQ,CAAC,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CACrD,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,cAAc,EAAE,OAAO,WAAW,CAAC,CAAC,CAAC,KAAG,aAAa,CAAC,CAAC,CAqB5F,CAAA;AAED,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,cAAc;IACpD,yFAAyF;IACzF,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAA;IAChC,yEAAyE;IACzE,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAA;CAC5D;AAoGD,eAAO,MAAM,cAAc,GAAI,CAAC,SAAS,cAAc,EACrD,MAAM,QAAQ,EACd,QAAQ,YAAY,CAAC,CAAC,CAAC,KACtB,SAOA,CAAA"}

package/dist/client.js

@@ -0,0 +1,127 @@
+import { createElement, Fragment, useRef } from 'react';
+import { Schema } from 'effect';
+import { Ui, UiViewContract, Wire, } from '@playfast/reform';
+/** Phantom brand carrying the server `RemoteContract` a view set was checked against. Typed
+ *  as a function OF `C` (never called) so the contract appears in the type WITHOUT needing a
+ *  runtime value of `C` — `remoteViews<C>(views)` can brand the set cast-free even though the
+ *  client imports the contract as a TYPE only (trpc-style), never as a value. */
+const ViewSetContract = Symbol.for('reform-remote/view-set-contract');
+/**
+ * Declare a server's `RemoteContract` with its precise key/contract types inferred (the
+ * `const` type parameter keeps each value's specific `UiClass<…>` instead of widening to
+ * the `UiClass<any>` bound). Define it ONCE next to the scene and export `typeof` it as the
+ * UI requirements the client implements against:
+ *
+ *   export const AppContract = remoteContract({ Shell: ShellUi, Sidebar: SidebarUi })
+ *   export type AppContract = typeof AppContract
+ *
+ * The client then imports only the TYPE and implements it:
+ *
+ *   import type { AppContract } from '…/app-contract'
+ *   export const views = remoteViews<AppContract>({ Shell: ShellView, Sidebar: SidebarView })
+ */
+export const remoteContract = (contract) => contract;
+/**
+ * Implement a server's UI shape: `remoteViews<AppContract>({ … })` takes the server's
+ * `RemoteContract` as a TYPE PARAMETER (the client imports only `typeof AppContract`, never a
+ * value — trpc-style) and a set of `Ui.make` views type-checked to implement EXACTLY that
+ * contract. Each view carries its own contract (`Ui.make(SomeUi, …)`), so the wire name and
+ * props schema are recovered from the view itself — a renamed/retyped contract can never
+ * drift from its presentation, and the SAME view authored for the local renderer is reused.
+ * The result is a `RemoteViewSet<C>` (the branded set `connect`/`renderWireTree`/`<RemoteUI>`
+ * accept); an unbranded `Record` can never be substituted.
+ */
+export const remoteViews = (views) => {
+    const list = Object.values(views);
+    const byName = Object.fromEntries(list.map((view) => {
+        const viewContract = view[UiViewContract];
+        const propsSchema = viewContract.manifest.props;
+        // `Node` is `ReactNode` and `ViewImpl`'s params widen to the dynamic shape the
+        // renderer calls, so the contract-typed view IS a `RemoteView` — no cast.
+        const entry = {
+            name: viewContract.manifest.name,
+            view,
+            ...(propsSchema !== undefined ? { propsSchema } : {}),
+        };
+        return [entry.name, entry];
+    }));
+    // Brand the record with the contract `C` it was checked against. The brand is a phantom
+    // function OF `C` that is never called, so it needs NO runtime value of `C` — the set is
+    // built cast-free even though the client only has the contract as a type. The renderer
+    // reads the set by string key; the brand is never read at runtime.
+    return Object.assign(byName, { [ViewSetContract]: (_contract) => { } });
+};
+/**
+ * A stable top-level component for one wire node — stable identity so React keeps a
+ * view's local state across frames (the `node.id` keys it). It decodes props, builds
+ * slot components, and runs the registered view INSIDE this component so the view's
+ * own hooks get a fiber. A child slot renders its wire children as nested `WireNodeView`s.
+ */
+const WireNodeView = ({ node, tree, config, }) => {
+    // The latest render inputs, for the stable slot closures below to read. Mutated every
+    // render so a slot always renders against the current tree, even though its function
+    // identity never changes.
+    const latest = useRef({ node, tree, config });
+    latest.current = { node, tree, config };
+    // Slot components cached by name across renders. CRITICAL for state preservation: a parent
+    // view that renders a slot as `<slots.Foo/>` (the Ui.make convention) passes the slot value
+    // as the element TYPE — if that value were a fresh closure each render (as it was before),
+    // React would see a new component type every frame and UNMOUNT+REMOUNT the whole slot
+    // subtree, resetting every descendant view's local hook state (e.g. a modal's open/step
+    // `useState` would snap back, closing the modal on any unrelated background patch). Caching
+    // the closure by slot name gives `<slots.Foo/>` a stable type, so React reconciles the slot's
+    // children by id instead of remounting them. The closure reads `latest` so it still renders
+    // the current tree.
+    const slotCache = useRef({});
+    const registered = config.views[node.name];
+    if (registered === undefined)
+        return null;
+    const encoded = {};
+    const events = {};
+    for (const prop of node.props) {
+        if (prop._tag === 'Data')
+            encoded[prop.name] = prop.value;
+        else
+            events[prop.name] = (payload) => config.invoke(prop.handle, payload);
+    }
+    const props = registered.propsSchema === undefined
+        ? encoded
+        : Schema.decodeUnknownSync(registered.propsSchema)(encoded);
+    const children = Wire.childrenOf(tree, node.id);
+    const slots = {};
+    for (const slotName of new Set(children.map((child) => child.slot))) {
+        if (slotName === null)
+            continue;
+        // A slot is a COMPONENT rendering that slot's wire children — usable as `<slots.Foo/>`
+        // (Ui.make convention) or `slots.Foo()` (thunk convention). The function is cached so its
+        // identity is STABLE across renders (see `slotCache` above); it reads `latest.current` so
+        // each invocation renders against the current tree/config.
+        //
+        // KEYED SLOTS: when the caller passes `slotKey` (`<slots.Row slotKey={id} />`), render only
+        // the ONE wire child whose `key` matches — the per-item identity the server captured from
+        // the parent's React `key` (see WireNode.key). This is what lets a LIST slot be invoked once
+        // per item without each call rendering the WHOLE list (the duplicate-rows bug). With NO
+        // `slotKey` the behaviour is unchanged: render every child of the slot (correct for a
+        // singleton slot rendered once, e.g. `<slots.Create/>`).
+        const cached = slotCache.current[slotName];
+        const stable = cached ??
+            ((slotProps) => {
+                const { node: currentNode, tree: currentTree, config: currentConfig } = latest.current;
+                const requestedKey = slotProps?.slotKey;
+                return createElement(Fragment, null, ...Wire.childrenOf(currentTree, currentNode.id)
+                    .filter((child) => child.slot === slotName)
+                    .filter((child) => requestedKey === undefined || child.key === requestedKey)
+                    .map((child) => createElement(WireNodeView, {
+                    key: child.id,
+                    node: child,
+                    tree: currentTree,
+                    config: currentConfig,
+                })));
+            });
+        slotCache.current[slotName] = stable;
+        slots[slotName] = stable;
+    }
+    return registered.view(props, slots, events);
+};
+export const renderWireTree = (tree, config) => createElement(Fragment, null, ...Wire.roots(tree).map((node) => createElement(WireNodeView, { key: node.id, node, tree, config })));
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,QAAQ,EAAkB,MAAM,EAAE,MAAM,OAAO,CAAA;AACvE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,EAEL,EAAE,EAEF,cAAc,EACd,IAAI,GAGL,MAAM,kBAAkB,CAAA;AA4DzB;;;iFAGiF;AACjF,MAAM,eAAe,GAAkB,MAAM,CAAC,GAAG,CAAC,iCAAiC,CAAC,CAAA;AAkCpF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAiC,QAAW,EAAK,EAAE,CAAC,QAAQ,CAAA;AAa1F;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAA2B,KAAqB,EAAoB,EAAE;IAC/F,MAAM,IAAI,GAA+B,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAC7D,MAAM,MAAM,GAAiB,MAAM,CAAC,WAAW,CAC7C,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,EAA2C,EAAE;QACzD,MAAM,YAAY,GAAG,IAAI,CAAC,cAAc,CAAC,CAAA;QACzC,MAAM,WAAW,GAAG,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAA;QAC/C,+EAA+E;QAC/E,0EAA0E;QAC1E,MAAM,KAAK,GAAyB;YAClC,IAAI,EAAE,YAAY,CAAC,QAAQ,CAAC,IAAI;YAChC,IAAI;YACJ,GAAG,CAAC,WAAW,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACtD,CAAA;QACD,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAA;IAC5B,CAAC,CAAC,CACH,CAAA;IACD,wFAAwF;IACxF,yFAAyF;IACzF,uFAAuF;IACvF,mEAAmE;IACnE,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,EAAE,CAAC,eAAe,CAAC,EAAE,CAAC,SAAY,EAAQ,EAAE,GAAE,CAAC,EAAE,CAAC,CAAA;AACjF,CAAC,CAAA;AAkBD;;;;;GAKG;AACH,MAAM,YAAY,GAAG,CAAC,EACpB,IAAI,EACJ,IAAI,EACJ,MAAM,GAKP,EAAa,EAAE;IACd,sFAAsF;IACtF,qFAAqF;IACrF,0BAA0B;IAC1B,MAAM,MAAM,GAAG,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAAA;IAC7C,MAAM,CAAC,OAAO,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,CAAA;IACvC,2FAA2F;IAC3F,4FAA4F;IAC5F,2FAA2F;IAC3F,sFAAsF;IACtF,wFAAwF;IACxF,4FAA4F;IAC5F,8FAA8F;IAC9F,4FAA4F;IAC5F,oBAAoB;IACpB,MAAM,SAAS,GAAG,MAAM,CAAkC,EAAE,CAAC,CAAA;IAE7D,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAC1C,IAAI,UAAU,KAAK,SAAS;QAAE,OAAO,IAAI,CAAA;IAEzC,MAAM,OAAO,GAA4B,EAAE,CAAA;IAC3C,MAAM,MAAM,GAA+C,EAAE,CAAA;IAC7D,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;QAC9B,IAAI,IAAI,CAAC,IAAI,KAAK,MAAM;YAAE,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,KAAK,CAAA;;YACpD,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC3E,CAAC;IACD,MAAM,KAAK,GACT,UAAU,CAAC,WAAW,KAAK,SAAS;QAClC,CAAC,CAAC,OAAO;QACT,CAAC,CAAC,MAAM,CAAC,iBAAiB,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC,OAAO,CAAC,CAAA;IAE/D,MAAM,QAAQ,GAAG,IAAI,CAAC,UAAU,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,CAAA;IAC/C,MAAM,KAAK,GAA6E,EAAE,CAAA;IAC1F,KAAK,MAAM,QAAQ,IAAI,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC;QACpE,IAAI,QAAQ,KAAK,IAAI;YAAE,SAAQ;QAC/B,uFAAuF;QACvF,0FAA0F;QAC1F,0FAA0F;QAC1F,2DAA2D;QAC3D,EAAE;QACF,4FAA4F;QAC5F,0FAA0F;QAC1F,6FAA6F;QAC7F,wFAAwF;QACxF,sFAAsF;QACtF,yDAAyD;QACzD,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAA;QAC1C,MAAM,MAAM,GACV,MAAM;YACN,CAAC,CAAC,SAAyC,EAAa,EAAE;gBACxD,MAAM,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,MAAM,EAAE,aAAa,EAAE,GAAG,MAAM,CAAC,OAAO,CAAA;gBACtF,MAAM,YAAY,GAAG,SAAS,EAAE,OAAO,CAAA;gBACvC,OAAO,aAAa,CAClB,QAAQ,EACR,IAAI,EACJ,GAAG,IAAI,CAAC,UAAU,CAAC,WAAW,EAAE,WAAW,CAAC,EAAE,CAAC;qBAC5C,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,QAAQ,CAAC;qBAC1C,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,KAAK,SAAS,IAAI,KAAK,CAAC,GAAG,KAAK,YAAY,CAAC;qBAC3E,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CACb,aAAa,CAAC,YAAY,EAAE;oBAC1B,GAAG,EAAE,KAAK,CAAC,EAAE;oBACb,IAAI,EAAE,KAAK;oBACX,IAAI,EAAE,WAAW;oBACjB,MAAM,EAAE,aAAa;iBACtB,CAAC,CACH,CACJ,CAAA;YACH,CAAC,CAAC,CAAA;QACJ,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAA;QACpC,KAAK,CAAC,QAAQ,CAAC,GAAG,MAAM,CAAA;IAC1B,CAAC;IAED,OAAO,UAAU,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,CAAC,CAAA;AAC9C,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,cAAc,GAAG,CAC5B,IAAc,EACd,MAAuB,EACZ,EAAE,CACb,aAAa,CACX,QAAQ,EACR,IAAI,EACJ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAC/B,aAAa,CAAC,YAAY,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC,CAClE,CACF,CAAA"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * as Server from './server';
+export * as Client from './client';
+export * as Transport from './transport';
+export * as Memory from './memory';
+export * as React from './react';
+export { makeRemoteServer, type RemoteServer } from './server';
+export { type ClientConfig, type RegisteredRemoteView, type RemoteContract, remoteContract, type RemoteView, type RemoteViews, type RemoteViewSet, remoteViews, renderWireTree, } from './client';
+export { type ClientBinding, connect, type ConnectOptions, type InvokeMessage, type PatchesMessage, type RemoteTransport, serve, type ServeOptions, type ServerBinding, type ServerMessage, type SnapshotMessage, } from './transport';
+export { inMemoryTransportPair, type TransportPair } from './memory';
+export { RemoteUI, type RemoteUIProps, type StatusReporter, useConnectionStatus, useRemoteUI, } from './react';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAEhC,OAAO,EAAE,gBAAgB,EAAE,KAAK,YAAY,EAAE,MAAM,UAAU,CAAA;AAC9D,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,cAAc,EACd,KAAK,UAAU,EACf,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,WAAW,EACX,cAAc,GACf,MAAM,UAAU,CAAA;AACjB,OAAO,EACL,KAAK,aAAa,EAClB,OAAO,EACP,KAAK,cAAc,EACnB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,EACL,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,aAAa,EAClB,KAAK,eAAe,GACrB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,qBAAqB,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AACpE,OAAO,EACL,QAAQ,EACR,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,mBAAmB,EACnB,WAAW,GACZ,MAAM,SAAS,CAAA"}

package/dist/index.js

@@ -0,0 +1,20 @@
+// @playfast/reform-remote — run a reform scene's logic on the server and stream
+// its rendered UI to a thin client over a transport. A fourth consumer of a
+// `Scene`, alongside @playfast/react, @playfast/react-native, and @playfast/proof.
+// See REMOTE_UI.md.
+//
+// Public API is exposed two ways (Effect-style): namespace barrels for discovery
+// (`import { Transport } from "@playfast/reform-remote"`) and per-path subpaths
+// for direct use (`import { connect } from "@playfast/reform-remote/transport"`).
+// The select re-exports below keep the common entry points nameable from the root.
+export * as Server from './server';
+export * as Client from './client';
+export * as Transport from './transport';
+export * as Memory from './memory';
+export * as React from './react';
+export { makeRemoteServer } from './server';
+export { remoteContract, remoteViews, renderWireTree, } from './client';
+export { connect, serve, } from './transport';
+export { inMemoryTransportPair } from './memory';
+export { RemoteUI, useConnectionStatus, useRemoteUI, } from './react';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,4EAA4E;AAC5E,mFAAmF;AACnF,oBAAoB;AACpB,EAAE;AACF,iFAAiF;AACjF,gFAAgF;AAChF,kFAAkF;AAClF,mFAAmF;AAEnF,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,SAAS,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,MAAM,MAAM,UAAU,CAAA;AAClC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAA;AAEhC,OAAO,EAAE,gBAAgB,EAAqB,MAAM,UAAU,CAAA;AAC9D,OAAO,EAIL,cAAc,EAId,WAAW,EACX,cAAc,GACf,MAAM,UAAU,CAAA;AACjB,OAAO,EAEL,OAAO,EAKP,KAAK,GAKN,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,qBAAqB,EAAsB,MAAM,UAAU,CAAA;AACpE,OAAO,EACL,QAAQ,EAGR,mBAAmB,EACnB,WAAW,GACZ,MAAM,SAAS,CAAA"}

package/dist/memory.d.ts

@@ -0,0 +1,15 @@
+import type { RemoteTransport } from './transport';
+/**
+ * The in-memory transport adapter: a duplex pair where what one end sends, the
+ * other receives — synchronously, in process. It is the simplest concrete
+ * `RemoteTransport`, and the one the test suite drives `serve`/`connect` over
+ * without a socket. A WebSocket adapter is the same shape with JSON framing
+ * across a wire; proving the loop here proves it everywhere.
+ */
+/** A linked `server`/`client` transport: each receives exactly what the other sends. */
+export interface TransportPair<Server, Client> {
+    readonly server: RemoteTransport<Server, Client>;
+    readonly client: RemoteTransport<Client, Server>;
+}
+export declare const inMemoryTransportPair: <Server, Client>() => TransportPair<Server, Client>;
+//# sourceMappingURL=memory.d.ts.map

package/dist/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../src/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAA;AAElD;;;;;;GAMG;AAEH,wFAAwF;AACxF,MAAM,WAAW,aAAa,CAAC,MAAM,EAAE,MAAM;IAC3C,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChD,QAAQ,CAAC,MAAM,EAAE,eAAe,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACjD;AAED,eAAO,MAAM,qBAAqB,GAAI,MAAM,EAAE,MAAM,OAAK,aAAa,CAAC,MAAM,EAAE,MAAM,CAmBpF,CAAA"}

package/dist/memory.js

@@ -0,0 +1,21 @@
+export const inMemoryTransportPair = () => {
+    const serverHandlers = new Set();
+    const clientHandlers = new Set();
+    return {
+        server: {
+            send: (message) => clientHandlers.forEach((handler) => handler(message)),
+            onMessage: (handler) => {
+                serverHandlers.add(handler);
+                return () => void serverHandlers.delete(handler);
+            },
+        },
+        client: {
+            send: (message) => serverHandlers.forEach((handler) => handler(message)),
+            onMessage: (handler) => {
+                clientHandlers.add(handler);
+                return () => void clientHandlers.delete(handler);
+            },
+        },
+    };
+};
+//# sourceMappingURL=memory.js.map

package/dist/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","sourceRoot":"","sources":["../src/memory.ts"],"names":[],"mappings":"AAgBA,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAkD,EAAE;IACvF,MAAM,cAAc,GAAG,IAAI,GAAG,EAA6B,CAAA;IAC3D,MAAM,cAAc,GAAG,IAAI,GAAG,EAA6B,CAAA;IAC3D,OAAO;QACL,MAAM,EAAE;YACN,IAAI,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YACxE,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE;gBACrB,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;gBAC3B,OAAO,GAAG,EAAE,CAAC,KAAK,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;YAClD,CAAC;SACF;QACD,MAAM,EAAE;YACN,IAAI,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YACxE,SAAS,EAAE,CAAC,OAAO,EAAE,EAAE;gBACrB,cAAc,CAAC,GAAG,CAAC,OAAO,CAAC,CAAA;gBAC3B,OAAO,GAAG,EAAE,CAAC,KAAK,cAAc,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;YAClD,CAAC;SACF;KACF,CAAA;AACH,CAAC,CAAA"}

package/dist/react.d.ts

@@ -0,0 +1,38 @@
+import { type ReactNode } from 'react';
+import { type InvokeMessage, type RemoteTransport, type ServerMessage } from './transport';
+import type { RemoteContract, RemoteViewSet } from './client';
+/**
+ * The React binding for the remote client. A consumer hands it a transport and a
+ * `views` map and gets a live React subtree — the framework owns the transport
+ * wiring (connect, the patch subscription, re-render on each frame, teardown on
+ * unmount). No `useSyncExternalStore`, `binding.subscribe`, or `binding.node()`
+ * at the call site.
+ */
+/**
+ * Render the remote scene as React. Pass a stable `transport` (created once,
+ * e.g. by `createWebSocketClientTransport`) — the binding is established on mount
+ * and disposed on unmount.
+ */
+export declare const useRemoteUI: <C extends RemoteContract>(transport: RemoteTransport<InvokeMessage, ServerMessage>, views: RemoteViewSet<C>) => ReactNode;
+export interface RemoteUIProps<C extends RemoteContract> {
+    readonly transport: RemoteTransport<InvokeMessage, ServerMessage>;
+    /** A contract-checked view set from `remoteViews<C>(…)` — an unbranded `Record` is rejected,
+     *  so `<RemoteUI>` can only render views proven to implement the server's shape. */
+    readonly views: RemoteViewSet<C>;
+}
+/** Component form of {@link useRemoteUI}: `<RemoteUI transport={…} views={…} />`. `C` is
+ *  inferred from `views` (the `remoteViews<AppContract>(…)` result), so the whole subtree is
+ *  typed to that app's contract. */
+export declare const RemoteUI: <C extends RemoteContract>({ transport, views, }: RemoteUIProps<C>) => ReactNode;
+/**
+ * Anything that reports an observable connection status — implemented by the
+ * WebSocket client transport. Kept structural so the React binding needs no
+ * dependency on a specific adapter.
+ */
+export interface StatusReporter<S> {
+    readonly status: () => S;
+    readonly onStatusChange: (listener: () => void) => () => void;
+}
+/** Subscribe to a transport's connection status (e.g. to show a reconnecting badge). */
+export declare const useConnectionStatus: <S>(reporter: StatusReporter<S>) => S;
+//# sourceMappingURL=react.d.ts.map

package/dist/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../src/react.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAA6C,MAAM,OAAO,CAAA;AACjF,OAAO,EAEL,KAAK,aAAa,EAClB,KAAK,eAAe,EACpB,KAAK,aAAa,EACnB,MAAM,aAAa,CAAA;AACpB,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAE7D;;;;;;GAMG;AAEH;;;;GAIG;AACH,eAAO,MAAM,WAAW,GAAI,CAAC,SAAS,cAAc,EAClD,WAAW,eAAe,CAAC,aAAa,EAAE,aAAa,CAAC,EACxD,OAAO,aAAa,CAAC,CAAC,CAAC,KACtB,SAOF,CAAA;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,cAAc;IACrD,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC,aAAa,EAAE,aAAa,CAAC,CAAA;IACjE;wFACoF;IACpF,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAA;CACjC;AAED;;oCAEoC;AACpC,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,cAAc,EAAE,uBAGhD,aAAa,CAAC,CAAC,CAAC,KAAG,SAA0C,CAAA;AAEhE;;;;GAIG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC;IAC/B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxB,QAAQ,CAAC,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;CAC9D;AAED,wFAAwF;AACxF,eAAO,MAAM,mBAAmB,GAAI,CAAC,EAAE,UAAU,cAAc,CAAC,CAAC,CAAC,KAAG,CACY,CAAA"}

package/dist/react.js

@@ -0,0 +1,29 @@
+import { useEffect, useState, useSyncExternalStore } from 'react';
+import { connect, } from './transport';
+/**
+ * The React binding for the remote client. A consumer hands it a transport and a
+ * `views` map and gets a live React subtree — the framework owns the transport
+ * wiring (connect, the patch subscription, re-render on each frame, teardown on
+ * unmount). No `useSyncExternalStore`, `binding.subscribe`, or `binding.node()`
+ * at the call site.
+ */
+/**
+ * Render the remote scene as React. Pass a stable `transport` (created once,
+ * e.g. by `createWebSocketClientTransport`) — the binding is established on mount
+ * and disposed on unmount.
+ */
+export const useRemoteUI = (transport, views) => {
+    // One binding for the life of the component (the transport is stable).
+    const [binding] = useState(() => connect({ transport, views }));
+    useEffect(() => () => binding.dispose(), [binding]);
+    // Re-render whenever a frame changes the tree; `snapshot` is a stable ref.
+    useSyncExternalStore(binding.subscribe, binding.snapshot, binding.snapshot);
+    return binding.node();
+};
+/** Component form of {@link useRemoteUI}: `<RemoteUI transport={…} views={…} />`. `C` is
+ *  inferred from `views` (the `remoteViews<AppContract>(…)` result), so the whole subtree is
+ *  typed to that app's contract. */
+export const RemoteUI = ({ transport, views, }) => useRemoteUI(transport, views);
+/** Subscribe to a transport's connection status (e.g. to show a reconnecting badge). */
+export const useConnectionStatus = (reporter) => useSyncExternalStore(reporter.onStatusChange, reporter.status, reporter.status);
+//# sourceMappingURL=react.js.map

package/dist/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","sourceRoot":"","sources":["../src/react.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,SAAS,EAAE,QAAQ,EAAE,oBAAoB,EAAE,MAAM,OAAO,CAAA;AACjF,OAAO,EACL,OAAO,GAIR,MAAM,aAAa,CAAA;AAGpB;;;;;;GAMG;AAEH;;;;GAIG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,SAAwD,EACxD,KAAuB,EACZ,EAAE;IACb,uEAAuE;IACvE,MAAM,CAAC,OAAO,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC,CAAC,CAAA;IAC/D,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,CAAA;IACnD,2EAA2E;IAC3E,oBAAoB,CAAC,OAAO,CAAC,SAAS,EAAE,OAAO,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC3E,OAAO,OAAO,CAAC,IAAI,EAAE,CAAA;AACvB,CAAC,CAAA;AASD;;oCAEoC;AACpC,MAAM,CAAC,MAAM,QAAQ,GAAG,CAA2B,EACjD,SAAS,EACT,KAAK,GACY,EAAa,EAAE,CAAC,WAAW,CAAC,SAAS,EAAE,KAAK,CAAC,CAAA;AAYhE,wFAAwF;AACxF,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAI,QAA2B,EAAK,EAAE,CACvE,oBAAoB,CAAC,QAAQ,CAAC,cAAc,EAAE,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAA"}

package/dist/server.d.ts

@@ -0,0 +1,26 @@
+import { type Scene, type WirePatch, type WireTree } from '@playfast/reform';
+export interface RemoteServer {
+    /** Render the current frame to a full wire tree; triggers are (re-)registered behind stable handles. */
+    readonly render: () => Promise<WireTree>;
+    /**
+     * Render and return only the patches since the previous frame (the streaming
+     * form). Handles of deleted nodes are revoked, so a stale client invocation
+     * fails cleanly rather than firing a dangling trigger.
+     */
+    readonly renderDiff: () => Promise<ReadonlyArray<WirePatch>>;
+    /** Fire a trigger the client referenced by handle, then settle the runtime. */
+    readonly invoke: (handle: string, encodedPayload: unknown) => Promise<void>;
+    /**
+     * Observe SERVER-INITIATED state changes. The listener fires (after the drain
+     * settles) whenever an event flows on the engine bus — i.e. when an async procedure
+     * resolves, a boot loader completes, or a scheduler ticks — NOT just in response to a
+     * client invoke. `serve` registers a `renderDiff`-and-push listener here so the client
+     * sees background updates (a repo list that finishes loading, a reconcile sweep) that
+     * no user interaction triggered. Returns an unsubscribe handle.
+     */
+    readonly subscribe: (listener: () => void) => () => void;
+    /** Tear down the runtime and its forked fibers. */
+    readonly dispose: () => Promise<void>;
+}
+export declare const makeRemoteServer: (scene: Scene) => RemoteServer;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAEA,OAAO,EAYL,KAAK,KAAK,EAUV,KAAK,SAAS,EAEd,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA2FzB,MAAM,WAAW,YAAY;IAC3B,wGAAwG;IACxG,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,QAAQ,CAAC,CAAA;IACxC;;;;OAIG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,OAAO,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC,CAAA;IAC5D,+EAA+E;IAC/E,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC3E;;;;;;;OAOG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;IACxD,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACtC;AAED,eAAO,MAAM,gBAAgB,GAAI,OAAO,KAAK,KAAG,YA8L/C,CAAA"}

package/dist/server.js

@@ -0,0 +1,206 @@
+import { Effect, Layer, ManagedRuntime, PubSub, Queue, Schema } from 'effect';
+import { isValidElement } from 'react';
+import { Bus, CaptureSink, Composition, forceSync, isFeatureBinding, publish, Triggers, Wire, } from '@playfast/reform';
+const SETTLE_DRAIN = 30;
+const settleDrain = Effect.yieldNow().pipe(Effect.repeatN(SETTLE_DRAIN));
+const makeSink = () => {
+    const state = { captures: [] };
+    return {
+        api: { record: (capture) => state.captures.push(capture) },
+        get captures() {
+            return state.captures;
+        },
+        reset: () => {
+            state.captures = [];
+        },
+    };
+};
+const closedSceneLayer = (scene) => scene.provide.reduce((a, b) => Layer.merge(a, b));
+const childComposition = (child) => isFeatureBinding(child) ? child.composition : child;
+/**
+ * Walk a rendered node and enqueue the child each slot placeholder stands for.
+ * Slot components are matched by identity (the host defers them as JSX), so this
+ * never invokes — nor needs hooks from — ordinary presentation components.
+ */
+const drive = (node, enqueueBy) => {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            drive(child, enqueueBy);
+        return;
+    }
+    if (!isValidElement(node))
+        return;
+    if (node.type instanceof Function) {
+        const enqueue = enqueueBy.get(node.type);
+        if (enqueue !== undefined) {
+            // `node.key` is the React key the parent set (`createElement(slots.Row, { key })`),
+            // carried onto the wire node so a KEYED slot can select this child on the client
+            // (see WireNode.key). React coerces a set key to a string; absent → null.
+            enqueue(node.props, node.key);
+            return;
+        }
+    }
+    drive(node.props.children, enqueueBy);
+};
+const handlesOf = (node) => node.props.flatMap((prop) => (prop._tag === 'Event' ? [prop.handle] : []));
+export const makeRemoteServer = (scene) => {
+    const sink = makeSink();
+    const runtime = ManagedRuntime.make(Layer.provideMerge(closedSceneLayer(scene), Layer.succeed(CaptureSink, sink.api)));
+    const registry = forceSync(() => runtime.runSync(Triggers.make));
+    const collect = (root) => Effect.gen(function* () {
+        const bindings = new Map();
+        const walk = (comp) => Effect.gen(function* () {
+            for (const slotClass of Object.values(comp.manifest.slots ?? {})) {
+                if (bindings.has(slotClass))
+                    continue;
+                const child = childComposition(yield* slotClass.tag);
+                bindings.set(slotClass, child);
+                yield* walk(child);
+            }
+        });
+        yield* walk(root);
+        return bindings;
+    });
+    const toWireNode = (m, capture) => Effect.gen(function* () {
+        // The composition's contract carries the wire schemas at runtime (the type is
+        // the erased `{ manifest }` carrier — `composition.ts:34`); read them as `UiManifest`.
+        const manifest = m.comp.manifest.ui.manifest;
+        const dataProps = [];
+        if (manifest.props !== undefined) {
+            const encoded = yield* Schema.encodeUnknown(manifest.props)(capture.props);
+            for (const [name, value] of Object.entries(encoded)) {
+                dataProps.push({ _tag: 'Data', name, value });
+            }
+        }
+        const eventSchemas = manifest.events ?? {};
+        const eventProps = [];
+        for (const [name, trigger] of Object.entries(capture.events)) {
+            const schema = eventSchemas[name];
+            if (schema === undefined)
+                continue;
+            const handle = `${m.id}:${name}`;
+            yield* registry.register(handle, trigger, schema);
+            eventProps.push({ _tag: 'Event', name, handle });
+        }
+        return {
+            id: m.id,
+            name: capture.name,
+            parentId: m.parentId,
+            childIndex: m.childIndex,
+            slot: m.slot,
+            key: m.key,
+            props: [...dataProps, ...eventProps],
+        };
+    });
+    const renderLevel = (frontier, bindings) => Effect.gen(function* () {
+        if (frontier.length === 0)
+            return [];
+        const next = [];
+        const nodes = [];
+        for (const mounted of frontier) {
+            const service = yield* mounted.comp.tag;
+            const slotIndex = new Map();
+            const enqueueBy = new Map();
+            const slots = {
+                slot: (name) => {
+                    const slotClass = mounted.comp.manifest.slots?.[name];
+                    const child = slotClass ? bindings.get(slotClass) : undefined;
+                    const component = () => null;
+                    if (child !== undefined) {
+                        enqueueBy.set(component, (childProps, key) => {
+                            const index = slotIndex.get(name) ?? 0;
+                            slotIndex.set(name, index + 1);
+                            next.push({
+                                comp: child,
+                                props: childProps,
+                                id: `${mounted.id}.${name}.${index}`,
+                                parentId: mounted.id,
+                                slot: name,
+                                childIndex: index,
+                                key,
+                            });
+                        });
+                    }
+                    return component;
+                },
+            };
+            const before = sink.captures.length;
+            const env = { props: mounted.props, tracker: { add: () => { } }, slots };
+            const node = yield* Composition.render(service, env);
+            const capture = sink.captures[before];
+            if (capture !== undefined)
+                nodes.push(yield* toWireNode(mounted, capture));
+            drive(node, enqueueBy);
+        }
+        const rest = yield* renderLevel(next, bindings);
+        return [...nodes, ...rest];
+    });
+    const renderEffect = Effect.gen(function* () {
+        yield* settleDrain;
+        sink.reset();
+        const bindings = yield* collect(scene.composition);
+        const root = {
+            comp: scene.composition,
+            props: {},
+            id: '0',
+            parentId: null,
+            slot: null,
+            childIndex: 0,
+            key: null,
+        };
+        return yield* renderLevel([root], bindings);
+    });
+    // Server-initiated change notification: a forked daemon subscribes to the engine bus
+    // and, after each batch settles, fans out to registered listeners. This is what lets a
+    // streaming binding push frames the client never asked for — a background load resolving
+    // long after connect. Forked BEFORE the boot publish below so nothing is missed (the
+    // listener set is empty until `subscribe` runs, so early ticks are harmless no-ops; the
+    // binding's opening snapshot captures all state up to `start`).
+    const changeListeners = new Set();
+    const notifyChange = () => {
+        for (const listener of changeListeners)
+            listener();
+    };
+    runtime.runFork(Effect.scoped(Effect.gen(function* () {
+        const bus = yield* Bus;
+        const subscription = yield* PubSub.subscribe(bus);
+        // Notify on each event; the consumer (`serve`) debounces, so the render it triggers
+        // runs a tick later — after the drain has folded this event into state. No settle
+        // here: it would only perturb the drain's own scheduling for no benefit.
+        yield* Queue.take(subscription).pipe(Effect.zipRight(Effect.sync(notifyChange)), Effect.forever);
+    })));
+    runtime.runSync(Effect.forEach(scene.boot ?? [], (event) => publish('High', event)));
+    // The last emitted frame, to diff against. A const holder whose field we swap
+    // (no reassigned binding), matching the sink's immutable-swap idiom.
+    const frame = { tree: [] };
+    const render = () => runtime.runPromise(renderEffect).then((tree) => {
+        frame.tree = tree;
+        return tree;
+    });
+    const renderDiff = () => runtime.runPromise(renderEffect).then((next) => {
+        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);
+        return runtime
+            .runPromise(Effect.forEach(staleHandles, (handle) => registry.revoke(handle)))
+            .then(() => 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);
+        },
+        dispose: () => runtime.dispose(),
+    };
+};
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/dist/transport.d.ts

@@ -0,0 +1,69 @@
+import type { ReactNode } from 'react';
+import { type WirePatch, type WireTree } from '@playfast/reform';
+import type { Scene } from '@playfast/reform';
+import { type RemoteContract, type RemoteViewSet } from './client';
+/**
+ * Binds the server driver and the client renderer to a transport. The wire
+ * carries only serializable data — patches one way, trigger invocations the
+ * other — so any duplex channel (WebSocket, postMessage, in-memory) works; a
+ * concrete adapter just implements `RemoteTransport`. See REMOTE_UI.md §5.
+ */
+/**
+ * Server → client: the full current tree, replacing whatever the client holds.
+ * The first frame of every (re)connection — a fresh server runtime diffs from
+ * empty, so it can only *add* nodes; a snapshot is what lets a reconnecting
+ * client drop the stale tree it accumulated on the previous socket.
+ */
+export interface SnapshotMessage {
+    readonly _tag: 'Snapshot';
+    readonly tree: WireTree;
+}
+/** Server → client: a batch of tree patches to fold with `Wire.apply`. */
+export interface PatchesMessage {
+    readonly _tag: 'Patches';
+    readonly patches: ReadonlyArray<WirePatch>;
+}
+/** Everything the server sends the client: a fresh snapshot or incremental patches. */
+export type ServerMessage = SnapshotMessage | PatchesMessage;
+/** Client → server: fire the trigger behind `handle` with an encoded payload. */
+export interface InvokeMessage {
+    readonly _tag: 'Invoke';
+    readonly handle: string;
+    readonly payload: unknown;
+}
+/** A duplex channel: send `Out`, receive `In`. */
+export interface RemoteTransport<Out, In> {
+    readonly send: (message: Out) => void;
+    readonly onMessage: (handler: (message: In) => void) => () => void;
+}
+export interface ServerBinding {
+    /** Render the first frame and push it. Call once the client is connected. */
+    readonly start: () => Promise<void>;
+    readonly dispose: () => Promise<void>;
+}
+/** Options for {@link serve} — a single named object so every reform-remote binding shares one shape. */
+export interface ServeOptions {
+    readonly scene: Scene;
+    readonly transport: RemoteTransport<ServerMessage, InvokeMessage>;
+}
+export declare const serve: (options: ServeOptions) => ServerBinding;
+export interface ClientBinding {
+    /** The current rendered node — re-read on each `subscribe` notification. */
+    readonly node: () => ReactNode;
+    /** Notified whenever applied patches change the tree. */
+    readonly subscribe: (listener: () => void) => () => void;
+    /**
+     * The current wire tree — a stable reference that changes only when a frame is
+     * applied, so it is a valid `useSyncExternalStore` snapshot (the React binding
+     * builds on this).
+     */
+    readonly snapshot: () => WireTree;
+    readonly dispose: () => void;
+}
+/** Options for {@link connect} — a single named object, mirroring {@link ServeOptions}. */
+export interface ConnectOptions<C extends RemoteContract> {
+    readonly transport: RemoteTransport<InvokeMessage, ServerMessage>;
+    readonly views: RemoteViewSet<C>;
+}
+export declare const connect: <C extends RemoteContract>(options: ConnectOptions<C>) => ClientBinding;
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,EAAQ,KAAK,SAAS,EAAE,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AACtE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAA;AAE7C,OAAO,EAAkB,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,UAAU,CAAA;AAElF;;;;;GAKG;AAEH;;;;;GAKG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;CACxB;AAED,0EAA0E;AAC1E,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAA;IACxB,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;CAC3C;AAED,uFAAuF;AACvF,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG,cAAc,CAAA;AAE5D,iFAAiF;AACjF,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAA;IACvB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAA;CAC1B;AAED,kDAAkD;AAClD,MAAM,WAAW,eAAe,CAAC,GAAG,EAAE,EAAE;IACtC,QAAQ,CAAC,IAAI,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAA;IACrC,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,EAAE,KAAK,IAAI,KAAK,MAAM,IAAI,CAAA;CACnE;AAED,MAAM,WAAW,aAAa;IAC5B,6EAA6E;IAC7E,QAAQ,CAAC,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;CACtC;AAUD,yGAAyG;AACzG,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,KAAK,EAAE,KAAK,CAAA;IACrB,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC,aAAa,EAAE,aAAa,CAAC,CAAA;CAClE;AAED,eAAO,MAAM,KAAK,GAAI,SAAS,YAAY,KAAG,aA0E7C,CAAA;AAED,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,MAAM,SAAS,CAAA;IAC9B,yDAAyD;IACzD,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAA;IACxD;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,QAAQ,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,IAAI,CAAA;CAC7B;AAED,2FAA2F;AAC3F,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,cAAc;IACtD,QAAQ,CAAC,SAAS,EAAE,eAAe,CAAC,aAAa,EAAE,aAAa,CAAC,CAAA;IACjE,QAAQ,CAAC,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,CAAA;CACjC;AAED,eAAO,MAAM,OAAO,GAAI,CAAC,SAAS,cAAc,EAAE,SAAS,cAAc,CAAC,CAAC,CAAC,KAAG,aA4B9E,CAAA"}

package/dist/transport.js

@@ -0,0 +1,116 @@
+import { Match } from 'effect';
+import { Wire } from '@playfast/reform';
+import { makeRemoteServer } from './server';
+import { renderWireTree } from './client';
+/**
+ * Debounce window for SERVER-initiated frame pushes (background loads, scheduler ticks).
+ * Long enough that the engine drain has folded the change into state and a burst of facts
+ * coalesces into one render; short enough to feel live. Client invokes don't wait on this —
+ * they push immediately.
+ */
+const BACKGROUND_FLUSH_MS = 16;
+export const serve = (options) => {
+    const { scene, transport } = options;
+    const server = makeRemoteServer(scene);
+    // The first frame is a full snapshot (replace); every frame after is the diff since the
+    // last (apply). Both keep the server's `frame` baseline in step, so the diffs always
+    // reference what the client actually holds. Diffs are emitted both after a client invoke
+    // AND whenever the server's OWN state changes (a background load resolving, a scheduler
+    // tick) — without the latter, anything the user didn't directly trigger would never reach
+    // the client (it would sit on the snapshot's loading state forever).
+    //
+    // `started` gates pushes until the opening snapshot is sent: a diff that raced ahead of
+    // the snapshot would reference a tree the client has not received.
+    //
+    // `push` is a COALESCING single-flight render: at most one `renderDiff` runs at a time
+    // (concurrent ones would interleave the sink captures and corrupt the frame baseline). If
+    // a change arrives WHILE a render is in flight — e.g. an async procedure folds its result
+    // mid-render — `dirty` is set and a follow-up render runs when the current one settles, so
+    // a late state change is never dropped. Both a client invoke and a server-side change
+    // (the bus subscriber) funnel through here, so there is exactly one push path.
+    const started = { value: false };
+    const flight = { promise: null, dirty: false };
+    const push = () => {
+        if (!started.value)
+            return Promise.resolve();
+        if (flight.promise !== null) {
+            flight.dirty = true;
+            return flight.promise;
+        }
+        const run = (async () => {
+            const patches = await server.renderDiff();
+            if (patches.length > 0)
+                transport.send({ _tag: 'Patches', patches });
+        })().finally(() => {
+            flight.promise = null;
+            if (flight.dirty) {
+                flight.dirty = false;
+                void push();
+            }
+        });
+        flight.promise = run;
+        return run;
+    };
+    // Server-initiated changes are flushed on a short DEBOUNCE rather than synchronously: it
+    // coalesces a burst (a procedure that dispatches several facts) into one render, and the
+    // delay lets the drain fold the change into state before we read it — so the diff reflects
+    // the settled result, and the background flush never races the synchronous invoke push
+    // above. A client invoke still pushes immediately (its own settle path), so user actions
+    // stay snappy; this path only carries updates no interaction triggered.
+    const debounce = { handle: null };
+    const scheduleFlush = () => {
+        if (!started.value || debounce.handle !== null)
+            return;
+        debounce.handle = setTimeout(() => {
+            debounce.handle = null;
+            void push();
+        }, BACKGROUND_FLUSH_MS);
+    };
+    const start = async () => {
+        const tree = await server.render();
+        transport.send({ _tag: 'Snapshot', tree });
+        started.value = true;
+        // Flush anything that changed during the (async) opening render window.
+        scheduleFlush();
+    };
+    const off = transport.onMessage((message) => {
+        void server.invoke(message.handle, message.payload).then(push);
+    });
+    const offChange = server.subscribe(scheduleFlush);
+    return {
+        start,
+        dispose: async () => {
+            off();
+            offChange();
+            if (debounce.handle !== null)
+                clearTimeout(debounce.handle);
+            await server.dispose();
+        },
+    };
+};
+export const connect = (options) => {
+    const { transport, views } = options;
+    const state = { tree: [] };
+    const listeners = new Set();
+    const config = {
+        views,
+        invoke: (handle, payload) => transport.send({ _tag: 'Invoke', handle, payload }),
+    };
+    const off = transport.onMessage((message) => {
+        // A snapshot replaces the tree wholesale (a fresh or reconnected session);
+        // patches fold into it. So a reconnect re-syncs without leaking stale nodes.
+        state.tree = Match.value(message).pipe(Match.tag('Snapshot', ({ tree }) => tree), Match.tag('Patches', ({ patches }) => Wire.apply(state.tree, patches)), Match.exhaustive);
+        for (const listener of listeners)
+            listener();
+    });
+    return {
+        node: () => renderWireTree(state.tree, config),
+        subscribe: (listener) => {
+            listeners.add(listener);
+            return () => void listeners.delete(listener);
+        },
+        snapshot: () => state.tree,
+        dispose: off,
+    };
+};
+//# sourceMappingURL=transport.js.map

package/dist/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAE9B,OAAO,EAAE,IAAI,EAAiC,MAAM,kBAAkB,CAAA;AAEtE,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAC3C,OAAO,EAAE,cAAc,EAA2C,MAAM,UAAU,CAAA;AAgDlF;;;;;GAKG;AACH,MAAM,mBAAmB,GAAG,EAAE,CAAA;AAQ9B,MAAM,CAAC,MAAM,KAAK,GAAG,CAAC,OAAqB,EAAiB,EAAE;IAC5D,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,OAAO,CAAA;IACpC,MAAM,MAAM,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAA;IACtC,wFAAwF;IACxF,qFAAqF;IACrF,yFAAyF;IACzF,wFAAwF;IACxF,0FAA0F;IAC1F,qEAAqE;IACrE,EAAE;IACF,wFAAwF;IACxF,mEAAmE;IACnE,EAAE;IACF,uFAAuF;IACvF,0FAA0F;IAC1F,0FAA0F;IAC1F,2FAA2F;IAC3F,sFAAsF;IACtF,+EAA+E;IAC/E,MAAM,OAAO,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,CAAA;IAChC,MAAM,MAAM,GAAG,EAAE,OAAO,EAAE,IAA4B,EAAE,KAAK,EAAE,KAAK,EAAE,CAAA;IACtE,MAAM,IAAI,GAAG,GAAkB,EAAE;QAC/B,IAAI,CAAC,OAAO,CAAC,KAAK;YAAE,OAAO,OAAO,CAAC,OAAO,EAAE,CAAA;QAC5C,IAAI,MAAM,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YAC5B,MAAM,CAAC,KAAK,GAAG,IAAI,CAAA;YACnB,OAAO,MAAM,CAAC,OAAO,CAAA;QACvB,CAAC;QACD,MAAM,GAAG,GAAG,CAAC,KAAK,IAAmB,EAAE;YACrC,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,UAAU,EAAE,CAAA;YACzC,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;gBAAE,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAA;QACtE,CAAC,CAAC,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE;YAChB,MAAM,CAAC,OAAO,GAAG,IAAI,CAAA;YACrB,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;gBACjB,MAAM,CAAC,KAAK,GAAG,KAAK,CAAA;gBACpB,KAAK,IAAI,EAAE,CAAA;YACb,CAAC;QACH,CAAC,CAAC,CAAA;QACF,MAAM,CAAC,OAAO,GAAG,GAAG,CAAA;QACpB,OAAO,GAAG,CAAA;IACZ,CAAC,CAAA;IACD,yFAAyF;IACzF,yFAAyF;IACzF,2FAA2F;IAC3F,uFAAuF;IACvF,yFAAyF;IACzF,wEAAwE;IACxE,MAAM,QAAQ,GAAG,EAAE,MAAM,EAAE,IAA4C,EAAE,CAAA;IACzE,MAAM,aAAa,GAAG,GAAS,EAAE;QAC/B,IAAI,CAAC,OAAO,CAAC,KAAK,IAAI,QAAQ,CAAC,MAAM,KAAK,IAAI;YAAE,OAAM;QACtD,QAAQ,CAAC,MAAM,GAAG,UAAU,CAAC,GAAG,EAAE;YAChC,QAAQ,CAAC,MAAM,GAAG,IAAI,CAAA;YACtB,KAAK,IAAI,EAAE,CAAA;QACb,CAAC,EAAE,mBAAmB,CAAC,CAAA;IACzB,CAAC,CAAA;IACD,MAAM,KAAK,GAAG,KAAK,IAAmB,EAAE;QACtC,MAAM,IAAI,GAAG,MAAM,MAAM,CAAC,MAAM,EAAE,CAAA;QAClC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,CAAC,CAAA;QAC1C,OAAO,CAAC,KAAK,GAAG,IAAI,CAAA;QACpB,wEAAwE;QACxE,aAAa,EAAE,CAAA;IACjB,CAAC,CAAA;IACD,MAAM,GAAG,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;QAC1C,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAChE,CAAC,CAAC,CAAA;IACF,MAAM,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC,aAAa,CAAC,CAAA;IACjD,OAAO;QACL,KAAK;QACL,OAAO,EAAE,KAAK,IAAmB,EAAE;YACjC,GAAG,EAAE,CAAA;YACL,SAAS,EAAE,CAAA;YACX,IAAI,QAAQ,CAAC,MAAM,KAAK,IAAI;gBAAE,YAAY,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;YAC3D,MAAM,MAAM,CAAC,OAAO,EAAE,CAAA;QACxB,CAAC;KACF,CAAA;AACH,CAAC,CAAA;AAsBD,MAAM,CAAC,MAAM,OAAO,GAAG,CAA2B,OAA0B,EAAiB,EAAE;IAC7F,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,GAAG,OAAO,CAAA;IACpC,MAAM,KAAK,GAAuB,EAAE,IAAI,EAAE,EAAE,EAAE,CAAA;IAC9C,MAAM,SAAS,GAAG,IAAI,GAAG,EAAc,CAAA;IACvC,MAAM,MAAM,GAAG;QACb,KAAK;QACL,MAAM,EAAE,CAAC,MAAc,EAAE,OAAgB,EAAQ,EAAE,CACjD,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC;KACtD,CAAA;IACD,MAAM,GAAG,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,OAAO,EAAE,EAAE;QAC1C,2EAA2E;QAC3E,6EAA6E;QAC7E,KAAK,CAAC,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,CACpC,KAAK,CAAC,GAAG,CAAC,UAAU,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,EACzC,KAAK,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,EACtE,KAAK,CAAC,UAAU,CACjB,CAAA;QACD,KAAK,MAAM,QAAQ,IAAI,SAAS;YAAE,QAAQ,EAAE,CAAA;IAC9C,CAAC,CAAC,CAAA;IACF,OAAO;QACL,IAAI,EAAE,GAAG,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,EAAE,MAAM,CAAC;QAC9C,SAAS,EAAE,CAAC,QAAQ,EAAE,EAAE;YACtB,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;YACvB,OAAO,GAAG,EAAE,CAAC,KAAK,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAA;QAC9C,CAAC;QACD,QAAQ,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,IAAI;QAC1B,OAAO,EAAE,GAAG;KACb,CAAA;AACH,CAAC,CAAA"}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@playfast/reform-remote",
+  "playbook": "./playbook",
+  "version": "0.0.2",
+  "type": "module",
+  "description": "Run a reform scene's logic on the server and stream its rendered UI to a thin client over any duplex transport.",
+  "keywords": [
+    "reform",
+    "effect",
+    "remote",
+    "server-driven-ui",
+    "transport",
+    "react"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/playfast/reform.git",
+    "directory": "packages/reform-remote"
+  },
+  "bugs": {
+    "url": "https://github.com/playfast/reform/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": "./src/index.ts",
+    "./*": "./src/*.ts"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "clean": "rm -rf dist .tsbuildinfo",
+    "check": "tsc --noEmit",
+    "build": "tsc -p tsconfig.build.json",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "coverage": "vitest run --coverage",
+    "lint": "oxlint src",
+    "lint:fix": "oxlint --fix src"
+  },
+  "peerDependencies": {
+    "effect": "*",
+    "react": "^19.0.0",
+    "@playfast/reform": "*"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}