@vesk/adapter 0.0.1

package/dist/platform-deploy.js

@@ -0,0 +1,354 @@
+import { writeFileSync, mkdirSync, rmSync, symlinkSync } from 'node:fs';
+import { resolve, dirname, relative } from 'node:path';
+import { generatePlatformHandlerSource, bundlePlatformHandler } from '@vesk/adapter/src/platform-handler';
+import { ensureCleanDir, writePlatformStatic, writePrerenderedStatic, listStaticDir, mimeFor } from '@vesk/adapter/src/platform-output';
+/**
+ * Universal deployment emit. The handler, the bundle and the static layout are
+ * shared across every platform — only the ~10-line shell each runtime mandates
+ * differs (artifact directory, bootstrap, function config). Deno-based platforms
+ * (Coxmos, Deno Deploy) share the exact same shell.
+ *
+ * Every artifact is written under `.vesk/<platform>/`; Vercel additionally gets
+ * a gitignored `.vercel/output` symlink because the Build Output API is keyed on
+ * that literal directory.
+ */
+export async function emitPlatformOutput(platform, ctx) {
+    if (platform === 'node')
+        return null;
+    const prerenderedPaths = ctx.prerenderedRoutes.map(r => r.path);
+    const handler = generatePlatformHandlerSource({
+        ssrRoutes: ctx.ssrRoutes,
+        apiRoutes: ctx.apiRoutes,
+        prerenderedPaths,
+        hasMiddleware: ctx.hasMiddleware,
+    });
+    const shell = shellFor(platform);
+    const projectRoot = resolve(ctx.outDir, '..');
+    const outRoot = resolve(projectRoot, shell.root);
+    ensureCleanDir(outRoot);
+    const staticDir = shell.staticSubdir === '' ? outRoot : resolve(outRoot, shell.staticSubdir || 'static');
+    writePlatformStatic(resolve(ctx.outDir, 'static'), staticDir);
+    writePrerenderedStatic(ctx.prerenderedRoutes, staticDir);
+    const entry = resolve(ctx.outDir, '.platform-entry.mjs');
+    let source = handler;
+    if (shell.imports)
+        source = `${shell.imports}\n${source}`;
+    if (shell.staticMode === 'embedded') {
+        if (shell.staticServe === 'disk-deno')
+            source += `\n${denoStaticSource()}`;
+        else if (shell.staticServe === 'disk-node')
+            source += `\n${nodeStaticSource()}`;
+        else if (shell.staticServe === 'inline')
+            source += `\n${inlineStaticSource(staticDir)}`;
+    }
+    source += `\n${shell.bootstrap}\n`;
+    writeFileSync(entry, source, 'utf-8');
+    let handlerRel;
+    if (shell.functionFile) {
+        const funcDir = resolve(outRoot, shell.functionFile.dir);
+        mkdirSync(funcDir, { recursive: true });
+        if (shell.functionConfig) {
+            writeFileSync(resolve(funcDir, '.vc-config.json'), JSON.stringify(shell.functionConfig, null, 2), 'utf-8');
+        }
+        handlerRel = `${shell.functionFile.dir}/${shell.functionFile.file}`;
+        await bundlePlatformHandler({ entry, outfile: resolve(funcDir, shell.functionFile.file), nodeBuiltins: shell.nodeBuiltins });
+    }
+    else {
+        handlerRel = shell.outfile || 'index.js';
+        await bundlePlatformHandler({ entry, outfile: resolve(outRoot, handlerRel), nodeBuiltins: shell.nodeBuiltins });
+    }
+    for (const file of shell.extraFiles || []) {
+        writeFileSync(resolve(outRoot, file.path), file.content, 'utf-8');
+    }
+    if (platform === 'vercel') {
+        writeFileSync(resolve(outRoot, 'config.json'), vercelConfigJson(prerenderedPaths), 'utf-8');
+    }
+    writeFileSync(resolve(outRoot, 'manifest.json'), JSON.stringify({
+        platform,
+        runtime: shell.nodeBuiltins ? 'node' : 'edge',
+        static: shell.staticMode,
+        handler: handlerRel,
+        routes: ctx.ssrRoutes.map(r => r.fullPath),
+        apiRoutes: ctx.apiRoutes.map(r => '/api' + r.fullPath),
+        prerendered: prerenderedPaths,
+    }, null, 2), 'utf-8');
+    if (platform === 'vercel') {
+        const vercelDir = resolve(projectRoot, '.vercel');
+        mkdirSync(vercelDir, { recursive: true });
+        const linkPath = resolve(vercelDir, 'output');
+        rmSync(linkPath, { recursive: true, force: true });
+        symlinkSync(relative(dirname(linkPath), outRoot), linkPath, 'dir');
+    }
+    rmSync(entry, { force: true });
+    return outRoot;
+}
+function vercelConfigJson(prerenderedPaths) {
+    const escapeRegex = (p) => p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const prerenderRoutes = prerenderedPaths.map(p => {
+        const htmlRel = p === '/' ? '/index.html' : `${p.replace(/\/$/, '')}.html`;
+        return { src: `^${escapeRegex(p === '/' ? '/' : p)}/?$`, dest: `/_vesk/static/public${htmlRel}` };
+    });
+    return JSON.stringify({
+        version: 3,
+        routes: [
+            ...prerenderRoutes,
+            { handle: 'filesystem' },
+            { src: '/(.*)', dest: '/__index' },
+        ],
+    }, null, 2);
+}
+function __relsSource() {
+    return `function __rels(p) {
+  if (p === '/' || p === '') return ['index.html'];
+  if (p.startsWith('/_vesk/static/') || p === '/_vesk/runtime.js') return [p === '/_vesk/runtime.js' ? '_vesk/runtime.js' : p.slice(1)];
+  if (p.endsWith('/')) return [p.slice(1) + 'index.html', p.slice(1, -1) + '.html'];
+  return [p.slice(1), p.slice(1) + '.html', p.slice(1) + '/index.html'];
+}`;
+}
+function __mimeSource() {
+    return `function __mime(rel) {
+  const i = rel.lastIndexOf('.');
+  const ext = i === -1 ? '' : rel.slice(i).toLowerCase();
+  const m = {
+    '.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',
+  };
+  return m[ext] || 'application/octet-stream';
+}`;
+}
+function denoStaticSource() {
+    return `${__relsSource()}
+${__mimeSource()}
+const __staticUrl = new URL('./static/', import.meta.url);
+async function serveEmbeddedStatic(request) {
+  const __url = new URL(request.url);
+  for (const rel of __rels(__url.pathname)) {
+    try {
+      const data = await Deno.readFile(new URL(rel, __staticUrl));
+      return new Response(data, { headers: { 'Content-Type': __mime(rel) } });
+    } catch {}
+  }
+  return null;
+}`;
+}
+function nodeStaticSource() {
+    return `${__relsSource()}
+${__mimeSource()}
+const __staticUrl = new URL('./static/', import.meta.url);
+function serveEmbeddedStatic(request) {
+  const __url = new URL(request.url);
+  for (const rel of __rels(__url.pathname)) {
+    try {
+      return new Response(readFileSync(new URL(rel, __staticUrl)), { headers: { 'Content-Type': __mime(rel) } });
+    } catch {}
+  }
+  return null;
+}`;
+}
+function inlineStaticSource(staticDir) {
+    const files = listStaticDir(staticDir);
+    const entries = files.map(f => {
+        const t = mimeFor(f.rel);
+        const isText = /\.(html|htm|js|mjs|css|json|svg|txt|xml|map|webmanifest)$/i.test(f.rel);
+        return isText
+            ? `${JSON.stringify(f.rel)}: { t: ${JSON.stringify(t)}, s: ${JSON.stringify(f.buffer.toString('utf8'))} }`
+            : `${JSON.stringify(f.rel)}: { t: ${JSON.stringify(t)}, b: ${JSON.stringify(f.buffer.toString('base64'))} }`;
+    });
+    return `${__relsSource()}
+const __STATIC = { ${entries.join(', ')} };
+function __decode(e) {
+  if (e.s !== undefined) return new TextEncoder().encode(e.s);
+  return new Uint8Array(atob(e.b).split('').map(function (c) { return c.charCodeAt(0); }));
+}
+function serveEmbeddedStatic(request) {
+  const __url = new URL(request.url);
+  for (const rel of __rels(__url.pathname)) {
+    const entry = __STATIC[rel];
+    if (entry) return new Response(__decode(entry), { headers: { 'Content-Type': entry.t } });
+  }
+  return null;
+}`;
+}
+function shellFor(platform) {
+    switch (platform) {
+        case 'vercel':
+            return {
+                root: '.vesk/vercel',
+                nodeBuiltins: true,
+                staticMode: 'platform',
+                staticSubdir: 'static',
+                functionFile: {
+                    dir: 'functions/__index.func',
+                    file: 'index.js',
+                },
+                functionConfig: {
+                    runtime: 'nodejs22.x',
+                    handler: 'index.js',
+                    launcherType: 'Nodejs',
+                    shouldAddHelpers: false,
+                    shouldAddSourcemapSupport: false,
+                    supportsResponseStreaming: true,
+                },
+                bootstrap: [
+                    'export default async function veskNodeEntry(req, res) {',
+                    "  const url = new URL(req.url, 'http://' + (req.headers.host || 'localhost'));",
+                    "  const method = req.method || 'GET';",
+                    '  let body;',
+                    "  if (method !== 'GET' && method !== 'HEAD') {",
+                    '    body = await new Promise((resolveBody, reject) => {',
+                    '      const chunks = [];',
+                    "      req.on('data', (c) => chunks.push(c));",
+                    '      req.on("error", reject);',
+                    '      req.on("end", () => resolveBody(Buffer.concat(chunks)));',
+                    '    });',
+                    '  }',
+                    '  const headers = {};',
+                    '  for (const key in req.headers) headers[key] = req.headers[key];',
+                    '  const request = new Request(url, { method, headers, body });',
+                    '  const response = await handleRequest(request);',
+                    '  res.writeHead(response.status, Object.fromEntries(response.headers));',
+                    '  res.end(await response.text());',
+                    '}',
+                ].join('\n'),
+            };
+        case 'netlify':
+            return {
+                root: '.vesk/netlify',
+                nodeBuiltins: true,
+                staticMode: 'platform',
+                staticSubdir: '',
+                functionFile: {
+                    dir: 'functions',
+                    file: '__index.js',
+                },
+                bootstrap: [
+                    'export default { fetch: handleRequest };',
+                    "export const config = { path: '/*', preferStatic: true };",
+                ].join('\n'),
+            };
+        case 'cloudflare':
+            return {
+                root: '.vesk/cloudflare',
+                nodeBuiltins: false,
+                staticMode: 'platform',
+                staticSubdir: '',
+                outfile: '_worker.js',
+                bootstrap: [
+                    'export default {',
+                    '  async fetch(request, env) {',
+                    '    const response = await handleRequest(request);',
+                    '    if (response.status !== 404) return response;',
+                    '    if (env && env.ASSETS) {',
+                    '      try {',
+                    '        const asset = await env.ASSETS.fetch(request);',
+                    '        if (asset.status !== 404) return asset;',
+                    '      } catch {}',
+                    '    }',
+                    '    return response;',
+                    '  }',
+                    '};',
+                ].join('\n'),
+            };
+        case 'deno':
+        case 'coxmos':
+            return {
+                root: platform === 'coxmos' ? '.vesk/coxmos' : '.vesk/deno',
+                nodeBuiltins: false,
+                staticMode: 'embedded',
+                staticSubdir: 'static',
+                staticServe: 'disk-deno',
+                bootstrap: [
+                    'if (typeof Deno !== "undefined" && typeof Deno.serve === "function") {',
+                    '  Deno.serve(async (request) => {',
+                    '    const staticResponse = await serveEmbeddedStatic(request);',
+                    '    if (staticResponse) return staticResponse;',
+                    '    return handleRequest(request);',
+                    '  });',
+                    '}',
+                    'export default handleRequest;',
+                ].join('\n'),
+            };
+        case 'aws':
+            return {
+                root: '.vesk/aws',
+                nodeBuiltins: true,
+                staticMode: 'embedded',
+                staticSubdir: 'static',
+                staticServe: 'disk-node',
+                imports: "import { readFileSync } from 'node:fs';",
+                outfile: 'index.mjs',
+                extraFiles: [
+                    {
+                        path: 'package.json',
+                        content: JSON.stringify({ name: 'vesk-aws-app', type: 'module', private: true }, null, 2),
+                    },
+                    {
+                        path: 'template.yaml',
+                        content: [
+                            "AWSTemplateFormatVersion: '2010-09-09'",
+                            'Transform: AWS::Serverless-2016-10-31',
+                            'Description: Vesk application deployed to AWS Lambda via SAM',
+                            '',
+                            'Resources:',
+                            '  VeskFunction:',
+                            '    Type: AWS::Serverless::Function',
+                            '    Properties:',
+                            '      CodeUri: ./',
+                            '      Handler: index.handler',
+                            '      Runtime: nodejs22.x',
+                            '      MemorySize: 512',
+                            '      Timeout: 30',
+                            '      Events:',
+                            '        HttpApiEvent:',
+                            '          Type: HttpApi',
+                            '          Properties:',
+                            '            Auth:',
+                            '              Authorizer: NONE',
+                            '            Path: $default',
+                            '            Method: ANY',
+                            '',
+                        ].join('\n'),
+                    },
+                ],
+                bootstrap: [
+                    'export async function handler(event) {',
+                    "  const url = new URL(event.rawPath || '/', 'http://' + (event.headers?.host || 'lambda.local'));",
+                    "  if (event.rawQueryString) url.search = event.rawQueryString;",
+                    '  const headers = {};',
+                    '  for (const [k, v] of Object.entries(event.headers || {})) headers[k.toLowerCase()] = String(v);',
+                    '  let body;',
+                    '  if (event.body) {',
+                    "    body = event.isBase64Encoded ? Buffer.from(event.body, 'base64') : event.body;",
+                    '  }',
+                    "  const request = new Request(url, { method: event.requestContext?.http?.method || event.httpMethod || 'GET', headers, body });",
+                    '  const response = await handleRequest(request);',
+                    "  return { statusCode: response.status, headers: Object.fromEntries(response.headers), body: Buffer.from(await response.text()).toString('base64'), isBase64Encoded: true };",
+                    '}',
+                ].join('\n'),
+            };
+        case 'edge':
+            return {
+                root: '.vesk/edge',
+                nodeBuiltins: false,
+                staticMode: 'embedded',
+                staticSubdir: 'static',
+                staticServe: 'inline',
+                bootstrap: [
+                    'export async function handleEdgeRequest(request) {',
+                    '  const staticResponse = await serveEmbeddedStatic(request);',
+                    '  if (staticResponse) return staticResponse;',
+                    '  return handleRequest(request);',
+                    '}',
+                    'export default handleEdgeRequest;',
+                ].join('\n'),
+            };
+        default:
+            throw new Error(`Unsupported platform: ${platform}`);
+    }
+}

