@nuraly/lumenjs 0.1.3 → 0.1.4

package/dist/build/build-prerender.js

@@ -0,0 +1,159 @@
+import path from 'path';
+import fs from 'fs';
+import { pathToFileURL } from 'url';
+import { filePathToTagName, stripOuterLitMarkers, dirToLayoutTagName, isRedirectResponse, patchLoaderDataSpread } from '../shared/utils.js';
+import { installDomShims } from '../shared/dom-shims.js';
+import { getLayoutDirsForPage } from './scan.js';
+export async function prerenderPages(opts) {
+    const { serverDir, clientDir, pagesDir, pageEntries, layoutEntries, manifest } = opts;
+    const prerenderEntries = pageEntries.filter(e => e.prerender);
+    if (prerenderEntries.length === 0)
+        return;
+    console.log(`[LumenJS] Pre-rendering ${prerenderEntries.length} page(s)...`);
+    // Load SSR runtime (installs global DOM shims)
+    const ssrRuntimePath = pathToFileURL(path.join(serverDir, 'ssr-runtime.js')).href;
+    const ssrRuntime = await import(ssrRuntimePath);
+    const { render, html, unsafeStatic } = ssrRuntime;
+    // Install additional DOM shims
+    installDomShims();
+    // Read the built index.html shell
+    const indexHtmlShell = fs.readFileSync(path.join(clientDir, 'index.html'), 'utf-8');
+    let prerenderCount = 0;
+    for (const page of prerenderEntries) {
+        // Resolve server module path (Rollup sanitizes brackets in filenames)
+        let modulePath = path.join(serverDir, `pages/${page.name}.js`);
+        if (!fs.existsSync(modulePath)) {
+            modulePath = path.join(serverDir, `pages/${page.name}.js`.replace(/\[/g, '_').replace(/\]/g, '_'));
+        }
+        if (!fs.existsSync(modulePath)) {
+            console.warn(`  Skipping ${page.routePath}: server module not found`);
+            continue;
+        }
+        const mod = await import(pathToFileURL(modulePath).href);
+        // Determine paths to pre-render
+        const isDynamic = page.routePath.includes(':');
+        let pathsToRender = [];
+        if (isDynamic) {
+            // Dynamic route — call prerenderPaths() for param combinations
+            if (typeof mod.prerenderPaths === 'function') {
+                const paramsList = await mod.prerenderPaths();
+                for (const params of paramsList) {
+                    // Build pathname from route pattern and params
+                    let pathname = page.routePath;
+                    for (const [key, value] of Object.entries(params)) {
+                        // Handle both :param and :...param (catch-all) patterns
+                        pathname = pathname.replace(`:...${key}`, value).replace(`:${key}`, value);
+                    }
+                    pathsToRender.push({ pathname, params: params });
+                }
+            }
+            else {
+                console.warn(`  Skipping ${page.routePath}: dynamic route without prerenderPaths()`);
+                continue;
+            }
+        }
+        else {
+            // Static route — render once
+            pathsToRender.push({ pathname: page.routePath, params: {} });
+        }
+        for (const { pathname, params } of pathsToRender) {
+            // Run loader if present
+            let loaderData = undefined;
+            if (mod.loader && typeof mod.loader === 'function') {
+                loaderData = await mod.loader({ params, query: {}, url: pathname, headers: {} });
+                if (isRedirectResponse(loaderData)) {
+                    console.warn(`  Skipping ${pathname}: loader returned redirect`);
+                    continue;
+                }
+            }
+            // Get tag name
+            const relPath = path.relative(pagesDir, page.filePath).replace(/\\/g, '/');
+            const tagName = filePathToTagName(relPath);
+            // Load and render layout chain
+            const routeLayouts = getLayoutDirsForPage(page.filePath, pagesDir, layoutEntries);
+            const layoutModules = [];
+            const layoutsData = [];
+            for (const dir of routeLayouts) {
+                const layout = layoutEntries.find(l => l.dir === dir);
+                if (!layout)
+                    continue;
+                let layoutLoaderData = undefined;
+                if (layout.hasLoader) {
+                    const manifestLayout = manifest.layouts.find(l => l.dir === dir);
+                    if (manifestLayout?.module) {
+                        const layoutModPath = path.join(serverDir, manifestLayout.module);
+                        if (fs.existsSync(layoutModPath)) {
+                            const layoutMod = await import(pathToFileURL(layoutModPath).href);
+                            if (layoutMod.loader && typeof layoutMod.loader === 'function') {
+                                layoutLoaderData = await layoutMod.loader({ params: {}, query: {}, url: pathname, headers: {} });
+                                if (isRedirectResponse(layoutLoaderData))
+                                    continue;
+                            }
+                        }
+                    }
+                }
+                const layoutTagName = dirToLayoutTagName(dir);
+                layoutModules.push({ tagName: layoutTagName, loaderData: layoutLoaderData });
+                layoutsData.push({ loaderPath: dir, data: layoutLoaderData });
+            }
+            // Patch element classes to spread loaderData
+            for (const lm of layoutModules) {
+                patchLoaderDataSpread(lm.tagName);
+            }
+            patchLoaderDataSpread(tagName);
+            // SSR render page
+            const pageTag = unsafeStatic(tagName);
+            const pageTemplate = html `<${pageTag} .loaderData=${loaderData}></${pageTag}>`;
+            let ssrHtml = '';
+            for (const chunk of render(pageTemplate)) {
+                ssrHtml += typeof chunk === 'string' ? chunk : String(chunk);
+            }
+            ssrHtml = stripOuterLitMarkers(ssrHtml);
+            // Wrap in layout chain (inside-out, deepest first)
+            for (let i = layoutModules.length - 1; i >= 0; i--) {
+                const lTag = unsafeStatic(layoutModules[i].tagName);
+                const lData = layoutModules[i].loaderData;
+                const lTemplate = html `<${lTag} .loaderData=${lData}></${lTag}>`;
+                let lHtml = '';
+                for (const chunk of render(lTemplate)) {
+                    lHtml += typeof chunk === 'string' ? chunk : String(chunk);
+                }
+                if (i > 0) {
+                    lHtml = stripOuterLitMarkers(lHtml);
+                }
+                const closingTag = `</${layoutModules[i].tagName}>`;
+                const closingIdx = lHtml.lastIndexOf(closingTag);
+                if (closingIdx !== -1) {
+                    ssrHtml = lHtml.slice(0, closingIdx) + ssrHtml + lHtml.slice(closingIdx);
+                }
+                else {
+                    ssrHtml = lHtml + ssrHtml;
+                }
+            }
+            // Build SSR data script
+            const ssrDataObj = layoutsData.length > 0
+                ? { page: loaderData, layouts: layoutsData }
+                : loaderData;
+            const loaderDataScript = ssrDataObj !== undefined
+                ? `<script type="application/json" id="__nk_ssr_data__">${JSON.stringify(ssrDataObj).replace(/</g, '\\u003c')}</script>`
+                : '';
+            const hydrateScript = `<script type="module">import '@lit-labs/ssr-client/lit-element-hydrate-support.js';</script>`;
+            // Build final HTML from the shell
+            let htmlOut = indexHtmlShell;
+            htmlOut = htmlOut.replace('<script type="module"', `${hydrateScript}\n  <script type="module"`);
+            htmlOut = htmlOut.replace(/<nk-app><\/nk-app>/, `${loaderDataScript}<nk-app data-nk-ssr><div id="nk-router-outlet">${ssrHtml}</div></nk-app>`);
+            // Write pre-rendered HTML file
+            const outPath = pathname === '/'
+                ? path.join(clientDir, 'index.html')
+                : path.join(clientDir, pathname, 'index.html');
+            // Don't overwrite the root index.html for non-root pages
+            if (pathname !== '/') {
+                fs.mkdirSync(path.dirname(outPath), { recursive: true });
+            }
+            fs.writeFileSync(outPath, htmlOut);
+            prerenderCount++;
+            console.log(`  Pre-rendered: ${pathname}`);
+        }
+    }
+    console.log(`[LumenJS] Pre-rendered ${prerenderCount} page(s).`);
+}

