@nuraly/lumenjs 0.1.0

package/dist/build/serve-api.js

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import path from 'path';
+import { readBody } from '../shared/utils.js';
+import { matchRoute } from '../shared/route-matching.js';
+export async function handleApiRoute(manifest, serverDir, pathname, queryString, method, req, res) {
+    const matched = matchRoute(manifest.apiRoutes, pathname);
+    if (!matched) {
+        res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ error: 'API route not found' }));
+        return;
+    }
+    const modulePath = path.join(serverDir, matched.route.module);
+    if (!fs.existsSync(modulePath)) {
+        res.writeHead(404, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ error: 'API route module not found' }));
+        return;
+    }
+    const mod = await import(modulePath);
+    const handler = mod[method];
+    if (!handler || typeof handler !== 'function') {
+        res.writeHead(405, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ error: `Method ${method} not allowed` }));
+        return;
+    }
+    // Parse query
+    const query = {};
+    if (queryString) {
+        for (const pair of queryString.split('&')) {
+            const [key, val] = pair.split('=');
+            query[decodeURIComponent(key)] = decodeURIComponent(val || '');
+        }
+    }
+    // Parse body for non-GET methods
+    let body = undefined;
+    if (method !== 'GET' && method !== 'HEAD') {
+        body = await readBody(req);
+    }
+    try {
+        const result = await handler({
+            method,
+            url: pathname,
+            query,
+            params: matched.params,
+            body,
+            headers: req.headers,
+        });
+        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';
+        res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ error: message }));
+    }
+}

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

@@ -0,0 +1,4 @@
+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 handleLoaderRequest(manifest: BuildManifest, serverDir: string, pagesDir: string, pathname: string, queryString: string | undefined, headers: http.IncomingHttpHeaders, res: http.ServerResponse): Promise<void>;

package/dist/build/serve-loaders.js