package/dist/platform-handler.d.ts

@@ -0,0 +1,32 @@
+import type { RouteNode, ApiRouteNode } from '@vesk/adapter/src/types';
+export interface PlatformHandlerInput {
+    ssrRoutes: RouteNode[];
+    apiRoutes: ApiRouteNode[];
+    prerenderedPaths: string[];
+    hasMiddleware: boolean;
+}
+export declare function routeName(segments: string[]): string;
+export declare function apiRouteName(fullPath: string): string;
+export declare function toId(s: string): string;
+/**
+ * Generate a self-contained platform handler: a `handleRequest(request: Request)`
+ * that routes SSR pages, API routes and middleware for any edge/serverless runtime.
+ * The output references server functions via relative imports so it can be bundled
+ * with esbuild for each target platform.
+ */
+export declare function generatePlatformHandlerSource(input: PlatformHandlerInput): string;
+export interface BundlePlatformOptions {
+    /** Keep real node builtins (node:fs, node:path) in the bundle. */
+    nodeBuiltins?: boolean;
+    outfile: string;
+    entry: string;
+}
+export declare function bundlePlatformHandler(options: BundlePlatformOptions): Promise<void>;
+export interface PlatformBuildContext {
+    outDir: string;
+    ssrRoutes: RouteNode[];
+    apiRoutes: ApiRouteNode[];
+    prerenderedPaths: string[];
+    hasMiddleware: boolean;
+}
+//# sourceMappingURL=platform-handler.d.ts.map

