@hypen-space/core 0.4.26 → 0.4.27

package/dist/remote/types.d.ts

@@ -2,7 +2,7 @@
  * Remote UI Protocol Types
  */
 import type { Patch } from "../types.js";
-export type RemoteMessage = InitialTreeMessage | PatchMessage | StateUpdateMessage | DispatchActionMessage | HelloMessage | SessionAckMessage | SessionExpiredMessage;
+export type RemoteMessage = InitialTreeMessage | PatchMessage | StateUpdateMessage | UpdateStateMessage | SubscribeStateMessage | DispatchActionMessage | HelloMessage | SessionAckMessage | SessionExpiredMessage;
 export interface InitialTreeMessage {
     type: "initialTree";
     module: string;
@@ -28,6 +28,23 @@ export interface DispatchActionMessage {
     action: string;
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypen-space/core",
-  "version": "0.4.26",
+  "version": "0.4.27",
   "description": "Hypen core engine - Platform-agnostic reactive UI runtime",
   "type": "module",
   "main": "./dist/index.js",
@@ -85,6 +85,7 @@
     "./remote/client": {
       "types": "./dist/remote/client.d.ts",
       "bun": "./src/remote/client.ts",
+      "browser": "./src/remote/client.ts",
       "import": "./dist/remote/client.js",
       "default": "./dist/remote/client.js"
     },

package/src/remote/client.ts

@@ -32,6 +32,8 @@ import type {
   InitialTreeMessage,
   PatchMessage,
   DispatchActionMessage,
+  UpdateStateMessage,
+  SubscribeStateMessage,
   HelloMessage,
   SessionAckMessage,
   SessionExpiredMessage,
@@ -278,6 +280,39 @@ export class RemoteEngine implements Disposable {
     this.ws.send(JSON.stringify(message));
   }
 
+  /**
+   * Subscribe to state updates after each render.
+   * Only subscribed clients receive stateUpdate messages (avoids overhead for native clients).
+   */
+  subscribeState(): void {
+    if (this.state !== "connected" || !this.ws) {
+      log.warn("Cannot subscribe to state: not connected");
+      return;
+    }
+
+    const message: SubscribeStateMessage = { type: "subscribeState" };
+    this.ws.send(JSON.stringify(message));
+  }
+
+  /**
+   * Override the remote module's state (e.g. for time-travel).
+   * The server will update state, re-render, and send back patches.
+   */
+  updateState(state: unknown): void {
+    if (this.state !== "connected" || !this.ws) {
+      log.warn("Cannot update state: not connected");
+      return;
+    }
+
+    const message: UpdateStateMessage = {
+      type: "updateState",
+      module: this.moduleName,
+      state,
+    };
+
+    this.ws.send(JSON.stringify(message));
+  }
+
   /**
    * Register callback for patches
    */

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;
 }
 
 /**
@@ -341,6 +345,7 @@ export class RemoteServer {
         connectedAt,
         sessionId: "",
         helloReceived: false,
+        stateSubscribed: false,
       };
 
       this.clients.set(ws, clientData);
@@ -497,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 (
@@ -515,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));
+              }
             }
           }
         }
@@ -637,6 +664,26 @@ export class RemoteServer {
           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;
+        }
+
         default:
           // Unknown message type
           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.26",
+  "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.26",
+  "version": "0.4.27",
   "license": "MIT",
   "repository": {
     "type": "git",