@kbve/droid 0.0.6 → 0.1.1

package/src/lib/gateway/strategies/WebWorkerStrategy.ts

@@ -0,0 +1,278 @@
+// Strategy for browsers without SharedWorker (Android, Safari)
+
+import type {
+	BroadcastEvent,
+	ISupabaseStrategy,
+	SelectOptions,
+	SessionResponse,
+	WebSocketStatus,
+} from '../types';
+import { WorkerPool } from '../WorkerPool';
+import { getWorkerCommunication } from '../WorkerCommunication';
+
+/**
+ * WebWorkerStrategy: Uses dedicated WebSocket worker + DB Worker Pool
+ *
+ * Architecture:
+ * - Dedicated WebSocket worker handles WebSocket, auth, and realtime (no cross-tab)
+ * - Worker pool (3 workers) handles database operations (parallel execution)
+ * - BroadcastChannel connects WebSocket worker to worker pool
+ *
+ * Best for: Android, Safari, browsers without SharedWorker
+ */
+export class WebWorkerStrategy implements ISupabaseStrategy {
+	private wsWorker?: Worker;
+	private workerPool?: WorkerPool;
+	private pending = new Map<
+		string,
+		{
+			resolve: (value: unknown) => void;
+			reject: (reason?: unknown) => void;
+		}
+	>();
+	private listeners = new Map<string, Set<(p: unknown) => void>>();
+	private comm = getWorkerCommunication();
+	private wsWorkerUrl: string | URL;
+	private dbWorkerUrl: string | URL;
+	private poolSize: number;
+
+	constructor(
+		wsWorkerUrl: string | URL,
+		dbWorkerUrl: string | URL,
+		poolSize = 3,
+	) {
+		this.wsWorkerUrl = wsWorkerUrl;
+		this.dbWorkerUrl = dbWorkerUrl;
+		this.poolSize = poolSize;
+
+		if (typeof window === 'undefined') return;
+		if (!('Worker' in window)) {
+			throw new Error('Worker not supported');
+		}
+	}
+
+	async init(
+		url: string,
+		anonKey: string,
+		options?: Record<string, unknown>,
+	): Promise<SessionResponse> {
+		console.log('[WebWorkerStrategy] Initializing...');
+
+		this.wsWorker = new Worker(this.wsWorkerUrl, {
+			type: 'module',
+			name: 'websocket-worker',
+		});
+		this.wsWorker.onmessage = (e) => this.onMessage(e.data);
+		this.wsWorker.onerror = (err) =>
+			console.error('[WebWorkerStrategy] WebSocket worker error:', err);
+
+		this.workerPool = new WorkerPool({
+			size: this.poolSize,
+			workerUrl: this.dbWorkerUrl,
+		});
+		await this.workerPool.init();
+
+		const wsWorkerInit = this.send<SessionResponse>('init', {
+			url,
+			anonKey,
+			options,
+		});
+
+		const poolInitPromises = Array.from({ length: this.poolSize }, () =>
+			this.workerPool?.send('init', { url, anonKey, options }),
+		);
+
+		await Promise.all([wsWorkerInit, ...poolInitPromises]);
+
+		console.log(
+			`[WebWorkerStrategy] Initialized (WebSocket worker + ${this.poolSize} DB workers)`,
+		);
+
+		return wsWorkerInit;
+	}
+
+	private onMessage(msg: unknown) {
+		const message = msg as
+			| (BroadcastEvent & {
+					id?: string;
+					ok?: boolean;
+					data?: unknown;
+					error?: string;
+					key?: string;
+			  })
+			| null
+			| undefined;
+		if (message?.type === 'ready' || message?.type === 'auth') {
+			this.emit(message.type, message);
+			return;
+		}
+		if (message?.type === 'realtime' && message.key) {
+			this.emit(`realtime:${message.key}`, message.payload);
+			return;
+		}
+		if (message?.type === 'ws.message') {
+			this.emit('ws.message', message.data);
+			return;
+		}
+		if (message?.type === 'ws.status') {
+			this.emit('ws.status', message);
+			return;
+		}
+
+		const id = message?.id;
+		const ok = message?.ok;
+		const data = message?.data;
+		const error = message?.error;
+		if (id && this.pending.has(id)) {
+			const pending = this.pending.get(id);
+			if (!pending) return;
+			const { resolve, reject } = pending;
+			this.pending.delete(id);
+			ok ? resolve(data) : reject(new Error(error));
+		}
+	}
+
+	private send<T>(type: string, payload?: unknown): Promise<T> {
+		const id = crypto.randomUUID();
+		return new Promise<T>((resolve, reject) => {
+			if (!this.wsWorker)
+				return reject(new Error('WebSocket worker unavailable'));
+			this.pending.set(id, {
+				resolve: resolve as (value: unknown) => void,
+				reject,
+			});
+			this.wsWorker.postMessage({ id, type, payload });
+		});
+	}
+
+	on(event: string, callback: (payload: unknown) => void): () => void {
+		if (!this.listeners.has(event)) {
+			this.listeners.set(event, new Set());
+		}
+		this.listeners.get(event)?.add(callback);
+
+		return () => {
+			const set = this.listeners.get(event);
+			if (set) {
+				set.delete(callback);
+				if (set.size === 0) this.listeners.delete(event);
+			}
+		};
+	}
+
+	private emit(event: string, payload: unknown) {
+		this.listeners.get(event)?.forEach((cb) => cb(payload));
+	}
+
+	// Auth (via WebSocket worker)
+	getSession(): Promise<SessionResponse> {
+		return this.send<SessionResponse>('getSession');
+	}
+
+	signInWithPassword(
+		email: string,
+		password: string,
+	): Promise<SessionResponse> {
+		return this.send<SessionResponse>('signInWithPassword', {
+			email,
+			password,
+		});
+	}
+
+	signOut(): Promise<void> {
+		return this.send('signOut');
+	}
+
+	// Database (via worker pool)
+	select(table: string, opts?: SelectOptions): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.select', { table, ...(opts ?? {}) });
+	}
+
+	insert(
+		table: string,
+		data: Record<string, unknown> | Record<string, unknown>[],
+	): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.insert', { table, data });
+	}
+
+	update(
+		table: string,
+		data: Record<string, unknown>,
+		match: Record<string, unknown>,
+	): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.update', { table, data, match });
+	}
+
+	upsert(
+		table: string,
+		data: Record<string, unknown> | Record<string, unknown>[],
+	): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.upsert', { table, data });
+	}
+
+	delete(table: string, match: Record<string, unknown>): Promise<unknown[]> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('from.delete', { table, match });
+	}
+
+	rpc(fn: string, args?: Record<string, unknown>): Promise<unknown> {
+		if (!this.workerPool) throw new Error('Worker pool not initialized');
+		return this.workerPool.send('rpc', { fn, args });
+	}
+
+	// Realtime (via WebSocket worker)
+	subscribePostgres(
+		key: string,
+		params: Record<string, unknown>,
+		callback: (payload: unknown) => void,
+	): () => void {
+		const off = this.on(`realtime:${key}`, callback);
+		this.send('realtime.subscribe', { key, params }).catch((e) => {
+			off();
+			console.error(e);
+		});
+		return () => {
+			off();
+			this.send('realtime.unsubscribe', { key }).catch(() => {
+				/* best-effort */
+			});
+		};
+	}
+
+	// WebSocket (via dedicated worker)
+	connectWebSocket(wsUrl?: string): Promise<WebSocketStatus> {
+		return this.send<WebSocketStatus>('ws.connect', { wsUrl });
+	}
+
+	disconnectWebSocket(): Promise<void> {
+		return this.send('ws.disconnect');
+	}
+
+	sendWebSocketMessage(data: unknown): Promise<void> {
+		return this.send('ws.send', { data });
+	}
+
+	getWebSocketStatus(): Promise<WebSocketStatus> {
+		return this.send<WebSocketStatus>('ws.status');
+	}
+
+	onWebSocketMessage(callback: (message: unknown) => void): () => void {
+		return this.on('ws.message', callback);
+	}
+
+	onWebSocketStatus(callback: (status: WebSocketStatus) => void): () => void {
+		return this.on('ws.status', callback as (payload: unknown) => void);
+	}
+
+	terminate() {
+		this.wsWorker?.terminate();
+		this.workerPool?.terminate();
+		this.comm.close();
+		this.listeners.clear();
+		this.pending.clear();
+	}
+}

