@kbve/droid 0.0.6 → 0.1.2

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,73 @@
+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(): Promise<{
+		data: unknown[] | null;
+		error: unknown;
+	}> {
+		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>): Promise<{
+		data: unknown[] | null;
+		error: 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();
+	});
+});

package/src/lib/state/auth.ts

@@ -0,0 +1,148 @@
+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;
+}
+
+const DEFAULT_AUTH: AuthState = {
+	tone: 'loading',
+	flags: AuthPresets.LOADING,
+	name: '',
+	username: undefined,
+	avatar: undefined,
+	id: '',
+	error: undefined,
+};
+
+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();
+	$auth.set({ ...current, ...state });
+}
+
+export function resetAuth() {
+	$auth.set({ ...DEFAULT_AUTH, tone: 'anon', flags: AuthPresets.GUEST });
+}

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

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import {
+	$bentoShipment,
+	$bentoLedger,
+	shipBentoWord,
+	advanceBentoShipment,
+	resetBentoFlow,
+} from './bento';
+
+beforeEach(() => {
+	resetBentoFlow();
+});
+
+describe('Bento flow state', () => {
+	it('shipBentoWord creates a shipped shipment', () => {
+		const shipment = shipBentoWord('games');
+		expect(shipment.word).toBe('games');
+		expect(shipment.stage).toBe('shipped');
+		expect($bentoShipment.get()).toEqual(shipment);
+		expect($bentoLedger.get()).toEqual([shipment]);
+	});
+
+	it('shipBentoWord assigns unique incrementing ids', () => {
+		const a = shipBentoWord('games');
+		const b = shipBentoWord('apps');
+		expect(b.id).toBeGreaterThan(a.id);
+	});
+
+	it('advanceBentoShipment updates stage and preserves word', () => {
+		const shipment = shipBentoWord('games');
+		const arrived = advanceBentoShipment(shipment.id, 'arrived');
+		expect(arrived?.word).toBe('games');
+		expect(arrived?.stage).toBe('arrived');
+		expect($bentoShipment.get()?.stage).toBe('arrived');
+		expect($bentoLedger.get()).toHaveLength(1);
+	});
+
+	it('advanceBentoShipment returns null for unknown id', () => {
+		expect(advanceBentoShipment(999, 'arrived')).toBeNull();
+	});
+
+	it('advanceBentoShipment returns null when stage unchanged', () => {
+		const shipment = shipBentoWord('games');
+		expect(advanceBentoShipment(shipment.id, 'shipped')).toBeNull();
+	});
+
+	it('listeners see each lifecycle transition', () => {
+		const handler = vi.fn();
+		const unsub = $bentoShipment.listen(handler);
+
+		const shipment = shipBentoWord('games');
+		advanceBentoShipment(shipment.id, 'arrived');
+		advanceBentoShipment(shipment.id, 'delivered');
+
+		expect(handler).toHaveBeenCalledTimes(3);
+		expect(handler.mock.calls.map(([s]) => s.stage)).toEqual([
+			'shipped',
+			'arrived',
+			'delivered',
+		]);
+		unsub();
+	});
+
+	it('ledger caps at 24 shipments', () => {
+		for (let i = 0; i < 30; i++) shipBentoWord(`word-${i}`);
+		expect($bentoLedger.get()).toHaveLength(24);
+		expect($bentoLedger.get()[23].word).toBe('word-29');
+	});
+
+	it('resetBentoFlow clears state', () => {
+		shipBentoWord('games');
+		resetBentoFlow();
+		expect($bentoShipment.get()).toBeNull();
+		expect($bentoLedger.get()).toEqual([]);
+	});
+});

package/src/lib/state/bento.ts

