@vesk/adapter 0.0.1

package/dist/platform-output.js

@@ -0,0 +1,119 @@
+import { mkdirSync, copyFileSync, readdirSync, statSync, existsSync, writeFileSync, rmSync, readFileSync, } from 'node:fs';
+import { resolve, join, extname, dirname } from 'node:path';
+export const MIME = {
+    '.html': 'text/html; charset=utf-8',
+    '.htm': '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',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.ico': 'image/x-icon',
+    '.txt': 'text/plain; charset=utf-8',
+    '.xml': 'application/xml',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.wasm': 'application/wasm',
+    '.map': 'application/json',
+    '.webmanifest': 'application/manifest+json',
+};
+export function ensureCleanDir(dir) {
+    rmSync(dir, { recursive: true, force: true });
+    mkdirSync(dir, { recursive: true });
+}
+export function copyDirContents(srcDir, destDir) {
+    if (!existsSync(srcDir))
+        return;
+    mkdirSync(destDir, { recursive: true });
+    for (const entry of readdirSync(srcDir)) {
+        const srcPath = join(srcDir, entry);
+        const destPath = join(destDir, entry);
+        if (statSync(srcPath).isDirectory()) {
+            copyDirContents(srcPath, destPath);
+        }
+        else {
+            mkdirSync(dirname(destPath), { recursive: true });
+            copyFileSync(srcPath, destPath);
+        }
+    }
+}
+export function writeFile(path, content) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content, 'utf-8');
+}
+/**
+ * Lay out `.vesk/static/**` into a platform `static/` directory using the
+ * URL scheme the SSR output expects:
+ *   /_vesk/static/*  <- .vesk/static/*
+ *   /_vesk/runtime.js <- .vesk/static/client.js (alias)
+ *   /* (public)       <- .vesk/static/public/*
+ */
+export function writePlatformStatic(buildStaticDir, platformStaticDir) {
+    mkdirSync(platformStaticDir, { recursive: true });
+    const publicDir = resolve(buildStaticDir, 'public');
+    if (existsSync(publicDir)) {
+        copyDirContents(publicDir, platformStaticDir);
+    }
+    const assetsDir = resolve(platformStaticDir, '_vesk', 'static');
+    copyDirContents(buildStaticDir, assetsDir);
+    const runtimeAlias = resolve(platformStaticDir, '_vesk', 'runtime.js');
+    const clientPath = resolve(buildStaticDir, 'client.js');
+    if (existsSync(clientPath)) {
+        mkdirSync(dirname(runtimeAlias), { recursive: true });
+        copyFileSync(clientPath, runtimeAlias);
+    }
+}
+/**
+ * Write SSG pages into a platform static dir. They land under
+ * `_vesk/static/public/<path>.html` — the exact location the platform
+ * handler's prerendered 308 redirect points to — plus a `<path>/index.html`
+ * twin for trailing-slash URLs. `route.html` is the prerendered file path.
+ */
+export function writePrerenderedStatic(prerenderedRoutes, platformStaticDir) {
+    for (const route of prerenderedRoutes) {
+        if (!existsSync(route.html))
+            continue;
+        const content = readFileSync(route.html);
+        const htmlRel = route.path === '/' ? 'index.html' : `${route.path.replace(/^\//, '')}.html`;
+        const target = resolve(platformStaticDir, '_vesk', 'static', 'public', htmlRel);
+        writeFile(target, content);
+        if (route.path !== '/' && route.path.endsWith('/')) {
+            const dirIndex = resolve(platformStaticDir, '_vesk', 'static', 'public', `${route.path.replace(/^\//, '')}index.html`);
+            writeFile(dirIndex, content);
+        }
+    }
+}
+/**
+ * Recursively list the files of a static dir as `{ rel, buffer }` so a target
+ * runtime without a filesystem (generic edge) can inline them into the bundle.
+ */
+export function listStaticDir(dir) {
+    const out = [];
+    if (!existsSync(dir))
+        return out;
+    function walk(d, prefix) {
+        for (const entry of readdirSync(d)) {
+            const full = join(d, entry);
+            const rel = prefix ? `${prefix}/${entry}` : entry;
+            if (statSync(full).isDirectory()) {
+                walk(full, rel);
+            }
+            else {
+                out.push({ rel, buffer: readFileSync(full) });
+            }
+        }
+    }
+    walk(dir, '');
+    return out;
+}
+export function mimeFor(path) {
+    return MIME[extname(path).toLowerCase()] || 'application/octet-stream';
+}