package/dist/build/build-server.d.ts

@@ -0,0 +1,17 @@
+import { type UserConfig, type Plugin } from 'vite';
+import type { PageEntry, LayoutEntry, ApiEntry } from './scan.js';
+export interface BuildServerOptions {
+    projectDir: string;
+    serverDir: string;
+    pageEntries: PageEntry[];
+    layoutEntries: LayoutEntry[];
+    apiEntries: ApiEntry[];
+    hasAuthConfig: boolean;
+    authConfigPath: string;
+    shared: {
+        resolve: UserConfig['resolve'];
+        esbuild: UserConfig['esbuild'];
+        plugins: Plugin[];
+    };
+}
+export declare function buildServer(opts: BuildServerOptions): Promise<void>;

package/dist/build/build-server.js

@@ -0,0 +1,98 @@
+import { build as viteBuild } from 'vite';
+import path from 'path';
+import fs from 'fs';
+export async function buildServer(opts) {
+    const { projectDir, serverDir, pageEntries, layoutEntries, apiEntries, hasAuthConfig, authConfigPath, shared } = opts;
+    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 || entry.prerender) {
+            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;
+    }
+    if (hasAuthConfig) {
+        serverEntries['auth-config'] = authConfigPath;
+    }
+    // If data/seed.ts exists, include it in the server bundle for prod seed support
+    const seedPath = path.join(projectDir, 'data', 'seed.ts');
+    if (fs.existsSync(seedPath)) {
+        serverEntries['seed'] = seedPath;
+    }
+    // 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);
+    const hasPrerenderPages = pageEntries.some(e => e.prerender);
+    if (hasPageLoaders || hasLayoutLoaders || hasPrerenderPages) {
+        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',
+                            // Native addons — must not be bundled, loaded from node_modules at runtime
+                            'better-sqlite3',
+                        ],
+                    },
+                },
+                logLevel: 'warn',
+                ssr: {
+                    noExternal: true,
+                },
+            });
+        }
+        else {
+            fs.mkdirSync(serverDir, { recursive: true });
+        }
+    }
+    finally {
+        if (fs.existsSync(ssrEntryPath)) {
+            fs.unlinkSync(ssrEntryPath);
+        }
+    }
+}

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 { 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,42 @@ 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
     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);
