@nuraly/lumenjs 0.1.2 → 0.1.4

package/dist/build/serve.js

@@ -5,11 +5,23 @@ import { readProjectConfig } from '../dev-server/config.js';
 import { installDomShims } from '../shared/dom-shims.js';
 import { serveStaticFile, sendCompressed } from './serve-static.js';
 import { handleApiRoute } from './serve-api.js';
-import { handleLoaderRequest, handleLayoutLoaderRequest } from './serve-loaders.js';
+import { handleLoaderRequest, handleLayoutLoaderRequest, handleSubscribeRequest, handleLayoutSubscribeRequest } from './serve-loaders.js';
 import { handlePageRoute } from './serve-ssr.js';
 import { renderErrorPage } from './error-page.js';
 import { handleI18nRequest } from './serve-i18n.js';
 import { resolveLocale } from '../dev-server/middleware/locale.js';
+import { runMiddlewareChain, extractMiddleware } from '../shared/middleware-runner.js';
+import { getMiddlewareDirsForPathname } from './scan.js';
+import { createAuthMiddleware } from '../auth/middleware.js';
+import { handleAuthRoutes } from '../auth/routes.js';
+import { loadAuthConfigProd } from '../auth/config.js';
+import { initLogger, logger } from '../shared/logger.js';
+import { createSecurityHeadersMiddleware } from '../shared/security-headers.js';
+import { createRateLimiter, createAuthRateLimiter } from '../shared/rate-limit.js';
+import { createHealthCheckHandler } from '../shared/health.js';
+import { createRequestIdMiddleware } from '../shared/request-id.js';
+import { getRequestId } from '../shared/request-id.js';
+import { setupGracefulShutdown } from '../shared/graceful-shutdown.js';
 export async function serveProject(options) {
     const { projectDir } = options;
     const port = options.port || 3000;
@@ -17,35 +29,198 @@ export async function serveProject(options) {
     const clientDir = path.join(outDir, 'client');
     const serverDir = path.join(outDir, 'server');
     const manifestPath = path.join(outDir, 'manifest.json');
+    // Initialize structured logging
+    initLogger();
     if (!fs.existsSync(manifestPath)) {
-        console.error('[LumenJS] No build found. Run `lumenjs build` first.');
+        logger.fatal('No build found. Run `lumenjs build` first.');
         process.exit(1);
     }
     const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
-    const { title } = readProjectConfig(projectDir);
+    const config = readProjectConfig(projectDir);
+    const { title } = config;
     const localesDir = path.join(outDir, 'locales');
+    // Production middleware stack
+    const requestIdMiddleware = createRequestIdMiddleware();
+    const securityHeaders = createSecurityHeadersMiddleware(config.securityHeaders);
+    const rateLimiter = createRateLimiter(config.rateLimit);
+    const authRateLimiter = createAuthRateLimiter();
+    const healthCheck = createHealthCheckHandler({ version: config.version });
     // Read the built index.html shell
     const indexHtmlPath = path.join(clientDir, 'index.html');
     if (!fs.existsSync(indexHtmlPath)) {
-        console.error('[LumenJS] No index.html found in build output.');
+        logger.fatal('No index.html found in build output.');
         process.exit(1);
     }
     const indexHtmlShell = fs.readFileSync(indexHtmlPath, 'utf-8');
-    // Load bundled SSR runtime first — it installs @lit-labs/ssr DOM shim
-    // which must be in place before any Lit class is instantiated.
+    // Load bundled SSR runtime first — its install-global-dom-shim sets up
+    // the proper HTMLElement/window/document shims that @lit-labs/ssr needs.
+    // The lit-shared chunk handles missing HTMLElement via a fallback to its own shim,
+    // so no pre-installation is needed.
     const ssrRuntimePath = path.join(serverDir, 'ssr-runtime.js');
     let ssrRuntime = null;
     if (fs.existsSync(ssrRuntimePath)) {
         ssrRuntime = await import(ssrRuntimePath);
     }
     // Install additional DOM shims that NuralyUI components may need
+    // (must run AFTER SSR runtime so we don't block its window/HTMLElement setup)
     installDomShims();
     const pagesDir = path.join(projectDir, 'pages');
+    // Load bundled middleware at startup
+    const middlewareModules = new Map();
+    if (manifest.middlewares) {
+        for (const entry of manifest.middlewares) {
+            const modPath = path.join(serverDir, entry.module);
+            if (fs.existsSync(modPath)) {
+                try {
+                    const mod = await import(modPath);
+                    middlewareModules.set(entry.dir, extractMiddleware(mod));
+                }
+                catch (err) {
+                    logger.error(`Failed to load middleware (${entry.dir || 'root'})`, { error: err?.message });
+                }
+            }
+        }
+    }
+    const middlewareEntries = manifest.middlewares
+        ? manifest.middlewares.map(e => ({ dir: e.dir, filePath: '' }))
+        : [];
+    // Load auth config if present
+    let authConfig = null;
+    let authMiddleware = null;
+    let authDb = null;
+    if (manifest.auth) {
+        try {
+            authConfig = await loadAuthConfigProd(serverDir, manifest.auth.configModule);
+            // Initialize DB for native auth
+            const { hasNativeAuth } = await import('../auth/config.js');
+            if (hasNativeAuth(authConfig)) {
+                try {
+                    const { setProjectDir } = await import('../db/context.js');
+                    const { useDb, waitForMigrations } = await import('../db/index.js');
+                    const { ensureUsersTable } = await import('../auth/native-auth.js');
+                    setProjectDir(projectDir);
+                    authDb = useDb();
+                    await waitForMigrations();
+                    await ensureUsersTable(authDb);
+                    // Run seed if not yet applied (SQLite and PG)
+                    {
+                        const seedModule = path.join(serverDir, 'seed.js');
+                        if (fs.existsSync(seedModule)) {
+                            try {
+                                if (authDb.isPg) {
+                                    await authDb.exec(`CREATE TABLE IF NOT EXISTS _lumen_seed_applied (
+                    name TEXT PRIMARY KEY,
+                    applied_at TIMESTAMP NOT NULL DEFAULT NOW()
+                  )`);
+                                }
+                                else {
+                                    await authDb.exec(`CREATE TABLE IF NOT EXISTS _lumen_seed_applied (
+                    name TEXT PRIMARY KEY,
+                    applied_at TEXT NOT NULL DEFAULT (datetime('now'))
+                  )`);
+                                }
+                                const seedRow = authDb.isPg
+                                    ? await authDb.get('SELECT 1 FROM _lumen_seed_applied WHERE name = $1', 'data/seed.ts')
+                                    : await authDb.get('SELECT 1 FROM _lumen_seed_applied WHERE name = ?', 'data/seed.ts');
+                                if (!seedRow) {
+                                    if (authDb.isPg) {
+                                        await authDb.run('INSERT INTO _lumen_seed_applied (name) VALUES ($1) ON CONFLICT DO NOTHING', 'data/seed.ts');
+                                    }
+                                    else {
+                                        await authDb.run('INSERT OR IGNORE INTO _lumen_seed_applied (name) VALUES (?)', 'data/seed.ts');
+                                    }
+                                    logger.info('Running seed file (prod)...');
+                                    const { default: seedFn } = await import(seedModule);
+                                    if (typeof seedFn === 'function')
+                                        await seedFn();
+                                    logger.info('Seed applied (prod).');
+                                }
+                            }
+                            catch (seedErr) {
+                                try {
+                                    if (authDb.isPg) {
+                                        await authDb.run('DELETE FROM _lumen_seed_applied WHERE name = $1', 'data/seed.ts');
+                                    }
+                                    else {
+                                        await authDb.run('DELETE FROM _lumen_seed_applied WHERE name = ?', 'data/seed.ts');
+                                    }
+                                }
+                                catch { }
+                                logger.warn('Seed failed', { error: seedErr?.message });
+                            }
+                        }
+                    }
+                }
+                catch (dbErr) {
+                    logger.warn('Native auth DB init failed', { error: dbErr?.message });
+                }
+            }
+            authMiddleware = createAuthMiddleware(authConfig, authDb);
+            logger.info('Auth middleware loaded.');
+        }
+        catch (err) {
+            logger.error('Failed to load auth config', { error: err?.message });
+        }
+    }
+    const runMiddleware = (mw, req, res) => new Promise((resolve, reject) => mw(req, res, (err) => err ? reject(err) : resolve()));
     const server = http.createServer(async (req, res) => {
+        const startTime = Date.now();
         const url = req.url || '/';
         const [pathname, queryString] = url.split('?');
         const method = req.method || 'GET';
         try {
+            // --- Production middleware pipeline ---
+            // Request ID (always first)
+            await runMiddleware(requestIdMiddleware, req, res);
+            // Health check (bypass everything else)
+            let healthHandled = false;
+            await new Promise(resolve => healthCheck(req, res, () => { resolve(); }));
+            if (res.writableEnded)
+                return;
+            // Security headers
+            await runMiddleware(securityHeaders, req, res);
+            // Rate limiting (stricter for auth routes)
+            if (pathname.startsWith('/__nk_auth/')) {
+                await runMiddleware(authRateLimiter, req, res);
+            }
+            else {
+                await runMiddleware(rateLimiter, req, res);
+            }
+            if (res.writableEnded)
+                return;
+            // --- Original request handling ---
+            // -2. Auth session middleware (attach req.nkAuth — must run before auth routes and user middleware)
+            if (authMiddleware && !pathname.includes('.') && !pathname.startsWith('/@')) {
+                await new Promise(resolve => authMiddleware(req, res, resolve));
+                if (res.writableEnded)
+                    return;
+            }
+            // -1. Auth routes (login, logout, me, signup, etc.)
+            if (authConfig && pathname.startsWith('/__nk_auth/')) {
+                const handled = await handleAuthRoutes(authConfig, req, res, authDb);
+                if (handled)
+                    return;
+            }
+            // 0. Run user middleware chain
+            if (middlewareModules.size > 0 && !pathname.includes('.') && !pathname.startsWith('/__nk_')) {
+                const matching = getMiddlewareDirsForPathname(pathname, middlewareEntries);
+                const allMw = [];
+                for (const entry of matching) {
+                    const mws = middlewareModules.get(entry.dir);
+                    if (mws)
+                        allMw.push(...mws);
+                }
+                if (allMw.length > 0) {
+                    const err = await new Promise(resolve => runMiddlewareChain(allMw, req, res, resolve));
+                    if (err) {
+                        res.statusCode = 500;
+                        res.end('Internal Server Error');
+                        return;
+                    }
+                    if (res.writableEnded)
+                        return;
+                }
+            }
             // 1. API routes
             if (pathname.startsWith('/api/')) {
                 await handleApiRoute(manifest, serverDir, pathname, queryString, method, req, res);
@@ -62,17 +237,28 @@ export async function serveProject(options) {
                 handleI18nRequest(localesDir, manifest.i18n.locales, pathname, req, res);
                 return;
             }
-            // 4. Layout loader endpoint
+            // 4. Layout subscribe endpoint (SSE)
+            if (pathname === '/__nk_subscribe/__layout/' || pathname === '/__nk_subscribe/__layout') {
+                const authUser = req.nkAuth?.user ?? undefined;
+                await handleLayoutSubscribeRequest(manifest, serverDir, queryString, req.headers, res, authUser);
+                return;
+            }
+            // 5. Subscribe endpoint (SSE)
+            if (pathname.startsWith('/__nk_subscribe/')) {
+                await handleSubscribeRequest(manifest, serverDir, pagesDir, pathname, queryString, req.headers, res, req.nkAuth?.user ?? undefined);
+                return;
+            }
+            // 6. Layout loader endpoint
             if (pathname === '/__nk_loader/__layout/' || pathname === '/__nk_loader/__layout') {
-                await handleLayoutLoaderRequest(manifest, serverDir, queryString, req.headers, res);
+                await handleLayoutLoaderRequest(manifest, serverDir, queryString, req.headers, res, req.nkAuth?.user ?? undefined);
                 return;
             }
-            // 5. Loader endpoint for client-side navigation
+            // 7. Loader endpoint for client-side navigation
             if (pathname.startsWith('/__nk_loader/')) {
-                await handleLoaderRequest(manifest, serverDir, pagesDir, pathname, queryString, req.headers, res);
+                await handleLoaderRequest(manifest, serverDir, pagesDir, pathname, queryString, req.headers, res, req.nkAuth?.user ?? undefined);
                 return;
             }
-            // 6. Resolve locale and strip prefix for page routing
+            // 8. Resolve locale and strip prefix for page routing
             let resolvedPathname = pathname;
             let locale;
             if (manifest.i18n) {
@@ -80,16 +266,45 @@ export async function serveProject(options) {
                 resolvedPathname = result.pathname;
                 locale = result.locale;
             }
-            // 7. Page routes — SSR render
+            // 9. Check for pre-rendered HTML file
+            const prerenderFile = path.join(clientDir, resolvedPathname === '/' ? '' : resolvedPathname, 'index.html');
+            if (resolvedPathname !== '/' && fs.existsSync(prerenderFile)) {
+                const prerenderHtml = fs.readFileSync(prerenderFile, 'utf-8');
+                sendCompressed(req, res, 200, 'text/html; charset=utf-8', prerenderHtml);
+                return;
+            }
+            // Check if the root index.html is a pre-rendered page (has data-nk-ssr attribute)
+            if (resolvedPathname === '/') {
+                const rootRoute = manifest.routes.find(r => r.path === '/');
+                if (rootRoute?.prerender) {
+                    sendCompressed(req, res, 200, 'text/html; charset=utf-8', indexHtmlShell);
+                    return;
+                }
+            }
+            // 10. Page routes — SSR render
             await handlePageRoute(manifest, serverDir, pagesDir, resolvedPathname, queryString, indexHtmlShell, title, ssrRuntime, req, res);
         }
         catch (err) {
-            console.error('[LumenJS] Request error:', err);
+            logger.error('Request error', {
+                method, url: pathname, error: err?.message, stack: err?.stack,
+                requestId: getRequestId(req),
+            });
             const html = renderErrorPage(500, 'Something went wrong', 'An unexpected error occurred while processing your request.', process.env.NODE_ENV !== 'production' ? err?.stack || err?.message : undefined);
             sendCompressed(req, res, 500, 'text/html; charset=utf-8', html);
         }
+        finally {
+            // Log request completion
+            const duration = Date.now() - startTime;
+            logger.request(req, res.statusCode, duration, { requestId: getRequestId(req) });
+        }
+    });
+    // Graceful shutdown
+    setupGracefulShutdown(server, {
+        onShutdown: async () => {
+            logger.info('Cleaning up resources...');
+        },
     });
     server.listen(port, () => {
-        console.log(`[LumenJS] Production server running at http://localhost:${port}`);
+        logger.info(`Production server running at http://localhost:${port}`, { port });
     });
 }

package/dist/cli.js

@@ -9,19 +9,32 @@ function getArg(name) {
     return undefined;
 }
 const USAGE = `Usage:
-  lumenjs dev   [--project <dir>] [--port <port>] [--base <path>] [--editor-mode]
-  lumenjs build [--project <dir>] [--out <dir>]
-  lumenjs serve [--project <dir>] [--port <port>]
-  lumenjs add   <integration>`;
-if (!command || !['dev', 'build', 'serve', 'add'].includes(command)) {
+  lumenjs create <name> [--template <default|blog|dashboard|social>]
+  lumenjs dev    [--project <dir>] [--port <port>] [--base <path>] [--editor-mode]
+  lumenjs build  [--project <dir>] [--out <dir>]
+  lumenjs serve  [--project <dir>] [--port <port>]
+  lumenjs add    <integration>
+  lumenjs db seed [--force] [--project <dir>]`;
+if (!command || !['create', 'dev', 'build', 'serve', 'add', 'db'].includes(command)) {
     console.error(USAGE);
     process.exit(1);
 }
 const projectDir = path.resolve(getArg('project') || '.');
 async function main() {
-    if (command === 'dev') {
+    if (command === 'create') {
+        const { createProject } = await import('./create.js');
+        const name = args[1];
+        const template = getArg('template') || 'default';
+        await createProject(name, template);
+        return;
+    }
+    else if (command === 'dev') {
         const { createDevServer } = await import('./dev-server/server.js');
         const port = parseInt(getArg('port') || '3000', 10);
+        if (isNaN(port) || port < 1 || port > 65535) {
+            console.error(`Invalid port number. Must be between 1 and 65535.`);
+            process.exit(1);
+        }
         const editorMode = args.includes('--editor-mode');
         const base = getArg('base') || '/';
         console.log(`[LumenJS] Starting dev server...`);
@@ -53,11 +66,29 @@ async function main() {
     else if (command === 'serve') {
         const { serveProject } = await import('./build/serve.js');
         const port = parseInt(getArg('port') || '3000', 10);
+        if (isNaN(port) || port < 1 || port > 65535) {
+            console.error(`Invalid port number. Must be between 1 and 65535.`);
+            process.exit(1);
+        }
         console.log(`[LumenJS] Starting production server...`);
         console.log(`  Project: ${projectDir}`);
         console.log(`  Port: ${port}`);
         await serveProject({ projectDir, port });
     }
+    else if (command === 'db') {
+        const subcommand = args[1];
+        if (subcommand === 'seed') {
+            const { setProjectDir } = await import('./db/context.js');
+            const { runSeed } = await import('./db/seed.js');
+            setProjectDir(projectDir);
+            const force = args.includes('--force');
+            await runSeed(projectDir, force);
+        }
+        else {
+            console.error(`Unknown db subcommand: ${subcommand}\n\n${USAGE}`);
+            process.exit(1);
+        }
+    }
 }
 main().catch(err => {
     console.error('[LumenJS] Failed to start:', err);

package/dist/communication/encryption.d.ts

@@ -0,0 +1,35 @@
+import type { KeyBundle, EncryptedEnvelope } from './types.js';
+import type { CommunicationStore } from './store.js';
+import type { LumenDb } from '../db/index.js';
+/** Context for encryption handlers */
+export interface EncryptionContext {
+    userId: string;
+    store: CommunicationStore;
+    /** Emit data to the current socket */
+    push: (data: any) => void;
+    /** Emit to a specific user's sockets */
+    emitToUser: (targetUserId: string, data: any) => void;
+    /** LumenJS database instance (optional) */
+    db?: LumenDb;
+}
+/**
+ * Handle a client uploading their public key bundle.
+ * Server stores the bundle — it never sees private keys.
+ */
+export declare function handleUploadKeys(ctx: EncryptionContext, data: KeyBundle): Promise<void>;
+/**
+ * Handle a client requesting another user's key bundle for session setup.
+ * Pops one one-time pre-key (consumed once).
+ */
+export declare function handleRequestKeys(ctx: EncryptionContext, data: {
+    recipientId: string;
+}): Promise<void>;
+/**
+ * Relay a session initialization message to the recipient.
+ * The server never reads the envelope — just forwards it.
+ */
+export declare function handleSessionInit(ctx: EncryptionContext, data: {
+    recipientId: string;
+    sessionId: string;
+    envelope: EncryptedEnvelope;
+}): void;

package/dist/communication/encryption.js

@@ -0,0 +1,90 @@
+// ── Key Upload ──────────────────────────────────────────────────
+/**
+ * Handle a client uploading their public key bundle.
+ * Server stores the bundle — it never sees private keys.
+ */
+export async function handleUploadKeys(ctx, data) {
+    // Ensure the bundle belongs to the sender
+    const bundle = {
+        ...data,
+        userId: ctx.userId,
+        uploadedAt: new Date().toISOString(),
+    };
+    // Store in memory
+    ctx.store.setKeyBundle(ctx.userId, bundle);
+    // Persist to DB if available
+    if (ctx.db) {
+        await ctx.db.run(`INSERT OR REPLACE INTO encryption_keys (user_id, identity_key, signed_pre_key_id, signed_pre_key, signed_pre_key_signature, uploaded_at)
+       VALUES (?, ?, ?, ?, ?, ?)`, ctx.userId, bundle.identityKey, bundle.signedPreKey.keyId, bundle.signedPreKey.publicKey, bundle.signedPreKeySignature, bundle.uploadedAt);
+        // Replace one-time pre-keys
+        await ctx.db.run(`DELETE FROM encryption_prekeys WHERE user_id = ?`, ctx.userId);
+        for (const otk of bundle.oneTimePreKeys) {
+            await ctx.db.run(`INSERT INTO encryption_prekeys (user_id, key_id, public_key) VALUES (?, ?, ?)`, ctx.userId, otk.keyId, otk.publicKey);
+        }
+    }
+    ctx.push({ event: 'encryption:keys-uploaded', data: { userId: ctx.userId, keyCount: bundle.oneTimePreKeys.length } });
+}
+// ── Key Request ─────────────────────────────────────────────────
+/**
+ * Handle a client requesting another user's key bundle for session setup.
+ * Pops one one-time pre-key (consumed once).
+ */
+export async function handleRequestKeys(ctx, data) {
+    let bundle = ctx.store.getKeyBundle(data.recipientId);
+    // Try loading from DB if not in memory
+    if (!bundle && ctx.db) {
+        const row = await ctx.db.get(`SELECT * FROM encryption_keys WHERE user_id = ?`, data.recipientId);
+        if (row) {
+            const prekeys = await ctx.db.all(`SELECT key_id, public_key FROM encryption_prekeys WHERE user_id = ? ORDER BY key_id`, data.recipientId);
+            bundle = {
+                userId: data.recipientId,
+                identityKey: row.identity_key,
+                signedPreKey: { keyId: row.signed_pre_key_id, publicKey: row.signed_pre_key },
+                signedPreKeySignature: row.signed_pre_key_signature,
+                oneTimePreKeys: prekeys.map((pk) => ({ keyId: pk.key_id, publicKey: pk.public_key })),
+                uploadedAt: row.uploaded_at,
+            };
+            ctx.store.setKeyBundle(data.recipientId, bundle);
+        }
+    }
+    if (!bundle) {
+        ctx.push({ event: 'encryption:keys-response', data: { error: 'no_keys', recipientId: data.recipientId } });
+        return;
+    }
+    // Pop one one-time pre-key (consumed once per session)
+    const oneTimePreKey = ctx.store.popOneTimePreKey(data.recipientId);
+    // Remove from DB too
+    if (oneTimePreKey && ctx.db) {
+        await ctx.db.run(`DELETE FROM encryption_prekeys WHERE user_id = ? AND key_id = ?`, data.recipientId, oneTimePreKey.keyId);
+    }
+    const response = {
+        recipientId: data.recipientId,
+        identityKey: bundle.identityKey,
+        signedPreKey: bundle.signedPreKey,
+        signedPreKeySignature: bundle.signedPreKeySignature,
+        oneTimePreKey,
+    };
+    ctx.push({ event: 'encryption:keys-response', data: response });
+    // Notify recipient if their one-time pre-keys are depleted
+    if (ctx.store.getOneTimePreKeyCount(data.recipientId) === 0) {
+        ctx.emitToUser(data.recipientId, {
+            event: 'encryption:keys-depleted',
+            data: { userId: data.recipientId },
+        });
+    }
+}
+// ── Session Init Relay ──────────────────────────────────────────
+/**
+ * Relay a session initialization message to the recipient.
+ * The server never reads the envelope — just forwards it.
+ */
+export function handleSessionInit(ctx, data) {
+    ctx.emitToUser(data.recipientId, {
+        event: 'encryption:session-init',
+        data: {
+            senderId: ctx.userId,
+            sessionId: data.sessionId,
+            envelope: data.envelope,
+        },
+    });
+}

package/dist/communication/handlers/context.d.ts

@@ -0,0 +1,27 @@
+import type { CommunicationConfig } from '../types.js';
+import type { CommunicationStore } from '../store.js';
+import type { LumenDb } from '../../db/index.js';
+import type { StorageAdapter } from '../../storage/adapters/types.js';
+/** Context passed to every handler from the socket connection */
+export interface HandlerContext {
+    userId: string;
+    store: CommunicationStore;
+    /** Resolved communication config */
+    config: CommunicationConfig;
+    /** Emit data to the current socket */
+    push: (data: any) => void;
+    /** Broadcast to all sockets in a room */
+    broadcastAll: (room: string, data: any) => void;
+    /** Broadcast to all sockets in a room except the sender */
+    broadcast: (room: string, data: any) => void;
+    /** Join a socket room */
+    joinRoom: (room: string) => void;
+    /** Leave a socket room */
+    leaveRoom: (room: string) => void;
+    /** Emit data to all sockets for a specific user */
+    emitToUser?: (userId: string, data: any) => void;
+    /** LumenJS database instance (optional — only if app has DB set up) */
+    db?: LumenDb;
+    /** Storage adapter for file uploads (optional — only if storage is configured) */
+    storage?: StorageAdapter;
+}

package/dist/communication/handlers/context.js

@@ -0,0 +1 @@
+export {};

package/dist/communication/handlers/conversation.d.ts

@@ -0,0 +1,24 @@
+import type { HandlerContext } from './context.js';
+export declare function handleConversationCreate(ctx: HandlerContext, data: {
+    type: 'direct' | 'group';
+    name?: string;
+    participantIds: string[];
+}): Promise<void>;
+export declare function handleConversationJoin(ctx: HandlerContext, data: {
+    conversationId: string;
+}): Promise<void>;
+export declare function handleConversationLeave(ctx: HandlerContext, data: {
+    conversationId: string;
+}): void;
+export declare function handleConversationArchive(ctx: HandlerContext, data: {
+    conversationId: string;
+    archived: boolean;
+}): Promise<void>;
+export declare function handleConversationMute(ctx: HandlerContext, data: {
+    conversationId: string;
+    muted: boolean;
+}): Promise<void>;
+export declare function handleConversationPin(ctx: HandlerContext, data: {
+    conversationId: string;
+    pinned: boolean;
+}): Promise<void>;