@kbve/droid 0.1.1 → 0.1.2

package/src/lib/gateway/SupabaseGateway.ts

@@ -17,6 +17,8 @@ import {
 import { SharedWorkerStrategy } from './strategies/SharedWorkerStrategy';
 import { WebWorkerStrategy } from './strategies/WebWorkerStrategy';
 import { DirectStrategy } from './strategies/DirectStrategy';
+import { getWorkerCommunication } from './WorkerCommunication';
+import { DroidEvents } from '../workers/events';
 
 // Vite ?worker&url imports — bundles workers as JS and returns their URL
 import defaultSharedWorkerUrl from '../workers/supabase-shared-worker?worker&url';
@@ -72,6 +74,22 @@ export class SupabaseGateway implements ISupabaseStrategy {
 				this.strategy = new DirectStrategy();
 				break;
 		}
+
+		// Forward worker-error events from BroadcastChannel to DroidEvents
+		if (typeof window !== 'undefined') {
+			const comm = getWorkerCommunication();
+			comm.on('worker-error', (payload) => {
+				DroidEvents.emit(
+					'worker-error',
+					payload as {
+						timestamp: number;
+						worker: 'shared' | 'db' | 'ws';
+						operation: string;
+						message: string;
+					},
+				);
+			});
+		}
 	}
 
 	getStrategyType(): StrategyType {
@@ -84,12 +102,47 @@ export class SupabaseGateway implements ISupabaseStrategy {
 
 	// Delegate all methods to the selected strategy
 
-	init(
+	async init(
 		url: string,
 		anonKey: string,
 		options?: Record<string, unknown>,
 	): Promise<SessionResponse> {
-		return this.strategy.init(url, anonKey, options);
+		if (this.strategyType === 'direct') {
+			return this.strategy.init(url, anonKey, options);
+		}
+
+		const WORKER_INIT_FALLBACK_MS = 3500;
+		const primary = this.strategy.init(url, anonKey, options);
+
+		let timer: ReturnType<typeof setTimeout> | null = null;
+		const fallback = new Promise<never>((_, reject) => {
+			timer = setTimeout(
+				() => reject(new Error('worker init stalled')),
+				WORKER_INIT_FALLBACK_MS,
+			);
+		});
+
+		try {
+			const result = await Promise.race([primary, fallback]);
+			if (timer) clearTimeout(timer);
+			return result;
+		} catch (err) {
+			if (timer) clearTimeout(timer);
+			const previousType = this.strategyType;
+			console.warn(
+				`[SupabaseGateway] ${previousType} init did not respond in ${WORKER_INIT_FALLBACK_MS}ms — switching to direct strategy.`,
+				err,
+			);
+			this.strategy = new DirectStrategy();
+			this.strategyType = 'direct';
+			DroidEvents.emit('gateway-strategy-fallback', {
+				timestamp: Date.now(),
+				from: previousType,
+				to: 'direct',
+				reason: err instanceof Error ? err.message : String(err),
+			});
+			return this.strategy.init(url, anonKey, options);
+		}
 	}
 
 	on(event: string, callback: (payload: unknown) => void): () => void {

package/src/lib/gateway/WorkerCommunication.ts

@@ -58,7 +58,7 @@ export class WorkerCommunication {
 		if (type === 'realtime' && key) {
 			this.emit(`realtime:${key}`, event.payload);
 		} else {
-			this.emit(type, event);
+			this.emit(type, event.data ?? event);
 		}
 	}
 

package/src/lib/gateway/capabilities.spec.ts

@@ -0,0 +1,144 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import {
+	detectCapabilities,
+	getStrategyDescription,
+	logCapabilities,
+	selectStrategy,
+} from './capabilities';
+
+const realUA = navigator.userAgent;
+
+afterEach(() => {
+	Object.defineProperty(navigator, 'userAgent', {
+		value: realUA,
+		configurable: true,
+	});
+	vi.restoreAllMocks();
+});
+
+function setUA(ua: string) {
+	Object.defineProperty(navigator, 'userAgent', {
+		value: ua,
+		configurable: true,
+	});
+}
+
+describe('detectCapabilities', () => {
+	it('flags Safari when Safari is in UA but Chrome is not', () => {
+		setUA(
+			'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.0 Safari/605.1.15',
+		);
+		const caps = detectCapabilities();
+		expect(caps.isSafari).toBe(true);
+		expect(caps.isAndroid).toBe(false);
+	});
+
+	it('does not flag Safari for Chrome on macOS', () => {
+		setUA(
+			'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Safari/537.36',
+		);
+		const caps = detectCapabilities();
+		expect(caps.isSafari).toBe(false);
+	});
+
+	it('flags Android UA', () => {
+		setUA(
+			'Mozilla/5.0 (Linux; Android 14; Pixel 8) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/127.0.0.0 Mobile Safari/537.36',
+		);
+		const caps = detectCapabilities();
+		expect(caps.isAndroid).toBe(true);
+	});
+});
+
+describe('selectStrategy', () => {
+	it('picks shared-worker on capable desktop', () => {
+		expect(
+			selectStrategy({
+				hasSharedWorker: true,
+				hasWorker: true,
+				hasBroadcastChannel: true,
+				isAndroid: false,
+				isSafari: false,
+			}),
+		).toBe('shared-worker');
+	});
+
+	it('falls back to web-worker on Android even with SharedWorker support', () => {
+		expect(
+			selectStrategy({
+				hasSharedWorker: true,
+				hasWorker: true,
+				hasBroadcastChannel: true,
+				isAndroid: true,
+				isSafari: false,
+			}),
+		).toBe('web-worker');
+	});
+
+	it('falls back to web-worker without SharedWorker', () => {
+		expect(
+			selectStrategy({
+				hasSharedWorker: false,
+				hasWorker: true,
+				hasBroadcastChannel: true,
+				isAndroid: false,
+				isSafari: true,
+			}),
+		).toBe('web-worker');
+	});
+
+	it('falls back to direct without BroadcastChannel', () => {
+		expect(
+			selectStrategy({
+				hasSharedWorker: true,
+				hasWorker: true,
+				hasBroadcastChannel: false,
+				isAndroid: false,
+				isSafari: false,
+			}),
+		).toBe('direct');
+	});
+
+	it('returns direct when Worker is unavailable', () => {
+		expect(
+			selectStrategy({
+				hasSharedWorker: false,
+				hasWorker: false,
+				hasBroadcastChannel: false,
+				isAndroid: false,
+				isSafari: false,
+			}),
+		).toBe('direct');
+	});
+});
+
+describe('getStrategyDescription', () => {
+	it('returns a description for every strategy variant', () => {
+		expect(getStrategyDescription('shared-worker')).toMatch(/SharedWorker/);
+		expect(getStrategyDescription('web-worker')).toMatch(/WebSocket/);
+		expect(getStrategyDescription('direct')).toMatch(/Direct/);
+	});
+});
+
+describe('logCapabilities', () => {
+	it('writes a single console.log with the capability snapshot', () => {
+		const spy = vi
+			.spyOn(console, 'log')
+			.mockImplementation(() => undefined);
+		logCapabilities({
+			hasSharedWorker: true,
+			hasWorker: true,
+			hasBroadcastChannel: true,
+			isAndroid: false,
+			isSafari: false,
+		});
+		expect(spy).toHaveBeenCalledTimes(1);
+		const [, payload] = spy.mock.calls[0];
+		expect(payload).toMatchObject({
+			SharedWorker: 'yes',
+			Worker: 'yes',
+			BroadcastChannel: 'yes',
+			Platform: 'Desktop',
+		});
+	});
+});

package/src/lib/gateway/types.ts

@@ -1,91 +1,118 @@
 // Shared types for all gateway strategies
 
 export interface SupabaseConfig {
-  url: string;
-  anonKey: string;
-  options?: Record<string, unknown>;
+	url: string;
+	anonKey: string;
+	options?: Record<string, unknown>;
 }
 
 export interface Session {
-  access_token: string;
-  refresh_token: string;
-  user: Record<string, unknown>;
-  expires_at?: number;
+	access_token: string;
+	refresh_token: string;
+	user: Record<string, unknown>;
+	expires_at?: number;
 }
 
 export interface SessionResponse {
-  session: Session | null;
-  user?: Record<string, unknown>;
+	session: Session | null;
+	user?: Record<string, unknown>;
 }
 
 export interface WebSocketStatus {
-  status: 'connected' | 'disconnected' | 'connecting' | 'error';
-  readyState: number | null;
-  error?: string;
+	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;
+	// 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;
+	columns?: string;
+	match?: Record<string, unknown>;
+	limit?: number;
 }
 
 // Worker communication messages
 export interface WorkerMessage {
-  id: string;
-  type: string;
-  payload?: unknown;
+	id: string;
+	type: string;
+	payload?: unknown;
 }
 
 export interface WorkerResponse {
-  id: string;
-  ok: boolean;
-  data?: unknown;
-  error?: string;
+	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;
+	type:
+		| 'auth'
+		| 'ws.message'
+		| 'ws.status'
+		| 'realtime'
+		| 'ready'
+		| 'worker-error';
+	data?: unknown;
+	key?: string;
+	payload?: unknown;
 }
 
 // Strategy types
@@ -93,20 +120,20 @@ export type StrategyType = 'shared-worker' | 'web-worker' | 'direct';
 
 // Browser capabilities
 export interface BrowserCapabilities {
-  hasSharedWorker: boolean;
-  hasWorker: boolean;
-  hasBroadcastChannel: boolean;
-  isAndroid: boolean;
-  isSafari: boolean;
+	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;
+	workerUrls?: {
+		sharedWorker?: string | URL;
+		dbWorker?: string | URL;
+		webSocketWorker?: string | URL;
+	};
+	forceStrategy?: StrategyType;
+	poolSize?: number;
 }

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

@@ -24,9 +24,8 @@ export const mod = {
 
 	async loadSupabaseClient() {
 		try {
-			const supabaseModule = await import(
-				'https://cdn.jsdelivr.net/npm/@supabase/supabase-js/+esm'
-			);
+			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) {
@@ -45,7 +44,10 @@ export const mod = {
 		}
 	},
 
-	async queryTestTable() {
+	async queryTestTable(): Promise<{
+		data: unknown[] | null;
+		error: unknown;
+	}> {
 		if (!supabase)
 			throw new Error(
 				'Supabase not configured. Call `configure()` first.',
@@ -54,7 +56,10 @@ export const mod = {
 		return { data, error };
 	},
 
-	async insertTest(payload: Record<string, unknown>) {
+	async insertTest(payload: Record<string, unknown>): Promise<{
+		data: unknown[] | null;
+		error: unknown;
+	}> {
 		if (!supabase)
 			throw new Error(
 				'Supabase not configured. Call `configure()` first.',

package/src/lib/state/auth.ts

@@ -1,10 +1,44 @@
-import { map } from 'nanostores';
+import { map, computed } from 'nanostores';
 
 export type AuthTone = 'loading' | 'auth' | 'anon' | 'error';
 
+// ---------------------------------------------------------------------------
+// Bitwise auth flags — composable visibility for UI elements.
+//
+// A guest has:  PUBLIC | ANON       = 0b0011 (3)
+// A user has:   PUBLIC | AUTH       = 0b0101 (5)
+// Staff has:    PUBLIC | AUTH | STAFF = 0b1101 (13)
+//
+// To check: (userFlags & requiredFlag) === requiredFlag
+// ---------------------------------------------------------------------------
+export const AuthFlags = {
+	NONE: 0b0000,
+	PUBLIC: 0b0001,
+	ANON: 0b0010,
+	AUTH: 0b0100,
+	STAFF: 0b1000,
+} as const;
+
+export type AuthFlag = (typeof AuthFlags)[keyof typeof AuthFlags];
+
+/** Convenience presets for common flag combinations. */
+export const AuthPresets = {
+	GUEST: AuthFlags.PUBLIC | AuthFlags.ANON,
+	USER: AuthFlags.PUBLIC | AuthFlags.AUTH,
+	STAFF: AuthFlags.PUBLIC | AuthFlags.AUTH | AuthFlags.STAFF,
+	LOADING: AuthFlags.NONE,
+} as const;
+
+/** Check if a user's flags satisfy a required flag bitmask. */
+export function hasAuthFlag(userFlags: number, required: number): boolean {
+	return (userFlags & required) === required;
+}
+
 export interface AuthState {
 	tone: AuthTone;
+	flags: number;
 	name: string;
+	username: string | undefined;
 	avatar: string | undefined;
 	id: string;
 	error: string | undefined;
@@ -12,13 +46,97 @@ export interface AuthState {
 
 const DEFAULT_AUTH: AuthState = {
 	tone: 'loading',
+	flags: AuthPresets.LOADING,
 	name: '',
+	username: undefined,
 	avatar: undefined,
 	id: '',
 	error: undefined,
 };
 
-export const $auth = map<AuthState>({ ...DEFAULT_AUTH });
+const SB_AUTH_TOKEN_KEY = 'sb-auth-token';
+const PROFILE_CACHE_KEY = 'cache:profile:me';
+const STAFF_CACHE_KEY = 'cache:staff:perms';
+
+function seedAuthFromStorage(): AuthState {
+	if (typeof localStorage === 'undefined') return { ...DEFAULT_AUTH };
+
+	let session: {
+		user?: { id?: string; user_metadata?: Record<string, unknown> };
+	} | null = null;
+	try {
+		const raw = localStorage.getItem(SB_AUTH_TOKEN_KEY);
+		if (!raw) return { ...DEFAULT_AUTH };
+		const parsed = JSON.parse(raw);
+		const inner = parsed?.currentSession ?? parsed;
+		if (inner?.user?.id) session = inner;
+	} catch {
+		return { ...DEFAULT_AUTH };
+	}
+	if (!session?.user?.id) return { ...DEFAULT_AUTH };
+
+	const meta = (session.user.user_metadata ?? {}) as Record<string, unknown>;
+	let username: string | undefined;
+	let avatar: string | undefined =
+		typeof meta['avatar_url'] === 'string'
+			? (meta['avatar_url'] as string)
+			: undefined;
+
+	try {
+		const raw = localStorage.getItem(PROFILE_CACHE_KEY);
+		if (raw && raw !== 'null') {
+			const env = JSON.parse(raw);
+			if (env?.user_id === session.user.id) {
+				const profile = env.profile ?? {};
+				if (typeof profile.username === 'string')
+					username = profile.username;
+				avatar =
+					profile.discord?.avatar_url ||
+					profile.github?.avatar_url ||
+					profile.twitch?.avatar_url ||
+					avatar;
+			}
+		}
+	} catch {
+		/* best effort */
+	}
+
+	let flags: number = AuthPresets.USER;
+	try {
+		const raw = localStorage.getItem(STAFF_CACHE_KEY);
+		if (raw && raw !== 'null') {
+			const env = JSON.parse(raw);
+			if (
+				env?.user_id === session.user.id &&
+				typeof env?.bitmask === 'number' &&
+				env.bitmask > 0
+			) {
+				flags = AuthPresets.STAFF;
+			}
+		}
+	} catch {
+		/* best effort */
+	}
+
+	return {
+		tone: 'auth',
+		flags,
+		name:
+			typeof meta['full_name'] === 'string'
+				? (meta['full_name'] as string)
+				: '',
+		username,
+		avatar,
+		id: session.user.id,
+		error: undefined,
+	};
+}
+
+export const $auth = map<AuthState>(seedAuthFromStorage());
+
+export const $isStaff = computed($auth, (s) =>
+	hasAuthFlag(s.flags, AuthFlags.STAFF),
+);
 
 export function setAuth(state: Partial<AuthState>) {
 	const current = $auth.get();
@@ -26,5 +144,5 @@ export function setAuth(state: Partial<AuthState>) {
 }
 
 export function resetAuth() {
-	$auth.set({ ...DEFAULT_AUTH, tone: 'anon' });
+	$auth.set({ ...DEFAULT_AUTH, tone: 'anon', flags: AuthPresets.GUEST });
 }