package/dist/platform-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-handler.d.ts","sourceRoot":"","sources":["../src/platform-handler.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAIvE,MAAM,WAAW,oBAAoB;IACnC,SAAS,EAAE,SAAS,EAAE,CAAC;IACvB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,aAAa,EAAE,OAAO,CAAC;CACxB;AAED,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAMpD;AAED,wBAAgB,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAGrD;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtC;AAQD;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,oBAAoB,GAAG,MAAM,CA4HjF;AAED,MAAM,WAAW,qBAAqB;IACpC,kEAAkE;IAClE,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,IAAI,CAAC,CA8DzF;AAED,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,SAAS,EAAE,CAAC;IACvB,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,aAAa,EAAE,OAAO,CAAC;CACxB"}

package/dist/platform-handler.js

@@ -0,0 +1,211 @@
+import { existsSync } from 'node:fs';
+import { resolve, dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+export function routeName(segments) {
+    const parts = segments.filter(Boolean).map(s => {
+        if (s.startsWith(':'))
+            return s.slice(1) || 'param';
+        return s;
+    });
+    return parts.join('_') || 'index';
+}
+export function apiRouteName(fullPath) {
+    const parts = fullPath.split('/').filter(Boolean);
+    return parts.map(s => (s.startsWith(':') ? s.slice(1) || 'param' : s)).join('_') || 'index';
+}
+export function toId(s) {
+    return s.replace(/[^a-zA-Z0-9_]/g, '_').replace(/^_/, '');
+}
+function findCompilerSrc() {
+    const monorepo = resolve(__dirname, '..', '..', '..', 'packages', 'compiler', 'dist');
+    if (existsSync(monorepo))
+        return monorepo;
+    throw new Error('@vesk/compiler/dist not found — run "npm run build" first');
+}
+/**
+ * Generate a self-contained platform handler: a `handleRequest(request: Request)`
+ * that routes SSR pages, API routes and middleware for any edge/serverless runtime.
+ * The output references server functions via relative imports so it can be bundled
+ * with esbuild for each target platform.
+ */
+export function generatePlatformHandlerSource(input) {
+    const { ssrRoutes, apiRoutes, prerenderedPaths, hasMiddleware } = input;
+    let imports = '';
+    const routeEntries = [];
+    for (const r of ssrRoutes) {
+        const name = routeName(r.fullPath.split('/').filter(Boolean));
+        const id = `__ssr_${toId(name)}`;
+        const funcPath = `./server/functions/${name}.js`;
+        imports += `import { handle as ${id} } from ${JSON.stringify(funcPath)};\n`;
+        const revalidate = r._revalidate != null ? `revalidate: ${r._revalidate}, ` : '';
+        const tags = r._isrTags ? `tags: ${JSON.stringify(r._isrTags)}, ` : '';
+        routeEntries.push(`{ path: ${JSON.stringify(r.fullPath)}, type: 'ssr', handler: ${id}, ${revalidate}${tags}}`);
+    }
+    for (const r of apiRoutes) {
+        const name = apiRouteName(r.fullPath);
+        const id = `__api_${toId(name)}`;
+        const funcPath = `./server/api/${name}.js`;
+        imports += `import { handle as ${id} } from ${JSON.stringify(funcPath)};\n`;
+        routeEntries.push(`{ path: ${JSON.stringify('/api' + r.fullPath)}, type: 'api', handler: ${id} }`);
+    }
+    const mwImport = hasMiddleware ? "import { execute as __executeMw } from './server/middleware.js';" : '';
+    const hasMwLiteral = hasMiddleware ? 'true' : 'false';
+    const prerenderedList = prerenderedPaths.length > 0
+        ? `const __prerendered = new Set(${JSON.stringify(prerenderedPaths)});\n`
+        : 'const __prerendered = new Set();\n';
+    const isrCache = 'const __isrCache = new Map();';
+    const compilerSrc = findCompilerSrc();
+    const parseCookiesImport = hasMiddleware
+        ? `import { parseCookies } from ${JSON.stringify(resolve(compilerSrc, 'server-cookies.js'))};`
+        : '';
+    return `
+${imports}
+${parseCookiesImport}
+${mwImport}
+${prerenderedList}
+${isrCache}
+const __routes = [${routeEntries.join(',\n')}];
+
+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;
+}
+
+export async function handleRequest(request) {
+  const url = new URL(request.url);
+  const pathname = url.pathname;
+  const isDataRequest = request.headers.get('x-vesk-data') === '1';
+
+  if (__prerendered.has(pathname) && !isDataRequest) {
+    return new Response(null, { status: 308, headers: { Location: '/_vesk/static/public' + (pathname.endsWith('/') ? pathname + 'index.html' : pathname + '.html') } });
+  }
+
+  if (${hasMwLiteral}) {
+    const mwCtx = {
+      request,
+      params: {},
+      url,
+      locals: {},
+      cookies: typeof parseCookies !== 'undefined' ? parseCookies(request.headers.get('cookie') || '') : {},
+      set(key, value) { this.locals[key] = value; },
+      get(key) { return this.locals[key]; },
+    };
+    const mwResult = await __executeMw(mwCtx);
+    if (mwResult.response) return mwResult.response;
+    if (mwResult.rewriteUrl) url.pathname = mwResult.rewriteUrl;
+  }
+
+  for (const route of __routes) {
+    const params = __matchPath(route.path, url.pathname);
+    if (!params) continue;
+
+    if (route.type === 'api') {
+      return await route.handler(request);
+    }
+
+    if (route.revalidate && route.revalidate > 0 && !isDataRequest) {
+      const cached = __isrCache.get(url.pathname);
+      if (cached && Date.now() - cached.ts < route.revalidate * 1000) {
+        return new Response(cached.html, {
+          status: 200,
+          headers: { 'Content-Type': 'text/html', ...cached.headers },
+        });
+      }
+    }
+
+    const response = await route.handler(request);
+
+    if (route.revalidate && route.revalidate > 0 && !isDataRequest) {
+      const html = await response.clone().text();
+      __isrCache.set(url.pathname, { html, headers: Object.fromEntries(response.headers), ts: Date.now() });
+    }
+
+    return response;
+  }
+
+  return new Response('<!DOCTYPE html><html><body><h1>404</h1><p>Not Found</p></body></html>', {
+    status: 404,
+    headers: { 'Content-Type': 'text/html' },
+  });
+}
+`;
+}
+export async function bundlePlatformHandler(options) {
+    const { nodeBuiltins = false, outfile, entry } = options;
+    const { build } = await import('./esbuild-fallback.js');
+    const plugins = [];
+    if (!nodeBuiltins) {
+        plugins.push({
+            name: 'empty-node-builtins',
+            setup(build) {
+                const builtins = /^(fs|path|node:fs|node:path|child_process|os|crypto|net|stream|buffer|events|util|url|querystring|http|https|zlib|tty)$/;
+                build.onResolve({ filter: builtins }, () => {
+                    return { path: 'node-builtin-empty', namespace: 'empty-node' };
+                });
+                build.onLoad({ filter: /.*/, namespace: 'empty-node' }, () => ({
+                    contents: `
+const __m = typeof Proxy !== 'undefined' ? new Proxy({}, {
+  get(_, key) { return typeof key === 'string' ? () => {} : undefined; },
+  has() { return true; },
+}) : {};
+export default __m;
+export const readFileSync = () => {};
+export const writeFileSync = () => {};
+export const existsSync = () => {};
+export const statSync = () => {};
+export const readdirSync = () => {};
+export const mkdirSync = () => {};
+export const unlinkSync = () => {};
+export const rmSync = () => {};
+export const copyFileSync = () => {};
+export const accessSync = () => {};
+export const join = (...a) => a.join('/');
+export const resolve = (...a) => a.join('/');
+export const dirname = () => '';
+export const basename = () => '';
+export const extname = () => '';
+export const relative = () => '';
+export const sep = '/';
+export const delimiter = ':';
+export const spawnSync = () => ({ status: 0 });
+export const execSync = () => '';
+export const randomBytes = () => ({});
+export const createHash = () => ({ update: () => {}, digest: () => '' });
+`,
+                    loader: 'js',
+                }));
+            },
+        });
+    }
+    const result = await build({
+        entryPoints: [entry],
+        bundle: true,
+        platform: nodeBuiltins ? 'node' : 'neutral',
+        format: 'esm',
+        target: ['es2022'],
+        outfile,
+        minify: false,
+        sourcemap: false,
+        logOverride: { 'direct-eval': 'silent' },
+        plugins,
+    });
+    if (result.errors.length > 0) {
+        throw new Error(`Platform bundle errors: ${result.errors.map((e) => e.text).join(', ')}`);
+    }
+}

package/dist/platform-output.d.ts

@@ -0,0 +1,30 @@
+import type { SsgRouteResult } from '@vesk/adapter/src/types';
+export declare const MIME: Record<string, string>;
+export declare function ensureCleanDir(dir: string): void;
+export declare function copyDirContents(srcDir: string, destDir: string): void;
+export declare function writeFile(path: string, content: string | Buffer): void;
+/**
+ * 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 declare function writePlatformStatic(buildStaticDir: string, platformStaticDir: string): void;
+/**
+ * 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 declare function writePrerenderedStatic(prerenderedRoutes: SsgRouteResult[], platformStaticDir: string): void;
+/**
+ * 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 declare function listStaticDir(dir: string): Array<{
+    rel: string;
+    buffer: Buffer;
+}>;
+export declare function mimeFor(path: string): string;
+//# sourceMappingURL=platform-output.d.ts.map

package/dist/platform-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform-output.d.ts","sourceRoot":"","sources":["../src/platform-output.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAE9D,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAwBvC,CAAC;AAEF,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAGhD;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAarE;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGtE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,cAAc,EAAE,MAAM,EAAE,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAiB3F;AAED;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,iBAAiB,EAAE,cAAc,EAAE,EAAE,iBAAiB,EAAE,MAAM,GAAG,IAAI,CAY3G;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAgBjF;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE5C"}