satset-react 0.0.1-beta.0

package/dist/server/dev.js

@@ -0,0 +1,1052 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startDevServer = startDevServer;
+const http_1 = __importDefault(require("http"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const file_system_1 = require("../router/file-system");
+const hmr_1 = require("./hmr");
+const env_1 = require("./env");
+const error_overlay_1 = require("./error-overlay");
+const bundler_1 = require("./bundler");
+const response_1 = require("./response");
+const util_1 = __importDefault(require("util"));
+let buildCache = new Map();
+async function startDevServer(config = {}) {
+    const { port = 3000, host = 'localhost', root = process.cwd(), publicDir = 'public', favicon, } = config;
+    // Favicon link - set during startup
+    let faviconHref = null;
+    // Load environment variables
+    const env = (0, env_1.loadEnv)(root, 'development');
+    console.log('🚀 Starting Satset dev server...');
+    // Debug: log current working root and contents to ensure correct project path
+    console.debug('[dev] starting with root:', root);
+    try {
+        const rootFiles = fs_1.default.readdirSync(root);
+        console.debug('[dev] root files:', rootFiles);
+    }
+    catch (e) {
+        const rootErrMsg = e?.message ?? String(e);
+        console.debug('[dev] could not read root dir', rootErrMsg);
+    }
+    // Scan routes
+    const { routes, apiRoutes } = (0, file_system_1.getRoutes)(root);
+    console.log(`📁 Found ${routes.length} pages and ${apiRoutes.length} API routes`);
+    // Generate sitemap and robots into public/ if not present
+    try {
+        const { generateAndSaveSitemap } = await import('../assets/sitemap.js');
+        const { generateAndSaveRobots } = await import('../assets/robots.js');
+        await generateAndSaveSitemap(root, routes);
+        await generateAndSaveRobots(root);
+    }
+    catch (e) {
+        // ignore if asset generators aren't available
+    }
+    // Ensure favicon if configured or generate default if missing
+    async function ensureFavicon(rootDir, publicDirName, faviconSetting) {
+        const publicPath = path_1.default.join(rootDir, publicDirName);
+        try {
+            if (!fs_1.default.existsSync(publicPath))
+                fs_1.default.mkdirSync(publicPath, { recursive: true });
+        }
+        catch (e) { }
+        // If a setting is provided, handle several types
+        if (faviconSetting) {
+            // github:username -> use generateFavicon helper
+            if (typeof faviconSetting === 'string' && faviconSetting.startsWith('github:')) {
+                const username = faviconSetting.split(':', 2)[1];
+                try {
+                    const { generateFavicon } = await import('../assets/favicon.js');
+                    await generateFavicon(rootDir, username);
+                    faviconHref = '/favicon.png';
+                    return;
+                }
+                catch (e) {
+                    console.warn('Could not generate favicon from github username:', e);
+                }
+            }
+            // URL -> download into public
+            if (/^https?:\/\//i.test(faviconSetting)) {
+                try {
+                    const url = faviconSetting;
+                    const ext = path_1.default.extname(new URL(url).pathname) || '.png';
+                    const destName = ext === '.ico' ? 'favicon.ico' : 'favicon.png';
+                    const destPath = path_1.default.join(publicPath, destName);
+                    await downloadToFile(url, destPath);
+                    faviconHref = `/${destName}`;
+                    return;
+                }
+                catch (e) {
+                    console.warn('Failed to download favicon from URL:', e);
+                }
+            }
+            // Local path relative to project
+            try {
+                const srcPath = path_1.default.isAbsolute(faviconSetting) ? faviconSetting : path_1.default.join(rootDir, faviconSetting);
+                if (fs_1.default.existsSync(srcPath)) {
+                    const ext = path_1.default.extname(srcPath) || '.png';
+                    const destName = ext === '.ico' ? 'favicon.ico' : 'favicon.png';
+                    const destPath = path_1.default.join(publicPath, destName);
+                    fs_1.default.copyFileSync(srcPath, destPath);
+                    faviconHref = `/${destName}`;
+                    return;
+                }
+            }
+            catch (e) {
+                console.warn('Failed to use local favicon path:', e);
+            }
+        }
+        // If still no favicon, try to generate a default favicon.png if it doesn't exist
+        const pngPath = path_1.default.join(publicPath, 'favicon.png');
+        const icoPath = path_1.default.join(publicPath, 'favicon.ico');
+        if (fs_1.default.existsSync(pngPath) || fs_1.default.existsSync(icoPath)) {
+            faviconHref = fs_1.default.existsSync(icoPath) ? '/favicon.ico' : '/favicon.png';
+            return;
+        }
+        try {
+            const { generateFavicon } = await import('../assets/favicon.js');
+            await generateFavicon(rootDir);
+            faviconHref = '/favicon.png';
+        }
+        catch (e) {
+            // ignore - favicon generation optional
+        }
+    }
+    function downloadToFile(url, dest) {
+        return new Promise((resolve, reject) => {
+            const proto = url.startsWith('https') ? require('https') : require('http');
+            const file = fs_1.default.createWriteStream(dest);
+            proto.get(url, (resp) => {
+                if (resp.statusCode !== 200)
+                    return reject(new Error('Failed to download'));
+                resp.pipe(file);
+                file.on('finish', () => { file.close(); resolve(); });
+            }).on('error', (err) => {
+                try {
+                    fs_1.default.unlinkSync(dest);
+                }
+                catch (e) { }
+                reject(err);
+            });
+        });
+    }
+    // Run now
+    await ensureFavicon(root, publicDir, favicon);
+    // Setup build output directory
+    const tempDir = path_1.default.join(root, '.satset', 'temp');
+    if (!fs_1.default.existsSync(tempDir)) {
+        fs_1.default.mkdirSync(tempDir, { recursive: true });
+    }
+    // Initial build
+    console.log('📦 Building client bundle...');
+    await buildClientBundle(root, tempDir, routes);
+    // Create HTTP server
+    const server = http_1.default.createServer(async (req, res) => {
+        const url = req.url || '/';
+        // Serve bundled JS files
+        if (url.startsWith('/_satset/')) {
+            const filePath = path_1.default.join(tempDir, url.replace('/_satset/', ''));
+            if (fs_1.default.existsSync(filePath)) {
+                const ext = path_1.default.extname(filePath);
+                const contentType = getContentType(ext);
+                res.writeHead(200, { 'Content-Type': contentType });
+                fs_1.default.createReadStream(filePath).pipe(res);
+                return;
+            }
+        }
+        // Serve static files from public/
+        if (url.startsWith('/public/') || url.startsWith('/assets/')) {
+            const filePath = path_1.default.join(root, publicDir, url.replace(/^\/(public|assets)\//, ''));
+            if (fs_1.default.existsSync(filePath)) {
+                const ext = path_1.default.extname(filePath);
+                const contentType = getContentType(ext);
+                res.writeHead(200, { 'Content-Type': contentType });
+                fs_1.default.createReadStream(filePath).pipe(res);
+                return;
+            }
+        }
+        // Serve direct public files at root URLs (e.g., /image.png -> public/image.png)
+        // This mirrors Vite's behavior where static files in `public/` are available at '/{file}'
+        try {
+            const reqPath = (url || '/').split('?')[0].split('#')[0];
+            const parsed = path_1.default.parse(reqPath);
+            if (parsed.ext) {
+                const publicFilePath = path_1.default.join(root, publicDir, reqPath.replace(/^\/+/, ''));
+                if (fs_1.default.existsSync(publicFilePath)) {
+                    const contentType = getContentType(parsed.ext.toLowerCase());
+                    res.writeHead(200, { 'Content-Type': contentType });
+                    fs_1.default.createReadStream(publicFilePath).pipe(res);
+                    return;
+                }
+            }
+        }
+        catch (e) {
+            // ignore file serving errors
+        }
+        // Handle error reporting endpoint
+        if (url === '/__satset_error' && req.method === 'POST') {
+            let body = '';
+            req.on('data', chunk => { body += chunk; });
+            req.on('end', () => {
+                try {
+                    const errorInfo = JSON.parse(body);
+                    console.error('🔴 Runtime Error:', errorInfo.message);
+                    if (errorInfo.file && errorInfo.line) {
+                        errorInfo.code = (0, error_overlay_1.extractCodeSnippet)(errorInfo.file, errorInfo.line);
+                    }
+                    const overlayHTML = (0, error_overlay_1.generateErrorOverlayHTML)(errorInfo);
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(overlayHTML);
+                }
+                catch (e) {
+                    res.writeHead(400, { 'Content-Type': 'text/plain' });
+                    res.end('Bad Request');
+                }
+            });
+            return;
+        }
+        // Simple Server Actions endpoint (POST JSON: { name: 'actionName', data: { ... } })
+        if (url === '/_satset/action' && req.method === 'POST') {
+            let body = '';
+            req.on('data', chunk => { body += chunk; });
+            req.on('end', async () => {
+                try {
+                    const payload = JSON.parse(body || '{}');
+                    const actionName = payload?.name;
+                    const data = payload?.data || {};
+                    if (!actionName) {
+                        res.writeHead(400, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'Missing action name' }));
+                        return;
+                    }
+                    // try to find actions file
+                    const candidates = ['src/app/actions.ts', 'src/app/actions.js', 'src/app/actions.tsx'];
+                    let actionsPath = null;
+                    for (const c of candidates) {
+                        const p = path_1.default.join(root, c.replace(/^src\//, 'src/'));
+                        if (fs_1.default.existsSync(p)) {
+                            actionsPath = p;
+                            break;
+                        }
+                    }
+                    if (!actionsPath) {
+                        res.writeHead(404, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: 'No actions file found' }));
+                        return;
+                    }
+                    const baseName = path_1.default.basename(actionsPath).replace(/\.[^.]+$/, '');
+                    const compiled = path_1.default.join(tempDir, baseName + '.actions.server.js');
+                    try {
+                        try {
+                            await bundler_1.bundler.bundleServer({ entryPoint: actionsPath, outfile: compiled, minify: false, root, sourcemap: true });
+                        }
+                        catch (err) {
+                            const msg = String(err && err.message ? err.message : err);
+                            if (/ENOSPC|not enough space|There is not enough space/i.test(msg)) {
+                                console.warn('Low disk space detected while bundling actions. Attempting to clear temp and retry without sourcemaps.');
+                                try {
+                                    if (fs_1.default.existsSync(tempDir)) {
+                                        fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+                                    }
+                                    fs_1.default.mkdirSync(tempDir, { recursive: true });
+                                }
+                                catch (cleanupErr) {
+                                    console.error('Failed to cleanup temp dir:', cleanupErr);
+                                }
+                                await bundler_1.bundler.bundleServer({ entryPoint: actionsPath, outfile: compiled, minify: false, root, sourcemap: false });
+                            }
+                            else {
+                                throw err;
+                            }
+                        }
+                        try {
+                            delete require.cache[require.resolve(compiled)];
+                        }
+                        catch (e) { }
+                        const ActionsModule = require(compiled);
+                        const fn = ActionsModule && (ActionsModule[actionName] || (ActionsModule.default && ActionsModule.default[actionName]));
+                        if (!fn || typeof fn !== 'function') {
+                            res.writeHead(404, { 'Content-Type': 'application/json' });
+                            res.end(JSON.stringify({ error: `Action not found: ${actionName}` }));
+                            return;
+                        }
+                        // basic FormData-like helper
+                        const formLike = { _map: data, get(k) { return this._map[k]; }, entries() { return Object.entries(this._map); } };
+                        try {
+                            global.__SATSET_ACTION_RES__ = res;
+                        }
+                        catch (e) { }
+                        let result;
+                        try {
+                            result = await fn(formLike);
+                        }
+                        finally {
+                            try {
+                                delete global.__SATSET_ACTION_RES__;
+                            }
+                            catch (e) { }
+                        }
+                        // SatsetResponse handling
+                        const respMod = require('./response');
+                        if (result instanceof respMod.SatsetResponse) {
+                            respMod.sendSatsetResponse(res, result);
+                            return;
+                        }
+                        res.writeHead(200, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ result }));
+                        return;
+                    }
+                    catch (e) {
+                        const errInfo = { message: (e && e.message) || String(e), stack: e && e.stack, file: actionsPath };
+                        const overlayHTML = (0, error_overlay_1.generateErrorOverlayHTML)(errInfo);
+                        res.writeHead(500, { 'Content-Type': 'text/html' });
+                        res.end(overlayHTML);
+                        return;
+                    }
+                }
+                catch (e) {
+                    res.writeHead(400, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ error: 'Invalid request' }));
+                }
+            });
+            return;
+        }
+        // Handle API routes (support dynamic patterns)
+        const apiMatch = (0, file_system_1.matchRoute)(url, apiRoutes);
+        if (apiMatch) {
+            await handleApiRoute(apiMatch.route, req, res, root, tempDir, apiMatch.params);
+            return;
+        }
+        // Handle page routes (SSR) with dynamic matching
+        const matched = (0, file_system_1.matchRoute)(url, routes);
+        if (matched) {
+            await handlePageRoute(matched.route, req, res, root, tempDir, matched.params, routes, publicDir);
+            return;
+        }
+        // 404
+        res.writeHead(404, { 'Content-Type': 'text/html' });
+        res.end('<h1>404 - Page Not Found</h1>');
+    });
+    // Start HMR with bundler integration
+    const hmrServer = (0, hmr_1.startHMR)(server, root, async (changedFile) => {
+        console.log(`🔄 Rebuilding: ${changedFile}`);
+        await buildClientBundle(root, tempDir, routes);
+    });
+    const bindHost = host === true ? '0.0.0.0' : (host === false ? 'localhost' : host);
+    server.listen(port, bindHost, () => {
+        console.log(`✅ Server running at http://${bindHost === '0.0.0.0' ? 'localhost' : bindHost}:${port}`);
+        if (host === true) {
+            try {
+                const os = require('os');
+                const nets = os.networkInterfaces();
+                const addresses = [];
+                for (const name of Object.keys(nets)) {
+                    for (const net of nets[name]) {
+                        if (net.family === 'IPv4' && !net.internal)
+                            addresses.push(net.address);
+                    }
+                }
+                for (const a of addresses) {
+                    console.log(`🔗 On your network: http://${a}:${port}`);
+                }
+            }
+            catch (e) { }
+        }
+        console.log(`🔥 HMR enabled`);
+    });
+    return { server, hmrServer };
+}
+async function buildClientBundle(root, outdir, routes) {
+    try {
+        // Create entry file that imports all pages
+        const importLines = [];
+        const routeDefLines = [];
+        let importIndex = 0;
+        for (const route of routes) {
+            if (!fs_1.default.existsSync(route.component)) {
+                // skip removed/missing components (can happen during HMR file moves)
+                console.warn('Skipping missing component while building client bundle:', route.component);
+                continue;
+            }
+            // Only include client components ("use client") in the client bundle
+            let includeInClient = false;
+            try {
+                const content = fs_1.default.readFileSync(route.component, 'utf-8');
+                if (content.includes("'use client'") || content.includes('"use client"')) {
+                    includeInClient = true;
+                }
+            }
+            catch (e) {
+                includeInClient = false;
+            }
+            if (!includeInClient) {
+                // Skip server-only pages to avoid bundling Node-only imports (fs/path)
+                console.debug('Skipping server-only page for client bundle:', route.component);
+                continue;
+            }
+            const relativePath = path_1.default.relative(root, route.component).replace(/\\/g, '/');
+            importLines.push(`import Page${importIndex} from '../../${relativePath}';`);
+            routeDefLines.push(`  { path: '${route.path}', component: Page${importIndex} },`);
+            importIndex++;
+        }
+        const entryContent = `
+import React from 'react';
+import { hydrateRoot } from 'react-dom/client';
+
+// Import all page components
+${importLines.join('\n')}
+
+// Route definitions
+const routeDefs = [
+${routeDefLines.join('\n')}
+];
+
+function matchPath(pathname) {
+  const pathSegments = pathname.split('/').filter(Boolean);
+  for (const r of routeDefs) {
+    const routeSegments = r.path.split('/').filter(Boolean);
+
+    // catch-all
+    if (r.path.includes('*')) {
+      const catchIndex = routeSegments.findIndex(s => s.startsWith('*'));
+      const paramName = routeSegments[catchIndex].slice(1);
+      const params = {};
+      params[paramName] = pathSegments.slice(catchIndex).join('/');
+      return { component: r.component, params };
+    }
+
+    if (routeSegments.length !== pathSegments.length) continue;
+
+    let matched = true;
+    const params = {};
+
+    for (let i = 0; i < routeSegments.length; i++) {
+      const rs = routeSegments[i];
+      const ps = pathSegments[i];
+
+      if (rs.startsWith(':')) {
+        params[rs.slice(1)] = ps;
+      } else if (rs !== ps) {
+        matched = false;
+        break;
+      }
+    }
+
+    if (matched) {
+      return { component: r.component, params };
+    }
+  }
+
+  // fallback to root route
+  return { component: routeDefs.find(r => r.path === '/')?.component, params: {} };
+}
+
+// Hydrate based on current path
+const currentPath = window.location.pathname;
+const match = matchPath(currentPath);
+// expose routes and params to Router
+window.__SATSET_ROUTES__ = routeDefs.map(r => r.path);
+window.__SATSET_PARAMS__ = match.params || {};
+
+const PageComponent = match.component;
+
+if (PageComponent) {
+  const root = document.getElementById('root');
+  if (root) {
+    hydrateRoot(root, React.createElement(PageComponent, match.params ? { params: match.params } : undefined));
+  }
+}
+    `;
+        const entryPath = path_1.default.join(outdir, '_entry.tsx');
+        fs_1.default.writeFileSync(entryPath, entryContent);
+        // Ensure a global CSS exists in outdir
+        const cssPath = path_1.default.join(outdir, 'globals.css');
+        try {
+            if (!fs_1.default.existsSync(cssPath)) {
+                // Try to copy project-specific styles if present
+                const projectCss = path_1.default.join(root, 'src', 'styles', 'global.css');
+                if (fs_1.default.existsSync(projectCss)) {
+                    try {
+                        console.debug('[dev] copying project global css from', projectCss, 'to', cssPath);
+                        fs_1.default.copyFileSync(projectCss, cssPath);
+                        console.debug('[dev] copied global css');
+                    }
+                    catch (err) {
+                        console.warn('[dev] failed to copy project css:', err);
+                        fs_1.default.writeFileSync(cssPath, 'body{font-family:system-ui;}.container{max-width:900px;margin:0 auto;padding:24px}');
+                    }
+                }
+                else {
+                    fs_1.default.writeFileSync(cssPath, 'body{font-family:system-ui;}.container{max-width:900px;margin:0 auto;padding:24px}');
+                    console.debug('[dev] wrote default globals.css to', cssPath);
+                }
+            }
+        }
+        catch (err) {
+            console.warn('[dev] error ensuring globals.css:', err);
+        }
+        // Bundle with esbuild
+        await bundler_1.bundler.bundle({
+            entryPoints: [entryPath],
+            outdir,
+            minify: false,
+            sourcemap: true,
+            watch: false,
+            root,
+        });
+        console.log('✅ Client bundle ready');
+    }
+    catch (error) {
+        console.error('❌ Build error:', error.message);
+    }
+}
+async function handleApiRoute(route, req, res, root, tempDir, params = {}) {
+    try {
+        // Compile API module to CJS before requiring to support TS/ESM sources
+        const baseName = path_1.default.basename(route.component).replace(/\.[^.]+$/, '');
+        const compiledApiPath = path_1.default.join(tempDir, baseName + '.api.server.js');
+        let ApiModule = null;
+        // Use the same safe bundler helper for API modules
+        async function safeBundleApi(entry, outfile) {
+            try {
+                await bundler_1.bundler.bundleServer({ entryPoint: entry, outfile, minify: false, root, sourcemap: true });
+            }
+            catch (err) {
+                const msg = String(err && err.message ? err.message : err);
+                if (/ENOSPC|not enough space|There is not enough space/i.test(msg)) {
+                    try {
+                        if (fs_1.default.existsSync(tempDir)) {
+                            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+                        }
+                        fs_1.default.mkdirSync(tempDir, { recursive: true });
+                    }
+                    catch (cleanupErr) {
+                        console.error('Failed to cleanup temp dir:', cleanupErr);
+                    }
+                    await bundler_1.bundler.bundleServer({ entryPoint: entry, outfile, minify: false, root, sourcemap: false });
+                    return;
+                }
+                throw err;
+            }
+        }
+        try {
+            await safeBundleApi(route.component, compiledApiPath);
+            try {
+                delete require.cache[require.resolve(compiledApiPath)];
+            }
+            catch (e) { }
+            ApiModule = require(compiledApiPath);
+        }
+        catch (err) {
+            console.error('API bundling failed for', route.component, err);
+            const errMsg = String(err && err.message ? err.message : err);
+            const errorInfo = {
+                message: /ENOSPC|not enough space|There is not enough space/i.test(errMsg) ? 'API bundling failed: not enough disk space. Free disk space or delete .satset/temp' : 'API bundling failed',
+                stack: err && err.stack ? err.stack : String(err),
+                file: route.component,
+            };
+            const overlayHTML = (0, error_overlay_1.generateErrorOverlayHTML)(errorInfo);
+            res.writeHead(500, { 'Content-Type': 'text/html' });
+            res.end(overlayHTML);
+            return;
+        }
+        function resolveHandler(mod) {
+            if (!mod)
+                return null;
+            // default export function
+            if (typeof mod === 'function')
+                return { default: mod };
+            if (mod && typeof mod === 'object') {
+                if (typeof mod.default === 'function')
+                    return { default: mod.default };
+                // method-named exports (GET, POST, etc.)
+                const methods = ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'];
+                const out = {};
+                for (const m of methods) {
+                    if (typeof mod[m] === 'function')
+                        out[m] = mod[m];
+                }
+                if (Object.keys(out).length)
+                    return out;
+            }
+            return null;
+        }
+        const handlerObj = resolveHandler(ApiModule);
+        const method = (req.method || 'GET').toUpperCase();
+        async function callHandlerWithNodeStyle(fn) {
+            // If function declares at least two args, assume Node-style (req, res)
+            if (fn.length >= 2) {
+                const maybe = await fn(req, res, params);
+                // If the handler returns a SatsetResponse, send it
+                if (response_1.SatsetResponse.isSatsetResponse(maybe)) {
+                    (0, response_1.sendSatsetResponse)(res, maybe);
+                }
+                // assume the handler handled the Node res
+                return true;
+            }
+            return false;
+        }
+        async function callHandlerWithWebStyle(fn) {
+            // Build a lightweight Request-like object for route handlers
+            const webReq = await (0, response_1.buildSatsetRequest)(req);
+            const result = await fn(webReq, { params });
+            if (response_1.SatsetResponse.isSatsetResponse(result)) {
+                (0, response_1.sendSatsetResponse)(res, result);
+                return true;
+            }
+            // If result is a native Response-like object with json/text, try to handle
+            if (result && typeof result === 'object' && typeof result.status === 'number' && (result.headers || result.json)) {
+                // Try basic mapping
+                const status = result.status || 200;
+                // Normalize headers: support Headers instance, array of tuples, or plain object
+                let headers = {};
+                const rawHeaders = result.headers;
+                if (rawHeaders) {
+                    if (typeof rawHeaders.get === 'function' && typeof rawHeaders.entries === 'function') {
+                        headers = Object.fromEntries(rawHeaders.entries());
+                    }
+                    else if (Array.isArray(rawHeaders)) {
+                        headers = Object.fromEntries(rawHeaders);
+                    }
+                    else if (typeof rawHeaders === 'object') {
+                        headers = rawHeaders;
+                    }
+                }
+                let body = undefined;
+                try {
+                    if (typeof result.json === 'function') {
+                        body = await result.json();
+                        res.writeHead(status, { 'Content-Type': 'application/json', ...headers });
+                        res.end(JSON.stringify(body));
+                        return true;
+                    }
+                    if (typeof result.text === 'function') {
+                        body = await result.text();
+                        res.writeHead(status, headers);
+                        res.end(body);
+                        return true;
+                    }
+                }
+                catch (e) {
+                    // fallthrough
+                }
+            }
+            // If result is an object, return as JSON
+            if (result && typeof result === 'object') {
+                const sat = response_1.SatsetResponse.json(result);
+                (0, response_1.sendSatsetResponse)(res, sat);
+                return true;
+            }
+            // If result is string or number, send as text
+            if (result != null) {
+                res.writeHead(200, { 'Content-Type': 'text/plain' });
+                res.end(String(result));
+                return true;
+            }
+            // undefined -> assume handler will manage res; if not, leave to caller
+            return false;
+        }
+        // Prefer method-named export for App-style handlers
+        if (handlerObj && typeof handlerObj[method] === 'function') {
+            const fn = handlerObj[method];
+            // Try node-style first
+            const nodeTook = await callHandlerWithNodeStyle(fn);
+            if (nodeTook)
+                return;
+            // Fallback to Web-style
+            const webTook = await callHandlerWithWebStyle(fn);
+            if (webTook)
+                return;
+            // no response produced
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        // Default export fallback
+        if (handlerObj && typeof handlerObj.default === 'function') {
+            const fn = handlerObj.default;
+            const nodeTook = await callHandlerWithNodeStyle(fn);
+            if (nodeTook)
+                return;
+            const webTook = await callHandlerWithWebStyle(fn);
+            if (webTook)
+                return;
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        res.writeHead(405, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Method not allowed' }));
+    }
+    catch (error) {
+        const errorInfo = {
+            message: error.message,
+            stack: error.stack,
+            file: route.component,
+        };
+        const overlayHTML = (0, error_overlay_1.generateErrorOverlayHTML)(errorInfo);
+        res.writeHead(500, { 'Content-Type': 'text/html' });
+        res.end(overlayHTML);
+    }
+}
+async function handlePageRoute(route, req, res, root, tempDir, initialParams = {}, allRoutes = [], publicDirName = 'public') {
+    try {
+        // Load env
+        const env = (0, env_1.loadEnv)(root, 'development');
+        const envScript = (0, env_1.getPublicEnvScript)(env.publicVars);
+        // Server-side render the component
+        // Compile page module to a temporary server file so Node can require it (handles tsx/esm)
+        const baseName = path_1.default.basename(route.component).replace(/\.[^.]+$/, '');
+        const compiledServerPath = path_1.default.join(tempDir, baseName + '.server.js');
+        let PageModule = null;
+        // Helper: bundle server build with low-disk fallback
+        async function safeBundleServer(entry, outfile) {
+            try {
+                await bundler_1.bundler.bundleServer({ entryPoint: entry, outfile, minify: false, root, sourcemap: true });
+            }
+            catch (err) {
+                const msg = String(err && err.message ? err.message : err);
+                // detect low-disk / ENOSPC errors (esbuild reports "There is not enough space on the disk" in Windows)
+                if (/ENOSPC|not enough space|There is not enough space/i.test(msg)) {
+                    console.warn('Low disk space detected while bundling. Attempting to clear temp and retry without sourcemaps.');
+                    try {
+                        // clear temp dir to free space
+                        if (fs_1.default.existsSync(tempDir)) {
+                            fs_1.default.rmSync(tempDir, { recursive: true, force: true });
+                        }
+                        fs_1.default.mkdirSync(tempDir, { recursive: true });
+                    }
+                    catch (cleanupErr) {
+                        console.error('Failed to cleanup temp dir:', cleanupErr);
+                    }
+                    try {
+                        await bundler_1.bundler.bundleServer({ entryPoint: entry, outfile, minify: false, root, sourcemap: false });
+                        return;
+                    }
+                    catch (retryErr) {
+                        // still failed
+                        throw retryErr;
+                    }
+                }
+                // Not a disk-space issue, rethrow
+                throw err;
+            }
+        }
+        try {
+            // Bundle the page for Node (CJS)
+            await safeBundleServer(route.component, compiledServerPath);
+            try {
+                delete require.cache[require.resolve(compiledServerPath)];
+            }
+            catch (e) {
+                // ignore
+            }
+            PageModule = require(compiledServerPath);
+        }
+        catch (err) {
+            // If bundling fails, show an overlay with the bundling error and do NOT require the original TSX (which would crash)
+            console.error('SSR bundling failed for', route.component, err);
+            let message = 'SSR bundling failed';
+            const errMsg = String(err && err.message ? err.message : err);
+            if (/ENOSPC|not enough space|There is not enough space/i.test(errMsg)) {
+                message = 'SSR bundling failed: not enough disk space. Try freeing disk space or deleting the .satset/temp folder.';
+            }
+            const errorInfo = {
+                message,
+                stack: err && err.stack ? err.stack : String(err),
+                file: route.component,
+            };
+            const overlayHTML = (0, error_overlay_1.generateErrorOverlayHTML)(errorInfo);
+            res.writeHead(500, { 'Content-Type': 'text/html' });
+            res.end(overlayHTML);
+            return;
+        }
+        function resolveExportedComponent(mod) {
+            if (!mod)
+                return null;
+            if (typeof mod === 'function')
+                return mod;
+            if (mod && typeof mod === 'object') {
+                if (typeof mod.default === 'function')
+                    return mod.default;
+                if (mod.default && typeof mod.default === 'object' && typeof mod.default.default === 'function')
+                    return mod.default.default;
+                for (const key of Object.keys(mod)) {
+                    if (typeof mod[key] === 'function')
+                        return mod[key];
+                }
+            }
+            return null;
+        }
+        const PageComponent = resolveExportedComponent(PageModule);
+        console.log('SSR: used component from', compiledServerPath, 'PageModule keys:', Object.keys(PageModule || {}), 'Resolved component type:', typeof PageComponent);
+        console.log('SSR: PageModule keys:', Object.keys(PageModule || {}), 'PageComponent type:', typeof PageComponent);
+        // Simple SSR with optional global layout composition
+        const React = require('react');
+        const { renderToString } = require('react-dom/server');
+        let pageHTML = '<div>Loading...</div>';
+        // Helper to render a component (sync or async) to HTML string
+        async function renderComponentToHtml(Comp, props = {}) {
+            if (!Comp || typeof Comp !== 'function') {
+                throw new Error('Invalid component to render');
+            }
+            const isAsync = Comp.constructor && Comp.constructor.name === 'AsyncFunction';
+            if (isAsync) {
+                const maybeNode = Comp(props);
+                const resolved = await Promise.resolve(maybeNode);
+                // If the async component returned a React element, render it
+                return renderToString(resolved);
+            }
+            return renderToString(React.createElement(Comp, props));
+        }
+        let statusCode = 200;
+        try {
+            // Ensure we actually have a function/component to render
+            if (!PageComponent || typeof PageComponent !== 'function') {
+                console.error('SSR Error: resolved page component is not a function. PageModule:', util_1.default.inspect(PageModule, { depth: 2 }));
+                const diagHtml = `<!doctype html><html><body><h1>500 - Component export error</h1><pre>${util_1.default.format('PageModule keys: %o\nResolved: %o', Object.keys(PageModule || {}), PageComponent)}</pre></body></html>`;
+                res.writeHead(500, { 'Content-Type': 'text/html' });
+                res.end(diagHtml);
+                return;
+            }
+            // Try to find a global layout route (path '/layout') in the discovered routes
+            let LayoutComponent = null;
+            try {
+                const layoutRoute = allRoutes.find(r => r.path === '/layout');
+                if (layoutRoute && layoutRoute.component) {
+                    const layoutBase = path_1.default.basename(layoutRoute.component).replace(/\.[^.]+$/, '');
+                    const layoutCompiled = path_1.default.join(tempDir, layoutBase + '.layout.server.js');
+                    await bundler_1.bundler.bundleServer({ entryPoint: layoutRoute.component, outfile: layoutCompiled, minify: false, root });
+                    try {
+                        delete require.cache[require.resolve(layoutCompiled)];
+                    }
+                    catch (e) { }
+                    const LayoutModule = require(layoutCompiled);
+                    // resolve exported component if present
+                    function resolveExportedComp(mod) {
+                        if (!mod)
+                            return null;
+                        if (typeof mod === 'function')
+                            return mod;
+                        if (mod && typeof mod === 'object') {
+                            if (typeof mod.default === 'function')
+                                return mod.default;
+                            for (const key of Object.keys(mod)) {
+                                if (typeof mod[key] === 'function')
+                                    return mod[key];
+                            }
+                        }
+                        return null;
+                    }
+                    LayoutComponent = resolveExportedComp(LayoutModule);
+                    if (!LayoutComponent) {
+                        console.warn('Layout module found but no component exported:', layoutRoute.component);
+                    }
+                    else {
+                        console.log('Using layout module for SSR:', layoutRoute.component);
+                    }
+                }
+            }
+            catch (e) {
+                const msg = e?.message ?? String(e);
+                console.warn('Could not load layout module:', msg);
+            }
+            // Render page (possibly async)
+            if (LayoutComponent) {
+                // render page as child and pass to layout
+                const PageFragmentHtml = await renderComponentToHtml(PageComponent, { params: initialParams });
+                // We need to render the Layout with the page element as `children` prop.
+                // Create a small wrapper component that returns the layout with children
+                const Wrapper = (props) => React.createElement(LayoutComponent, null, React.createElement(PageComponent, { params: initialParams }));
+                pageHTML = await renderComponentToHtml(Wrapper);
+            }
+            else {
+                pageHTML = await renderComponentToHtml(PageComponent, { params: initialParams });
+            }
+        }
+        catch (err) {
+            console.error('SSR Error:', err);
+            // special handling: notFound() throws a sentinel that we can identify
+            if (err && err.__SATSET_NOT_FOUND) {
+                statusCode = 404;
+                // attempt to render a root-level /not-found route if present
+                try {
+                    const nf = allRoutes.find(r => r.path === '/not-found' || r.path === '/404');
+                    if (nf && nf.component) {
+                        const nfBase = path_1.default.basename(nf.component).replace(/\.[^.]+$/, '');
+                        const nfCompiled = path_1.default.join(tempDir, nfBase + '.notfound.server.js');
+                        await bundler_1.bundler.bundleServer({ entryPoint: nf.component, outfile: nfCompiled, minify: false, root });
+                        try {
+                            delete require.cache[require.resolve(nfCompiled)];
+                        }
+                        catch (e) { }
+                        const NfModule = require(nfCompiled);
+                        const NfComp = (typeof NfModule === 'function') ? NfModule : (NfModule && typeof NfModule.default === 'function') ? NfModule.default : null;
+                        if (NfComp) {
+                            pageHTML = await renderComponentToHtml(NfComp, { params: initialParams });
+                        }
+                        else {
+                            pageHTML = '<h1>404 - Page Not Found</h1>';
+                        }
+                    }
+                    else {
+                        pageHTML = '<h1>404 - Page Not Found</h1>';
+                    }
+                }
+                catch (e) {
+                    pageHTML = '<h1>404 - Page Not Found</h1>';
+                }
+            }
+            else {
+                // general error: try to render /error route if present
+                statusCode = 500;
+                try {
+                    const er = allRoutes.find(r => r.path === '/error');
+                    if (er && er.component) {
+                        const erBase = path_1.default.basename(er.component).replace(/\.[^.]+$/, '');
+                        const erCompiled = path_1.default.join(tempDir, erBase + '.error.server.js');
+                        await bundler_1.bundler.bundleServer({ entryPoint: er.component, outfile: erCompiled, minify: false, root });
+                        try {
+                            delete require.cache[require.resolve(erCompiled)];
+                        }
+                        catch (e) { }
+                        const ErModule = require(erCompiled);
+                        const ErComp = (typeof ErModule === 'function') ? ErModule : (ErModule && typeof ErModule.default === 'function') ? ErModule.default : null;
+                        if (ErComp) {
+                            // pass error details to the error component for display
+                            pageHTML = await renderComponentToHtml(ErComp, { error: err, reset: () => { } });
+                        }
+                        else {
+                            throw err;
+                        }
+                    }
+                    else {
+                        throw err;
+                    }
+                }
+                catch (e) {
+                    // If all else fails, produce the dev overlay
+                    const errorInfo = {
+                        message: err?.message || String(err),
+                        stack: err?.stack,
+                        file: route.component,
+                    };
+                    const overlayHTML = (0, error_overlay_1.generateErrorOverlayHTML)(errorInfo);
+                    res.writeHead(500, { 'Content-Type': 'text/html' });
+                    res.end(overlayHTML);
+                    return;
+                }
+            }
+        }
+        // expose routes + initial params to client for Router
+        const routePaths = allRoutes.length ? allRoutes.map(r => r.path) : [];
+        // Check whether layout and CSS ended up in the rendered HTML for debugging
+        try {
+            const hasHeader = pageHTML.includes('<header');
+            const hasFooter = pageHTML.includes('<footer');
+            console.log(`SSR: rendered page includes header=${hasHeader} footer=${hasFooter}`);
+            const cssPath = path_1.default.join(tempDir, 'globals.css');
+            console.log('SSR: globals.css exists at', cssPath, fs_1.default.existsSync(cssPath));
+        }
+        catch (e) {
+            // ignore
+        }
+        // attempt to obtain metadata from the page module (static or via getMetadata)
+        let metaHtml = '';
+        try {
+            const { renderMetaTags } = await import('../assets/metadata.js');
+            // metadata may be exported as `metadata` or `getMetadata` function
+            let metaObj = null;
+            if (PageModule && PageModule.metadata) {
+                metaObj = PageModule.metadata;
+            }
+            else if (PageModule && typeof PageModule.getMetadata === 'function') {
+                try {
+                    metaObj = await PageModule.getMetadata({ params: initialParams });
+                }
+                catch (e) {
+                    metaObj = null;
+                }
+            }
+            // The `<Head>` component was removed; rely on exported `metadata` or `getMetadata` from the page/layout module.
+            metaHtml = renderMetaTags(metaObj);
+        }
+        catch (e) {
+            // ignore
+        }
+        const initialParamsScript = `<script>window.__SATSET_ROUTES__ = ${JSON.stringify(routePaths)}; window.__SATSET_PARAMS__ = ${JSON.stringify(initialParams)};</script>`;
+        // Determine favicon at request time (in case it was created/changed)
+        let computedFavicon = null;
+        try {
+            const publicPath = path_1.default.join(root, publicDirName);
+            if (fs_1.default.existsSync(path_1.default.join(publicPath, 'favicon.ico')))
+                computedFavicon = '/favicon.ico';
+            else if (fs_1.default.existsSync(path_1.default.join(publicPath, 'favicon.png')))
+                computedFavicon = '/favicon.png';
+        }
+        catch (e) {
+            // ignore
+        }
+        const faviconLink = computedFavicon ? `<link rel="icon" href="${computedFavicon}" />` : '';
+        const html = `
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    ${metaHtml}
+    ${faviconLink}
+    <link rel="stylesheet" href="/_satset/globals.css" />
+  </head>
+  <body>
+    <div id="root">${pageHTML}</div>
+    <script>${envScript}</script>
+    ${initialParamsScript}
+    <script type="module" src="/_satset/_entry.js"></script>
+    <script src="/__hmr"></script>
+    <!-- ... rest of scripts -->
+  </body>
+</html>
+    `;
+        res.writeHead(200, { 'Content-Type': 'text/html' });
+        res.end(html);
+    }
+    catch (error) {
+        const errorInfo = {
+            message: error.message,
+            stack: error.stack,
+            file: route.component,
+        };
+        if (route.component && fs_1.default.existsSync(route.component)) {
+            const stackLines = error.stack?.split('\n') || [];
+            const lineMatch = stackLines[0]?.match(/:(\d+):(\d+)/);
+            if (lineMatch) {
+                const line = parseInt(lineMatch[1]);
+                errorInfo.line = line;
+                errorInfo.column = parseInt(lineMatch[2]);
+                errorInfo.code = (0, error_overlay_1.extractCodeSnippet)(route.component, line);
+            }
+        }
+        const overlayHTML = (0, error_overlay_1.generateErrorOverlayHTML)(errorInfo);
+        res.writeHead(500, { 'Content-Type': 'text/html' });
+        res.end(overlayHTML);
+    }
+}
+function getContentType(ext) {
+    const types = {
+        '.html': 'text/html',
+        '.css': 'text/css',
+        '.js': 'application/javascript',
+        '.json': 'application/json',
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.svg': 'image/svg+xml',
+        '.woff': 'font/woff',
+        '.woff2': 'font/woff2',
+    };
+    return types[ext] || 'text/plain';
+}
+//# sourceMappingURL=dev.js.map