package/dist/platform.d.ts

@@ -0,0 +1,17 @@
+export type Platform = 'node' | 'vercel' | 'netlify' | 'cloudflare' | 'deno' | 'aws' | 'edge' | 'coxmos';
+export interface PlatformEnv {
+    [key: string]: string | undefined;
+}
+/**
+ * Detect the deployment platform from the build environment so `vesk build`
+ * emits the correct artifact (Vercel Build Output API, Netlify functions,
+ * Cloudflare _worker.js, Deno entry, etc.) without extra flags.
+ *
+ * Precedence:
+ *   1. Explicit `--platform <name>` CLI override
+ *   2. Well-known platform environment variables set by CI/build systems
+ *   3. Defaults to `node`
+ */
+export declare function detectPlatform(args?: string[], env?: PlatformEnv): Platform;
+export declare function platformLabel(platform: Platform): string;
+//# sourceMappingURL=platform.d.ts.map

package/dist/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../src/platform.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,SAAS,GAAG,YAAY,GAAG,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,CAAC;AAIzG,MAAM,WAAW,WAAW;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,IAAI,GAAE,MAAM,EAAO,EAAE,GAAG,GAAE,WAAwC,GAAG,QAAQ,CAoB3G;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAExD"}

package/dist/platform.js

@@ -0,0 +1,35 @@
+const VALID = ['node', 'vercel', 'netlify', 'cloudflare', 'deno', 'aws', 'edge', 'coxmos'];
+/**
+ * Detect the deployment platform from the build environment so `vesk build`
+ * emits the correct artifact (Vercel Build Output API, Netlify functions,
+ * Cloudflare _worker.js, Deno entry, etc.) without extra flags.
+ *
+ * Precedence:
+ *   1. Explicit `--platform <name>` CLI override
+ *   2. Well-known platform environment variables set by CI/build systems
+ *   3. Defaults to `node`
+ */
+export function detectPlatform(args = [], env = process.env) {
+    const flagIdx = args.indexOf('--platform');
+    if (flagIdx !== -1) {
+        const explicit = (args[flagIdx + 1] || '').toLowerCase();
+        if (VALID.includes(explicit))
+            return explicit;
+    }
+    if (env.VERCEL || env.VERCEL_ENV || env.NOW_REGION || env.VERCEL_GIT_COMMIT_SHA)
+        return 'vercel';
+    if (env.NETLIFY || env.NETLIFY_BUILD_CONTEXT || env.NETLIFY_LOCAL || env.NETLIFY_EDGE)
+        return 'netlify';
+    if (env.CF_PAGES || env.CF_PAGES_BRANCH || env.CF_PAGES_URL || env.CLOUDFLARE_WORKERS || env.WORKERS_NAME)
+        return 'cloudflare';
+    if (env.DENO_DEPLOYMENT_ID || env.DENO_REGION || env.DENO_DEPLOY_URL)
+        return 'deno';
+    if (env.AWS_LAMBDA_FUNCTION_NAME || env.AWS_LAMBDA_FUNCTION_VERSION || env.LAMBDA_TASK_ROOT || env.LAMBDA_RUNTIME_DIR)
+        return 'aws';
+    if (env.COXMOS || env.COXMOS_DEPLOYMENT_ID || env.COXMOS_ENV || env.VESK_DEPLOY || env.VESK_PLATFORM === 'coxmos')
+        return 'coxmos';
+    return 'node';
+}
+export function platformLabel(platform) {
+    return platform === 'node' ? 'node (default)' : platform;
+}

package/dist/prod-server.d.ts

@@ -0,0 +1,5 @@
+import { type Server } from 'node:http';
+export declare function startProdServer(outDir: string, options?: {
+    port?: number;
+}): Promise<Server>;
+//# sourceMappingURL=prod-server.d.ts.map

package/dist/prod-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prod-server.d.ts","sourceRoot":"","sources":["../src/prod-server.ts"],"names":[],"mappings":"AAEA,OAAO,EAA2D,KAAK,MAAM,EAAE,MAAM,WAAW,CAAC;AAgGjG,wBAAsB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAyWlG"}

package/dist/prod-server.js