package/src/lib/gateway/types.ts

@@ -0,0 +1,112 @@
+// Shared types for all gateway strategies
+
+export interface SupabaseConfig {
+  url: string;
+  anonKey: string;
+  options?: Record<string, unknown>;
+}
+
+export interface Session {
+  access_token: string;
+  refresh_token: string;
+  user: Record<string, unknown>;
+  expires_at?: number;
+}
+
+export interface SessionResponse {
+  session: Session | null;
+  user?: Record<string, unknown>;
+}
+
+export interface WebSocketStatus {
+  status: 'connected' | 'disconnected' | 'connecting' | 'error';
+  readyState: number | null;
+  error?: string;
+}
+
+// Unified API that all strategies must implement
+export interface ISupabaseStrategy {
+  // Lifecycle
+  init(url: string, anonKey: string, options?: Record<string, unknown>): Promise<SessionResponse>;
+
+  // Event handling
+  on(event: string, callback: (payload: unknown) => void): () => void;
+
+  // Auth
+  getSession(): Promise<SessionResponse>;
+  signInWithPassword(email: string, password: string): Promise<SessionResponse>;
+  signOut(): Promise<void>;
+
+  // Database
+  select(table: string, opts?: SelectOptions): Promise<unknown[]>;
+  insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<unknown[]>;
+  update(table: string, data: Record<string, unknown>, match: Record<string, unknown>): Promise<unknown[]>;
+  upsert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<unknown[]>;
+  delete(table: string, match: Record<string, unknown>): Promise<unknown[]>;
+  rpc(fn: string, args?: Record<string, unknown>): Promise<unknown>;
+
+  // Realtime
+  subscribePostgres(key: string, params: Record<string, unknown>, callback: (payload: unknown) => void): () => void;
+
+  // WebSocket
+  connectWebSocket(wsUrl?: string): Promise<WebSocketStatus>;
+  disconnectWebSocket(): Promise<void>;
+  sendWebSocketMessage(data: unknown): Promise<void>;
+  getWebSocketStatus(): Promise<WebSocketStatus>;
+  onWebSocketMessage(callback: (message: unknown) => void): () => void;
+  onWebSocketStatus(callback: (status: WebSocketStatus) => void): () => void;
+
+  // Cleanup
+  terminate(): void;
+}
+
+export interface SelectOptions {
+  columns?: string;
+  match?: Record<string, unknown>;
+  limit?: number;
+}
+
+// Worker communication messages
+export interface WorkerMessage {
+  id: string;
+  type: string;
+  payload?: unknown;
+}
+
+export interface WorkerResponse {
+  id: string;
+  ok: boolean;
+  data?: unknown;
+  error?: string;
+}
+
+// BroadcastChannel event types
+export interface BroadcastEvent {
+  type: 'auth' | 'ws.message' | 'ws.status' | 'realtime' | 'ready';
+  data?: unknown;
+  key?: string;
+  payload?: unknown;
+}
+
+// Strategy types
+export type StrategyType = 'shared-worker' | 'web-worker' | 'direct';
+
+// Browser capabilities
+export interface BrowserCapabilities {
+  hasSharedWorker: boolean;
+  hasWorker: boolean;
+  hasBroadcastChannel: boolean;
+  isAndroid: boolean;
+  isSafari: boolean;
+}
+
+// Gateway configuration
+export interface GatewayConfig {
+  workerUrls?: {
+    sharedWorker?: string | URL;
+    dbWorker?: string | URL;
+    webSocketWorker?: string | URL;
+  };
+  forceStrategy?: StrategyType;
+  poolSize?: number;
+}

