@vistagenic/vista 0.3.2 → 0.3.4

package/dist/deploy/adapters/netlify.js

@@ -8,12 +8,13 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const cli_runner_1 = require("../cli-runner");
 const preflight_1 = require("../preflight");
+const runtime_pack_1 = require("../runtime-pack");
 const utils_1 = require("../utils");
 const NETLIFY_OUTPUT_DIR = '.vista/deploy/netlify';
 function getNetlifyOutputDir(ctx) {
     return path_1.default.join(ctx.cwd, NETLIFY_OUTPUT_DIR);
 }
-function writeNetlifyToml(ctx) {
+function writeStaticNetlifyToml(ctx) {
     const targetFile = path_1.default.join(ctx.cwd, 'netlify.toml');
     const content = `[build]
   command = "npm run build"
@@ -26,38 +27,74 @@ function writeNetlifyToml(ctx) {
     (0, utils_1.writeFileIfAllowed)(targetFile, content, ctx.force);
     return targetFile;
 }
-function writeRedirects(outputDir) {
-    const redirectsPath = path_1.default.join(outputDir, '_redirects');
-    const lines = [
-        '/_vista/* /:splat 200',
-        '/ /static/pages/index.html 200',
-        '/rsc /static/pages/index.rsc 200',
-        '/_rsc/* /static/pages/:splat.rsc 200',
-        '/* /static/pages/:splat.html 200',
-    ];
-    fs_1.default.writeFileSync(redirectsPath, `${lines.join('\n')}\n`, 'utf8');
-    return redirectsPath;
+function writeFullRuntimeNetlifyToml(ctx) {
+    const targetFile = path_1.default.join(ctx.cwd, 'netlify.toml');
+    const content = `[build]
+  command = "npm run build"
+  publish = ".vista/deploy/netlify"
+  functions = "netlify/functions"
+
+[functions]
+  node_bundler = "none"
+  included_files = ["netlify/functions/.vista/**", "netlify/functions/node_modules/**"]
+
+[dev]
+  command = "npm run dev"
+  port = 3003
+
+[[redirects]]
+  from = "/_vista/*"
+  to = "/_vista/:splat"
+  status = 200
+
+[[redirects]]
+  from = "/*"
+  to = "/.netlify/functions/ssr"
+  status = 200
+`;
+    (0, utils_1.writeFileIfAllowed)(targetFile, content, ctx.force);
+    return targetFile;
 }
 exports.netlifyAdapter = {
     id: 'netlify',
-    requiredOutput: 'static',
-    supportsFullRuntime: false,
+    requiredOutput: 'standalone',
+    supportsFullRuntime: true,
     async preflight(ctx) {
-        return (0, preflight_1.runStaticHostPreflight)(ctx);
+        if ((0, runtime_pack_1.isStaticOnlyDeploy)(ctx)) {
+            return (0, preflight_1.runStaticHostPreflight)(ctx);
+        }
+        return (0, preflight_1.runStandalonePreflight)(ctx);
     },
     async emit(ctx) {
         const outputDir = getNetlifyOutputDir(ctx);
         fs_1.default.rmSync(outputDir, { recursive: true, force: true });
         (0, utils_1.ensureDir)(outputDir);
+        if ((0, runtime_pack_1.isStaticOnlyDeploy)(ctx)) {
+            (0, utils_1.copyStaticHostAssets)(ctx.cwd, ctx.vistaDir, outputDir);
+            (0, utils_1.prepareStaticCdnOutput)(outputDir);
+            const netlifyTomlPath = writeStaticNetlifyToml(ctx);
+            return {
+                status: 'emitted',
+                target: 'netlify',
+                artifactPaths: [outputDir, netlifyTomlPath],
+                instructions: ['Static mode: Netlify serves pre-rendered pages only.'],
+            };
+        }
         (0, utils_1.copyStaticHostAssets)(ctx.cwd, ctx.vistaDir, outputDir);
-        const redirectsPath = writeRedirects(outputDir);
-        const netlifyTomlPath = writeNetlifyToml(ctx);
+        (0, utils_1.copyDirectoryRecursive)(path_1.default.join(ctx.vistaDir, 'static'), path_1.default.join(outputDir, '_vista', 'static'));
+        const functionDir = path_1.default.join(ctx.cwd, 'netlify', 'functions');
+        fs_1.default.rmSync(functionDir, { recursive: true, force: true });
+        (0, runtime_pack_1.writeNetlifySsrHandler)(functionDir);
+        (0, utils_1.copyDirectoryRecursive)(ctx.vistaDir, path_1.default.join(functionDir, '.vista'));
+        (0, runtime_pack_1.packRuntimeNodeModules)(ctx.cwd, functionDir);
+        const netlifyTomlPath = writeFullRuntimeNetlifyToml(ctx);
         return {
             status: 'emitted',
             target: 'netlify',
-            artifactPaths: [outputDir, redirectsPath, netlifyTomlPath],
+            artifactPaths: [outputDir, functionDir, netlifyTomlPath],
             instructions: [
-                'Netlify deploy uses pre-rendered static output from .vista/deploy/netlify.',
+                'Netlify Functions run the Vista Flight SSR server.',
+                'Deploy with: netlify deploy --prod --dir=".vista/deploy/netlify" --functions="netlify/functions"',
             ],
         };
     },
@@ -75,7 +112,6 @@ exports.netlifyAdapter = {
                 warnings: [...warnings, ...errors],
             };
         }
-        const outputDir = getNetlifyOutputDir(ctx);
         if (!(0, cli_runner_1.isCliAvailable)('netlify')) {
             return {
                 status: 'emitted',
@@ -84,13 +120,13 @@ exports.netlifyAdapter = {
                 warnings: [...warnings, 'Netlify CLI not found. Install with: npm i -g netlify-cli'],
                 instructions: [
                     'Install Netlify CLI: npm i -g netlify-cli',
-                    `Then run: netlify deploy --prod --dir="${outputDir}"`,
+                    'Then run: netlify deploy --prod --dir=".vista/deploy/netlify" --functions="netlify/functions"',
                 ],
             };
         }
         const command = ctx.prod
-            ? `netlify deploy --prod --dir="${outputDir}"`
-            : `netlify deploy --dir="${outputDir}"`;
+            ? 'netlify deploy --prod --dir=".vista/deploy/netlify" --functions="netlify/functions"'
+            : 'netlify deploy --dir=".vista/deploy/netlify" --functions="netlify/functions"';
         const result = (0, cli_runner_1.runCliCommand)(command, { cwd: ctx.cwd, dryRun: ctx.dryRun });
         if (!result.ok) {
             return {
@@ -98,10 +134,7 @@ exports.netlifyAdapter = {
                 target: 'netlify',
                 artifactPaths: emitted.artifactPaths,
                 warnings: [...warnings, result.stderr || 'Netlify deploy failed.'],
-                instructions: [
-                    'Run: netlify login',
-                    'Or set NETLIFY_AUTH_TOKEN in your environment.',
-                ],
+                instructions: ['Run: netlify login', 'Or set NETLIFY_AUTH_TOKEN.'],
             };
         }
         return {

package/dist/deploy/adapters/vercel.js

@@ -11,6 +11,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const cli_runner_1 = require("../cli-runner");
 const preflight_1 = require("../preflight");
+const runtime_pack_1 = require("../runtime-pack");
 const utils_1 = require("../utils");
 function isVercelBuildEnvironment() {
     return process.env.VERCEL === '1' || process.env.NOW_REGION !== undefined;
@@ -23,81 +24,114 @@ function writeVercelBuildOutput(options) {
     if (!force && !isVercelBuildEnvironment()) {
         return false;
     }
-    if (!force && hasUserVercelConfig(cwd)) {
-        if (debug) {
-            console.log('[vista:deploy] Found custom vercel.json, skipping internal Vercel output.');
+    const standaloneServer = path_1.default.join(vistaDir, 'standalone', 'server.js');
+    const staticOnly = !fs_1.default.existsSync(standaloneServer);
+    if (staticOnly) {
+        if (!force && hasUserVercelConfig(cwd)) {
+            if (debug) {
+                console.log('[vista:deploy] Found custom vercel.json, skipping internal Vercel output.');
+            }
+            return false;
         }
-        return false;
+        const vercelOutputDir = path_1.default.join(cwd, '.vercel', 'output');
+        const vercelStaticDir = path_1.default.join(vercelOutputDir, 'static');
+        fs_1.default.rmSync(vercelOutputDir, { recursive: true, force: true });
+        (0, utils_1.ensureDir)(vercelStaticDir);
+        (0, utils_1.copyStaticHostAssets)(cwd, vistaDir, vercelStaticDir);
+        fs_1.default.writeFileSync(path_1.default.join(vercelOutputDir, 'config.json'), JSON.stringify({ version: 3, routes: utils_1.STATIC_HOST_ROUTE_RULES }, null, 2));
+        return true;
     }
-    const vercelOutputDir = path_1.default.join(cwd, '.vercel', 'output');
-    const vercelStaticDir = path_1.default.join(vercelOutputDir, 'static');
-    fs_1.default.rmSync(vercelOutputDir, { recursive: true, force: true });
-    (0, utils_1.ensureDir)(vercelStaticDir);
-    (0, utils_1.copyStaticHostAssets)(cwd, vistaDir, vercelStaticDir);
-    const config = {
-        version: 3,
-        routes: utils_1.STATIC_HOST_ROUTE_RULES,
-    };
-    fs_1.default.writeFileSync(path_1.default.join(vercelOutputDir, 'config.json'), JSON.stringify(config, null, 2));
+    (0, runtime_pack_1.packVercelFullRuntime)({
+        cwd,
+        vistaDir,
+        config: {},
+        deployConfig: {
+            target: 'vercel',
+            output: 'standalone',
+            prod: true,
+            preferBuildOutputApi: true,
+        },
+        target: 'vercel',
+        dryRun: true,
+        skipBuild: true,
+        prod: true,
+        preview: false,
+        force: true,
+        debug,
+    });
     if (debug) {
-        console.log('[vista:deploy] Generated internal Vercel Build Output at .vercel/output/');
+        console.log('[vista:deploy] Generated Vercel Node SSR output at .vercel/output/');
     }
     return true;
 }
-function writeLegacyVercelJson(ctx) {
+function writeVercelJson(ctx, fullRuntime) {
     const targetFile = path_1.default.join(ctx.cwd, 'vercel.json');
-    const payload = {
-        version: 2,
-        buildCommand: 'npm run build',
-        outputDirectory: '.vista',
-        framework: null,
-        installCommand: 'npm install --legacy-peer-deps --no-audit --no-fund',
-        devCommand: 'npm run dev',
-        routes: utils_1.STATIC_HOST_ROUTE_RULES,
-    };
+    const payload = fullRuntime
+        ? {
+            version: 2,
+            buildCommand: 'npm run build',
+            installCommand: 'npm install --legacy-peer-deps --no-audit --no-fund',
+            framework: null,
+        }
+        : {
+            version: 2,
+            buildCommand: 'npm run build',
+            outputDirectory: '.vista',
+            framework: null,
+            installCommand: 'npm install --legacy-peer-deps --no-audit --no-fund',
+            devCommand: 'npm run dev',
+            routes: utils_1.STATIC_HOST_ROUTE_RULES,
+        };
     const result = (0, utils_1.writeFileIfAllowed)(targetFile, `${JSON.stringify(payload, null, 2)}\n`, ctx.force);
     return result.written || result.skipped ? targetFile : null;
 }
 exports.vercelAdapter = {
     id: 'vercel',
-    requiredOutput: 'static',
-    supportsFullRuntime: false,
+    requiredOutput: 'standalone',
+    supportsFullRuntime: true,
     async preflight(ctx) {
-        return (0, preflight_1.runStaticHostPreflight)(ctx);
+        if ((0, runtime_pack_1.isStaticOnlyDeploy)(ctx)) {
+            return (0, preflight_1.runStaticHostPreflight)(ctx);
+        }
+        return (0, preflight_1.runStandalonePreflight)(ctx);
     },
     async emit(ctx) {
         const artifactPaths = [];
         const warnings = [];
-        if (ctx.deployConfig.preferBuildOutputApi) {
+        const staticOnly = (0, runtime_pack_1.isStaticOnlyDeploy)(ctx);
+        if (staticOnly) {
             const wrote = writeVercelBuildOutput({
                 cwd: ctx.cwd,
                 vistaDir: ctx.vistaDir,
                 debug: ctx.debug,
                 force: true,
             });
-            if (wrote) {
+            if (wrote)
                 artifactPaths.push(path_1.default.join(ctx.cwd, '.vercel', 'output'));
-            }
-        }
-        else if (!hasUserVercelConfig(ctx.cwd) || ctx.force) {
-            const legacyPath = writeLegacyVercelJson(ctx);
-            if (legacyPath)
-                artifactPaths.push(legacyPath);
+            artifactPaths.push(path_1.default.join(ctx.vistaDir, 'static'));
         }
         else {
-            artifactPaths.push(path_1.default.join(ctx.cwd, 'vercel.json'));
+            artifactPaths.push(...(0, runtime_pack_1.packVercelFullRuntime)(ctx));
         }
-        (0, utils_1.copyStaticHostAssets)(ctx.cwd, ctx.vistaDir, path_1.default.join(ctx.vistaDir));
-        artifactPaths.push(path_1.default.join(ctx.vistaDir, 'static'));
+        const vercelJson = writeVercelJson(ctx, !staticOnly);
+        if (vercelJson)
+            artifactPaths.push(vercelJson);
         return {
             status: 'emitted',
             target: 'vercel',
             artifactPaths,
             warnings,
-            instructions: [
-                'Vercel deploy uses pre-rendered static pages from .vista/static.',
-                'For full SSR, server actions, and typed API, deploy with --target render or --target docker.',
-            ],
+            instructions: staticOnly
+                ? [
+                    'Static mode: Vercel serves pre-rendered pages from .vista/static.',
+                    'For Flight SSR, omit deploy.output "static" (default is standalone).',
+                ]
+                : [
+                    'Vercel Build Output includes a Node.js serverless function that runs Flight SSR.',
+                    'Deploy with: vercel deploy --prebuilt --prod',
+                    'Connect the Git repo on Vercel; build command is "npm run build".',
+                    'Cold start spawns the Flight upstream in-process. Raise maxDuration in .vc-config.json if pages are slow.',
+                ],
         };
     },
     async deploy(ctx) {
@@ -134,8 +168,8 @@ exports.vercelAdapter = {
                 ],
                 instructions: [
                     'Install Vercel CLI: npm i -g vercel',
-                    'Then run: vercel deploy --prod',
-                    'Or connect this repository in the Vercel dashboard with buildCommand "npm run build".',
+                    'Then run: vercel login && vercel deploy --prebuilt --prod',
+                    'Or import the Git repository in the Vercel dashboard (build: npm run build).',
                 ],
             };
         }
@@ -146,11 +180,7 @@ exports.vercelAdapter = {
                 target: 'vercel',
                 artifactPaths: emitted.artifactPaths,
                 warnings: [...warnings, result.stderr || 'Vercel deploy failed.'],
-                instructions: [
-                    'Ensure you are logged in: vercel login',
-                    'Or set VERCEL_TOKEN in your environment.',
-                    'You can also deploy from the Vercel dashboard using npm run build.',
-                ],
+                instructions: ['Ensure you are logged in: vercel login', 'Or set VERCEL_TOKEN.'],
             };
         }
         return {

package/dist/deploy/preflight.js

@@ -11,6 +11,7 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const config_1 = require("../config");
 const artifact_validator_1 = require("../server/artifact-validator");
+const app_dir_1 = require("../server/app-dir");
 const utils_1 = require("./utils");
 function hasDynamicOnlyRoutes(vistaDir) {
     const routesManifest = (0, utils_1.readJsonSafe)(path_1.default.join(vistaDir, 'routes-manifest.json'));
@@ -42,13 +43,13 @@ async function runStaticHostPreflight(ctx) {
         errors.push('No pre-rendered pages found at .vista/static/pages. Static hosts require SSG output from "vista build".');
     }
     if (hasDynamicOnlyRoutes(ctx.vistaDir)) {
-        errors.push('This app appears to rely on dynamic server rendering without static fallbacks. Deploy to Render or Docker for full runtime support.');
+        errors.push('This app appears to rely on dynamic server rendering without static fallbacks. Use the default standalone deploy (Vercel Node, Netlify Functions, Cloudflare Containers, Render, or Docker) instead of deploy.output "static".');
     }
     const typedApi = (0, config_1.resolveTypedApiConfig)(ctx.config);
     if (typedApi.enabled) {
-        errors.push('Typed API is enabled. Static CDN hosts cannot run typed API runtime. Use deploy.target "render" or "docker".');
+        errors.push('Typed API is enabled. Static CDN hosts cannot run typed API runtime. Omit deploy.output "static" so the Node Flight server is packed.');
     }
-    const appApiDir = path_1.default.join(ctx.cwd, 'app', 'api');
+    const appApiDir = path_1.default.join((0, app_dir_1.resolveAppDir)(ctx.cwd), 'api');
     if (fs_1.default.existsSync(appApiDir)) {
         warnings.push('Found app/api routes. Server-side API routes are not supported on static CDN deploy targets.');
     }

package/dist/deploy/runtime-pack.d.ts

@@ -0,0 +1,11 @@
+import type { DeployContext } from './types';
+export declare function isStaticOnlyDeploy(ctx: DeployContext): boolean;
+export declare function resolveStandaloneServerPath(ctx: DeployContext): string;
+export declare function copyStandaloneRuntime(ctx: DeployContext, targetDir: string): void;
+export declare function packRuntimeNodeModules(cwd: string, destDir: string): void;
+export declare const VERCEL_SSR_FUNCTION_NAME = "index";
+export declare function writeVercelNodeHandler(funcDir: string): void;
+export declare function writeNetlifySsrHandler(functionDir: string): void;
+export declare function writeCloudflareContainerWorker(outputDir: string): void;
+export declare function writeCloudflareFullRuntimeToml(ctx: DeployContext): string;
+export declare function packVercelFullRuntime(ctx: DeployContext): string[];

package/dist/deploy/runtime-pack.js

@@ -0,0 +1,300 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERCEL_SSR_FUNCTION_NAME = void 0;
+exports.isStaticOnlyDeploy = isStaticOnlyDeploy;
+exports.resolveStandaloneServerPath = resolveStandaloneServerPath;
+exports.copyStandaloneRuntime = copyStandaloneRuntime;
+exports.packRuntimeNodeModules = packRuntimeNodeModules;
+exports.writeVercelNodeHandler = writeVercelNodeHandler;
+exports.writeNetlifySsrHandler = writeNetlifySsrHandler;
+exports.writeCloudflareContainerWorker = writeCloudflareContainerWorker;
+exports.writeCloudflareFullRuntimeToml = writeCloudflareFullRuntimeToml;
+exports.packVercelFullRuntime = packVercelFullRuntime;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const utils_1 = require("./utils");
+function isStaticOnlyDeploy(ctx) {
+    return ctx.deployConfig.output === 'static';
+}
+function resolveStandaloneServerPath(ctx) {
+    return path_1.default.join(ctx.vistaDir, 'standalone', 'server.js');
+}
+function copyStandaloneRuntime(ctx, targetDir) {
+    const standaloneDir = path_1.default.join(ctx.vistaDir, 'standalone');
+    (0, utils_1.copyDirectoryRecursive)(standaloneDir, targetDir);
+}
+function packRuntimeNodeModules(cwd, destDir) {
+    const nodeModules = path_1.default.join(cwd, 'node_modules');
+    if (fs_1.default.existsSync(nodeModules)) {
+        (0, utils_1.copyDirectoryRecursive)(nodeModules, path_1.default.join(destDir, 'node_modules'));
+    }
+    const packageJson = path_1.default.join(cwd, 'package.json');
+    if (fs_1.default.existsSync(packageJson)) {
+        fs_1.default.copyFileSync(packageJson, path_1.default.join(destDir, 'package.json'));
+    }
+}
+exports.VERCEL_SSR_FUNCTION_NAME = 'index';
+function writeVercelNodeHandler(funcDir) {
+    (0, utils_1.ensureDir)(funcDir);
+    const handler = `#!/usr/bin/env node
+const path = require('path');
+
+process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+process.env.VISTA_ARTIFACT_ROOT = process.env.VISTA_ARTIFACT_ROOT || __dirname;
+process.chdir(__dirname);
+
+const standalone = require(path.join(__dirname, '.vista', 'standalone', 'server.js'));
+const listener = standalone.createRequestListener
+  ? standalone.createRequestListener()
+  : standalone.startStandaloneServer({ listen: false });
+
+module.exports = function vistaHandler(req, res) {
+  return listener(req, res);
+};
+`;
+    fs_1.default.writeFileSync(path_1.default.join(funcDir, 'index.js'), handler, 'utf8');
+    fs_1.default.writeFileSync(path_1.default.join(funcDir, '.vc-config.json'), JSON.stringify({
+        runtime: 'nodejs20.x',
+        handler: 'index.js',
+        launcherType: 'Nodejs',
+        shouldAddHelpers: false,
+        supportsResponseStreaming: true,
+        maxDuration: 60,
+        memory: 1024,
+    }, null, 2), 'utf8');
+}
+function writeNetlifySsrHandler(functionDir) {
+    (0, utils_1.ensureDir)(functionDir);
+    const handler = `const path = require('path');
+const http = require('http');
+const stream = require('stream');
+
+process.env.NODE_ENV = process.env.NODE_ENV || 'production';
+process.env.VISTA_ARTIFACT_ROOT = process.env.VISTA_ARTIFACT_ROOT || __dirname;
+process.chdir(__dirname);
+
+const standalone = require(path.join(__dirname, '.vista', 'standalone', 'server.js'));
+const listener = standalone.createRequestListener
+  ? standalone.createRequestListener()
+  : standalone.startStandaloneServer({ listen: false });
+
+function queryFromEvent(event) {
+  if (event.rawQuery) return '?' + event.rawQuery;
+  const params = event.multiValueQueryStringParameters || event.queryStringParameters || {};
+  const search = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (Array.isArray(value)) {
+      value.forEach((entry) => search.append(key, String(entry)));
+    } else if (value != null) {
+      search.append(key, String(value));
+    }
+  }
+  const encoded = search.toString();
+  return encoded ? '?' + encoded : '';
+}
+
+function normalizeHeaders(raw) {
+  const headers = {};
+  for (const [key, value] of Object.entries(raw || {})) {
+    if (value == null) continue;
+    headers[String(key).toLowerCase()] = Array.isArray(value) ? value.join(',') : String(value);
+  }
+  return headers;
+}
+
+function createIncomingMessage(event) {
+  const socket = new stream.Duplex({
+    read() {},
+    write(_chunk, _enc, cb) { cb(); },
+  });
+  socket.remoteAddress = event.headers?.['x-nf-client-connection-ip'] || event.headers?.['x-forwarded-for'] || '127.0.0.1';
+  socket.encrypted = true;
+  socket.destroy = function destroy() {};
+
+  const req = new http.IncomingMessage(socket);
+  req.method = event.httpMethod || event.method || 'GET';
+  req.url = (event.path || event.rawPath || '/') + queryFromEvent(event);
+  req.headers = normalizeHeaders(event.headers);
+  req.httpVersion = '1.1';
+  req.httpVersionMajor = 1;
+  req.httpVersionMinor = 1;
+
+  const body = event.body
+    ? event.isBase64Encoded
+      ? Buffer.from(event.body, 'base64')
+      : Buffer.from(event.body)
+    : null;
+  if (body && body.length) {
+    req.push(body);
+  }
+  req.push(null);
+  return req;
+}
+
+function createServerResponse(req) {
+  const chunks = [];
+  const res = new http.ServerResponse(req);
+  const sink = new stream.Writable({
+    write(chunk, _enc, cb) {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+      cb();
+    },
+  });
+  res.assignSocket(sink);
+  res.flushHeaders = res.flushHeaders || function flushHeaders() {
+    if (!this._header) this._implicitHeader();
+  };
+  return {
+    res,
+    getBody() {
+      return Buffer.concat(chunks);
+    },
+  };
+}
+
+function toLambdaResponse(res, body) {
+  const headers = {};
+  const multiValueHeaders = {};
+  const raw = typeof res.getHeaders === 'function' ? res.getHeaders() : {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (Array.isArray(value)) {
+      multiValueHeaders[key] = value.map((entry) => String(entry));
+    } else if (value != null) {
+      headers[key] = String(value);
+    }
+  }
+  return {
+    statusCode: res.statusCode || 200,
+    headers,
+    multiValueHeaders,
+    body: body.toString('base64'),
+    isBase64Encoded: true,
+  };
+}
+
+exports.handler = async function handler(event) {
+  const req = createIncomingMessage(event);
+  const { res, getBody } = createServerResponse(req);
+
+  return await new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      resolve(toLambdaResponse(res, getBody()));
+    };
+    res.once('finish', finish);
+    res.once('close', finish);
+    res.once('error', reject);
+    try {
+      const handled = listener(req, res);
+      if (handled && typeof handled.then === 'function') {
+        handled.catch(reject);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  });
+};
+`;
+    fs_1.default.writeFileSync(path_1.default.join(functionDir, 'ssr.js'), handler, 'utf8');
+}
+function writeCloudflareContainerWorker(outputDir) {
+    (0, utils_1.ensureDir)(outputDir);
+    const worker = `export class VistaSSR {
+  constructor(ctx, env) {
+    this.ctx = ctx;
+    this.env = env;
+  }
+
+  async fetch(request) {
+    const container = this.ctx.container;
+    if (!container) {
+      return new Response(
+        'Vista SSR container is not available. Enable Cloudflare Containers or run the generated Dockerfile on a Node host.',
+        { status: 503, headers: { 'content-type': 'text/plain; charset=utf-8' } }
+      );
+    }
+
+    if (!container.running) {
+      await container.start({
+        env: {
+          NODE_ENV: 'production',
+          PORT: '3003',
+        },
+      });
+    }
+
+    return container.getTcpPort(3003).fetch(request);
+  }
+}
+
+export default {
+  async fetch(request, env) {
+    const id = env.VISTA_SSR.idFromName('vista');
+    return env.VISTA_SSR.get(id).fetch(request);
+  },
+};
+`;
+    fs_1.default.writeFileSync(path_1.default.join(outputDir, 'worker.js'), worker, 'utf8');
+}
+function writeCloudflareFullRuntimeToml(ctx) {
+    const targetFile = path_1.default.join(ctx.cwd, 'wrangler.toml');
+    const content = `name = "vista-app"
+compatibility_date = "2026-09-20"
+main = ".vista/deploy/cloudflare/worker.js"
+
+[vars]
+VISTA_RUNTIME = "standalone"
+
+# Full Flight SSR runs in a Node container (same image as vista deploy --target docker).
+[[containers]]
+class_name = "VistaSSR"
+image = "./Dockerfile"
+max_instances = 4
+
+[[durable_objects.bindings]]
+name = "VISTA_SSR"
+class_name = "VistaSSR"
+
+[[migrations]]
+tag = "v1"
+new_sqlite_classes = ["VistaSSR"]
+`;
+    (0, utils_1.writeFileIfAllowed)(targetFile, content, ctx.force);
+    return targetFile;
+}
+function packVercelFullRuntime(ctx) {
+    const outputDir = path_1.default.join(ctx.cwd, '.vercel', 'output');
+    const staticDir = path_1.default.join(outputDir, 'static');
+    const funcDir = path_1.default.join(outputDir, 'functions', `${exports.VERCEL_SSR_FUNCTION_NAME}.func`);
+    fs_1.default.rmSync(outputDir, { recursive: true, force: true });
+    (0, utils_1.ensureDir)(staticDir);
+    (0, utils_1.ensureDir)(funcDir);
+    (0, utils_1.copyStaticHostAssets)(ctx.cwd, ctx.vistaDir, staticDir);
+    const vistaStatic = path_1.default.join(ctx.vistaDir, 'static');
+    if (fs_1.default.existsSync(vistaStatic)) {
+        (0, utils_1.copyDirectoryRecursive)(vistaStatic, path_1.default.join(staticDir, '_vista', 'static'));
+    }
+    // Keep the standalone layout: <root>/.vista/standalone/server.js so projectRoot is <root>.
+    (0, utils_1.copyDirectoryRecursive)(ctx.vistaDir, path_1.default.join(funcDir, '.vista'));
+    packRuntimeNodeModules(ctx.cwd, funcDir);
+    writeVercelNodeHandler(funcDir);
+    const config = {
+        version: 3,
+        routes: [
+            {
+                src: '^/_vista/static/(.*)$',
+                headers: { 'cache-control': 'public, max-age=31536000, immutable' },
+                dest: '/_vista/static/$1',
+            },
+            { handle: 'filesystem' },
+            { src: '/(.*)', dest: '/' },
+        ],
+    };
+    fs_1.default.writeFileSync(path_1.default.join(outputDir, 'config.json'), JSON.stringify(config, null, 2));
+    return [outputDir, funcDir, staticDir];
+}