@@ -0,0 +1,429 @@
+import { readFileSync, existsSync, statSync } from 'node:fs';
+import { resolve, extname, dirname } from 'node:path';
+import { createServer } from 'node:http';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+import { createRateLimiter, resolveComponentName } from '@vesk/compiler/src/server-codegen';
+import { securityHeaders, getClientProtocol } from '@vesk/compiler/src/server-utils';
+const _require = createRequire(import.meta.url);
+const __dirname = dirname(fileURLToPath(import.meta.url));
+async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    return Buffer.concat(chunks);
+}
+function makeWebRequest(nodeReq, url) {
+    const parsedUrl = new URL(url, `http://${nodeReq.headers.host || 'localhost'}`);
+    const method = nodeReq.method || 'GET';
+    let _bodyBuffer = null;
+    async function getBody() {
+        if (_bodyBuffer)
+            return _bodyBuffer;
+        const chunks = [];
+        for await (const chunk of nodeReq)
+            chunks.push(Buffer.from(chunk));
+        _bodyBuffer = Buffer.concat(chunks);
+        return _bodyBuffer;
+    }
+    const webRequest = new Request(parsedUrl, { method, headers: nodeReq.headers, body: null });
+    webRequest.json = async () => { try {
+        return JSON.parse((await getBody()).toString());
+    }
+    catch {
+        return null;
+    } };
+    webRequest.text = async () => (await getBody()).toString('utf-8');
+    webRequest.formData = async () => {
+        const body = await getBody();
+        const ct = String(nodeReq.headers['content-type'] || '');
+        if (ct.includes('multipart/form-data')) {
+            const temp = new Request('http://localhost', { method: 'POST', headers: nodeReq.headers, body: body });
+            return temp.formData();
+        }
+        const fd = new FormData();
+        if (ct.includes('x-www-form-urlencoded')) {
+            for (const [k, v] of new URLSearchParams(body.toString()).entries())
+                fd.append(k, v);
+        }
+        return fd;
+    };
+    webRequest.clone = () => webRequest;
+    const cookies = {};
+    for (const [k, v] of String(nodeReq.headers.cookie || '').split(';').map(s => s.trim()).filter(Boolean)) {
+        const eq = k.indexOf('=');
+        if (eq > -1)
+            cookies[k.slice(0, eq)] = decodeURIComponent(k.slice(eq + 1));
+    }
+    webRequest.cookies = cookies;
+    const query = {};
+    for (const [k, v] of parsedUrl.searchParams.entries())
+        query[k] = v;
+    webRequest.query = query;
+    return webRequest;
+}
+const MIME = {
+    '.svg': 'image/svg+xml', '.css': 'text/css', '.js': 'application/javascript',
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.ico': 'image/x-icon', '.html': 'text/html', '.json': 'application/json',
+    '.woff': 'font/woff', '.woff2': 'font/woff2', '.wasm': 'application/wasm',
+};
+export async function startProdServer(outDir, options) {
+    const port = options?.port || 3000;
+    const staticDir = resolve(outDir, 'static');
+    const configPath = resolve(outDir, 'config.json');
+    if (!existsSync(configPath)) {
+        console.error(`vesk start: no build found at ${outDir}`);
+        console.error('Run "vesk build" first');
+        process.exit(1);
+    }
+    const buildConfig = JSON.parse(readFileSync(configPath, 'utf-8'));
+    console.error(`vesk start: serving from ${outDir}`);
+    const projectDir = resolve(outDir, '..');
+    let securityConfig = {};
+    try {
+        const veskConfigPath = resolve(projectDir, 'vesk.config.js');
+        const veskConfigTsPath = resolve(projectDir, 'vesk.config.ts');
+        let rawConfig = {};
+        if (existsSync(veskConfigPath)) {
+            rawConfig = _require(veskConfigPath);
+        }
+        else if (existsSync(veskConfigTsPath)) {
+            const { transpile } = _require('typescript');
+            const src = readFileSync(veskConfigTsPath, 'utf-8');
+            const result = transpile(src, { module: 99, target: 99 });
+            rawConfig = eval(`(${result})`);
+        }
+        if (typeof rawConfig === 'function')
+            rawConfig = rawConfig();
+        const configObj = rawConfig;
+        securityConfig = { security: configObj.security };
+    }
+    catch {
+        // ignore config load errors
+    }
+    let rateLimiter = null;
+    if (securityConfig?.rateLimit) {
+        const rlConfig = securityConfig.rateLimit;
+        rateLimiter = createRateLimiter({ windowMs: rlConfig.windowMs || 60000, max: rlConfig.max || 100 });
+    }
+    let securityHeadersFn = null;
+    try {
+        securityHeadersFn = securityHeaders;
+    }
+    catch {
+        // security headers not available
+    }
+    let middlewareMod = null;
+    const mwPath = resolve(outDir, 'server', 'middleware.js');
+    if (existsSync(mwPath)) {
+        try {
+            middlewareMod = await import(`${mwPath}?t=${Date.now()}`);
+        }
+        catch {
+            // ignore
+        }
+    }
+    const functionCache = new Map();
+    async function loadFunction(funcPath) {
+        if (functionCache.has(funcPath))
+            return functionCache.get(funcPath);
+        const fullPath = resolve(outDir, funcPath);
+        if (!existsSync(fullPath))
+            return null;
+        try {
+            const mod = await import(`${fullPath}?t=${Date.now()}`);
+            functionCache.set(funcPath, mod);
+            return mod;
+        }
+        catch {
+            return null;
+        }
+    }
+    function matchPath(pattern, pathname) {
+        const patternParts = pattern.split('/').filter(Boolean);
+        const pathParts = pathname.split('/').filter(Boolean);
+        let pi = 0, pp = 0;
+        const params = {};
+        while (pi < pathParts.length && pp < patternParts.length) {
+            if (patternParts[pp].startsWith(':')) {
+                const name = patternParts[pp].slice(1);
+                params[name] = pathParts[pi];
+                pi++;
+                pp++;
+            }
+            else if (patternParts[pp] === pathParts[pi]) {
+                pi++;
+                pp++;
+            }
+            else {
+                return null;
+            }
+        }
+        if (pp === patternParts.length && pi === pathParts.length)
+            return params;
+        return null;
+    }
+    function getClientIpFromReq(req) {
+        if (!securityConfig?.trustProxy)
+            return req.socket?.remoteAddress || 'unknown';
+        const forwarded = req.headers['x-forwarded-for'];
+        if (forwarded)
+            return (typeof forwarded === 'string' ? forwarded.split(',')[0] : forwarded[0]).trim();
+        return req.headers['x-real-ip'] || req.socket?.remoteAddress || 'unknown';
+    }
+    const server = createServer(async (req, res) => {
+        const url = new URL(req.url || '/', `http://localhost:${port}`);
+        const reqHost = req.headers.host || `localhost:${port}`;
+        const proto = req.socket.encrypted
+            ? 'https'
+            : getClientProtocol({ headers: req.headers }, !!securityConfig?.trustProxy);
+        globalThis.__vesk_ssr_base_url = `${proto}://${reqHost}`;
+        if (rateLimiter) {
+            const clientIp = getClientIpFromReq(req);
+            if (!rateLimiter.check(clientIp)) {
+                const retryAfter = Math.ceil((securityConfig?.rateLimit?.windowMs || 60000) / 1000);
+                res.writeHead(429, { 'Content-Type': 'application/json', 'Retry-After': String(retryAfter) });
+                res.end(JSON.stringify({ error: 'Too Many Requests' }));
+                return;
+            }
+        }
+        const origWriteHead = res.writeHead.bind(res);
+        let secHeadersApplied = false;
+        res.writeHead = ((statusCode, headers) => {
+            if (!secHeadersApplied && securityHeadersFn) {
+                secHeadersApplied = true;
+                const sh = securityHeadersFn({ security: securityConfig?.security || {} });
+                headers = { ...sh, ...headers };
+            }
+            return origWriteHead(statusCode, headers);
+        });
+        const publicDir = resolve(staticDir, 'public');
+        const sanitized = url.pathname.replace(/\.\./g, '');
+        const rootFile = resolve(publicDir, sanitized.slice(1));
+        if (rootFile.startsWith(publicDir) && existsSync(rootFile) && statSync(rootFile).isFile()) {
+            const ext = extname(rootFile);
+            res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream' });
+            res.end(readFileSync(rootFile));
+            return;
+        }
+        if (url.pathname === '/ssr-data.js') {
+            const token = url.searchParams.get('t') || '';
+            const store = globalThis.__vsk_ssr_data_store;
+            const payload = store?.[token];
+            if (payload)
+                delete store[token];
+            const lines = [];
+            if (payload?.props)
+                lines.push(`globalThis.__vesk_props = ${JSON.stringify(payload.props)};`);
+            if (payload?.ssrData)
+                lines.push(`globalThis.__vsk_ssr_data = ${JSON.stringify(payload.ssrData)};`);
+            res.writeHead(200, { 'Content-Type': 'application/javascript', 'Cache-Control': 'no-store' });
+            res.end(lines.join('\n') || '// no ssr data');
+            return;
+        }
+        if (url.pathname === '/_vesk/runtime.js') {
+            const clientPath = resolve(staticDir, 'client.js');
+            if (existsSync(clientPath)) {
+                res.writeHead(200, { 'Content-Type': 'application/javascript' });
+                res.end(readFileSync(clientPath));
+                return;
+            }
+        }
+        if (url.pathname.startsWith('/_vesk/static/')) {
+            const relPath = url.pathname.replace('/_vesk/static/', '').replace(/\.\./g, '');
+            const staticPath = resolve(staticDir, relPath);
+            if (!staticPath.startsWith(staticDir)) {
+                res.writeHead(403);
+                res.end('Forbidden');
+                return;
+            }
+            if (existsSync(staticPath) && statSync(staticPath).isFile()) {
+                const ext = extname(staticPath);
+                res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream' });
+                res.end(readFileSync(staticPath));
+                return;
+            }
+        }
+        if (buildConfig.prerendered) {
+            const prerendered = buildConfig.prerendered.find(r => r.path === url.pathname);
+            if (prerendered) {
+                const htmlPath = resolve(outDir, prerendered.file);
+                if (existsSync(htmlPath)) {
+                    res.writeHead(200, { 'Content-Type': 'text/html' });
+                    res.end(readFileSync(htmlPath));
+                    return;
+                }
+            }
+        }
+        if (middlewareMod) {
+            const mwCtx = {
+                request: new Request(url.href, { headers: req.headers, method: req.method || 'GET' }),
+                params: {},
+                url,
+                locals: {},
+                cookies: {},
+                set(key, value) { this.locals[key] = value; },
+                get(key) { return this.locals[key]; },
+            };
+            const mwResult = await middlewareMod.execute(mwCtx);
+            if (mwResult.response) {
+                const body = await mwResult.response.text();
+                res.writeHead(mwResult.response.status, Object.fromEntries(mwResult.response.headers));
+                res.end(body);
+                return;
+            }
+            if (mwResult.rewriteUrl) {
+                url.pathname = mwResult.rewriteUrl;
+            }
+        }
+        if (url.pathname.startsWith('/_vesk/action/')) {
+            const actionId = url.pathname.replace('/_vesk/action/', '');
+            const actionEntry = buildConfig.actions && buildConfig.actions.find(a => a.id === actionId);
+            if (!actionEntry) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: 'Action not found' }));
+                return;
+            }
+            const mod = await loadFunction(actionEntry.function);
+            if (!mod || !mod.handleAction) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: 'Action not found' }));
+                return;
+            }
+            try {
+                const webRequest = makeWebRequest(req, url.href);
+                const response = await mod.handleAction(webRequest, actionId);
+                const body = await response.text();
+                res.writeHead(response.status, Object.fromEntries(response.headers));
+                res.end(body);
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ ok: false, error: message }));
+            }
+            return;
+        }
+        if (url.pathname.startsWith('/api')) {
+            for (const route of buildConfig.routes) {
+                if (route.type === 'api') {
+                    const params = matchPath(route.path, url.pathname);
+                    if (params) {
+                        const mod = await loadFunction(route.function);
+                        if (mod) {
+                            try {
+                                const webRequest = makeWebRequest(req, url.href);
+                                const response = await mod.handle(webRequest);
+                                const body = await response.text();
+                                res.writeHead(response.status, Object.fromEntries(response.headers));
+                                res.end(body);
+                                return;
+                            }
+                            catch (e) {
+                                const message = e instanceof Error ? e.message : String(e);
+                                res.writeHead(500, { 'Content-Type': 'application/json' });
+                                res.end(JSON.stringify({ error: message }));
+                                return;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        const appDir = resolve(projectDir, 'app');
+        const nfPath = resolve(appDir, 'not-found.vsk');
+        let notFoundHtml = null;
+        if (existsSync(nfPath)) {
+            try {
+                const runtimePath = resolve(outDir, 'server', 'runtime.js');
+                const { renderFullPage } = await import(runtimePath);
+                const src = readFileSync(nfPath, 'utf-8');
+                const compName = resolveComponentName(src) || 'NotFound';
+                notFoundHtml = await renderFullPage(src, compName, { params: {}, url: url.pathname }, new Map(), { hydrate: true, cssUrls: ['/_vesk/static/_tailwind.css', '/_vesk/static/global.css'], security: securityConfig?.security || {}, sourcePath: nfPath });
+            }
+            catch { }
+        }
+        for (const route of buildConfig.routes) {
+            if (route.type === 'ssr') {
+                const params = matchPath(route.path, url.pathname);
+                if (params) {
+                    const mod = await loadFunction(route.function);
+                    if (mod) {
+                        try {
+                            const webRequest = makeWebRequest(req, url.href);
+                            let cachedResult = null;
+                            if (route.revalidate && route.revalidate > 0) {
+                                const { pageIsr } = await import('@vesk/runtime/src/index-server');
+                                cachedResult = await pageIsr(url.pathname, async () => {
+                                    const response = await mod.handle(webRequest);
+                                    return { html: await response.text(), headers: Object.fromEntries(response.headers) };
+                                }, { revalidate: route.revalidate, tags: route.tags || [] });
+                            }
+                            if (cachedResult) {
+                                res.writeHead(200, cachedResult.headers || { 'Content-Type': 'text/html' });
+                                res.end(cachedResult.html);
+                                return;
+                            }
+                            const response = await mod.handle(webRequest);
+                            const headers = Object.fromEntries(response.headers);
+                            if (!headers['content-type'] && !headers['Content-Type'])
+                                headers['Content-Type'] = 'text/html';
+                            if (response.body && typeof response.body.getReader === 'function') {
+                                res.writeHead(response.status, headers);
+                                const reader = response.body.getReader();
+                                const pump = () => {
+                                    reader.read().then(({ done, value }) => {
+                                        if (done) {
+                                            res.end();
+                                            return;
+                                        }
+                                        res.write(value);
+                                        pump();
+                                    }).catch(() => res.end());
+                                };
+                                pump();
+                            }
+                            else {
+                                const body = await response.text();
+                                res.writeHead(response.status, headers);
+                                res.end(body);
+                            }
+                            return;
+                        }
+                        catch (e) {
+                            const err = e instanceof Error ? e : new Error(String(e));
+                            if (err.name === 'NotFoundError') {
+                                res.writeHead(404, { 'Content-Type': 'text/html' });
+                                res.end(notFoundHtml || '<!DOCTYPE html><html><body><h1>404</h1><p>Not Found</p></body></html>');
+                                return;
+                            }
+                            console.error('vesk ssr error:', err.message);
+                            const errPath = resolve(appDir, 'error.vsk');
+                            let errorHtml = null;
+                            if (existsSync(errPath)) {
+                                try {
+                                    const runtimePath = resolve(outDir, 'server', 'runtime.js');
+                                    const { renderFullPage } = await import(runtimePath);
+                                    const src = readFileSync(errPath, 'utf-8');
+                                    const compName = resolveComponentName(src) || 'Error';
+                                    errorHtml = await renderFullPage(src, compName, { error: err.message, stack: err.stack, statusCode: 500, url: url.pathname }, new Map(), { hydrate: true, cssUrls: ['/_vesk/static/_tailwind.css', '/_vesk/static/global.css'], security: securityConfig?.security || {}, sourcePath: errPath });
+                                }
+                                catch { }
+                            }
+                            res.writeHead(500, { 'Content-Type': 'text/html' });
+                            res.end(errorHtml || '<!DOCTYPE html><html><body><h1>500</h1><pre>Internal Server Error</pre></body></html>');
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+        res.writeHead(404, { 'Content-Type': 'text/html' });
+        res.end(notFoundHtml || '<!DOCTYPE html><html><body><h1>404</h1><p>Not Found</p></body></html>');
+    });
+    server.listen(port, () => {
+        console.error(`vesk production server at http://localhost:${port}`);
+    });
+    return server;
+}

package/dist/runtime-bundle.d.ts

@@ -0,0 +1,2 @@
+export declare function bundleRuntime(appDir: string, outDir: string): Promise<string>;
+//# sourceMappingURL=runtime-bundle.d.ts.map

package/dist/runtime-bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-bundle.d.ts","sourceRoot":"","sources":["../src/runtime-bundle.ts"],"names":[],"mappings":"AAuCA,wBAAsB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAsGnF"}