@@ -0,0 +1,115 @@
+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) {
+    const query = {};
+    if (queryString) {
+        for (const pair of queryString.split('&')) {
+            const [key, val] = pair.split('=');
+            query[decodeURIComponent(key)] = decodeURIComponent(val || '');
+        }
+    }
+    const dir = query.__dir || '';
+    // Find the layout in manifest
+    const layout = (manifest.layouts || []).find(l => l.dir === dir);
+    if (!layout || !layout.hasLoader || !layout.module) {
+        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ __nk_no_loader: true }));
+        return;
+    }
+    const modulePath = path.join(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 }));
+        return;
+    }
+    try {
+        const mod = await import(modulePath);
+        if (!mod.loader || typeof mod.loader !== 'function') {
+            res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+            res.end(JSON.stringify({ __nk_no_loader: true }));
+            return;
+        }
+        const result = await mod.loader({ params: {}, query: {}, url: `/__layout/${dir}`, headers });
+        if (isRedirectResponse(result)) {
+            res.writeHead(result.status || 302, { Location: result.location });
+            res.end();
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify(result ?? null));
+    }
+    catch (err) {
+        if (isRedirectResponse(err)) {
+            res.writeHead(err.status || 302, { Location: err.location });
+            res.end();
+            return;
+        }
+        console.error(`[LumenJS] Layout loader error for dir=${dir}:`, err);
+        const status = err?.status || 500;
+        const message = err?.message || 'Layout loader failed';
+        res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ error: message }));
+    }
+}
+export async function handleLoaderRequest(manifest, serverDir, pagesDir, pathname, queryString, headers, res) {
+    const pagePath = pathname.replace('/__nk_loader', '') || '/';
+    // Parse query params
+    const query = {};
+    if (queryString) {
+        for (const pair of queryString.split('&')) {
+            const [key, val] = pair.split('=');
+            query[decodeURIComponent(key)] = decodeURIComponent(val || '');
+        }
+    }
+    let params = {};
+    if (query.__params) {
+        try {
+            params = JSON.parse(query.__params);
+        }
+        catch { /* ignore */ }
+        delete query.__params;
+    }
+    // Find the matching route with a loader
+    const matched = matchRoute(manifest.routes.filter(r => r.hasLoader), pagePath);
+    if (!matched || !matched.route.module) {
+        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ __nk_no_loader: true }));
+        return;
+    }
+    const modulePath = path.join(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 }));
+        return;
+    }
+    try {
+        const mod = await import(modulePath);
+        if (!mod.loader || typeof mod.loader !== 'function') {
+            res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+            res.end(JSON.stringify({ __nk_no_loader: true }));
+            return;
+        }
+        const result = await mod.loader({ params: matched.params, query, url: pagePath, headers });
+        if (isRedirectResponse(result)) {
+            res.writeHead(result.status || 302, { Location: result.location });
+            res.end();
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify(result ?? null));
+    }
+    catch (err) {
+        if (isRedirectResponse(err)) {
+            res.writeHead(err.status || 302, { Location: err.location });
+            res.end();
+            return;
+        }
+        console.error(`[LumenJS] Loader error for ${pagePath}:`, err);
+        const status = err?.status || 500;
+        const message = err?.message || 'Loader failed';
+        res.writeHead(status, { 'Content-Type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ error: message }));
+    }
+}

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

@@ -0,0 +1,7 @@
+import http from 'http';
+import type { BuildManifest } from '../shared/types.js';
+export declare function handlePageRoute(manifest: BuildManifest, serverDir: string, pagesDir: string, pathname: string, queryString: string | undefined, indexHtmlShell: string, title: string, ssrRuntime: {
+    render: any;
+    html: any;
+    unsafeStatic: any;
+} | null, req: http.IncomingMessage, res: http.ServerResponse): Promise<void>;

package/dist/build/serve-ssr.js

@@ -0,0 +1,121 @@
+import fs from 'fs';
+import path from 'path';
+import { stripOuterLitMarkers, dirToLayoutTagName, findTagName, isRedirectResponse } from '../shared/utils.js';
+import { matchRoute } from '../shared/route-matching.js';
+import { sendCompressed } from './serve-static.js';
+export async function handlePageRoute(manifest, serverDir, pagesDir, pathname, queryString, indexHtmlShell, title, ssrRuntime, req, res) {
+    // Find matching route (any route, not just those with loaders)
+    const allMatched = matchRoute(manifest.routes, pathname);
+    // Try SSR for routes with loaders
+    const matched = matchRoute(manifest.routes.filter(r => r.hasLoader), pathname);
+    if (matched && matched.route.module) {
+        const modulePath = path.join(serverDir, matched.route.module);
+        if (fs.existsSync(modulePath)) {
+            try {
+                const mod = await import(modulePath);
+                // Run loader
+                let loaderData = undefined;
+                if (mod.loader && typeof mod.loader === 'function') {
+                    loaderData = await mod.loader({ params: matched.params, query: {}, url: pathname, headers: req.headers });
+                    if (isRedirectResponse(loaderData)) {
+                        res.writeHead(loaderData.status || 302, { Location: loaderData.location });
+                        res.end();
+                        return;
+                    }
+                }
+                // Find tag name from module
+                const tagName = findTagName(mod);
+                // Run layout loaders
+                const layoutDirs = (allMatched || matched).route.layouts || [];
+                const layoutsData = [];
+                const layoutModules = [];
+                for (const dir of layoutDirs) {
+                    const layout = (manifest.layouts || []).find(l => l.dir === dir);
+                    if (!layout)
+                        continue;
+                    let layoutLoaderData = undefined;
+                    if (layout.hasLoader && layout.module) {
+                        const layoutModulePath = path.join(serverDir, layout.module);
+                        if (fs.existsSync(layoutModulePath)) {
+                            const layoutMod = await import(layoutModulePath);
+                            if (layoutMod.loader && typeof layoutMod.loader === 'function') {
+                                layoutLoaderData = await layoutMod.loader({ params: {}, query: {}, url: pathname, headers: req.headers });
+                                if (isRedirectResponse(layoutLoaderData)) {
+                                    res.writeHead(layoutLoaderData.status || 302, { Location: layoutLoaderData.location });
+                                    res.end();
+                                    return;
+                                }
+                            }
+                        }
+                    }
+                    const layoutTagName = dirToLayoutTagName(dir);
+                    layoutsData.push({ loaderPath: dir, data: layoutLoaderData });
+                    layoutModules.push({ tagName: layoutTagName, loaderData: layoutLoaderData });
+                }
+                if (tagName && ssrRuntime) {
+                    // SSR render with the bundled @lit-labs/ssr runtime
+                    try {
+                        const { render, html, unsafeStatic } = ssrRuntime;
+                        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);
+                        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>`;
+                        let html_out = indexHtmlShell;
+                        html_out = html_out.replace(/<nk-app><\/nk-app>/, `${loaderDataScript}<nk-app data-nk-ssr><div id="nk-router-outlet">${ssrHtml}</div></nk-app>${hydrateScript}`);
+                        sendCompressed(req, res, 200, 'text/html; charset=utf-8', html_out);
+                        return;
+                    }
+                    catch (ssrErr) {
+                        console.error('[LumenJS] SSR render failed, falling back to CSR:', ssrErr);
+                    }
+                }
+                // Fallback: inject loader data without SSR HTML
+                if (loaderData !== undefined || layoutsData.length > 0) {
+                    const ssrDataObj = layoutsData.length > 0
+                        ? { page: loaderData, layouts: layoutsData }
+                        : loaderData;
+                    const loaderDataScript = `<script type="application/json" id="__nk_ssr_data__">${JSON.stringify(ssrDataObj).replace(/</g, '\\u003c')}</script>`;
+                    let html_out = indexHtmlShell.replace('<nk-app>', `${loaderDataScript}<nk-app>`);
+                    sendCompressed(req, res, 200, 'text/html; charset=utf-8', html_out);
+                    return;
+                }
+            }
+            catch (err) {
+                console.error('[LumenJS] Page handler error:', err);
+            }
+        }
+    }
+    // SPA fallback — serve the built index.html
+    sendCompressed(req, res, 200, 'text/html; charset=utf-8', indexHtmlShell);
+}

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

@@ -0,0 +1,6 @@
+import http from 'http';
+export declare const MIME_TYPES: Record<string, string>;
+export declare function isCompressible(contentType: string): boolean;
+export declare function acceptsGzip(req: http.IncomingMessage): boolean;
+export declare function sendCompressed(req: http.IncomingMessage, res: http.ServerResponse, statusCode: number, contentType: string, body: string | Buffer): void;
+export declare function serveStaticFile(clientDir: string, pathname: string, req: http.IncomingMessage, res: http.ServerResponse): boolean;

package/dist/build/serve-static.js

@@ -0,0 +1,80 @@
+import fs from 'fs';
+import path from 'path';
+import { createGzip } from 'zlib';
+import { pipeline } from 'stream';
+export const MIME_TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'application/javascript; charset=utf-8',
+    '.mjs': 'application/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.json': 'application/json; charset=utf-8',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.webp': 'image/webp',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.otf': 'font/otf',
+    '.map': 'application/json',
+    '.txt': 'text/plain; charset=utf-8',
+    '.xml': 'application/xml',
+    '.webmanifest': 'application/manifest+json',
+};
+const COMPRESSIBLE_TYPES = new Set([
+    'text/html', 'text/css', 'text/plain', 'text/xml',
+    'application/javascript', 'application/json', 'application/xml',
+    'application/manifest+json', 'image/svg+xml',
+]);
+export function isCompressible(contentType) {
+    const base = contentType.split(';')[0].trim();
+    return COMPRESSIBLE_TYPES.has(base);
+}
+export function acceptsGzip(req) {
+    const ae = req.headers['accept-encoding'];
+    return typeof ae === 'string' && ae.includes('gzip');
+}
+export function sendCompressed(req, res, statusCode, contentType, body) {
+    if (acceptsGzip(req) && isCompressible(contentType) && Buffer.byteLength(body) > 1024) {
+        res.writeHead(statusCode, { 'Content-Type': contentType, 'Content-Encoding': 'gzip', 'Vary': 'Accept-Encoding' });
+        const gzip = createGzip();
+        pipeline(gzip, res, () => { });
+        gzip.end(body);
+    }
+    else {
+        res.writeHead(statusCode, { 'Content-Type': contentType });
+        res.end(body);
+    }
+}
+export function serveStaticFile(clientDir, pathname, req, res) {
+    // Prevent directory traversal
+    const safePath = path.normalize(pathname).replace(/^(\.\.[/\\])+/, '');
+    const filePath = path.join(clientDir, safePath);
+    if (!filePath.startsWith(clientDir)) {
+        return false;
+    }
+    if (!fs.existsSync(filePath) || fs.statSync(filePath).isDirectory()) {
+        return false;
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    const contentType = MIME_TYPES[ext] || 'application/octet-stream';
+    const cacheControl = pathname.includes('/assets/') && /\.[a-f0-9]{8,}\./.test(pathname)
+        ? 'public, max-age=31536000, immutable'
+        : 'public, max-age=3600';
+    const content = fs.readFileSync(filePath);
+    if (acceptsGzip(req) && isCompressible(contentType) && content.length > 1024) {
+        res.writeHead(200, { 'Content-Type': contentType, 'Cache-Control': cacheControl, 'Content-Encoding': 'gzip', 'Vary': 'Accept-Encoding' });
+        const gzip = createGzip();
+        pipeline(gzip, res, () => { });
+        gzip.end(content);
+    }
+    else {
+        res.writeHead(200, { 'Content-Type': contentType, 'Cache-Control': cacheControl });
+        res.end(content);
+    }
+    return true;
+}

package/dist/build/serve.d.ts

@@ -0,0 +1,5 @@
+export interface ServeOptions {
+    projectDir: string;
+    port?: number;
+}
+export declare function serveProject(options: ServeOptions): Promise<void>;

package/dist/build/serve.js

@@ -0,0 +1,79 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+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 { handlePageRoute } from './serve-ssr.js';
+import { renderErrorPage } from './error-page.js';
+export async function serveProject(options) {
+    const { projectDir } = options;
+    const port = options.port || 3000;
+    const outDir = path.join(projectDir, '.lumenjs');
+    const clientDir = path.join(outDir, 'client');
+    const serverDir = path.join(outDir, 'server');
+    const manifestPath = path.join(outDir, 'manifest.json');
+    if (!fs.existsSync(manifestPath)) {
+        console.error('[LumenJS] No build found. Run `lumenjs build` first.');
+        process.exit(1);
+    }
+    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+    const { title } = readProjectConfig(projectDir);
+    // 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.');
+        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.
+    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
+    installDomShims();
+    const pagesDir = path.join(projectDir, 'pages');
+    const server = http.createServer(async (req, res) => {
+        const url = req.url || '/';
+        const [pathname, queryString] = url.split('?');
+        const method = req.method || 'GET';
+        try {
+            // 1. API routes
+            if (pathname.startsWith('/api/')) {
+                await handleApiRoute(manifest, serverDir, pathname, queryString, method, req, res);
+                return;
+            }
+            // 2. Static assets — try to serve from client dir
+            if (pathname.includes('.')) {
+                const served = serveStaticFile(clientDir, pathname, req, res);
+                if (served)
+                    return;
+            }
+            // 3. Layout loader endpoint
+            if (pathname === '/__nk_loader/__layout/' || pathname === '/__nk_loader/__layout') {
+                await handleLayoutLoaderRequest(manifest, serverDir, queryString, req.headers, res);
+                return;
+            }
+            // 4. Loader endpoint for client-side navigation
+            if (pathname.startsWith('/__nk_loader/')) {
+                await handleLoaderRequest(manifest, serverDir, pagesDir, pathname, queryString, req.headers, res);
+                return;
+            }
+            // 5. Page routes — SSR render
+            await handlePageRoute(manifest, serverDir, pagesDir, pathname, queryString, indexHtmlShell, title, ssrRuntime, req, res);
+        }
+        catch (err) {
+            console.error('[LumenJS] Request error:', err);
+            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);
+        }
+    });
+    server.listen(port, () => {
+        console.log(`[LumenJS] Production server running at http://localhost:${port}`);
+    });
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import path from 'path';
+const args = process.argv.slice(2);
+const command = args[0];
+function getArg(name) {
+    const idx = args.indexOf(`--${name}`);
+    if (idx !== -1 && idx + 1 < args.length)
+        return args[idx + 1];
+    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)) {
+    console.error(USAGE);
+    process.exit(1);
+}
+const projectDir = path.resolve(getArg('project') || '.');
+async function main() {
+    if (command === 'dev') {
+        const { createDevServer } = await import('./dev-server/server.js');
+        const port = parseInt(getArg('port') || '3000', 10);
+        const editorMode = args.includes('--editor-mode');
+        const base = getArg('base') || '/';
+        console.log(`[LumenJS] Starting dev server...`);
+        console.log(`  Project: ${projectDir}`);
+        console.log(`  Port: ${port}`);
+        if (base !== '/')
+            console.log(`  Base: ${base}`);
+        console.log(`  Editor mode: ${editorMode}`);
+        const server = await createDevServer({ projectDir, port, editorMode, base });
+        await server.listen();
+        const address = server.httpServer?.address();
+        const actualPort = typeof address === 'object' && address ? address.port : port;
+        console.log(`[LumenJS] Dev server running at http://localhost:${actualPort}`);
+    }
+    else if (command === 'build') {
+        const { buildProject } = await import('./build/build.js');
+        const outDir = getArg('out');
+        console.log(`[LumenJS] Starting production build...`);
+        console.log(`  Project: ${projectDir}`);
+        if (outDir)
+            console.log(`  Output: ${outDir}`);
+        await buildProject({ projectDir, outDir });
+    }
+    else if (command === 'add') {
+        const integration = args[1];
+        const { addIntegration } = await import('./integrations/add.js');
+        await addIntegration(projectDir, integration);
+    }
+    else if (command === 'serve') {
+        const { serveProject } = await import('./build/serve.js');
+        const port = parseInt(getArg('port') || '3000', 10);
+        console.log(`[LumenJS] Starting production server...`);
+        console.log(`  Project: ${projectDir}`);
+        console.log(`  Port: ${port}`);
+        await serveProject({ projectDir, port });
+    }
+}
+main().catch(err => {
+    console.error('[LumenJS] Failed to start:', err);
+    process.exit(1);
+});

package/dist/dev-server/config.d.ts

@@ -0,0 +1,25 @@
+export interface ProjectConfig {
+    title: string;
+    integrations: string[];
+}
+/**
+ * Reads the project config from lumenjs.config.ts.
+ */
+export declare function readProjectConfig(projectDir: string): ProjectConfig;
+/**
+ * Reads the project title from lumenjs.config.ts (or returns default).
+ * @deprecated Use readProjectConfig() instead.
+ */
+export declare function readProjectTitle(projectDir: string): string;
+/**
+ * Returns the path to lumenjs's own node_modules.
+ */
+export declare function getLumenJSNodeModules(): string;
+/**
+ * Returns paths to lumenjs's compiled dist/ runtime and editor directories.
+ */
+export declare function getLumenJSDirs(): {
+    distDir: string;
+    runtimeDir: string;
+    editorDir: string;
+};

package/dist/dev-server/config.js

@@ -0,0 +1,55 @@
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+/**
+ * Reads the project config from lumenjs.config.ts.
+ */
+export function readProjectConfig(projectDir) {
+    let title = 'LumenJS App';
+    let integrations = [];
+    const configPath = path.join(projectDir, 'lumenjs.config.ts');
+    if (fs.existsSync(configPath)) {
+        try {
+            const configContent = fs.readFileSync(configPath, 'utf-8');
+            const titleMatch = configContent.match(/title\s*:\s*['"]([^'"]+)['"]/);
+            if (titleMatch)
+                title = titleMatch[1];
+            const intMatch = configContent.match(/integrations\s*:\s*\[([^\]]*)\]/);
+            if (intMatch) {
+                integrations = intMatch[1]
+                    .split(',')
+                    .map(s => s.trim().replace(/^['"]|['"]$/g, ''))
+                    .filter(Boolean);
+            }
+        }
+        catch { /* use defaults */ }
+    }
+    return { title, integrations };
+}
+/**
+ * Reads the project title from lumenjs.config.ts (or returns default).
+ * @deprecated Use readProjectConfig() instead.
+ */
+export function readProjectTitle(projectDir) {
+    return readProjectConfig(projectDir).title;
+}
+/**
+ * Returns the path to lumenjs's own node_modules.
+ */
+export function getLumenJSNodeModules() {
+    return path.resolve(__dirname, '../../node_modules');
+}
+/**
+ * Returns paths to lumenjs's compiled dist/ runtime and editor directories.
+ */
+export function getLumenJSDirs() {
+    const lumenRoot = path.resolve(__dirname, '../..');
+    const distDir = path.join(lumenRoot, 'dist');
+    return {
+        distDir,
+        runtimeDir: path.join(distDir, 'runtime'),
+        editorDir: path.join(distDir, 'editor'),
+    };
+}

package/dist/dev-server/index-html.d.ts

@@ -0,0 +1,16 @@
+export interface IndexHtmlOptions {
+    title: string;
+    editorMode: boolean;
+    ssrContent?: string;
+    loaderData?: any;
+    layoutsData?: Array<{
+        loaderPath: string;
+        data: any;
+    }>;
+    integrations?: string[];
+}
+/**
+ * Generates the index.html shell that loads the LumenJS app.
+ * Includes the router, app shell, and optionally the editor bridge.
+ */
+export declare function generateIndexHtml(options: IndexHtmlOptions): string;