package/src/lib/mod/mod-manager.ts

@@ -1,11 +1,16 @@
-import { wrap, proxy  } from 'comlink';
-import type { Remote } from 'comlink';
-import type { ModManager, ModHandle, ModMeta, BaseModAPI } from '../types/modules';
-import type { KBVEGlobal } from '../../types'; 
+import { wrap } from 'comlink';
+import type {
+	ModManager,
+	ModHandle,
+	ModMeta,
+	BaseModAPI,
+} from '../types/modules';
 
 let _modManager: ModManager | null = null;
 
-export async function getModManager(modWorkerResolver?: (url: string) => string): Promise<ModManager> {
+export async function getModManager(
+	modWorkerResolver?: (url: string) => string,
+): Promise<ModManager> {
 	if (_modManager) return _modManager;
 
 	const registry: Record<string, ModHandle> = {};
@@ -15,7 +20,7 @@ export async function getModManager(modWorkerResolver?: (url: string) => string)
 		const worker = new Worker(resolvedURL, { type: 'module' });
 		const instance = wrap<BaseModAPI>(worker);
 
-		const meta: ModMeta = await instance.getMeta?.() ?? {
+		const meta: ModMeta = (await instance.getMeta?.()) ?? {
 			name: 'unknown',
 			version: '0.0.1',
 		};
@@ -51,7 +56,7 @@ export async function getModManager(modWorkerResolver?: (url: string) => string)
 	}
 
 	function list() {
-		return Object.values(registry).map(m => m.meta);
+		return Object.values(registry).map((m) => m.meta);
 	}
 
 	async function reload(id: string): Promise<ModHandle> {
@@ -70,4 +75,4 @@ export async function getModManager(modWorkerResolver?: (url: string) => string)
 	};
 
 	return _modManager;
-}
+}