@@ -0,0 +1,51 @@
+import { atom } from 'nanostores';
+
+export type BentoStage = 'shipped' | 'arrived' | 'delivered' | 'dropped';
+
+export interface BentoShipment {
+	id: number;
+	word: string;
+	stage: BentoStage;
+	at: number;
+}
+
+const LEDGER_MAX = 24;
+
+let nextShipmentId = 1;
+
+export const $bentoShipment = atom<BentoShipment | null>(null);
+export const $bentoLedger = atom<readonly BentoShipment[]>([]);
+
+function record(shipment: BentoShipment) {
+	const rest = $bentoLedger.get().filter((s) => s.id !== shipment.id);
+	$bentoLedger.set([...rest, shipment].slice(-LEDGER_MAX));
+	$bentoShipment.set(shipment);
+}
+
+export function shipBentoWord(word: string): BentoShipment {
+	const shipment: BentoShipment = {
+		id: nextShipmentId++,
+		word,
+		stage: 'shipped',
+		at: Date.now(),
+	};
+	record(shipment);
+	return shipment;
+}
+
+export function advanceBentoShipment(
+	id: number,
+	stage: BentoStage,
+): BentoShipment | null {
+	const current = $bentoLedger.get().find((s) => s.id === id);
+	if (!current || current.stage === stage) return null;
+	const updated: BentoShipment = { ...current, stage, at: Date.now() };
+	record(updated);
+	return updated;
+}
+
+export function resetBentoFlow() {
+	nextShipmentId = 1;
+	$bentoShipment.set(null);
+	$bentoLedger.set([]);
+}

package/src/lib/state/index.ts

@@ -0,0 +1,98 @@
+export {
+	$auth,
+	$isStaff,
+	setAuth,
+	resetAuth,
+	AuthFlags,
+	AuthPresets,
+	hasAuthFlag,
+	type AuthTone,
+	type AuthFlag,
+	type AuthState,
+} from './auth';
+
+export { $currentPath, bootRouter } from './router';
+
+export {
+	$activeTooltip,
+	$drawerOpen,
+	$modalId,
+	openTooltip,
+	closeTooltip,
+	openDrawer,
+	closeDrawer,
+	openModal,
+	closeModal,
+} from './ui';
+
+export {
+	$bentoShipment,
+	$bentoLedger,
+	shipBentoWord,
+	advanceBentoShipment,
+	resetBentoFlow,
+	type BentoStage,
+	type BentoShipment,
+} from './bento';
+
+export { $toasts, addToast, removeToast } from './toasts';
+
+export { showWelcomeToast } from './welcome-toast';
+
+export {
+	syncThemeToDexie,
+	broadcastThemeChange,
+	observeThemeChanges,
+} from './theme-sync';
+
+export { OverlayManager } from './overlay-manager';
+export type { RenderPath } from './overlay-manager';
+
+export {
+	$profileCache,
+	clearProfileCache,
+	fetchAndCacheProfile,
+	fetchProfileFromApi,
+	getProfileFromCache,
+	PROFILE_CACHE_TTL_MS,
+	PROFILE_DEFAULT_API_BASE,
+	readProfileForFastPaint,
+	readSupabaseSessionFromStorage,
+	setProfileCache,
+	type CachedSupabaseSession,
+	type DroidProfile,
+	type FetchProfileOptions,
+	type ProfileCacheEnvelope,
+	type ProfileFastPaintResult,
+} from './profile';
+
+export {
+	$staffPermissions,
+	applyStaffFlagFromCache,
+	bootStaffPermissions,
+	clearStaffPermsCache,
+	fetchAndCacheStaffPermissions,
+	fetchStaffPermissionsFromApi,
+	getStaffPermsFromCache,
+	setStaffPermsCache,
+	STAFF_CACHE_TTL_MS,
+	type FetchStaffPermsOptions,
+	type StaffPermsEnvelope,
+} from './staff';
+
+export {
+	broadcastProfileClear,
+	broadcastProfileRefresh,
+	broadcastStaffClear,
+	broadcastStaffRefresh,
+	installSyncBusListener,
+	type SyncBusMessage,
+} from './sync-bus';
+
+export {
+	disposeProfileSync,
+	installProfileSync,
+	refreshProfileSyncNow,
+	type AuthEventLike,
+	type ProfileSyncOptions,
+} from './profile-sync';