svelte-adapter-uws 0.5.2 → 0.5.3

package/README.md

@@ -699,12 +699,25 @@ export function open(ws, { platform }) {
   ws.subscribe(`user:${userId}`);
 }
 
-// Called when a message is received
+// Called when a message is received.
 // Note: subscribe/unsubscribe messages from the client store are
-// handled automatically BEFORE this function is called
-export function message(ws, { data, isBinary }) {
-  const msg = JSON.parse(Buffer.from(data).toString());
-  console.log('Got message:', msg);
+// handled automatically BEFORE this function is called.
+//
+// `msg` is the JSON-parsed envelope when the adapter parsed the frame
+// for control-message routing but no control type matched (i.e. it
+// looks like `{"type":"<custom>",...}` from a plugin). The adapter
+// already did `TextDecoder + JSON.parse` once during routing, so this
+// avoids a second parse on the dispatch path. `msg` is `undefined`
+// for binary frames, prefix-miss frames, parse failures, or frames
+// that parse to a non-object.
+export function message(ws, { data, isBinary, msg }) {
+  if (msg) {
+    // Already-parsed JSON object envelope - dispatch by msg.type
+    console.log('Got envelope:', msg);
+    return;
+  }
+  // Binary or non-envelope text frame - decode manually
+  console.log('Got raw frame, byteLength:', data.byteLength);
 }
 
 // Called when a client tries to subscribe to a topic (optional)

package/files/handler.js

@@ -3035,17 +3035,30 @@ if (WS_ENABLED) {
 			// The 8192-byte ceiling is generous enough for subscribe-batch with
 			// many topics (N * 256-char names) while keeping the JSON.parse
 			// guard against truly large user messages.
+			// `msg` is hoisted to outer scope so it can be forwarded to the user
+			// handler in the fall-through delegation below. When the prefix
+			// matched and JSON.parse produced an object that did NOT match any
+			// known control type, the parsed value reaches plugin-layer
+			// dispatchers (e.g. svelte-realtime's `onJsonMessage`) directly, so
+			// they don't re-run TextDecoder + JSON.parse on every frame.
+			/** @type {any} */
+			let msg;
 			if (!isBinary && message.byteLength < 8192 &&
 				(new Uint8Array(message))[3] === 0x79 /* 'y' in {"type" */) {
 				/** @type {any} */
-				let msg;
+				let parsed;
 				try {
-					msg = JSON.parse(textDecoder.decode(message));
+					parsed = JSON.parse(textDecoder.decode(message));
 				} catch {
-					// Not valid JSON - fall through to user handler.
-					wsModule.message?.(ws, { data: message, isBinary, platform: ws.getUserData()[WS_PLATFORM] });
+					parsed = undefined;
+				}
+				if (parsed === null || typeof parsed !== 'object') {
+					// Not a JSON object envelope (parse failed, or parsed to
+					// null / primitive / array). Forward raw bytes only.
+					wsModule.message?.(ws, { data: message, isBinary, msg, platform: ws.getUserData()[WS_PLATFORM] });
 					return;
 				}
+				msg = parsed;
 				if (msg.type === 'subscribe' && typeof msg.topic === 'string') {
 					const ref = hasRef(msg.ref) ? msg.ref : null;
 					if (!isValidWireTopic(msg.topic, ALLOW_NON_ASCII_TOPICS)) {
@@ -3230,8 +3243,10 @@ if (WS_ENABLED) {
 					return;
 				}
 			}
-			// Delegate everything else to the user's handler (if provided)
-			wsModule.message?.(ws, { data: message, isBinary, platform: ws.getUserData()[WS_PLATFORM] });
+			// Delegate everything else to the user's handler (if provided).
+			// `msg` is the JSON-parsed envelope when the prefix matched + parsed
+			// to an object + no control type matched; otherwise undefined.
+			wsModule.message?.(ws, { data: message, isBinary, msg, platform: ws.getUserData()[WS_PLATFORM] });
 		},
 
 		drain: (ws) => {

package/index.d.ts

@@ -517,6 +517,26 @@ export interface MessageContext {
 	data: ArrayBuffer;
 	/** Whether the message is binary. */
 	isBinary: boolean;
+	/**
+	 * The JSON-parsed envelope, when the adapter parsed the frame for
+	 * control-message routing (subscribe / unsubscribe / hello / resume /
+	 * reply / subscribe-batch) but no control type matched.
+	 *
+	 * Plugin-layer JSON envelope dispatchers (e.g. svelte-realtime's
+	 * `createMessage({ onJsonMessage })`) consume this directly instead of
+	 * re-running `TextDecoder + JSON.parse` on every frame.
+	 *
+	 * `undefined` when:
+	 * - the frame is binary (`isBinary === true`), or
+	 * - the frame did not start with `{"ty` (byte[3] !== 0x79), or
+	 * - the frame was larger than 8 KiB, or
+	 * - `JSON.parse` threw, or
+	 * - the parsed value was not a plain object (null / array / primitive).
+	 *
+	 * The adapter's `websocket.maxPayloadLength` (default 1 MB) is the
+	 * structural ceiling for frame size; this field adds no separate cap.
+	 */
+	msg?: any;
 	/** The platform API - publish, send, topic helpers, etc. */
 	platform: Platform;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-adapter-uws",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "publishConfig": {
     "tag": "latest"
   },

package/plugins/presence/client.js

@@ -15,7 +15,7 @@
 
 const TOPIC_PREFIX = '__presence:';
 
-import { on } from '../../client.js';
+import { on, connect, status } from '../../client.js';
 import { writable } from 'svelte/store';
 
 /** @type {Map<string, { subscribe: (fn: Function) => (() => void) }>} */
@@ -83,9 +83,11 @@ export function presence(topic, options) {
 	const output = writable(/** @type {any[]} */ ([]));
 
 	let sourceUnsub = /** @type {(() => void) | null} */ (null);
+	let statusUnsub = /** @type {(() => void) | null} */ (null);
 	/** @type {ReturnType<typeof setInterval> | null} */
 	let sweepTimer = null;
 	let refCount = 0;
+	let cancelled = false;
 
 	function flush() {
 		output.set([...userMap.values()]);
@@ -105,6 +107,7 @@ export function presence(topic, options) {
 	}
 
 	function startListening() {
+		cancelled = false;
 		// Fresh on() call each time - the underlying writable in client.js
 		// is cleaned up on full unsubscribe, so a stale reference would
 		// silently stop receiving events.
@@ -150,29 +153,67 @@ export function presence(topic, options) {
 				return;
 			}
 
-			if (event.event === 'heartbeat' && Array.isArray(event.data)) {
-				// Server confirms these keys are still active - refresh their
-				// timestamps so maxAge doesn't expire them. Keys not in the
-				// heartbeat are left alone (maxAge will handle them).
+			if (event.event === 'heartbeat') {
 				const now = Date.now();
-				for (const key of event.data) {
-					if (timestamps.has(key)) {
+				let changed = false;
+				if (event.data && typeof event.data === 'object' && !Array.isArray(event.data)) {
+					// New shape: `{userKey: data}` map. Refresh existing AND
+					// re-add any entry that aged out between heartbeats. The
+					// older "refresh existing only" branch (below) could not
+					// recover entries the local sweep had already removed -
+					// once an entry aged out, the next heartbeat couldn't
+					// bring it back and the user stayed missing until a
+					// presence_diff or presence_state arrived.
+					for (const [key, data] of Object.entries(event.data)) {
 						timestamps.set(key, now);
+						const prev = userMap.get(key);
+						if (prev !== data) {
+							userMap.set(key, data);
+							changed = true;
+						}
+					}
+				} else if (Array.isArray(event.data)) {
+					// Back-compat: keys-only heartbeat (older server). Refresh
+					// existing entries; cannot recover aged-out ones from this
+					// shape. The presence_diff / presence_state reconciliation
+					// path still corrects missing entries on the next event.
+					for (const key of event.data) {
+						if (timestamps.has(key)) {
+							timestamps.set(key, now);
+						}
 					}
 				}
+				if (changed) flush();
+				return;
 			}
 		});
 
 		if (maxAge > 0) {
 			sweepTimer = setInterval(sweep, Math.max(maxAge / 2, 1000));
 		}
+
+		// Request a presence snapshot every time the socket opens (initial
+		// connect AND reconnects). Without this, a reconnecting client
+		// missed any presence_diff frames that fired during the disconnect
+		// window and its in-memory map stayed at whatever it last knew.
+		// Symmetric to the cursor plugin's `cursor-snapshot` send.
+		statusUnsub = status.subscribe((s) => {
+			if (s === 'open' && !cancelled) {
+				connect().send({ type: 'presence-snapshot', topic });
+			}
+		});
 	}
 
 	function stopListening() {
+		cancelled = true;
 		if (sourceUnsub) {
 			sourceUnsub();
 			sourceUnsub = null;
 		}
+		if (statusUnsub) {
+			statusUnsub();
+			statusUnsub = null;
+		}
 		if (sweepTimer) {
 			clearInterval(sweepTimer);
 			sweepTimer = null;

package/testing.js

@@ -568,12 +568,27 @@ export async function createTestServer(options = {}) {
 
 		async message(ws, message, isBinary) {
 			bumpInT(ws, message);
-			// Handle subscribe/unsubscribe from client store
+			// Handle subscribe/unsubscribe from client store.
+			//
+			// `msg` is hoisted to outer scope so it can be forwarded to the
+			// user handler in the fall-through delegation below. When the
+			// prefix matched and JSON.parse produced an object that did NOT
+			// match any known control type, the parsed value reaches plugin-
+			// layer dispatchers (e.g. svelte-realtime's `onJsonMessage`)
+			// directly, so they don't re-run TextDecoder + JSON.parse on
+			// every frame. Mirrors handler.js + vite.js.
+			/** @type {any} */
+			let msg;
 			if (!isBinary && message.byteLength < 8192) {
 				const bytes = new Uint8Array(message);
 				if (bytes[3] === 0x79) {
 					try {
-						const msg = JSON.parse(Buffer.from(message).toString());
+						msg = JSON.parse(Buffer.from(message).toString());
+						// Reject null / primitives / arrays so `msg` only reaches
+						// the user handler as a {type,...} object envelope. Throw
+						// to the catch (which clears `msg`) for a unified fall-
+						// through path with parse failures.
+						if (msg === null || typeof msg !== 'object' || Array.isArray(msg)) throw 0;
 						if (msg.type === 'subscribe' && typeof msg.topic === 'string') {
 							const ref = hasRefT(msg.ref) ? msg.ref : null;
 							if (!isValidWireTopic(msg.topic, ALLOW_NON_ASCII_TOPICS_T)) {
@@ -702,7 +717,13 @@ export async function createTestServer(options = {}) {
 							sendOutboundT(ws, '{"type":"resumed"}');
 							return;
 						}
-					} catch {}
+					} catch {
+						// Not JSON, not an object envelope, or a known control
+						// type that threw inside its handler. Clear `msg` so the
+						// fall-through delegation sees `msg: undefined` (raw
+						// bytes only).
+						msg = undefined;
+					}
 				}
 			}
 
@@ -712,7 +733,9 @@ export async function createTestServer(options = {}) {
 			}
 			messageWaiters = [];
 
-			handler.message?.(ws, { data: message, isBinary, platform: ws.getUserData()[WS_PLATFORM] });
+			// `msg` is the JSON-parsed envelope when the prefix matched + parsed
+			// to an object + no control type matched; otherwise undefined.
+			handler.message?.(ws, { data: message, isBinary, msg, platform: ws.getUserData()[WS_PLATFORM] });
 		},
 
 		close(ws, code, message) {

package/vite.js

@@ -1003,9 +1003,24 @@ export default function uws(options = {}) {
 				// {"topic" have byte[3]='o' - skip JSON.parse for non-control messages.
 				// 8192 bytes matches the production handler ceiling and is large
 				// enough for a subscribe-batch with many topics.
+				//
+				// `msg` is hoisted to outer scope so it can be forwarded to the
+				// user handler in the fall-through delegation below. When the
+				// prefix matched and JSON.parse produced an object that did NOT
+				// match any known control type, the parsed value reaches plugin-
+				// layer dispatchers (e.g. svelte-realtime's `onJsonMessage`)
+				// directly, so they don't re-run TextDecoder + JSON.parse on
+				// every frame.
+					/** @type {any} */
+					let msg;
 					if (!isBinary && buf.byteLength < 8192 && buf[3] === 0x79) {
 						try {
-							const msg = JSON.parse(buf.toString());
+							msg = JSON.parse(buf.toString());
+							// Reject null / primitives / arrays so `msg` only reaches
+							// the user handler as a {type,...} object envelope. Throw
+							// to the catch (which clears `msg`) for a unified fall-
+							// through path with parse failures.
+							if (msg === null || typeof msg !== 'object' || Array.isArray(msg)) throw 0;
 							if (msg.type === 'subscribe' && typeof msg.topic === 'string') {
 								const ref = hasRefValue(msg.ref) ? msg.ref : null;
 								if (!isValidWireTopic(msg.topic, ALLOW_NON_ASCII_TOPICS_V)) {
@@ -1149,14 +1164,20 @@ export default function uws(options = {}) {
 								return;
 							}
 						} catch {
-							// Not JSON - fall through to user handler
+							// Not JSON, not an object envelope, or a known control
+							// type that threw inside its handler. Clear `msg` so the
+							// fall-through delegation sees `msg: undefined` (raw
+							// bytes only).
+							msg = undefined;
 						}
 					}
 
-					// Delegate to user handler
+					// Delegate to user handler. `msg` is the JSON-parsed envelope
+					// when the prefix matched + parsed to an object + no control
+					// type matched; otherwise undefined.
 					await handlerReady;
 					if (userHandlers.message) {
-						userHandlers.message(wrapped, { data: arrayBuffer, isBinary: !!isBinary, platform: wrapped.getUserData()[WS_PLATFORM] });
+						userHandlers.message(wrapped, { data: arrayBuffer, isBinary: !!isBinary, msg, platform: wrapped.getUserData()[WS_PLATFORM] });
 					}
 				});