package/src/lib/mod/module/bento/mod-bento.worker.ts

@@ -8,7 +8,7 @@ import {
 	BENTO_VARIANT_CLASS_MAP,
 } from '../../../types/bento';
 
-let emitToMain: ((msg: any) => void) | undefined;
+let emitToMain: ((msg: unknown) => void) | undefined;
 
 function createVNodeFromTile(tile: BentoTile): VirtualNode {
 	const variant = tile.variant ?? 'default';

package/src/lib/mod/module/supabase/mod-supabase.spec.ts

@@ -1,30 +1,26 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import { droid } from '../../../droid';
-import type { Remote } from 'comlink';
-import type { ModHandle, SupabaseModAPI  } from '../../../types/modules';
+import { describe, it, expect } from 'vitest';
+import { mod } from './mod-supabase';
 
-console.log('[spec] Starting mod-supabase test file...');
-
-
-let mod: Remote<SupabaseModAPI>;
-let meta: { name: string; version: string };
 describe('mod-supabase', () => {
-	it('should have meta info', async () => {
-		await droid();
-		if (!window.kbve?.mod) {
-			throw new Error('Mod manager not available');
-		}
+	it('should have meta info', () => {
+		const meta = mod.getMeta();
 
-		console.log('[test] Loading Supabase mod...');
-		const modURL = new URL('./mod-supabase.worker.ts', import.meta.url);
-        console.log('Resolved worker URL:', modURL.href);
+		expect(meta.name).toBe('supabase');
+		expect(meta.version).toBe('1.0.0');
+		expect(meta.description).toBeDefined();
+		expect(meta.author).toBe('kbve');
+	});
 
-		const handle = await window.kbve.mod.load(modURL.href);
-		const mod: Remote<SupabaseModAPI> = handle.instance;
-		const meta = handle.meta;
+	it('should accept init context', () => {
+		mod.init({ test: true });
+		// init stores context internally — no throw = success
+	});
 
-		console.log('[test] Supabase mod loaded:', meta);
-		expect(meta.name).toBe('supabase');
-		expect(meta.version).toBeDefined();
-	}, 30_000);
-});
+	it('should reject queries before configure', async () => {
+		await expect(mod.queryTestTable()).rejects.toThrow('Supabase not configured');
+	});
+
+	it('should reject inserts before configure', async () => {
+		await expect(mod.insertTest({ foo: 'bar' })).rejects.toThrow('Supabase not configured');
+	});
+});

package/src/lib/mod/module/supabase/mod-supabase.ts

@@ -0,0 +1,68 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { ModInitContext } from '../../../types/modules';
+
+let supabase: SupabaseClient | null = null;
+let initialized = false;
+
+const state = {
+	ctx: null as ModInitContext | null,
+	url: '',
+	key: '',
+};
+
+export const mod = {
+	getMeta: () => ({
+		name: 'supabase',
+		version: '1.0.0',
+		description: 'Supabase mod for async DB access',
+		author: 'kbve',
+	}),
+
+	init(ctx: ModInitContext) {
+		state.ctx = ctx;
+	},
+
+	async loadSupabaseClient() {
+		try {
+			const supabaseModule = await import(
+				'https://cdn.jsdelivr.net/npm/@supabase/supabase-js/+esm'
+			);
+			console.log('[mod-supabase] Supabase module loaded');
+			return supabaseModule.createClient;
+		} catch (err) {
+			console.error('[mod-supabase] Failed to load Supabase:', err);
+			throw err;
+		}
+	},
+
+	async configure(url: string, key: string) {
+		if (!initialized) {
+			const createClient = await this.loadSupabaseClient();
+			supabase = createClient(url, key);
+			state.url = url;
+			state.key = key;
+			initialized = true;
+		}
+	},
+
+	async queryTestTable() {
+		if (!supabase)
+			throw new Error(
+				'Supabase not configured. Call `configure()` first.',
+			);
+		const { data, error } = await supabase.from('test').select('*');
+		return { data, error };
+	},
+
+	async insertTest(payload: Record<string, unknown>) {
+		if (!supabase)
+			throw new Error(
+				'Supabase not configured. Call `configure()` first.',
+			);
+		const { data, error } = await supabase
+			.from('test')
+			.insert(payload)
+			.select();
+		return { data, error };
+	},
+};

