@hypen-space/core 0.4.25 → 0.4.27

package/src/remote/server.ts

@@ -37,6 +37,8 @@ import type {
   RemoteServerConfig,
   InitialTreeMessage,
   PatchMessage,
+  StateUpdateMessage,
+  UpdateStateMessage,
   DispatchActionMessage,
   HelloMessage,
   SessionAckMessage,
@@ -68,6 +70,8 @@ interface ClientData {
   helloReceived: boolean;
   /** Timeout for legacy clients that don't send hello */
   helloTimeout?: ReturnType<typeof setTimeout>;
+  /** Whether this client subscribes to state updates after each render */
+  stateSubscribed: boolean;
 }
 
 /**
@@ -87,6 +91,7 @@ export class RemoteServer {
   private nextClientId = 1;
   private server: ReturnType<typeof Bun.serve> | null = null;
   private sessionManager: SessionManager | null = null;
+  private _syncActions: boolean = false;
 
   /**
    * Set the module for this app
@@ -141,6 +146,16 @@ export class RemoteServer {
     return this;
   }
 
+  /**
+   * Enable action synchronization across all connected clients.
+   * When enabled, an action dispatched by any client is also dispatched
+   * to every other client's engine, keeping all clients in sync.
+   */
+  syncActions(): this {
+    this._syncActions = true;
+    return this;
+  }
+
   /**
    * Register connection callback
    */
@@ -330,6 +345,7 @@ export class RemoteServer {
         connectedAt,
         sessionId: "",
         helloReceived: false,
+        stateSubscribed: false,
       };
 
       this.clients.set(ws, clientData);
@@ -486,14 +502,25 @@ export class RemoteServer {
 
       data.revision++;
 
-      const message: PatchMessage = {
+      const patchMessage: PatchMessage = {
         type: "patch",
         module: this._moduleName,
         patches,
         revision: data.revision,
       };
 
-      ws.send(JSON.stringify(message));
+      ws.send(JSON.stringify(patchMessage));
+
+      // Only send state snapshot to clients that opted in (e.g. Studio)
+      if (data.stateSubscribed) {
+        const stateMessage: StateUpdateMessage = {
+          type: "stateUpdate",
+          module: this._moduleName,
+          state: data.moduleInstance.getState(),
+          revision: data.revision,
+        };
+        ws.send(JSON.stringify(stateMessage));
+      }
 
       // If allow-multiple, broadcast to other connections on same session
       if (
@@ -504,7 +531,18 @@ export class RemoteServer {
         if (connections) {
           for (const conn of connections) {
             if (conn !== ws) {
-              (conn as ServerWebSocket<unknown>).send(JSON.stringify(message));
+              const otherWs = conn as ServerWebSocket<unknown>;
+              const otherData = this.clients.get(otherWs);
+              otherWs.send(JSON.stringify(patchMessage));
+              if (otherData?.stateSubscribed) {
+                const stateMessage: StateUpdateMessage = {
+                  type: "stateUpdate",
+                  module: this._moduleName,
+                  state: data.moduleInstance.getState(),
+                  revision: data.revision,
+                };
+                otherWs.send(JSON.stringify(stateMessage));
+              }
             }
           }
         }
@@ -615,6 +653,34 @@ export class RemoteServer {
         case "dispatchAction": {
           const actionMsg = msg as DispatchActionMessage;
           clientData.engine.dispatchAction(actionMsg.action, actionMsg.payload);
+
+          // Sync mode: dispatch to all other clients' engines
+          if (this._syncActions) {
+            for (const [otherWs, otherClient] of this.clients) {
+              if (otherWs === ws || !otherClient.helloReceived) continue;
+              otherClient.engine.dispatchAction(actionMsg.action, actionMsg.payload);
+            }
+          }
+          break;
+        }
+
+        case "updateState": {
+          const stateMsg = msg as UpdateStateMessage;
+          clientData.moduleInstance.updateState(stateMsg.state);
+
+          // Sync mode: update state on all other clients' engines
+          if (this._syncActions) {
+            for (const [otherWs, otherClient] of this.clients) {
+              if (otherWs === ws || !otherClient.helloReceived) continue;
+              otherClient.moduleInstance.updateState(stateMsg.state);
+            }
+          }
+          break;
+        }
+
+        case "subscribeState": {
+          clientData.stateSubscribed = true;
+          log.info(`Client ${clientData.id} subscribed to state updates`);
           break;
         }
 

package/src/remote/types.ts

@@ -8,6 +8,8 @@ export type RemoteMessage =
   | InitialTreeMessage
   | PatchMessage
   | StateUpdateMessage
+  | UpdateStateMessage
+  | SubscribeStateMessage
   | DispatchActionMessage
   | HelloMessage
   | SessionAckMessage
@@ -42,6 +44,25 @@ export interface DispatchActionMessage {
   payload?: any;
 }
 
+/**
+ * Client → Server: Override the module's state (e.g. for time-travel)
+ * Server will update the module instance and re-render, sending back
+ * patch + stateUpdate messages.
+ */
+export interface UpdateStateMessage {
+  type: "updateState";
+  module: string;
+  state: any;
+}
+
+/**
+ * Client → Server: Opt-in to receiving stateUpdate messages after each render.
+ * Only subscribed clients receive state snapshots (e.g. Studio for time-travel).
+ */
+export interface SubscribeStateMessage {
+  type: "subscribeState";
+}
+
 /**
  * Client → Server: First message after WebSocket opens
  * Used to establish or resume a session

package/wasm-browser/package.json

@@ -5,7 +5,7 @@
     "Hypen Contributors"
   ],
   "description": "A Rust implementation of the Hypen engine",
-  "version": "0.4.25",
+  "version": "0.4.27",
   "license": "MIT",
   "repository": {
     "type": "git",

package/wasm-node/package.json

@@ -4,7 +4,7 @@
     "Hypen Contributors"
   ],
   "description": "A Rust implementation of the Hypen engine",
-  "version": "0.4.25",
+  "version": "0.4.27",
   "license": "MIT",
   "repository": {
     "type": "git",