@nuraly/lumenjs 0.1.3 → 0.2.0

package/dist/build/build.js

@@ -1,11 +1,12 @@
-import { build as viteBuild } from 'vite';
 import path from 'path';
 import fs from 'fs';
 import { getSharedViteConfig } from '../dev-server/server.js';
 import { readProjectConfig } from '../dev-server/config.js';
-import { generateIndexHtml } from '../dev-server/index-html.js';
 import { filePathToTagName } from '../shared/utils.js';
-import { scanPages, scanLayouts, scanApiRoutes, getLayoutDirsForPage } from './scan.js';
+import { scanPages, scanLayouts, scanApiRoutes, scanMiddleware, getLayoutDirsForPage } from './scan.js';
+import { buildClient } from './build-client.js';
+import { buildServer } from './build-server.js';
+import { prerenderPages } from './build-prerender.js';
 export async function buildProject(options) {
     const { projectDir } = options;
     const outDir = options.outDir || path.join(projectDir, '.lumenjs');
@@ -19,130 +20,44 @@ export async function buildProject(options) {
         fs.rmSync(outDir, { recursive: true });
     }
     fs.mkdirSync(outDir, { recursive: true });
-    const { title, integrations, i18n: i18nConfig } = readProjectConfig(projectDir);
+    const { title, integrations, i18n: i18nConfig, prefetch: prefetchStrategy, prerender: globalPrerender } = readProjectConfig(projectDir);
     const shared = getSharedViteConfig(projectDir, { mode: 'production', integrations });
-    // Scan pages, layouts, and API routes for the manifest
+    // Scan pages, layouts, API routes, and middleware for the manifest
     const pageEntries = scanPages(pagesDir);
     const layoutEntries = scanLayouts(pagesDir);
     const apiEntries = scanApiRoutes(apiDir);
-    // --- Client build ---
-    console.log('[LumenJS] Building client bundle...');
-    // Generate index.html as build entry
-    const indexHtml = generateIndexHtml({ title, editorMode: false, integrations });
-    const tempIndexPath = path.join(projectDir, '__nk_build_index.html');
-    fs.writeFileSync(tempIndexPath, indexHtml);
-    try {
-        await viteBuild({
-            root: projectDir,
-            publicDir: fs.existsSync(publicDir) ? publicDir : undefined,
-            resolve: shared.resolve,
-            plugins: shared.plugins,
-            esbuild: shared.esbuild,
-            build: {
-                outDir: clientDir,
-                emptyOutDir: true,
-                rollupOptions: {
-                    input: tempIndexPath,
-                },
-            },
-            logLevel: 'warn',
-        });
-    }
-    finally {
-        // Clean up temp file
-        if (fs.existsSync(tempIndexPath)) {
-            fs.unlinkSync(tempIndexPath);
+    const middlewareEntries = scanMiddleware(pagesDir);
+    // Check for auth config
+    const authConfigPath = path.join(projectDir, 'lumenjs.auth.ts');
+    const hasAuthConfig = fs.existsSync(authConfigPath);
+    // Apply global prerender flag from config
+    if (globalPrerender) {
+        for (const entry of pageEntries) {
+            entry.prerender = true;
         }
     }
-    // Rename the built HTML file from __nk_build_index.html to index.html
-    const builtHtmlPath = path.join(clientDir, '__nk_build_index.html');
-    const finalHtmlPath = path.join(clientDir, 'index.html');
-    if (fs.existsSync(builtHtmlPath)) {
-        fs.renameSync(builtHtmlPath, finalHtmlPath);
-    }
+    // --- Client build ---
+    await buildClient({
+        projectDir,
+        clientDir,
+        title,
+        integrations,
+        prefetchStrategy,
+        publicDir,
+        shared,
+    });
     // --- Server build ---
-    console.log('[LumenJS] Building server bundle...');
-    // Collect server entry points (pages with loaders + layouts with loaders + API routes)
-    const serverEntries = {};
-    for (const entry of pageEntries) {
-        if (entry.hasLoader || entry.hasSubscribe) {
-            serverEntries[`pages/${entry.name}`] = entry.filePath;
-        }
-    }
-    for (const entry of layoutEntries) {
-        if (entry.hasLoader || entry.hasSubscribe) {
-            const entryName = entry.dir ? `layouts/${entry.dir}/_layout` : 'layouts/_layout';
-            serverEntries[entryName] = entry.filePath;
-        }
-    }
-    for (const entry of apiEntries) {
-        serverEntries[`api/${entry.name}`] = entry.filePath;
-    }
-    // Create SSR runtime entry — bundles @lit-labs/ssr alongside Lit so all
-    // server modules share one Lit instance (avoids _$EM mismatches).
-    const ssrEntryPath = path.join(projectDir, '__nk_ssr_entry.js');
-    const hasPageLoaders = pageEntries.some(e => e.hasLoader);
-    const hasLayoutLoaders = layoutEntries.some(e => e.hasLoader);
-    if (hasPageLoaders || hasLayoutLoaders) {
-        fs.writeFileSync(ssrEntryPath, [
-            "import '@lit-labs/ssr/lib/install-global-dom-shim.js';",
-            "export { render } from '@lit-labs/ssr';",
-            "export { html, unsafeStatic } from 'lit/static-html.js';",
-        ].join('\n'));
-        serverEntries['ssr-runtime'] = ssrEntryPath;
-    }
-    try {
-        if (Object.keys(serverEntries).length > 0) {
-            await viteBuild({
-                root: projectDir,
-                resolve: shared.resolve,
-                plugins: shared.plugins,
-                esbuild: shared.esbuild,
-                build: {
-                    outDir: serverDir,
-                    emptyOutDir: true,
-                    ssr: true,
-                    rollupOptions: {
-                        input: serverEntries,
-                        output: {
-                            format: 'esm',
-                            entryFileNames: '[name].js',
-                            chunkFileNames: 'assets/[name]-[hash].js',
-                            manualChunks(id) {
-                                // Force all Lit packages into a single shared chunk so SSR runtime
-                                // and page modules use the exact same Lit class instances.
-                                if (id.includes('/node_modules/lit/') ||
-                                    id.includes('/node_modules/lit-html/') ||
-                                    id.includes('/node_modules/lit-element/') ||
-                                    id.includes('/node_modules/@lit/reactive-element/')) {
-                                    return 'lit-shared';
-                                }
-                            },
-                        },
-                        external: [
-                            /^node:/,
-                            'os', 'fs', 'path', 'url', 'util', 'crypto', 'http', 'https', 'net',
-                            'stream', 'zlib', 'events', 'buffer', 'querystring', 'child_process',
-                            'worker_threads', 'cluster', 'dns', 'tls', 'assert', 'constants',
-                            'better-sqlite3',
-                        ],
-                    },
-                },
-                logLevel: 'warn',
-                ssr: {
-                    noExternal: true,
-                },
-            });
-        }
-        else {
-            fs.mkdirSync(serverDir, { recursive: true });
-        }
-    }
-    finally {
-        if (fs.existsSync(ssrEntryPath)) {
-            fs.unlinkSync(ssrEntryPath);
-        }
-    }
+    await buildServer({
+        projectDir,
+        serverDir,
+        pageEntries,
+        layoutEntries,
+        apiEntries,
+        middlewareEntries,
+        hasAuthConfig,
+        authConfigPath,
+        shared,
+    });
     // --- Copy locales ---
     if (i18nConfig) {
         const localesDir = path.join(projectDir, 'locales');
@@ -160,20 +75,25 @@ export async function buildProject(options) {
     // --- Write manifest ---
     const manifest = {
         routes: pageEntries.map(e => {
-            const routeLayouts = getLayoutDirsForPage(e.filePath, pagesDir, layoutEntries);
+            const routeLayouts = e.hasStandalone ? [] : getLayoutDirsForPage(e.filePath, pagesDir, layoutEntries);
             const relPath = path.relative(pagesDir, e.filePath).replace(/\\/g, '/');
             return {
                 path: e.routePath,
-                module: (e.hasLoader || e.hasSubscribe) ? `pages/${e.name}.js` : '',
+                module: (e.hasLoader || e.hasSubscribe || e.hasSocket || e.prerender) ? `pages/${e.name.replace(/\[(\w+)\]/g, '_$1_')}.js` : '',
                 hasLoader: e.hasLoader,
                 hasSubscribe: e.hasSubscribe,
                 tagName: filePathToTagName(relPath),
                 ...(routeLayouts.length > 0 ? { layouts: routeLayouts } : {}),
+                ...(e.hasSocket ? { hasSocket: true } : {}),
+                ...(e.hasAuth ? { hasAuth: true } : {}),
+                ...(e.hasMeta ? { hasMeta: true } : {}),
+                ...(e.hasStandalone ? { hasStandalone: true } : {}),
+                ...(e.prerender ? { prerender: true } : {}),
             };
         }),
         apiRoutes: apiEntries.map(e => ({
             path: `/api/${e.routePath}`,
-            module: `api/${e.name}.js`,
+            module: `api/${e.name.replace(/\[(\w+)\]/g, '_$1_')}.js`,
             hasLoader: false,
             hasSubscribe: false,
         })),
@@ -183,9 +103,26 @@ export async function buildProject(options) {
             hasLoader: e.hasLoader,
             hasSubscribe: e.hasSubscribe,
         })),
+        ...(middlewareEntries.length > 0 ? {
+            middlewares: middlewareEntries.map(e => ({
+                dir: e.dir,
+                module: e.dir ? `middleware/${e.dir}/_middleware.js` : 'middleware/_middleware.js',
+            })),
+        } : {}),
         ...(i18nConfig ? { i18n: i18nConfig } : {}),
+        ...(hasAuthConfig ? { auth: { configModule: 'auth-config.js' } } : {}),
+        prefetch: prefetchStrategy,
     };
     fs.writeFileSync(path.join(outDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+    // --- Pre-render phase ---
+    await prerenderPages({
+        serverDir,
+        clientDir,
+        pagesDir,
+        pageEntries,
+        layoutEntries,
+        manifest,
+    });
     console.log('[LumenJS] Build complete.');
     console.log(`  Output: ${outDir}`);
     console.log(`  Client assets: ${clientDir}`);

package/dist/build/scan.d.ts

@@ -4,6 +4,11 @@ export interface PageEntry {
     routePath: string;
     hasLoader: boolean;
     hasSubscribe: boolean;
+    hasSocket: boolean;
+    hasAuth: boolean;
+    hasMeta: boolean;
+    hasStandalone: boolean;
+    prerender: boolean;
 }
 export interface LayoutEntry {
     dir: string;
@@ -21,3 +26,16 @@ export declare function scanLayouts(pagesDir: string): LayoutEntry[];
 export declare function scanApiRoutes(apiDir: string): ApiEntry[];
 /** Get the layout directory chain for a given page file */
 export declare function getLayoutDirsForPage(pageFilePath: string, pagesDir: string, layouts: LayoutEntry[]): string[];
+export interface MiddlewareEntry {
+    dir: string;
+    filePath: string;
+}
+/**
+ * Scan for _middleware.ts files in the pages directory tree.
+ */
+export declare function scanMiddleware(pagesDir: string): MiddlewareEntry[];
+/**
+ * Get middleware directories that match a given URL pathname.
+ * Returns matching middleware entries from root → deepest.
+ */
+export declare function getMiddlewareDirsForPathname(pathname: string, entries: MiddlewareEntry[]): MiddlewareEntry[];

package/dist/build/scan.js

@@ -1,6 +1,33 @@
 import fs from 'fs';
 import path from 'path';
-import { fileHasLoader, fileHasSubscribe, filePathToRoute } from '../shared/utils.js';
+import { filePathToRoute, fileHasLoader, fileHasSubscribe } from '../shared/utils.js';
+/** Read a page file once and check all flags from the same content. */
+function analyzePageFile(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const classStart = content.search(/export\s+class\s+\w+/);
+        const hasExportBefore = (regex) => {
+            const match = regex.exec(content);
+            if (!match)
+                return false;
+            if (classStart >= 0 && match.index > classStart)
+                return false;
+            return true;
+        };
+        return {
+            hasLoader: hasExportBefore(/export\s+(async\s+)?function\s+loader\s*\(/),
+            hasSubscribe: hasExportBefore(/export\s+(async\s+)?function\s+subscribe\s*\(/),
+            hasSocket: /export\s+(function|const)\s+socket[\s(=]/.test(content),
+            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*=/),
+            prerender: /export\s+const\s+prerender\s*=\s*true/.test(content),
+        };
+    }
+    catch {
+        return { hasLoader: false, hasSubscribe: false, hasSocket: false, hasAuth: false, hasMeta: false, hasStandalone: false, prerender: false };
+    }
+}
 export function scanPages(pagesDir) {
     if (!fs.existsSync(pagesDir))
         return [];
@@ -44,18 +71,23 @@ export function getLayoutDirsForPage(pageFilePath, pagesDir, layouts) {
 function walkDir(baseDir, relativePath, entries, pagesDir) {
     const fullDir = path.join(baseDir, relativePath);
     const dirEntries = fs.readdirSync(fullDir, { withFileTypes: true });
+    // Check if this subdirectory contains an index file (folder route)
+    // Only applies to subdirectories, not the root pages directory
+    const hasIndex = relativePath !== '' && dirEntries.some(e => e.isFile() && /^index\.(ts|js)$/.test(e.name));
     for (const entry of dirEntries) {
         const entryRelative = path.join(relativePath, entry.name);
-        if (entry.isDirectory()) {
+        if (entry.isDirectory() && !entry.name.startsWith('_')) {
             walkDir(baseDir, entryRelative, entries, pagesDir);
         }
         else if (entry.isFile() && /\.(ts|js)$/.test(entry.name) && !entry.name.startsWith('_')) {
+            // In a folder route (has index file), only register the index file and dynamic param files
+            if (hasIndex && !/^index\.(ts|js)$/.test(entry.name) && !entry.name.startsWith('['))
+                continue;
             const filePath = path.join(pagesDir, entryRelative);
             const name = entryRelative.replace(/\.(ts|js)$/, '').replace(/\\/g, '/');
             const routePath = filePathToRoute(entryRelative);
-            const hasLoader = fileHasLoader(filePath);
-            const hasSubscribe = fileHasSubscribe(filePath);
-            entries.push({ name, filePath, routePath, hasLoader, hasSubscribe });
+            const flags = analyzePageFile(filePath);
+            entries.push({ name, filePath, routePath, ...flags });
         }
     }
 }
@@ -68,11 +100,50 @@ function walkForLayouts(baseDir, relativePath, entries) {
             const dir = relativePath.replace(/\\/g, '/');
             entries.push({ dir, filePath, hasLoader: fileHasLoader(filePath), hasSubscribe: fileHasSubscribe(filePath) });
         }
-        if (entry.isDirectory()) {
+        if (entry.isDirectory() && !entry.name.startsWith('_')) {
             walkForLayouts(baseDir, path.join(relativePath, entry.name), entries);
         }
     }
 }
+/**
+ * Scan for _middleware.ts files in the pages directory tree.
+ */
+export function scanMiddleware(pagesDir) {
+    if (!fs.existsSync(pagesDir))
+        return [];
+    const entries = [];
+    walkForMiddleware(pagesDir, '', entries);
+    return entries;
+}
+/**
+ * Get middleware directories that match a given URL pathname.
+ * Returns matching middleware entries from root → deepest.
+ */
+export function getMiddlewareDirsForPathname(pathname, entries) {
+    const urlSegments = pathname.replace(/^\//, '').split('/').filter(Boolean);
+    return entries.filter(entry => {
+        if (entry.dir === '')
+            return true; // Root middleware applies to all routes
+        const dirSegments = entry.dir.split('/').filter(Boolean);
+        if (dirSegments.length > urlSegments.length)
+            return false;
+        return dirSegments.every((seg, i) => seg === urlSegments[i]);
+    }).sort((a, b) => a.dir.split('/').length - b.dir.split('/').length);
+}
+function walkForMiddleware(baseDir, relativePath, entries) {
+    const fullDir = path.join(baseDir, relativePath);
+    const dirEntries = fs.readdirSync(fullDir, { withFileTypes: true });
+    for (const entry of dirEntries) {
+        if (entry.isFile() && /^_middleware\.(ts|js)$/.test(entry.name)) {
+            const filePath = path.join(fullDir, entry.name);
+            const dir = relativePath.replace(/\\/g, '/');
+            entries.push({ dir, filePath });
+        }
+        if (entry.isDirectory() && !entry.name.startsWith('_')) {
+            walkForMiddleware(baseDir, path.join(relativePath, entry.name), entries);
+        }
+    }
+}
 function walkApiDir(baseDir, relativePath, entries, apiDir) {
     const fullDir = path.join(baseDir, relativePath);
     const dirEntries = fs.readdirSync(fullDir, { withFileTypes: true });

package/dist/build/serve-api.js

@@ -2,6 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { readBody } from '../shared/utils.js';
 import { matchRoute } from '../shared/route-matching.js';
+import { useStorage } from '../storage/index.js';
 export async function handleApiRoute(manifest, serverDir, pathname, queryString, method, req, res) {
     const matched = matchRoute(manifest.apiRoutes, pathname);
     if (!matched) {
@@ -9,7 +10,9 @@ export async function handleApiRoute(manifest, serverDir, pathname, queryString,
         res.end(JSON.stringify({ error: 'API route not found' }));
         return;
     }
-    const modulePath = path.join(serverDir, matched.route.module);
+    // Vite replaces [param] with _param_ in output filenames
+    const resolvedModule = matched.route.module.replace(/\[([^\]]+)\]/g, '_$1_');
+    const modulePath = path.join(serverDir, resolvedModule);
     if (!fs.existsSync(modulePath)) {
         res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
         res.end(JSON.stringify({ error: 'API route module not found' }));
@@ -43,13 +46,16 @@ export async function handleApiRoute(manifest, serverDir, pathname, queryString,
             params: matched.params,
             body,
             headers: req.headers,
+            storage: useStorage(),
+            nkAuth: req.nkAuth,
         });
         res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
         res.end(JSON.stringify(result));
     }
     catch (err) {
         const status = err?.status || 500;
-        const message = err?.message || 'Internal server error';
+        // Only expose error messages for client errors (4xx); hide internals for 5xx
+        const message = status < 500 ? (err?.message || 'Request error') : 'Internal server error';
         res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
         res.end(JSON.stringify({ error: message }));
     }

package/dist/build/serve-loaders.d.ts

@@ -1,6 +1,6 @@
 import http from 'http';
 import type { BuildManifest } from '../shared/types.js';
-export declare function handleLayoutLoaderRequest(manifest: BuildManifest, serverDir: string, queryString: string | undefined, headers: http.IncomingHttpHeaders, res: http.ServerResponse): Promise<void>;
-export declare function handleLayoutSubscribeRequest(manifest: BuildManifest, serverDir: string, queryString: string | undefined, headers: http.IncomingHttpHeaders, res: http.ServerResponse): Promise<void>;
-export declare function handleSubscribeRequest(manifest: BuildManifest, serverDir: string, pagesDir: string, pathname: string, queryString: string | undefined, headers: http.IncomingHttpHeaders, res: http.ServerResponse): Promise<void>;
-export declare function handleLoaderRequest(manifest: BuildManifest, serverDir: string, pagesDir: string, pathname: string, queryString: string | undefined, headers: http.IncomingHttpHeaders, res: http.ServerResponse): Promise<void>;
+export declare function handleLayoutLoaderRequest(manifest: BuildManifest, serverDir: string, queryString: string | undefined, headers: http.IncomingHttpHeaders, res: http.ServerResponse, user?: any): Promise<void>;
+export declare function handleLayoutSubscribeRequest(manifest: BuildManifest, serverDir: string, queryString: string | undefined, headers: http.IncomingHttpHeaders, res: http.ServerResponse, user?: any): Promise<void>;
+export declare function handleSubscribeRequest(manifest: BuildManifest, serverDir: string, pagesDir: string, pathname: string, queryString: string | undefined, headers: http.IncomingHttpHeaders, res: http.ServerResponse, user?: any): Promise<void>;
+export declare function handleLoaderRequest(manifest: BuildManifest, serverDir: string, pagesDir: string, pathname: string, queryString: string | undefined, headers: http.IncomingHttpHeaders, res: http.ServerResponse, user?: any): Promise<void>;

package/dist/build/serve-loaders.js

@@ -2,7 +2,15 @@ import fs from 'fs';
 import path from 'path';
 import { isRedirectResponse } from '../shared/utils.js';
 import { matchRoute } from '../shared/route-matching.js';
-export async function handleLayoutLoaderRequest(manifest, serverDir, queryString, headers, res) {
+import { logger } from '../shared/logger.js';
+/** Resolve a module path, falling back to bracket-sanitized filename (Rollup replaces [] with _) */
+function resolveModulePath(serverDir, moduleName) {
+    const p = path.join(serverDir, moduleName);
+    if (fs.existsSync(p))
+        return p;
+    return path.join(serverDir, moduleName.replace(/\[/g, '_').replace(/\]/g, '_'));
+}
+export async function handleLayoutLoaderRequest(manifest, serverDir, queryString, headers, res, user) {
     const query = {};
     if (queryString) {
         for (const pair of queryString.split('&')) {
@@ -18,7 +26,7 @@ export async function handleLayoutLoaderRequest(manifest, serverDir, queryString
         res.end(JSON.stringify({ __nk_no_loader: true }));
         return;
     }
-    const modulePath = path.join(serverDir, layout.module);
+    const modulePath = resolveModulePath(serverDir, layout.module);
     if (!fs.existsSync(modulePath)) {
         res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
         res.end(JSON.stringify({ __nk_no_loader: true }));
@@ -34,7 +42,7 @@ export async function handleLayoutLoaderRequest(manifest, serverDir, queryString
         // Parse locale from query for layout loader
         const locale = query.__locale;
         delete query.__locale;
-        const result = await mod.loader({ params: {}, query: {}, url: `/__layout/${dir}`, headers, locale });
+        const result = await mod.loader({ params: {}, query: {}, url: `/__layout/${dir}`, headers, locale, user: user ?? null });
         if (isRedirectResponse(result)) {
             res.writeHead(result.status || 302, { Location: result.location });
             res.end();
@@ -49,14 +57,14 @@ export async function handleLayoutLoaderRequest(manifest, serverDir, queryString
             res.end();
             return;
         }
-        console.error(`[LumenJS] Layout loader error for dir=${dir}:`, err);
+        logger.error(`Layout loader error`, { dir, error: err?.message });
         const status = err?.status || 500;
-        const message = err?.message || 'Layout loader failed';
+        const message = status < 500 ? (err?.message || 'Layout loader failed') : 'Internal server error';
         res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
         res.end(JSON.stringify({ error: message }));
     }
 }
-export async function handleLayoutSubscribeRequest(manifest, serverDir, queryString, headers, res) {
+export async function handleLayoutSubscribeRequest(manifest, serverDir, queryString, headers, res, user) {
     const query = {};
     if (queryString) {
         for (const pair of queryString.split('&')) {
@@ -71,7 +79,7 @@ export async function handleLayoutSubscribeRequest(manifest, serverDir, queryStr
         res.end();
         return;
     }
-    const modulePath = path.join(serverDir, layout.module);
+    const modulePath = resolveModulePath(serverDir, layout.module);
     if (!fs.existsSync(modulePath)) {
         res.writeHead(204);
         res.end();
@@ -93,21 +101,21 @@ export async function handleLayoutSubscribeRequest(manifest, serverDir, queryStr
         const push = (data) => {
             res.write(`data: ${JSON.stringify(data)}\n\n`);
         };
-        const cleanup = mod.subscribe({ params: {}, push, headers, locale });
+        const cleanup = mod.subscribe({ params: {}, push, headers, locale, user: user ?? null });
         res.on('close', () => {
             if (typeof cleanup === 'function')
                 cleanup();
         });
     }
     catch (err) {
-        console.error(`[LumenJS] Layout subscribe error for dir=${dir}:`, err);
+        logger.error(`Layout subscribe error`, { dir, error: err?.message });
         if (!res.headersSent) {
             res.writeHead(500);
             res.end();
         }
     }
 }
-export async function handleSubscribeRequest(manifest, serverDir, pagesDir, pathname, queryString, headers, res) {
+export async function handleSubscribeRequest(manifest, serverDir, pagesDir, pathname, queryString, headers, res, user) {
     const pagePath = pathname.replace('/__nk_subscribe', '') || '/';
     const query = {};
     if (queryString) {
@@ -130,7 +138,7 @@ export async function handleSubscribeRequest(manifest, serverDir, pagesDir, path
         res.end();
         return;
     }
-    const modulePath = path.join(serverDir, matched.route.module);
+    const modulePath = resolveModulePath(serverDir, matched.route.module);
     if (!fs.existsSync(modulePath)) {
         res.writeHead(204);
         res.end();
@@ -152,21 +160,21 @@ export async function handleSubscribeRequest(manifest, serverDir, pagesDir, path
         const push = (data) => {
             res.write(`data: ${JSON.stringify(data)}\n\n`);
         };
-        const cleanup = mod.subscribe({ params: matched.params, push, headers, locale });
+        const cleanup = mod.subscribe({ params: matched.params, push, headers, locale, user: user ?? null });
         res.on('close', () => {
             if (typeof cleanup === 'function')
                 cleanup();
         });
     }
     catch (err) {
-        console.error(`[LumenJS] Subscribe error for ${pagePath}:`, err);
+        logger.error(`Subscribe error`, { pagePath, error: err?.message });
         if (!res.headersSent) {
             res.writeHead(500);
             res.end();
         }
     }
 }
-export async function handleLoaderRequest(manifest, serverDir, pagesDir, pathname, queryString, headers, res) {
+export async function handleLoaderRequest(manifest, serverDir, pagesDir, pathname, queryString, headers, res, user) {
     const pagePath = pathname.replace('/__nk_loader', '') || '/';
     // Parse query params
     const query = {};
@@ -191,7 +199,7 @@ export async function handleLoaderRequest(manifest, serverDir, pagesDir, pathnam
         res.end(JSON.stringify({ __nk_no_loader: true }));
         return;
     }
-    const modulePath = path.join(serverDir, matched.route.module);
+    const modulePath = resolveModulePath(serverDir, matched.route.module);
     if (!fs.existsSync(modulePath)) {
         res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
         res.end(JSON.stringify({ __nk_no_loader: true }));
@@ -206,7 +214,7 @@ export async function handleLoaderRequest(manifest, serverDir, pagesDir, pathnam
         }
         const locale = query.__locale;
         delete query.__locale;
-        const result = await mod.loader({ params: matched.params, query, url: pagePath, headers, locale });
+        const result = await mod.loader({ params: matched.params, query, url: pagePath, headers, locale, user: user ?? null });
         if (isRedirectResponse(result)) {
             res.writeHead(result.status || 302, { Location: result.location });
             res.end();
@@ -221,9 +229,9 @@ export async function handleLoaderRequest(manifest, serverDir, pagesDir, pathnam
             res.end();
             return;
         }
-        console.error(`[LumenJS] Loader error for ${pagePath}:`, err);
+        logger.error(`Loader error`, { pagePath, error: err?.message });
         const status = err?.status || 500;
-        const message = err?.message || 'Loader failed';
+        const message = status < 500 ? (err?.message || 'Loader failed') : 'Internal server error';
         res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
         res.end(JSON.stringify({ error: message }));
     }