rwsdk 0.1.23 → 0.1.24

package/dist/runtime/client.d.ts

@@ -6,12 +6,14 @@ export type ActionResponse<Result> = {
 };
 type TransportContext = {
     setRscPayload: <Result>(v: Promise<ActionResponse<Result>>) => void;
+    handleResponse?: (response: Response) => boolean;
 };
 export type Transport = (context: TransportContext) => CallServerCallback;
 export type CreateCallServer = (context: TransportContext) => <Result>(id: null | string, args: null | unknown[]) => Promise<Result>;
 export declare const fetchTransport: Transport;
-export declare const initClient: ({ transport, hydrateRootOptions, }?: {
+export declare const initClient: ({ transport, hydrateRootOptions, handleResponse, }?: {
     transport?: Transport;
     hydrateRootOptions?: HydrationOptions;
+    handleResponse?: (response: Response) => boolean;
 }) => Promise<void>;
 export {};

package/dist/runtime/client.js

@@ -11,21 +11,41 @@ export const fetchTransport = (transportContext) => {
         if (id != null) {
             url.searchParams.set("__rsc_action_id", id);
         }
-        const streamData = createFromFetch(fetch(url, {
+        const fetchPromise = fetch(url, {
             method: "POST",
             body: args != null ? await encodeReply(args) : null,
-        }), { callServer: fetchCallServer });
+        });
+        // If there's a response handler, check the response first
+        if (transportContext.handleResponse) {
+            const response = await fetchPromise;
+            const shouldContinue = transportContext.handleResponse(response);
+            if (!shouldContinue) {
+                return;
+            }
+            // Continue with the response if handler returned true
+            const streamData = createFromFetch(Promise.resolve(response), {
+                callServer: fetchCallServer,
+            });
+            transportContext.setRscPayload(streamData);
+            const result = await streamData;
+            return result.actionResult;
+        }
+        // Original behavior when no handler is present
+        const streamData = createFromFetch(fetchPromise, {
+            callServer: fetchCallServer,
+        });
         transportContext.setRscPayload(streamData);
         const result = await streamData;
         return result.actionResult;
     };
     return fetchCallServer;
 };
-export const initClient = async ({ transport = fetchTransport, hydrateRootOptions, } = {}) => {
+export const initClient = async ({ transport = fetchTransport, hydrateRootOptions, handleResponse, } = {}) => {
     const React = await import("react");
     const { hydrateRoot } = await import("react-dom/client");
     const transportContext = {
         setRscPayload: () => { },
+        handleResponse,
     };
     let transportCallServer = transport(transportContext);
     const callServer = (id, args) => transportCallServer(id, args);

package/dist/runtime/clientNavigation.d.ts

@@ -1,4 +1,6 @@
 export declare function validateClickEvent(event: MouseEvent, target: HTMLElement): boolean;
 export declare function initClientNavigation(opts?: {
     onNavigate: () => void;
-}): void;
+}): {
+    handleResponse: (response: Response) => boolean;
+};

package/dist/runtime/clientNavigation.js

@@ -50,4 +50,15 @@ export function initClientNavigation(opts = {
     window.addEventListener("popstate", async function handlePopState() {
         await opts.onNavigate();
     });
+    // Return a handleResponse function for use with initClient
+    return {
+        handleResponse: function handleResponse(response) {
+            if (!response.ok) {
+                // Redirect to the current page (window.location) to show the error
+                window.location.href = window.location.href;
+                return false;
+            }
+            return true;
+        },
+    };
 }

package/dist/runtime/lib/realtime/client.d.ts

@@ -1,7 +1,9 @@
 import { type Transport } from "../../client";
-export declare const initRealtimeClient: ({ key, }?: {
+export declare const initRealtimeClient: ({ key, handleResponse, }?: {
     key?: string;
+    handleResponse?: (response: Response) => boolean;
 }) => Promise<void>;
-export declare const realtimeTransport: ({ key }: {
+export declare const realtimeTransport: ({ key, handleResponse, }: {
     key?: string;
+    handleResponse?: (response: Response) => boolean;
 }) => Transport;

package/dist/runtime/lib/realtime/client.js

@@ -1,12 +1,13 @@
 import { initClient } from "../../client";
 import { createFromReadableStream } from "react-server-dom-webpack/client.browser";
 import { MESSAGE_TYPE } from "./shared";
+import { packMessage, unpackMessage, } from "./protocol";
 const DEFAULT_KEY = "default";
-export const initRealtimeClient = ({ key = DEFAULT_KEY, } = {}) => {
-    const transport = realtimeTransport({ key });
-    return initClient({ transport });
+export const initRealtimeClient = ({ key = DEFAULT_KEY, handleResponse, } = {}) => {
+    const transport = realtimeTransport({ key, handleResponse });
+    return initClient({ transport, handleResponse });
 };
-export const realtimeTransport = ({ key = DEFAULT_KEY }) => (transportContext) => {
+export const realtimeTransport = ({ key = DEFAULT_KEY, handleResponse, }) => (transportContext) => {
     let ws = null;
     let isConnected = false;
     const clientId = crypto.randomUUID();
@@ -14,14 +15,15 @@ export const realtimeTransport = ({ key = DEFAULT_KEY }) => (transportContext) =
     const isHttps = clientUrl.protocol === "https:";
     clientUrl.protocol = "";
     clientUrl.host = "";
-    const setupWebSocket = () => {
+    const setupWebSocket = async () => {
         if (ws)
             return;
         const protocol = isHttps ? "wss" : "ws";
         ws = new WebSocket(`${protocol}://${window.location.host}/__realtime?` +
             `key=${encodeURIComponent(key)}&` +
             `url=${encodeURIComponent(clientUrl.toString())}&` +
-            `clientId=${encodeURIComponent(clientId)}`);
+            `clientId=${encodeURIComponent(clientId)}&` +
+            `shouldForwardResponses=${encodeURIComponent(handleResponse ? "true" : "false")}`);
         ws.binaryType = "arraybuffer";
         ws.addEventListener("open", () => {
             isConnected = true;
@@ -29,45 +31,15 @@ export const realtimeTransport = ({ key = DEFAULT_KEY }) => (transportContext) =
         ws.addEventListener("error", (event) => {
             console.error("[Realtime] WebSocket error", event);
         });
-        ws.addEventListener("message", (event) => {
-            const data = new Uint8Array(event.data);
-            const messageType = data[0];
-            if (messageType === MESSAGE_TYPE.RSC_START) {
-                const decoder = new TextDecoder();
-                const rscId = decoder.decode(data.slice(1, 37)); // Extract RSC stream ID
-                const stream = new ReadableStream({
-                    start(controller) {
-                        ws.addEventListener("message", function streamHandler(event) {
-                            const data = new Uint8Array(event.data);
-                            const messageType = data[0];
-                            // Extract the RSC stream ID and verify it matches
-                            const responseId = decoder.decode(data.slice(1, 37));
-                            if (responseId !== rscId) {
-                                return; // Not for this stream
-                            }
-                            const payload = data.slice(37);
-                            if (messageType === MESSAGE_TYPE.RSC_CHUNK) {
-                                controller.enqueue(payload);
-                            }
-                            else if (messageType === MESSAGE_TYPE.RSC_END) {
-                                controller.close();
-                                ws.removeEventListener("message", streamHandler);
-                            }
-                        });
-                    },
-                });
-                const rscPayload = createFromReadableStream(stream, {
-                    callServer: realtimeCallServer,
-                });
-                transportContext.setRscPayload(rscPayload);
-            }
-        });
         ws.addEventListener("close", () => {
             console.warn("[Realtime] WebSocket closed, attempting to reconnect...");
             ws = null;
             isConnected = false;
             setTimeout(setupWebSocket, 5000);
         });
+        listenForUpdates(ws, (response) => {
+            processResponse(response);
+        });
     };
     const ensureWs = () => {
         if (!ws && isConnected) {
@@ -89,78 +61,139 @@ export const realtimeTransport = ({ key = DEFAULT_KEY }) => (transportContext) =
             clientUrl.host = "";
             const encodedArgs = args != null ? await encodeReply(args) : null;
             const requestId = crypto.randomUUID();
-            const messageData = JSON.stringify({
+            const message = packMessage({
+                type: MESSAGE_TYPE.ACTION_REQUEST,
                 id,
                 args: encodedArgs,
                 requestId,
-                clientUrl,
+                clientUrl: clientUrl.toString(),
             });
-            const encoder = new TextEncoder();
-            const messageBytes = encoder.encode(messageData);
-            const message = new Uint8Array(messageBytes.length + 1);
-            message[0] = MESSAGE_TYPE.ACTION_REQUEST;
-            message.set(messageBytes, 1);
+            const promisedResponse = respondToRequest(requestId, socket);
             socket.send(message);
-            return new Promise(async (resolve, reject) => {
-                const stream = new ReadableStream({
-                    start(controller) {
-                        const messageHandler = (event) => {
-                            const data = new Uint8Array(event.data);
-                            const messageType = data[0];
-                            // First byte is message type
-                            // Next 36 bytes (or fixed size) should be UUID as requestId
-                            // Remaining bytes are the payload
-                            // Extract the requestId from the message
-                            const decoder = new TextDecoder();
-                            const responseId = decoder.decode(data.slice(1, 37)); // Assuming UUID is 36 chars
-                            // Only process messages meant for this request
-                            if (responseId !== requestId) {
-                                return;
-                            }
-                            // The actual payload starts after the requestId
-                            const payload = data.slice(37);
-                            if (messageType === MESSAGE_TYPE.ACTION_CHUNK) {
-                                controller.enqueue(payload);
-                            }
-                            else if (messageType === MESSAGE_TYPE.ACTION_END) {
-                                controller.close();
-                                socket.removeEventListener("message", messageHandler);
-                            }
-                            else if (messageType === MESSAGE_TYPE.ACTION_ERROR) {
-                                const errorJson = decoder.decode(payload);
-                                let errorMsg = "Unknown error";
-                                try {
-                                    const errorObj = JSON.parse(errorJson);
-                                    errorMsg = errorObj.error || errorMsg;
-                                }
-                                catch (e) {
-                                    // Use default error message
-                                }
-                                controller.error(new Error(errorMsg));
-                                socket.removeEventListener("message", messageHandler);
-                            }
-                        };
-                        socket.addEventListener("message", messageHandler);
-                    },
-                });
-                const rscPayload = createFromReadableStream(stream, {
-                    callServer: realtimeCallServer,
-                });
-                transportContext.setRscPayload(rscPayload);
-                try {
-                    const result = await rscPayload;
-                    resolve(result.actionResult);
-                }
-                catch (rscPayloadError) {
-                    reject(rscPayloadError);
-                }
-            });
+            return await processResponse(await promisedResponse);
         }
         catch (e) {
             console.error("[Realtime] Error calling server", e);
             return null;
         }
     };
+    const processResponse = async (response) => {
+        try {
+            let streamForRsc;
+            let shouldContinue = true;
+            if (transportContext.handleResponse) {
+                const [stream1, stream2] = response.body.tee();
+                const clonedResponse = new Response(stream1, response);
+                streamForRsc = stream2;
+                shouldContinue = transportContext.handleResponse(clonedResponse);
+            }
+            else {
+                streamForRsc = response.body;
+            }
+            if (!shouldContinue) {
+                return null;
+            }
+            const rscPayload = createFromReadableStream(streamForRsc, {
+                callServer: realtimeCallServer,
+            });
+            transportContext.setRscPayload(rscPayload);
+            return (await rscPayload).actionResult;
+        }
+        catch (err) {
+            throw err;
+        }
+    };
     setupWebSocket();
     return realtimeCallServer;
 };
+function respondToRequest(requestId, socket) {
+    const messageTypes = {
+        start: MESSAGE_TYPE.ACTION_START,
+        chunk: MESSAGE_TYPE.ACTION_CHUNK,
+        end: MESSAGE_TYPE.ACTION_END,
+        error: MESSAGE_TYPE.ACTION_ERROR,
+    };
+    return new Promise((resolve, reject) => {
+        const handler = (event) => {
+            const unpacked = unpackMessage(new Uint8Array(event.data));
+            if (unpacked.type === MESSAGE_TYPE.ACTION_REQUEST) {
+                return;
+            }
+            if (unpacked.id !== requestId) {
+                return;
+            }
+            if (unpacked.type === messageTypes.start) {
+                const message = unpacked;
+                socket.removeEventListener("message", handler);
+                const stream = createUpdateStreamFromSocket(requestId, socket, messageTypes, reject);
+                const response = new Response(stream, {
+                    status: message.status,
+                    headers: { "Content-Type": "text/plain" },
+                });
+                resolve(response);
+            }
+        };
+        socket.addEventListener("message", handler);
+    });
+}
+function listenForUpdates(socket, onUpdate) {
+    const messageTypes = {
+        start: MESSAGE_TYPE.RSC_START,
+        chunk: MESSAGE_TYPE.RSC_CHUNK,
+        end: MESSAGE_TYPE.RSC_END,
+    };
+    const handler = async (event) => {
+        const unpacked = unpackMessage(new Uint8Array(event.data));
+        if (unpacked.type === MESSAGE_TYPE.ACTION_REQUEST ||
+            unpacked.type === MESSAGE_TYPE.ACTION_CHUNK ||
+            unpacked.type === MESSAGE_TYPE.ACTION_END ||
+            unpacked.type === MESSAGE_TYPE.ACTION_ERROR) {
+            return;
+        }
+        if (unpacked.type === messageTypes.start) {
+            const message = unpacked;
+            const stream = createUpdateStreamFromSocket(message.id, socket, messageTypes, (error) => {
+                console.error("[Realtime] Error creating update stream", error);
+            });
+            const response = new Response(stream, {
+                status: message.status,
+                headers: { "Content-Type": "text/plain" },
+            });
+            onUpdate(response);
+        }
+    };
+    socket.addEventListener("message", handler);
+}
+const createUpdateStreamFromSocket = (id, socket, messageTypes, onError) => {
+    let deferredStreamController = Promise.withResolvers();
+    const stream = new ReadableStream({
+        start(controller) {
+            deferredStreamController.resolve(controller);
+        },
+    });
+    const handler = async (event) => {
+        const unpacked = unpackMessage(new Uint8Array(event.data));
+        if (unpacked.type === MESSAGE_TYPE.ACTION_REQUEST) {
+            return;
+        }
+        if (unpacked.id !== id) {
+            return;
+        }
+        const streamController = await deferredStreamController.promise;
+        if (unpacked.type === messageTypes.chunk) {
+            const message = unpacked;
+            streamController.enqueue(message.payload);
+        }
+        else if (unpacked.type === messageTypes.end) {
+            streamController.close();
+            socket.removeEventListener("message", handler);
+        }
+        else if (messageTypes.error && unpacked.type === messageTypes.error) {
+            const message = unpacked;
+            onError(new Error(message.error));
+            socket.removeEventListener("message", handler);
+        }
+    };
+    socket.addEventListener("message", handler);
+    return stream;
+};

package/dist/runtime/lib/realtime/durableObject.d.ts

@@ -3,6 +3,7 @@ interface ClientInfo {
     url: string;
     clientId: string;
     cookieHeaders: string;
+    shouldForwardResponses: boolean;
 }
 export declare class RealtimeDurableObject extends DurableObject {
     state: DurableObjectState;

package/dist/runtime/lib/realtime/durableObject.js

@@ -1,6 +1,7 @@
 import { DurableObject } from "cloudflare:workers";
 import { MESSAGE_TYPE } from "./shared";
 import { validateUpgradeRequest } from "./validateUpgradeRequest";
+import { packMessage, unpackMessage, } from "./protocol";
 export class RealtimeDurableObject extends DurableObject {
     constructor(state, env) {
         super(state, env);
@@ -23,6 +24,7 @@ export class RealtimeDurableObject extends DurableObject {
             url: url.searchParams.get("url"),
             clientId: url.searchParams.get("clientId"),
             cookieHeaders: request.headers.get("Cookie") || "",
+            shouldForwardResponses: url.searchParams.get("shouldForwardResponses") === "true",
         };
     }
     async storeClientInfo(clientInfo) {
@@ -51,54 +53,62 @@ export class RealtimeDurableObject extends DurableObject {
     async webSocketMessage(ws, data) {
         const clientId = ws.deserializeAttachment();
         let clientInfo = await this.getClientInfo(clientId);
-        const message = new Uint8Array(data);
-        const messageType = message[0];
-        if (messageType === MESSAGE_TYPE.ACTION_REQUEST) {
-            const decoder = new TextDecoder();
-            const jsonData = decoder.decode(message.slice(1));
-            const { id, args, requestId, clientUrl } = JSON.parse(jsonData);
+        const unpacked = unpackMessage(new Uint8Array(data));
+        if (unpacked.type === MESSAGE_TYPE.ACTION_REQUEST) {
+            const message = unpacked;
             clientInfo = {
                 ...clientInfo,
-                url: clientUrl,
+                url: message.clientUrl,
             };
             await this.storeClientInfo(clientInfo);
             try {
-                await this.handleAction(ws, id, args, clientInfo, requestId, clientUrl);
+                await this.handleAction(ws, message.id, message.args, clientInfo, message.requestId, message.clientUrl);
             }
             catch (error) {
-                const encoder = new TextEncoder();
-                const requestIdBytes = encoder.encode(requestId);
-                const errorData = JSON.stringify({
+                ws.send(packMessage({
+                    type: MESSAGE_TYPE.ACTION_ERROR,
+                    id: message.requestId,
                     error: error instanceof Error ? error.message : String(error),
-                });
-                const errorBytes = encoder.encode(errorData);
-                const errorResponse = new Uint8Array(1 + requestIdBytes.length + errorBytes.length);
-                errorResponse[0] = MESSAGE_TYPE.ACTION_ERROR;
-                errorResponse.set(requestIdBytes, 1);
-                errorResponse.set(errorBytes, 1 + requestIdBytes.length);
-                ws.send(errorResponse);
+                }));
             }
         }
     }
     async streamResponse(response, ws, messageTypes, streamId) {
+        const startMessage = messageTypes.start === MESSAGE_TYPE.ACTION_START
+            ? {
+                type: MESSAGE_TYPE.ACTION_START,
+                id: streamId,
+                status: response.status,
+            }
+            : {
+                type: MESSAGE_TYPE.RSC_START,
+                id: streamId,
+                status: response.status,
+            };
+        ws.send(packMessage(startMessage));
         const reader = response.body.getReader();
-        const encoder = new TextEncoder();
-        const streamIdBytes = encoder.encode(streamId);
         try {
             while (true) {
                 const { done, value } = await reader.read();
                 if (done) {
-                    const endMessage = new Uint8Array(1 + streamIdBytes.length);
-                    endMessage[0] = messageTypes.end;
-                    endMessage.set(streamIdBytes, 1);
-                    ws.send(endMessage);
+                    const endMessage = messageTypes.end === MESSAGE_TYPE.ACTION_END
+                        ? { type: MESSAGE_TYPE.ACTION_END, id: streamId }
+                        : { type: MESSAGE_TYPE.RSC_END, id: streamId };
+                    ws.send(packMessage(endMessage));
                     break;
                 }
-                const chunkMessage = new Uint8Array(1 + streamIdBytes.length + value.length);
-                chunkMessage[0] = messageTypes.chunk;
-                chunkMessage.set(streamIdBytes, 1);
-                chunkMessage.set(value, 1 + streamIdBytes.length);
-                ws.send(chunkMessage);
+                const chunkMessage = messageTypes.chunk === MESSAGE_TYPE.ACTION_CHUNK
+                    ? {
+                        type: MESSAGE_TYPE.ACTION_CHUNK,
+                        id: streamId,
+                        payload: value,
+                    }
+                    : {
+                        type: MESSAGE_TYPE.RSC_CHUNK,
+                        id: streamId,
+                        payload: value,
+                    };
+                ws.send(packMessage(chunkMessage));
             }
         }
         finally {
@@ -119,13 +129,14 @@ export class RealtimeDurableObject extends DurableObject {
                 Cookie: clientInfo.cookieHeaders,
             },
         });
-        if (!response.ok) {
+        if (!response.ok && !clientInfo.shouldForwardResponses) {
             throw new Error(`Action failed: ${response.statusText}`);
         }
         this.render({
             exclude: [clientInfo.clientId],
         });
         await this.streamResponse(response, ws, {
+            start: MESSAGE_TYPE.ACTION_START,
             chunk: MESSAGE_TYPE.ACTION_CHUNK,
             end: MESSAGE_TYPE.ACTION_END,
         }, requestId);
@@ -167,11 +178,8 @@ export class RealtimeDurableObject extends DurableObject {
                     return;
                 }
                 const rscId = crypto.randomUUID();
-                const startMessage = new Uint8Array(1 + 36);
-                startMessage[0] = MESSAGE_TYPE.RSC_START;
-                startMessage.set(new TextEncoder().encode(rscId), 1);
-                socket.send(startMessage);
                 await this.streamResponse(response, socket, {
+                    start: MESSAGE_TYPE.RSC_START,
                     chunk: MESSAGE_TYPE.RSC_CHUNK,
                     end: MESSAGE_TYPE.RSC_END,
                 }, rscId);

package/dist/runtime/lib/realtime/protocol.d.ts

@@ -0,0 +1,50 @@
+import { MESSAGE_TYPE } from "./shared";
+export type Message = ActionRequestMessage | ActionStartMessage | ActionChunkMessage | ActionEndMessage | ActionErrorMessage | RscStartMessage | RscChunkMessage | RscEndMessage;
+export type ActionRequestMessage = {
+    type: typeof MESSAGE_TYPE.ACTION_REQUEST;
+    id: string | null;
+    args: any;
+    requestId: string;
+    clientUrl: string;
+};
+export type ActionStartMessage = {
+    type: typeof MESSAGE_TYPE.ACTION_START;
+    id: string;
+    status: number;
+};
+export type ActionChunkMessage = {
+    type: typeof MESSAGE_TYPE.ACTION_CHUNK;
+    id: string;
+    payload: Uint8Array;
+};
+export type ActionEndMessage = {
+    type: typeof MESSAGE_TYPE.ACTION_END;
+    id: string;
+};
+export type ActionErrorMessage = {
+    type: typeof MESSAGE_TYPE.ACTION_ERROR;
+    id: string;
+    error: string;
+};
+export type RscStartMessage = {
+    type: typeof MESSAGE_TYPE.RSC_START;
+    id: string;
+    status: number;
+};
+export type RscChunkMessage = {
+    type: typeof MESSAGE_TYPE.RSC_CHUNK;
+    id: string;
+    payload: Uint8Array;
+};
+export type RscEndMessage = {
+    type: typeof MESSAGE_TYPE.RSC_END;
+    id: string;
+};
+/**
+ * Packs a message object into a Uint8Array for sending over WebSocket.
+ */
+export declare function packMessage(message: Message): Uint8Array;
+/**
+ * Unpacks a Uint8Array from WebSocket into a message object.
+ */
+export declare function unpackMessage(data: Uint8Array): Message;

package/dist/runtime/lib/realtime/protocol.js

@@ -0,0 +1,141 @@
+import { MESSAGE_TYPE } from "./shared";
+const TEXT_ENCODER = new TextEncoder();
+const TEXT_DECODER = new TextDecoder();
+const ID_LENGTH = 36; // Length of a UUID string
+/**
+ * Packs a message object into a Uint8Array for sending over WebSocket.
+ */
+export function packMessage(message) {
+    switch (message.type) {
+        case MESSAGE_TYPE.ACTION_REQUEST: {
+            const msg = message;
+            const jsonPayload = JSON.stringify({
+                id: msg.id,
+                args: msg.args,
+                requestId: msg.requestId,
+                clientUrl: msg.clientUrl,
+            });
+            const payloadBytes = TEXT_ENCODER.encode(jsonPayload);
+            const packed = new Uint8Array(1 + payloadBytes.length);
+            packed[0] = msg.type;
+            packed.set(payloadBytes, 1);
+            return packed;
+        }
+        case MESSAGE_TYPE.ACTION_START:
+        case MESSAGE_TYPE.RSC_START: {
+            const msg = message;
+            const idBytes = TEXT_ENCODER.encode(msg.id);
+            if (idBytes.length !== ID_LENGTH) {
+                throw new Error("Invalid message ID length for START message");
+            }
+            const packed = new Uint8Array(1 + 2 + ID_LENGTH); // 1 for type, 2 for status
+            const view = new DataView(packed.buffer);
+            view.setUint8(0, msg.type);
+            view.setUint16(1, msg.status, false); // Big-endian
+            packed.set(idBytes, 3);
+            return packed;
+        }
+        case MESSAGE_TYPE.ACTION_CHUNK:
+        case MESSAGE_TYPE.RSC_CHUNK: {
+            const msg = message;
+            const idBytes = TEXT_ENCODER.encode(msg.id);
+            if (idBytes.length !== ID_LENGTH) {
+                throw new Error("Invalid message ID length for CHUNK message");
+            }
+            const packed = new Uint8Array(1 + ID_LENGTH + msg.payload.length);
+            packed[0] = msg.type;
+            packed.set(idBytes, 1);
+            packed.set(msg.payload, 1 + ID_LENGTH);
+            return packed;
+        }
+        case MESSAGE_TYPE.ACTION_END:
+        case MESSAGE_TYPE.RSC_END: {
+            const msg = message;
+            const idBytes = TEXT_ENCODER.encode(msg.id);
+            if (idBytes.length !== ID_LENGTH) {
+                throw new Error("Invalid message ID length for END message");
+            }
+            const packed = new Uint8Array(1 + ID_LENGTH);
+            packed[0] = msg.type;
+            packed.set(idBytes, 1);
+            return packed;
+        }
+        case MESSAGE_TYPE.ACTION_ERROR: {
+            const msg = message;
+            const idBytes = TEXT_ENCODER.encode(msg.id);
+            if (idBytes.length !== ID_LENGTH) {
+                throw new Error("Invalid message ID length for ERROR message");
+            }
+            const errorPayload = JSON.stringify({ error: msg.error });
+            const errorBytes = TEXT_ENCODER.encode(errorPayload);
+            const packed = new Uint8Array(1 + ID_LENGTH + errorBytes.length);
+            packed[0] = msg.type;
+            packed.set(idBytes, 1);
+            packed.set(errorBytes, 1 + ID_LENGTH);
+            return packed;
+        }
+        default:
+            // This should be unreachable if all message types are handled
+            throw new Error(`Unknown message type for packing`);
+    }
+}
+/**
+ * Unpacks a Uint8Array from WebSocket into a message object.
+ */
+export function unpackMessage(data) {
+    if (data.length === 0) {
+        throw new Error("Cannot unpack empty message");
+    }
+    const messageType = data[0];
+    switch (messageType) {
+        case MESSAGE_TYPE.ACTION_REQUEST: {
+            const jsonPayload = TEXT_DECODER.decode(data.slice(1));
+            const parsed = JSON.parse(jsonPayload);
+            return { type: messageType, ...parsed };
+        }
+        case MESSAGE_TYPE.ACTION_START:
+        case MESSAGE_TYPE.RSC_START: {
+            if (data.length !== 1 + 2 + ID_LENGTH) {
+                throw new Error("Invalid START message length");
+            }
+            const view = new DataView(data.buffer);
+            const status = view.getUint16(1, false);
+            const id = TEXT_DECODER.decode(data.slice(3));
+            return { type: messageType, id, status };
+        }
+        case MESSAGE_TYPE.ACTION_CHUNK:
+        case MESSAGE_TYPE.RSC_CHUNK: {
+            if (data.length < 1 + ID_LENGTH) {
+                throw new Error("Invalid CHUNK message length");
+            }
+            const id = TEXT_DECODER.decode(data.slice(1, 1 + ID_LENGTH));
+            const payload = data.slice(1 + ID_LENGTH);
+            return { type: messageType, id, payload };
+        }
+        case MESSAGE_TYPE.ACTION_END:
+        case MESSAGE_TYPE.RSC_END: {
+            if (data.length !== 1 + ID_LENGTH) {
+                throw new Error("Invalid END message length");
+            }
+            const id = TEXT_DECODER.decode(data.slice(1, 1 + ID_LENGTH));
+            return { type: messageType, id };
+        }
+        case MESSAGE_TYPE.ACTION_ERROR: {
+            if (data.length < 1 + ID_LENGTH) {
+                throw new Error("Invalid ERROR message length");
+            }
+            const id = TEXT_DECODER.decode(data.slice(1, 1 + ID_LENGTH));
+            const errorPayload = TEXT_DECODER.decode(data.slice(1 + ID_LENGTH));
+            let error = "Unknown error";
+            try {
+                error = JSON.parse(errorPayload).error;
+            }
+            catch (e) {
+                // ignore if it's not a json
+            }
+            return { type: messageType, id, error };
+        }
+        default:
+            throw new Error(`Unknown message type for unpacking: ${messageType}`);
+    }
+}

package/dist/runtime/lib/realtime/shared.d.ts

@@ -1,10 +1,10 @@
 export declare const MESSAGE_TYPE: {
-    readonly RSC_START: 0;
-    readonly RSC_CHUNK: 1;
-    readonly RSC_END: 2;
-    readonly ACTION_REQUEST: 3;
-    readonly ACTION_RESPONSE: 4;
-    readonly ACTION_ERROR: 5;
-    readonly ACTION_CHUNK: 6;
-    readonly ACTION_END: 7;
+    RSC_START: number;
+    RSC_CHUNK: number;
+    RSC_END: number;
+    ACTION_REQUEST: number;
+    ACTION_START: number;
+    ACTION_CHUNK: number;
+    ACTION_END: number;
+    ACTION_ERROR: number;
 };

package/dist/runtime/lib/realtime/shared.js

@@ -3,8 +3,8 @@ export const MESSAGE_TYPE = {
     RSC_CHUNK: 1,
     RSC_END: 2,
     ACTION_REQUEST: 3,
-    ACTION_RESPONSE: 4,
-    ACTION_ERROR: 5,
-    ACTION_CHUNK: 6,
-    ACTION_END: 7,
+    ACTION_START: 4,
+    ACTION_CHUNK: 5,
+    ACTION_END: 6,
+    ACTION_ERROR: 7,
 };

package/dist/scripts/debug-sync.mjs

@@ -15,7 +15,8 @@ const getPackageManagerInfo = (targetDir) => {
     if (existsSync(path.join(targetDir, "yarn.lock"))) {
         return { name: "yarn", lockFile: "yarn.lock", command: "add" };
     }
-    if (existsSync(path.join(targetDir, "pnpm-lock.yaml"))) {
+    if (existsSync(path.join(targetDir, "pnpm-lock.yaml")) ||
+        existsSync(path.join(targetDir, "node_modules", ".pnpm"))) {
         return pnpmResult;
     }
     if (existsSync(path.join(targetDir, "package-lock.json"))) {
@@ -23,51 +24,75 @@ const getPackageManagerInfo = (targetDir) => {
     }
     return pnpmResult;
 };
-const performFullSync = async (sdkDir, targetDir) => {
-    console.log("📦 Packing SDK...");
-    const packResult = await $ `npm pack`;
-    const tarballName = packResult.stdout?.trim() ?? "";
-    if (!tarballName) {
-        console.error("❌ Failed to get tarball name from npm pack.");
-        return;
-    }
-    const tarballPath = path.resolve(sdkDir, tarballName);
-    console.log(`💿 Installing ${tarballName} in ${targetDir}...`);
-    const pm = getPackageManagerInfo(targetDir);
-    const packageJsonPath = path.join(targetDir, "package.json");
-    const lockfilePath = path.join(targetDir, pm.lockFile);
-    const originalPackageJson = await fs
-        .readFile(packageJsonPath, "utf-8")
-        .catch(() => null);
-    const originalLockfile = await fs
-        .readFile(lockfilePath, "utf-8")
-        .catch(() => null);
+const performFullSync = async (sdkDir, targetDir, cacheBust = false) => {
+    const sdkPackageJsonPath = path.join(sdkDir, "package.json");
+    let originalSdkPackageJson = null;
+    let tarballPath = "";
+    let tarballName = "";
     try {
-        const cmd = pm.name;
-        const args = [pm.command];
-        if (pm.name === "yarn") {
-            args.push(`file:${tarballPath}`);
+        if (cacheBust) {
+            console.log("💥 Cache-busting version for full sync...");
+            originalSdkPackageJson = await fs.readFile(sdkPackageJsonPath, "utf-8");
+            const packageJson = JSON.parse(originalSdkPackageJson);
+            const now = Date.now();
+            // This is a temporary version used for cache busting
+            packageJson.version = `${packageJson.version}-dev.${now}`;
+            await fs.writeFile(sdkPackageJsonPath, JSON.stringify(packageJson, null, 2));
+        }
+        console.log("📦 Packing SDK...");
+        const packResult = await $({ cwd: sdkDir }) `npm pack`;
+        tarballName = packResult.stdout?.trim() ?? "";
+        if (!tarballName) {
+            console.error("❌ Failed to get tarball name from npm pack.");
+            return;
         }
-        else {
-            args.push(tarballPath);
+        tarballPath = path.resolve(sdkDir, tarballName);
+        console.log(`💿 Installing ${tarballName} in ${targetDir}...`);
+        const pm = getPackageManagerInfo(targetDir);
+        const packageJsonPath = path.join(targetDir, "package.json");
+        const lockfilePath = path.join(targetDir, pm.lockFile);
+        const originalPackageJson = await fs
+            .readFile(packageJsonPath, "utf-8")
+            .catch(() => null);
+        const originalLockfile = await fs
+            .readFile(lockfilePath, "utf-8")
+            .catch(() => null);
+        try {
+            const cmd = pm.name;
+            const args = [pm.command];
+            if (pm.name === "yarn") {
+                args.push(`file:${tarballPath}`);
+            }
+            else {
+                args.push(tarballPath);
+            }
+            await $(cmd, args, {
+                cwd: targetDir,
+                stdio: "inherit",
+            });
+        }
+        finally {
+            if (originalPackageJson) {
+                console.log("Restoring package.json...");
+                await fs.writeFile(packageJsonPath, originalPackageJson);
+            }
+            if (originalLockfile) {
+                console.log(`Restoring ${pm.lockFile}...`);
+                await fs.writeFile(lockfilePath, originalLockfile);
+            }
         }
-        await $(cmd, args, {
-            cwd: targetDir,
-            stdio: "inherit",
-        });
     }
     finally {
-        if (originalPackageJson) {
+        if (originalSdkPackageJson) {
             console.log("Restoring package.json...");
-            await fs.writeFile(packageJsonPath, originalPackageJson);
+            await fs.writeFile(sdkPackageJsonPath, originalSdkPackageJson);
         }
-        if (originalLockfile) {
-            console.log(`Restoring ${pm.lockFile}...`);
-            await fs.writeFile(lockfilePath, originalLockfile);
+        if (tarballPath) {
+            console.log("Removing tarball...");
+            await fs.unlink(tarballPath).catch(() => {
+                // ignore if deletion fails
+            });
         }
-        await fs.unlink(tarballPath).catch(() => {
-            // ignore if deletion fails
-        });
     }
 };
 const performFastSync = async (sdkDir, targetDir) => {
@@ -87,6 +112,13 @@ const performFastSync = async (sdkDir, targetDir) => {
 const performSync = async (sdkDir, targetDir) => {
     console.log("🏗️  Rebuilding SDK...");
     await $ `pnpm build`;
+    const forceFullSync = Boolean(process.env.RWSDK_FORCE_FULL_SYNC);
+    if (forceFullSync) {
+        console.log("🏃 Force full sync mode is enabled.");
+        await performFullSync(sdkDir, targetDir, true);
+        console.log("✅ Done syncing");
+        return;
+    }
     const sdkPackageJsonPath = path.join(sdkDir, "package.json");
     const installedSdkPackageJsonPath = path.join(targetDir, "node_modules/rwsdk/package.json");
     let packageJsonChanged = true;
@@ -166,8 +198,21 @@ export const debugSync = async (opts) => {
         ignoreInitial: true,
         cwd: sdkDir,
     });
-    watcher.on("all", async () => {
-        console.log("\nDetected change, re-syncing...");
+    let syncing = false;
+    // todo(justinvdm, 2025-07-22): Figure out wtf makes the full sync
+    // cause chokidar to find out about package.json after sync has resolved
+    let expectingFileChanges = Boolean(process.env.RWSDK_FORCE_FULL_SYNC);
+    watcher.on("all", async (_event, filePath) => {
+        if (syncing || filePath.endsWith(".tgz")) {
+            return;
+        }
+        if (expectingFileChanges && process.env.RWSDK_FORCE_FULL_SYNC) {
+            expectingFileChanges = false;
+            return;
+        }
+        syncing = true;
+        expectingFileChanges = true;
+        console.log(`\nDetected change, re-syncing... (file: ${filePath})`);
         if (childProc && !childProc.killed) {
             console.log("Stopping running process...");
             childProc.kill();
@@ -176,6 +221,7 @@ export const debugSync = async (opts) => {
             });
         }
         try {
+            watcher.unwatch(filesToWatch);
             await performSync(sdkDir, targetDir);
             runWatchedCommand();
         }
@@ -183,6 +229,10 @@ export const debugSync = async (opts) => {
             console.error("❌ Sync failed:", error);
             console.log("   Still watching for changes...");
         }
+        finally {
+            syncing = false;
+            watcher.add(filesToWatch);
+        }
     });
     const cleanup = async () => {
         console.log("\nCleaning up...");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rwsdk",
-  "version": "0.1.23",
+  "version": "0.1.24",
   "description": "Build fast, server-driven webapps on Cloudflare with SSR, RSC, and realtime",
   "type": "module",
   "bin": {