+    // 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,
+        hasAuthConfig,
+        authConfigPath,
+        shared,
+    });
     // --- Copy locales ---
     if (i18nConfig) {
         const localesDir = path.join(projectDir, 'locales');
@@ -160,15 +73,19 @@ 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.prerender) ? `pages/${e.name}.js` : '',
                 hasLoader: e.hasLoader,
                 hasSubscribe: e.hasSubscribe,
                 tagName: filePathToTagName(relPath),
                 ...(routeLayouts.length > 0 ? { layouts: routeLayouts } : {}),
+                ...(e.hasAuth ? { hasAuth: true } : {}),
+                ...(e.hasMeta ? { hasMeta: true } : {}),
+                ...(e.hasStandalone ? { hasStandalone: true } : {}),
+                ...(e.prerender ? { prerender: true } : {}),
             };
         }),
         apiRoutes: apiEntries.map(e => ({
@@ -184,8 +101,19 @@ export async function buildProject(options) {
             hasSubscribe: e.hasSubscribe,
         })),
         ...(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,10 @@ export interface PageEntry {
     routePath: string;
     hasLoader: boolean;
     hasSubscribe: boolean;
+    hasAuth: boolean;
+    hasMeta: boolean;
+    hasStandalone: boolean;
+    prerender: boolean;
 }
 export interface LayoutEntry {
     dir: string;
@@ -21,3 +25,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,32 @@
 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*\(/),
+            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, hasAuth: false, hasMeta: false, hasStandalone: false, prerender: false };
+    }
+}
 export function scanPages(pagesDir) {
     if (!fs.existsSync(pagesDir))
         return [];
@@ -44,18 +70,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 +99,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 }));
     }