package/src/lib/mod/module/supabase/mod-supabase.worker.ts

@@ -1,59 +1,4 @@
 import { expose } from 'comlink';
-import type { SupabaseClient } from '@supabase/supabase-js';
-
-let supabase: SupabaseClient | null = null;
-let initialized = false;
-
-const state = {
-	ctx: null as any,
-	url: '',
-	key: '',
-};
-
-const mod = {
-	getMeta: () => ({
-		name: 'supabase',
-		version: '1.0.0',
-		description: 'Supabase mod for async DB access',
-		author: 'kbve',
-	}),
-
-	init(ctx: any) {
-		state.ctx = ctx;
-	},
-
-	async loadSupabaseClient() {
-		try {
-			const supabaseModule = await import('https://cdn.jsdelivr.net/npm/@supabase/supabase-js/+esm');
-			console.log('[mod-supabase] Supabase module loaded');
-			return supabaseModule.createClient;
-		} catch (err) {
-			console.error('[mod-supabase] Failed to load Supabase:', err);
-			throw err;
-		}
-	},
-
-	async configure(url: string, key: string) {
-		if (!initialized) {
-			const createClient = await this.loadSupabaseClient();
-			supabase = createClient(url, key);
-			state.url = url;
-			state.key = key;
-			initialized = true;
-		}
-	},
-
-	async queryTestTable() {
-		if (!supabase) throw new Error('Supabase not configured. Call `configure()` first.');
-		const { data, error } = await supabase.from('test').select('*');
-		return { data, error };
-	},
-
-	async insertTest(payload: Record<string, any>) {
-		if (!supabase) throw new Error('Supabase not configured. Call `configure()` first.');
-		const { data, error } = await supabase.from('test').insert(payload).select();
-		return { data, error };
-	}
-};
+import { mod } from './mod-supabase';
 
 expose(mod);

package/src/lib/state/auth.spec.ts

@@ -0,0 +1,58 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { $auth, setAuth, resetAuth } from './auth';
+
+beforeEach(() => {
+	resetAuth();
+	// resetAuth sets tone to 'anon', restore to default 'loading' for clean tests
+	$auth.set({
+		tone: 'loading',
+		name: '',
+		avatar: undefined,
+		id: '',
+		error: undefined,
+	});
+});
+
+describe('Auth state', () => {
+	it('starts with loading tone', () => {
+		expect($auth.get().tone).toBe('loading');
+	});
+
+	it('setAuth merges partial state', () => {
+		setAuth({ tone: 'auth', name: 'Alice', id: 'u1' });
+
+		const state = $auth.get();
+		expect(state.tone).toBe('auth');
+		expect(state.name).toBe('Alice');
+		expect(state.id).toBe('u1');
+		expect(state.avatar).toBeUndefined();
+	});
+
+	it('setAuth preserves existing fields', () => {
+		setAuth({ tone: 'auth', name: 'Alice', id: 'u1' });
+		setAuth({ avatar: 'https://example.com/avatar.png' });
+
+		const state = $auth.get();
+		expect(state.name).toBe('Alice');
+		expect(state.avatar).toBe('https://example.com/avatar.png');
+	});
+
+	it('setAuth can set error state', () => {
+		setAuth({ tone: 'error', error: 'Token expired' });
+
+		expect($auth.get().tone).toBe('error');
+		expect($auth.get().error).toBe('Token expired');
+	});
+
+	it('resetAuth clears to anon defaults', () => {
+		setAuth({ tone: 'auth', name: 'Alice', id: 'u1', avatar: 'img.png' });
+		resetAuth();
+
+		const state = $auth.get();
+		expect(state.tone).toBe('anon');
+		expect(state.name).toBe('');
+		expect(state.id).toBe('');
+		expect(state.avatar).toBeUndefined();
+		expect(state.error).toBeUndefined();
+	});
+});