@kbve/droid 0.1.1 → 0.1.2

package/src/lib/types/event-types.ts

@@ -43,6 +43,72 @@ export const DroidUpscaleSchema = z.object({
 	level: z.string(),
 });
 
+export const AuthReadySchema = z.object({
+	timestamp: z.number(),
+	tone: z.enum(['auth', 'anon']),
+	name: z.string().optional(),
+});
+
+export const AuthErrorSchema = z.object({
+	timestamp: z.number(),
+	message: z.string(),
+});
+
+export const WorkerErrorSchema = z.object({
+	timestamp: z.number(),
+	worker: z.enum(['shared', 'db', 'ws']),
+	operation: z.string(),
+	message: z.string(),
+});
+
+export const GatewayStrategyFallbackSchema = z.object({
+	timestamp: z.number(),
+	from: z.enum(['shared-worker', 'web-worker', 'direct']),
+	to: z.enum(['shared-worker', 'web-worker', 'direct']),
+	reason: z.string(),
+});
+
+// Page lifecycle — emitted by @kbve/astro's onMount/onSwap helpers so any
+// module on the bus (mods, plugins, vanilla driver) can react to navigation
+// without knowing whether the host is using ClientRouter, native cross-doc
+// view transitions, full reloads, or bfcache restores.
+export const PageLifecycleSchema = z.object({
+	timestamp: z.number(),
+	url: z.string(),
+	source: z.enum(['initial', 'astro-swap', 'page-reveal', 'bfcache']),
+});
+
+export const PalworldLiveSnapshotSchema = z.object({
+	ts: z.number(),
+	offline: z.boolean(),
+	players: z.array(
+		z.object({
+			name: z.string(),
+			level: z.number(),
+			x: z.number(),
+			y: z.number(),
+		}),
+	),
+	bosses: z.array(
+		z.object({
+			id: z.string(),
+			x: z.number(),
+			y: z.number(),
+			defeated_at: z.number(),
+			respawn_at: z.number(),
+		}),
+	),
+	events: z.array(
+		z.object({
+			kind: z.string(),
+			class: z.string(),
+			x: z.number(),
+			y: z.number(),
+			first_seen: z.number(),
+		}),
+	),
+});
+
 export const DroidEventSchemas = {
 	'droid-first-connect': DroidFirstConnectSchema,
 	'droid-ready': DroidReadySchema,
@@ -57,6 +123,14 @@ export const DroidEventSchemas = {
 	'tooltip-closed': TooltipPayloadSchema.pick({ id: true }),
 	'modal-opened': ModalPayloadSchema,
 	'modal-closed': ModalPayloadSchema.pick({ id: true }),
+	'auth-ready': AuthReadySchema,
+	'auth-error': AuthErrorSchema,
+	'worker-error': WorkerErrorSchema,
+	'gateway-strategy-fallback': GatewayStrategyFallbackSchema,
+	'page-mount': PageLifecycleSchema,
+	'page-swap': PageLifecycleSchema,
+	'page-hide': PageLifecycleSchema,
+	'palworld-live-snapshot': PalworldLiveSnapshotSchema,
 };
 
 export type DroidEventMap = {

package/src/lib/workers/data.ts

@@ -1,4 +1,8 @@
-import { PayloadFormat, JediEnvelopeFlex, MessageKind } from '../types/jedi';
+import {
+	PayloadFormat,
+	type JediEnvelopeFlex,
+	MessageKind,
+} from '../types/jedi';
 import { builder, toReference } from './flexbuilder';
 
 function buildFlexPayload<T extends Record<string, unknown>>(

package/src/lib/workers/db-worker.ts

@@ -1,7 +1,6 @@
 import { expose } from 'comlink';
 import Dexie, { type Table } from 'dexie';
 import type { DiscordServer, DiscordTag, Profile } from '../types/discord';
-import { toReference } from './flexbuilder';
 
 interface SharedWorkerGlobalScope extends Worker {
 	onconnect: (event: MessageEvent) => void;
@@ -16,7 +15,10 @@ class AppDexie extends Dexie {
 	servers!: Table<DiscordServer>;
 	tags!: Table<DiscordTag>;
 	profiles!: Table<Profile>;
-	ws_messages!: Table<{ key: string; message: Record<string, unknown> }>;
+	ws_messages!: Table<{
+		key: string;
+		message: Uint8Array | Record<string, unknown>;
+	}>;
 	auth_tokens!: Table<{ key: string; value: string; expires_at?: number }>;
 
 	constructor() {
@@ -36,6 +38,29 @@ class AppDexie extends Dexie {
 }
 const db = new AppDexie();
 
+// --- ws-worker → db-worker direct pipeline ---
+// Listen for WebSocket messages from the ws-worker via BroadcastChannel.
+// This keeps the main thread out of the data storage path entirely.
+if (typeof BroadcastChannel !== 'undefined') {
+	const wsChannel = new BroadcastChannel('kbve_ws_data');
+	wsChannel.onmessage = (e: MessageEvent) => {
+		const msg = e.data;
+		if (msg?.type !== 'ws.store') return;
+
+		const key = `ws:${msg.ts ?? Date.now()}`;
+		const message =
+			msg.format === 'text'
+				? new TextEncoder().encode(msg.data)
+				: msg.data instanceof Uint8Array
+					? msg.data
+					: new Uint8Array(msg.data ?? []);
+
+		db.ws_messages.put({ key, message }).catch((err) => {
+			console.error('[DB] Failed to store ws message:', err);
+		});
+	};
+}
+
 function renderHtmlForServer(server: DiscordServer): string {
 	return `
 		<div class="flex flex-col gap-2 p-2">
@@ -52,11 +77,12 @@ const storageAPI = {
 	// WebSocket
 
 	async storeWsMessage(key: string, buffer: ArrayBuffer) {
-		const decoded = toReference(buffer).toObject() as Record<
-			string,
-			unknown
-		>;
-		await db.ws_messages.put({ key, message: decoded });
+		// Store raw bytes — format-agnostic so the ws-worker can carry
+		// any protocol (IRC text, FlatBuffers, Protobuf, etc.).
+		// Uint8Array is natively supported by IndexedDB and safe for
+		// Dexie's BroadcastChannel multi-tab sync (no DataCloneError).
+		// Consumers decode on read using the appropriate deserializer.
+		await db.ws_messages.put({ key, message: new Uint8Array(buffer) });
 	},
 
 	async getWsMessage(key: string) {
@@ -64,7 +90,7 @@ const storageAPI = {
 	},
 
 	async getAllWsMessages(): Promise<
-		{ key: string; message: Record<string, unknown> }[]
+		{ key: string; message: Uint8Array | Record<string, unknown> }[]
 	> {
 		const raw = await db.ws_messages.toArray();
 		return raw.sort((a, b) => {

package/src/lib/workers/main.ts

@@ -1,4 +1,4 @@
-import { wrap, proxy } from 'comlink';
+import { wrap } from 'comlink';
 import type { Remote } from 'comlink';
 import { persistentMap } from '@nanostores/persistent';
 import type { LocalStorageAPI } from './db-worker';
@@ -582,22 +582,6 @@ function initSWComlink() {
 	channel.port1.start();
 }
 
-// --- Bridge ---
-export function bridgeWsToDb(
-	ws: Remote<WSInstance>,
-	db: Remote<LocalStorageAPI>,
-) {
-	const handler = proxy(async (data: string | ArrayBuffer) => {
-		if (typeof data === 'string') return;
-		dispatchAsync(() => {
-			const key = `ws:${Date.now()}`;
-			void db.storeWsMessage(key, data);
-		});
-	});
-
-	ws.onMessage(handler);
-}
-
 // --- MAIN ---
 export async function main(opts?: {
 	workerURLs?: Record<string, string>;
@@ -694,7 +678,8 @@ export async function main(opts?: {
 					});
 				}
 
-				bridgeWsToDb(ws, api);
+				// ws-worker → db-worker storage now happens directly via
+				// BroadcastChannel ('kbve_ws_data'), no main-thread bridge needed.
 
 				const data = scopeData;
 				i18n.api = api;

package/src/lib/workers/supabase-db-worker.ts

@@ -85,7 +85,17 @@ const memoryStorage = {
 
 console.log('[DB Worker] Initializing...');
 
+// Dedicated workers receive `event.origin === ''` from their owning page;
+// reject anything else to satisfy CodeQL js/missing-origin-check.
+function isAllowedOrigin(event: MessageEvent): boolean {
+	return event.origin === '' || event.origin === self.location.origin;
+}
+
 self.onmessage = async (e: MessageEvent<WorkerMessage>) => {
+	if (!isAllowedOrigin(e)) {
+		console.warn('[DB Worker] Rejected message from origin:', e.origin);
+		return;
+	}
 	const msg = e.data;
 	const { id, type, payload } = msg;
 
@@ -109,8 +119,12 @@ self.onmessage = async (e: MessageEvent<WorkerMessage>) => {
 						...authOverrides,
 						storage: memoryStorage,
 						storageKey: 'sb-auth-token',
-						autoRefreshToken: true,
-						persistSession: true,
+						// DB pool workers are stateless (memoryStorage) — token
+						// refresh is handled by the SharedWorker which owns the
+						// IDB-backed session. Disabling here avoids SDK-internal
+						// callbacks that produce non-cloneable objects.
+						autoRefreshToken: false,
+						persistSession: false,
 						detectSessionInUrl: false,
 					},
 				});
@@ -215,7 +229,15 @@ function respond(
 	id: string,
 	response: { ok: true; data?: unknown } | { ok: false; error: string },
 ) {
-	self.postMessage({ id, ...response });
+	// JSON round-trip strips non-cloneable SDK internals (functions, circular
+	// refs) that would cause DataCloneError in postMessage.
+	let safe: typeof response;
+	try {
+		safe = JSON.parse(JSON.stringify(response));
+	} catch {
+		safe = { ok: false, error: 'Response contained non-serializable data' };
+	}
+	self.postMessage({ id, ...safe });
 }
 
 console.log('[DB Worker] Ready');

package/src/lib/workers/supabase-shared-worker.ts

@@ -97,13 +97,29 @@ type Res =
 
 const ports = new Set<MessagePort>();
 
+/** Emit a worker-error event via BroadcastChannel so the main thread can surface it. */
+function broadcastError(operation: string, err: unknown) {
+	const message = err instanceof Error ? err.message : String(err);
+	console.error(`[SharedWorker] ${operation}:`, message);
+	comm.broadcast({
+		type: 'worker-error',
+		data: {
+			timestamp: Date.now(),
+			worker: 'shared',
+			operation,
+			message,
+		},
+	});
+}
+
 /** Post to all connected ports, removing dead ones on failure */
 function safeBroadcast(msg: unknown) {
 	for (const p of ports) {
 		try {
 			p.postMessage(msg);
-		} catch {
+		} catch (err) {
 			ports.delete(p);
+			broadcastError('postMessage', err);
 		}
 	}
 }
@@ -234,14 +250,12 @@ async function connectWebSocket(wsUrl?: string) {
 			safeBroadcast({ type: 'ws.message', data: message });
 			comm.broadcast({ type: 'ws.message', data: message });
 		} catch (error) {
-			console.error(
-				'[SharedWorker] Failed to parse WebSocket message:',
-				error,
-			);
+			broadcastError('ws.onmessage', error);
 		}
 	};
 
 	ws.onerror = () => {
+		broadcastError('ws.connect', 'WebSocket connection error');
 		safeBroadcast({
 			type: 'ws.status',
 			status: 'error',
@@ -364,15 +378,35 @@ async function ensureClient(
 	});
 
 	client.auth.onAuthStateChange(async (_event, session) => {
-		safeBroadcast({ type: 'auth', session });
-		comm.broadcast({ type: 'auth', data: { session } });
+		// Supabase session objects may contain non-cloneable references
+		// (internal SDK callbacks, circular refs). JSON round-trip strips
+		// them so postMessage / BroadcastChannel.postMessage won't throw
+		// DataCloneError.
+		const safe = session ? JSON.parse(JSON.stringify(session)) : null;
+		safeBroadcast({ type: 'auth', session: safe });
+		comm.broadcast({ type: 'auth', data: { session: safe } });
 	});
 
 	return client;
 }
 
+/** JSON round-trip to strip non-cloneable refs (functions, circular) before postMessage. */
+function cloneSafe(obj: Res): Res {
+	try {
+		return JSON.parse(JSON.stringify(obj));
+	} catch {
+		// JSON.stringify failed (circular refs, BigInt, etc.)
+		// Return a safe error response instead of the non-cloneable original
+		return {
+			id: (obj as { id?: string }).id ?? 'unknown',
+			ok: false,
+			error: 'Response contained non-serializable data',
+		};
+	}
+}
+
 function reply(port: MessagePort, msg: Res) {
-	port.postMessage(msg);
+	port.postMessage(cloneSafe(msg));
 }
 
 (self as unknown as SharedWorkerGlobalScope).onconnect = (
@@ -559,6 +593,7 @@ function reply(port: MessagePort, msg: Res) {
 				}
 			}
 		} catch (err: unknown) {
+			broadcastError(m.type, err);
 			reply(port, {
 				id: m.id,
 				ok: false,

package/src/lib/workers/ws-worker.spec.ts

@@ -0,0 +1,41 @@
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import { reconnectDelayMs } from './ws-worker';
+
+afterEach(() => {
+	vi.restoreAllMocks();
+});
+
+describe('reconnectDelayMs', () => {
+	it('returns base delay on first attempt', () => {
+		vi.spyOn(Math, 'random').mockReturnValue(0);
+		expect(reconnectDelayMs(1)).toBe(1000);
+	});
+
+	it('doubles each attempt', () => {
+		vi.spyOn(Math, 'random').mockReturnValue(0);
+		expect(reconnectDelayMs(1)).toBe(1000);
+		expect(reconnectDelayMs(2)).toBe(2000);
+		expect(reconnectDelayMs(3)).toBe(4000);
+		expect(reconnectDelayMs(4)).toBe(8000);
+		expect(reconnectDelayMs(5)).toBe(16000);
+	});
+
+	it('caps at the 30s ceiling', () => {
+		vi.spyOn(Math, 'random').mockReturnValue(0);
+		expect(reconnectDelayMs(10)).toBe(30000);
+		expect(reconnectDelayMs(100)).toBe(30000);
+	});
+
+	it('adds jitter up to 500ms', () => {
+		vi.spyOn(Math, 'random').mockReturnValue(0.99999);
+		const delay = reconnectDelayMs(1);
+		expect(delay).toBeGreaterThanOrEqual(1000);
+		expect(delay).toBeLessThan(1500);
+	});
+
+	it('treats 0 and negative attempts as the first attempt', () => {
+		vi.spyOn(Math, 'random').mockReturnValue(0);
+		expect(reconnectDelayMs(0)).toBe(1000);
+		expect(reconnectDelayMs(-5)).toBe(1000);
+	});
+});

package/src/lib/workers/ws-worker.ts

@@ -6,8 +6,40 @@ interface SharedWorkerGlobalScope extends Worker {
 declare const self: SharedWorkerGlobalScope;
 
 let ws: WebSocket | null = null;
-let onMessageCallback: ((data: string | ArrayBuffer) => void) | null = null;
-let onStatusCallback: ((status: string) => void) | null = null;
+
+// ---------------------------------------------------------------------------
+// Transport channels
+//
+// `kbve_ws_data`   — raw WebSocket payloads for the db-worker to persist.
+//                    Payload: { type: 'ws.store', format, data, ts }
+//
+// `kbve_ws_events` — status + message events for UI consumers (chat service,
+//                    presence, overlays, etc.).
+//                    Payload:
+//                      { type: 'status',  status: string }
+//                      { type: 'message', format: 'text',   data: string }
+//                      { type: 'message', format: 'binary', data: Uint8Array }
+//
+// Keeping persistence and UI on separate channels means each consumer only
+// sees what it cares about, and a new subscriber (e.g. cross-tab presence)
+// drops in without filtering db-bound payloads.
+//
+// Historical note: an earlier design exposed onMessage(cb) / onStatus(cb)
+// through Comlink. That failed with DataCloneError because Comlink forwards
+// method args via postMessage, and functions are not structured-cloneable.
+// If a future strategy wants a different transport (SharedArrayBuffer,
+// MessagePort, proxied-Comlink callbacks), add it alongside — don't remove
+// the BroadcastChannel path, it's the fallback that works everywhere.
+// ---------------------------------------------------------------------------
+const dbChannel =
+	typeof BroadcastChannel !== 'undefined'
+		? new BroadcastChannel('kbve_ws_data')
+		: null;
+
+const eventsChannel =
+	typeof BroadcastChannel !== 'undefined'
+		? new BroadcastChannel('kbve_ws_events')
+		: null;
 
 // Heartbeat
 let heartbeatTimer: ReturnType<typeof setInterval> | null = null;
@@ -15,12 +47,22 @@ let lastPongTime = 0;
 const HEARTBEAT_INTERVAL_MS = 30000;
 const HEARTBEAT_TIMEOUT_MS = 60000;
 
-// Reconnect
 let reconnectTimer: ReturnType<typeof setTimeout> | null = null;
 let reconnectAttempts = 0;
 let lastUrl: string | null = null;
 const MAX_RECONNECT_ATTEMPTS = 5;
-const RECONNECT_DELAY_MS = 3000;
+const RECONNECT_BASE_MS = 1000;
+const RECONNECT_MAX_MS = 30000;
+const RECONNECT_JITTER_MS = 500;
+
+export function reconnectDelayMs(attempt: number): number {
+	const exp = Math.min(
+		RECONNECT_MAX_MS,
+		RECONNECT_BASE_MS * 2 ** Math.max(0, attempt - 1),
+	);
+	const jitter = Math.floor(Math.random() * RECONNECT_JITTER_MS);
+	return exp + jitter;
+}
 
 function startHeartbeat() {
 	stopHeartbeat();
@@ -53,8 +95,11 @@ function stopHeartbeat() {
 	}
 }
 
-function broadcastStatus(status: string) {
-	onStatusCallback?.(status);
+function broadcastStatus(
+	status: string,
+	detail?: { code?: number; reason?: string; wasClean?: boolean },
+) {
+	eventsChannel?.postMessage({ type: 'status', status, ...detail });
 }
 
 function attemptReconnect() {
@@ -69,17 +114,25 @@ function attemptReconnect() {
 	}
 
 	reconnectAttempts++;
+	const delay = reconnectDelayMs(reconnectAttempts);
 	console.log(
-		`[WS] Reconnecting (${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS})...`,
+		`[WS] Reconnecting (${reconnectAttempts}/${MAX_RECONNECT_ATTEMPTS}) in ${delay}ms...`,
 	);
 	broadcastStatus('reconnecting');
 
 	reconnectTimer = setTimeout(() => {
 		if (lastUrl) wsInstanceAPI.connect(lastUrl);
-	}, RECONNECT_DELAY_MS);
+	}, delay);
 }
 
-// --- WebSocket API ---
+// ---------------------------------------------------------------------------
+// WebSocket API exposed via Comlink
+//
+// Only commands that carry structured-cloneable data cross this bridge
+// (strings, typed arrays). Event subscription is deliberately NOT here —
+// it lives on the BroadcastChannel side to avoid DataCloneError when a
+// caller passes a raw function.
+// ---------------------------------------------------------------------------
 const wsInstanceAPI = {
 	async connect(url: string) {
 		if (ws && ws.readyState === WebSocket.OPEN) return;
@@ -92,11 +145,13 @@ const wsInstanceAPI = {
 		}
 
 		lastUrl = url;
+		const safeUrl = url.replace(/(token=)[^&]+/i, '$1<redacted>');
+		console.log('[WS] Connecting to', safeUrl);
 		ws = new WebSocket(url);
 		ws.binaryType = 'arraybuffer';
 
 		ws.onopen = () => {
-			console.log('[WS] Connected:', url);
+			console.log('[WS] Connected:', safeUrl);
 			reconnectAttempts = 0;
 			lastPongTime = Date.now();
 			startHeartbeat();
@@ -118,10 +173,43 @@ const wsInstanceAPI = {
 					}
 				}
 
-				if (e.data instanceof ArrayBuffer) {
-					onMessageCallback?.(e.data);
-				} else {
-					onMessageCallback?.(e.data);
+				// Fan out to db-worker (persistence pipeline).
+				// Structured-cloneable payloads only — strings and
+				// Uint8Array are both safe across BroadcastChannel.
+				if (dbChannel) {
+					if (typeof e.data === 'string') {
+						dbChannel.postMessage({
+							type: 'ws.store',
+							format: 'text',
+							data: e.data,
+							ts: Date.now(),
+						});
+					} else if (e.data instanceof ArrayBuffer) {
+						dbChannel.postMessage({
+							type: 'ws.store',
+							format: 'binary',
+							data: new Uint8Array(e.data),
+							ts: Date.now(),
+						});
+					}
+				}
+
+				// Fan out to UI consumers (chat service, presence, etc.).
+				// Same structured-cloneable constraint applies.
+				if (eventsChannel) {
+					if (typeof e.data === 'string') {
+						eventsChannel.postMessage({
+							type: 'message',
+							format: 'text',
+							data: e.data,
+						});
+					} else if (e.data instanceof ArrayBuffer) {
+						eventsChannel.postMessage({
+							type: 'message',
+							format: 'binary',
+							data: new Uint8Array(e.data),
+						});
+					}
 				}
 			} catch (err) {
 				console.error('[WS] Failed to forward message', err);
@@ -129,17 +217,24 @@ const wsInstanceAPI = {
 		};
 
 		ws.onerror = (e) => {
-			console.error('[WS] Error:', e);
-			broadcastStatus('error');
+			console.error('[WS] Error event:', e);
+			broadcastStatus('error', {
+				reason: 'WebSocket error event (no detail in browser API)',
+			});
 		};
 
 		ws.onclose = (event) => {
-			console.log('[WS] Disconnected:', event.code, event.reason);
+			console.log(
+				`[WS] Disconnected code=${event.code} reason="${event.reason}" wasClean=${event.wasClean}`,
+			);
 			ws = null;
 			stopHeartbeat();
-			broadcastStatus('disconnected');
+			broadcastStatus('disconnected', {
+				code: event.code,
+				reason: event.reason,
+				wasClean: event.wasClean,
+			});
 
-			// Auto-reconnect on abnormal closure
 			if (event.code !== 1000) {
 				attemptReconnect();
 			}
@@ -148,7 +243,13 @@ const wsInstanceAPI = {
 
 	async send(payload: Uint8Array) {
 		if (ws?.readyState === WebSocket.OPEN) {
-			ws.send(payload);
+			// Cast narrows Uint8Array<ArrayBufferLike> to BufferSource for
+			// WebSocket.send. Newer TS DOM lib parameterizes Uint8Array over
+			// ArrayBuffer | SharedArrayBuffer, but send() only accepts
+			// ArrayBuffer-backed views. Every caller here posts a freshly
+			// encoded payload (Uint8Array from TextEncoder or similar), so
+			// the backing buffer is always a plain ArrayBuffer.
+			ws.send(payload as BufferSource);
 		} else {
 			console.warn('[WS] Tried to send while disconnected');
 		}
@@ -167,14 +268,6 @@ const wsInstanceAPI = {
 		broadcastStatus('disconnected');
 	},
 
-	onMessage(callback: (data: string | ArrayBuffer) => void) {
-		onMessageCallback = callback;
-	},
-
-	onStatus(callback: (status: string) => void) {
-		onStatusCallback = callback;
-	},
-
 	async getStatus(): Promise<string> {
 		if (!ws) return 'disconnected';
 		const map: Record<number, string> = {

package/workers/main.js

@@ -1,12 +1,2 @@
-import "../comlink.js";
-import { a6 as o, K as r, L as i, a7 as l, a8 as c, a9 as m, aa as n, a5 as p } from "../main.js";
-export {
-  o as bridgeWsToDb,
-  r as downscale,
-  i as getScaleLevel,
-  l as i18n,
-  c as main,
-  m as resolveWorkerURL,
-  n as uiux,
-  p as upscale
-};
+import { a as e, i as t, n, o as r, r as i, s as a, t as o } from "../main.js";
+export { o as downscale, n as getScaleLevel, i as i18n, t as main, e as resolveWorkerURL, r as uiux, a as upscale };