@nuraly/lumenjs 0.3.0 → 0.6.0

package/README.md

@@ -7,6 +7,8 @@
 
 # LumenJS
 
+> **Mirror**: This repository is a read-only mirror of the original private repository, automatically synced on push to main.
+
 A full-stack web framework for [Lit](https://lit.dev/) web components. File-based routing, server loaders, real-time subscriptions (SSE), SSR with hydration, nested layouts, API routes, i18n, and a visual editor — all powered by Vite.
 
 ## Getting Started
@@ -88,6 +90,36 @@ export class BlogPost extends LitElement {
 }
 ```
 
+### Splitting large loaders
+
+For folder routes (`pages/foo/index.ts`), you can move the loader into a co-located `_loader.ts` file. The framework discovers it automatically — no import or wrapper needed in the page file.
+
+```
+pages/
+└── dashboard/
+    ├── index.ts      ← page component only
+    └── _loader.ts    ← auto-discovered loader
+```
+
+```typescript
+// pages/dashboard/_loader.ts
+export async function loader({ user }) {
+  const stats = await db.getStats(user.id);
+  return { stats };
+}
+```
+
+```typescript
+// pages/dashboard/index.ts — no loader here at all
+export class PageDashboard extends LitElement {
+  static properties = { stats: { type: Array } };
+  stats = [];
+  render() { ... }
+}
+```
+
+Both patterns work side by side — the inline loader always takes precedence. Only folder routes (`index.ts`) support `_loader.ts` discovery; flat pages (`about.ts`) keep the loader inline.
+
 ### Loader Context
 
 | Property | Type | Description |

package/dist/build/build-server.js

@@ -9,6 +9,25 @@ export async function buildServer(opts) {
     // Include all pages in server build (enables SSR for .md endpoints)
     for (const entry of pageEntries) {
         serverEntries[`pages/${entry.name}`] = entry.filePath;
+        // Co-located _loader.ts / _socket.ts for folder index pages
+        if (path.basename(entry.filePath).replace(/\.(ts|js)$/, '') === 'index') {
+            const dir = path.dirname(entry.filePath);
+            const entryDir = path.dirname(entry.name);
+            for (const ext of ['.ts', '.js']) {
+                const loaderFile = path.join(dir, `_loader${ext}`);
+                if (fs.existsSync(loaderFile)) {
+                    serverEntries[`pages/${entryDir}/_loader`] = loaderFile;
+                    break;
+                }
+            }
+            for (const ext of ['.ts', '.js']) {
+                const socketFile = path.join(dir, `_socket${ext}`);
+                if (fs.existsSync(socketFile)) {
+                    serverEntries[`pages/${entryDir}/_socket`] = socketFile;
+                    break;
+                }
+            }
+        }
     }
     for (const entry of layoutEntries) {
         if (entry.hasLoader || entry.hasSubscribe) {

package/dist/build/scan.js

@@ -14,10 +14,16 @@ function analyzePageFile(filePath) {
                 return false;
             return true;
         };
+        const isIndex = path.basename(filePath).replace(/\.(ts|js)$/, '') === 'index';
+        const dir = path.dirname(filePath);
+        const hasColocatedLoader = isIndex &&
+            (fs.existsSync(path.join(dir, '_loader.ts')) || fs.existsSync(path.join(dir, '_loader.js')));
+        const hasColocatedSocket = isIndex &&
+            (fs.existsSync(path.join(dir, '_socket.ts')) || fs.existsSync(path.join(dir, '_socket.js')));
         return {
-            hasLoader: hasExportBefore(/export\s+(async\s+)?function\s+loader\s*\(/),
+            hasLoader: hasExportBefore(/export\s+(async\s+)?function\s+loader\s*\(/) || hasColocatedLoader,
             hasSubscribe: hasExportBefore(/export\s+(async\s+)?function\s+subscribe\s*\(/),
-            hasSocket: /export\s+(function|const)\s+socket[\s(=]/.test(content),
+            hasSocket: /export\s+(function|const)\s+socket[\s(=]/.test(content) || hasColocatedSocket,
             hasAuth: hasExportBefore(/export\s+const\s+auth\s*=/),
             hasMeta: hasExportBefore(/export\s+(const\s+meta\s*=|(async\s+)?function\s+meta\s*\()/),
             hasStandalone: hasExportBefore(/export\s+const\s+standalone\s*=/),

package/dist/build/serve-loaders.js

@@ -207,14 +207,24 @@ export async function handleLoaderRequest(manifest, serverDir, pagesDir, pathnam
     }
     try {
         const mod = await import(modulePath);
-        if (!mod.loader || typeof mod.loader !== 'function') {
+        let loaderFn = mod.loader && typeof mod.loader === 'function' ? mod.loader : null;
+        // Fallback: co-located _loader.js for folder index pages
+        if (!loaderFn && path.basename(modulePath, '.js') === 'index') {
+            const colocated = path.join(path.dirname(modulePath), '_loader.js');
+            if (fs.existsSync(colocated)) {
+                const loaderMod = await import(colocated);
+                if (loaderMod.loader && typeof loaderMod.loader === 'function')
+                    loaderFn = loaderMod.loader;
+            }
+        }
+        if (!loaderFn) {
             res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
             res.end(JSON.stringify({ __nk_no_loader: true }));
             return;
         }
         const locale = query.__locale;
         delete query.__locale;
-        const result = await mod.loader({ params: matched.params, query, url: pagePath, headers, locale, user: user ?? null });
+        const result = await loaderFn({ params: matched.params, query, url: pagePath, headers, locale, user: user ?? null });
         if (isRedirectResponse(result)) {
             res.writeHead(result.status || 302, { Location: result.location });
             res.end();

package/dist/build/serve-ssr.js

@@ -18,10 +18,19 @@ export async function handlePageRoute(manifest, serverDir, pagesDir, pathname, q
         if (fs.existsSync(modulePath)) {
             try {
                 const mod = await import(modulePath);
-                // Run loader
+                // Run loader (inline or co-located _loader.js)
                 let loaderData = undefined;
-                if (mod.loader && typeof mod.loader === 'function') {
-                    loaderData = await mod.loader({ params: matched.params, query: {}, url: pathname, headers: req.headers, user: req.nkAuth?.user ?? null });
+                let loaderFn = mod.loader && typeof mod.loader === 'function' ? mod.loader : null;
+                if (!loaderFn && path.basename(modulePath, '.js') === 'index') {
+                    const colocated = path.join(path.dirname(modulePath), '_loader.js');
+                    if (fs.existsSync(colocated)) {
+                        const loaderMod = await import(colocated);
+                        if (loaderMod.loader && typeof loaderMod.loader === 'function')
+                            loaderFn = loaderMod.loader;
+                    }
+                }
+                if (loaderFn) {
+                    loaderData = await loaderFn({ params: matched.params, query: {}, url: pathname, headers: req.headers, user: req.nkAuth?.user ?? null });
                     if (isRedirectResponse(loaderData)) {
                         res.writeHead(loaderData.status || 302, { Location: loaderData.location });
                         res.end();

package/dist/communication/server.js

@@ -70,6 +70,7 @@ export function createCommunicationHandler(options = {}) {
                 }
             },
             broadcastAll: ctx.room.broadcastAll,
+            db: options.db,
         };
         // Broadcast online status if this is the user's first socket
         if (isFirstSocket) {

package/dist/communication/signaling.d.ts

@@ -8,6 +8,8 @@ export interface SignalingContext {
     emitToSocket: (socketId: string, data: any) => void;
     /** Broadcast to all sockets in a room */
     broadcastAll: (room: string, data: any) => void;
+    /** Optional database for persisting call logs */
+    db?: any;
 }
 export declare function handleCallInitiate(ctx: SignalingContext, data: {
     conversationId: string;

package/dist/communication/signaling.js

@@ -130,6 +130,47 @@ export function handleCallHangup(ctx, data) {
                 data: { callId: data.callId, state: 'ended', endReason: data.reason },
             });
         }
+        // Persist call log as a message in the conversation
+        if (ctx.db && call.conversationId) {
+            try {
+                const callStatus = data.reason === 'rejected' ? 'declined'
+                    : data.reason === 'missed' ? 'missed'
+                        : 'completed';
+                const attachment = JSON.stringify({
+                    callType: call.type || 'audio',
+                    callStatus,
+                    duration: data.duration || null,
+                });
+                const msgId = `call-${data.callId}`;
+                const isPg = !!ctx.db.isPg;
+                if (isPg) {
+                    ctx.db.run(`INSERT INTO messages (id, conversation_id, sender_id, content, type, attachment, created_at)
+             VALUES ($1, $2, $3, $4, $5, $6, NOW()) ON CONFLICT (id) DO NOTHING`, msgId, call.conversationId, call.callerId, '', 'call', attachment);
+                    ctx.db.run(`UPDATE conversations SET updated_at = NOW() WHERE id = $1`, call.conversationId);
+                }
+                else {
+                    ctx.db.run(`INSERT OR IGNORE INTO messages (id, conversation_id, sender_id, content, type, attachment, created_at)
+             VALUES (?, ?, ?, '', 'call', ?, datetime('now'))`, msgId, call.conversationId, call.callerId, attachment);
+                    ctx.db.run(`UPDATE conversations SET updated_at = datetime('now') WHERE id = ?`, call.conversationId);
+                }
+                // Broadcast call message to all participants
+                const callMsg = {
+                    id: msgId,
+                    conversationId: call.conversationId,
+                    senderId: call.callerId,
+                    content: '',
+                    type: 'call',
+                    attachment: { callType: call.type || 'audio', callStatus, duration: data.duration || null },
+                    createdAt: new Date().toISOString(),
+                };
+                for (const uid of allUsers) {
+                    emitToUser(ctx, uid, { event: 'message:new', data: callMsg });
+                }
+                // Also emit to the caller
+                emitToUser(ctx, ctx.userId, { event: 'message:new', data: callMsg });
+            }
+            catch { }
+        }
         ctx.store.removeCall(data.callId);
     }
 }

package/dist/dev-server/plugins/vite-plugin-loaders.js

@@ -159,7 +159,21 @@ export function lumenLoadersPlugin(pagesDir) {
                     // Provide minimal DOM shims for SSR so Lit class definitions don't crash
                     installDomShims();
                     const mod = await server.ssrLoadModule(filePath);
-                    if (!mod.loader || typeof mod.loader !== 'function') {
+                    let loaderFn = mod.loader && typeof mod.loader === 'function' ? mod.loader : null;
+                    // Fallback: co-located _loader.ts for folder index pages
+                    if (!loaderFn && path.basename(filePath).replace(/\.(ts|js)$/, '') === 'index') {
+                        for (const ext of ['.ts', '.js']) {
+                            const colocated = path.join(path.dirname(filePath), `_loader${ext}`);
+                            if (fs.existsSync(colocated)) {
+                                const loaderMod = await server.ssrLoadModule(colocated);
+                                if (loaderMod.loader && typeof loaderMod.loader === 'function') {
+                                    loaderFn = loaderMod.loader;
+                                }
+                                break;
+                            }
+                        }
+                    }
+                    if (!loaderFn) {
                         // No loader — return empty data
                         res.statusCode = 200;
                         res.setHeader('Content-Type', 'application/json');
@@ -205,7 +219,7 @@ export function lumenLoadersPlugin(pagesDir) {
                         }
                         catch { }
                     }
-                    const result = await mod.loader({ params, query, url: pagePath, headers: req.headers, locale, user });
+                    const result = await loaderFn({ params, query, url: pagePath, headers: req.headers, locale, user });
                     if (isRedirectResponse(result)) {
                         res.statusCode = result.status || 302;
                         res.setHeader('Location', result.location);

package/dist/dev-server/ssr-render.js

@@ -44,10 +44,22 @@ export async function ssrRenderPage(server, pagesDir, pathname, headers, locale,
         const mod = await server.ssrLoadModule(pageModuleUrl);
         if (registry)
             registry.__nk_bypass_get = false;
-        // Run loader if present
+        // Run loader if present (inline or co-located _loader.ts)
         let loaderData = undefined;
-        if (mod.loader && typeof mod.loader === 'function') {
-            loaderData = await mod.loader({ params, query: {}, url: pathname, headers: headers || {}, locale, user: user ?? null });
+        let loaderFn = mod.loader && typeof mod.loader === 'function' ? mod.loader : null;
+        if (!loaderFn && path.basename(filePath).replace(/\.(ts|js)$/, '') === 'index') {
+            for (const ext of ['.ts', '.js']) {
+                const colocated = path.join(path.dirname(filePath), `_loader${ext}`);
+                if (fs.existsSync(colocated)) {
+                    const loaderMod = await server.ssrLoadModule('/' + path.relative(path.resolve(pagesDir, '..'), colocated).replace(/\\/g, '/'));
+                    if (loaderMod.loader && typeof loaderMod.loader === 'function')
+                        loaderFn = loaderMod.loader;
+                    break;
+                }
+            }
+        }
+        if (loaderFn) {
+            loaderData = await loaderFn({ params, query: {}, url: pathname, headers: headers || {}, locale, user: user ?? null });
             if (loaderData && typeof loaderData === 'object' && loaderData.__nk_redirect) {
                 return { html: '', loaderData: null, redirect: { location: loaderData.location, status: loaderData.status || 302 } };
             }

package/dist/runtime/webrtc.d.ts

@@ -66,7 +66,14 @@ export declare class GroupWebRTCManager {
     getRemoteStream(userId: string): MediaStream | null;
     getRemoteStreams(): Map<string, MediaStream>;
     /** Acquire local media — call once before adding peers */
-    startLocalMedia(video?: boolean, audio?: boolean): Promise<MediaStream>;
+    startLocalMedia(video?: boolean, audio?: boolean, deviceIds?: {
+        audioInputId?: string | null;
+        videoInputId?: string | null;
+    }): Promise<MediaStream>;
+    /** Replace the audio track on all peer connections (for switching mic mid-call) */
+    replaceAudioTrack(newTrack: MediaStreamTrack): Promise<void>;
+    /** Replace the video track on all peer connections (for switching camera mid-call) */
+    replaceVideoTrack(newTrack: MediaStreamTrack): Promise<void>;
     /** Create a peer connection for a remote user and optionally create an offer */
     addPeer(userId: string, isCaller: boolean): Promise<string | void>;
     /** Remove and close a peer connection */

package/dist/runtime/webrtc.js

@@ -54,16 +54,11 @@ export class WebRTCManager {
             throw err;
         }
         try {
-            // Always request video so both peers negotiate a video track in the SDP.
-            // For audio-only calls the video track is immediately disabled (black frame)
-            // but stays in the SDP as sendrecv, allowing replaceTrack for screen sharing.
-            this._localStream = await navigator.mediaDevices.getUserMedia({ video: true, audio });
+            // Only request video when the call type is video.
+            // For audio-only calls, skip the camera entirely to avoid the permission
+            // prompt and camera LED. Screen sharing can add a video track later.
+            this._localStream = await navigator.mediaDevices.getUserMedia({ video, audio });
             this._callbacks.onLocalStream(this._localStream);
-            if (!video) {
-                for (const vt of this._localStream.getVideoTracks()) {
-                    vt.enabled = false;
-                }
-            }
             for (const track of this._localStream.getTracks()) {
                 this._pc?.addTrack(track, this._localStream);
             }
@@ -232,19 +227,24 @@ export class GroupWebRTCManager {
         return result;
     }
     /** Acquire local media — call once before adding peers */
-    async startLocalMedia(video = true, audio = true) {
+    async startLocalMedia(video = true, audio = true, deviceIds) {
         if (!navigator.mediaDevices?.getUserMedia) {
             const err = new Error('Media devices unavailable — HTTPS is required for calls');
             this._callbacks.onError(err);
             throw err;
         }
         try {
-            this._localStream = await navigator.mediaDevices.getUserMedia({ video: true, audio });
+            const audioConstraint = audio
+                ? (deviceIds?.audioInputId ? { deviceId: { exact: deviceIds.audioInputId } } : true)
+                : false;
+            const videoConstraint = video
+                ? (deviceIds?.videoInputId ? { deviceId: { exact: deviceIds.videoInputId } } : true)
+                : false;
+            this._localStream = await navigator.mediaDevices.getUserMedia({
+                audio: audioConstraint,
+                video: videoConstraint,
+            });
             this._callbacks.onLocalStream(this._localStream);
-            if (!video) {
-                for (const vt of this._localStream.getVideoTracks())
-                    vt.enabled = false;
-            }
             return this._localStream;
         }
         catch (err) {
@@ -252,6 +252,40 @@ export class GroupWebRTCManager {
             throw err;
         }
     }
+    /** Replace the audio track on all peer connections (for switching mic mid-call) */
+    async replaceAudioTrack(newTrack) {
+        // Replace in local stream
+        if (this._localStream) {
+            const old = this._localStream.getAudioTracks()[0];
+            if (old) {
+                this._localStream.removeTrack(old);
+                old.stop();
+            }
+            this._localStream.addTrack(newTrack);
+        }
+        // Replace on all peer connections
+        for (const [, entry] of this._peers) {
+            const sender = entry.pc.getSenders().find(s => s.track?.kind === 'audio');
+            if (sender)
+                await sender.replaceTrack(newTrack);
+        }
+    }
+    /** Replace the video track on all peer connections (for switching camera mid-call) */
+    async replaceVideoTrack(newTrack) {
+        if (this._localStream) {
+            const old = this._localStream.getVideoTracks()[0];
+            if (old) {
+                this._localStream.removeTrack(old);
+                old.stop();
+            }
+            this._localStream.addTrack(newTrack);
+        }
+        for (const [, entry] of this._peers) {
+            const sender = entry.pc.getSenders().find(s => s.track?.kind === 'video');
+            if (sender)
+                await sender.replaceTrack(newTrack);
+        }
+    }
     /** Create a peer connection for a remote user and optionally create an offer */
     async addPeer(userId, isCaller) {
         if (this._peers.has(userId))

package/dist/shared/socket-io-setup.js

@@ -1,5 +1,7 @@
 import { createRequire } from 'module';
 import { pathToFileURL } from 'url';
+import fs from 'fs';
+import path from 'path';
 export async function setupSocketIO(options) {
     // Resolve socket.io from the project's node_modules (not from lumenjs's own node_modules)
     let SocketIOServer;
@@ -23,7 +25,20 @@ export async function setupSocketIO(options) {
         io.of(ns).on('connection', async (socket) => {
             try {
                 const mod = await options.loadModule(route.filePath);
-                if (!mod.socket)
+                let socketFn = mod?.socket;
+                // Co-located _socket.ts fallback (folder route convention)
+                if (!socketFn && path.basename(route.filePath).replace(/\.(ts|js)$/, '') === 'index') {
+                    const dir = path.dirname(route.filePath);
+                    for (const ext of ['.ts', '.js']) {
+                        const colocated = path.join(dir, `_socket${ext}`);
+                        if (fs.existsSync(colocated)) {
+                            const socketMod = await options.loadModule(colocated);
+                            socketFn = socketMod?.socket;
+                            break;
+                        }
+                    }
+                }
+                if (!socketFn)
                     return;
                 const push = (data) => socket.emit('nk:data', data);
                 const on = (event, handler) => {
@@ -38,7 +53,7 @@ export async function setupSocketIO(options) {
                 const params = socket.handshake.query.__params
                     ? JSON.parse(socket.handshake.query.__params) : {};
                 const locale = socket.handshake.query.__locale;
-                const cleanup = mod.socket({ on, push, room, params, headers: socket.handshake.headers, locale, socket });
+                const cleanup = socketFn({ on, push, room, params, headers: socket.handshake.headers, locale, socket });
                 socket.on('disconnect', () => { if (typeof cleanup === 'function')
                     cleanup(); });
             }

package/dist/shared/utils.js

@@ -1,4 +1,5 @@
 import fs from 'fs';
+import path from 'path';
 /**
  * Strip the outer Lit SSR template markers from rendered HTML.
  * Lit SSR wraps every template render in <!--lit-part HASH-->...<!--/lit-part-->.
@@ -158,6 +159,13 @@ export function fileHasPrerender(filePath) {
  */
 export function fileHasLoader(filePath) {
     try {
+        // Check for co-located _loader.ts (folder route convention: index.ts + _loader.ts)
+        if (path.basename(filePath).replace(/\.(ts|js)$/, '') === 'index') {
+            const dir = path.dirname(filePath);
+            if (fs.existsSync(path.join(dir, '_loader.ts')) || fs.existsSync(path.join(dir, '_loader.js'))) {
+                return true;
+            }
+        }
         const content = fs.readFileSync(filePath, 'utf-8');
         return hasTopLevelExport(content, 'loader');
     }
@@ -220,6 +228,13 @@ export function fileHasMeta(filePath) {
  */
 export function fileHasSocket(filePath) {
     try {
+        // Check for co-located _socket.ts (folder route convention: index.ts + _socket.ts)
+        if (path.basename(filePath).replace(/\.(ts|js)$/, '') === 'index') {
+            const dir = path.dirname(filePath);
+            if (fs.existsSync(path.join(dir, '_socket.ts')) || fs.existsSync(path.join(dir, '_socket.js'))) {
+                return true;
+            }
+        }
         const content = fs.readFileSync(filePath, 'utf-8');
         return /export\s+(function|const)\s+socket[\s(=]/.test(content);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuraly/lumenjs",
-  "version": "0.3.0",
+  "version": "0.6.0",
   "description": "Full-stack Lit web component framework with file-based routing, server loaders, SSR, and API routes",
   "type": "module",
   "main": "dist/cli.js",
@@ -43,7 +43,7 @@
   "license": "MIT",
   "dependencies": {
     "@lit-labs/ssr": "^3.2.0",
-    "glob": "^10.3.0",
+    "glob": "^10.2.1",
     "lit": "^3.1.0",
     "vite": "^5.4.0"
   },