@vistagenic/vista 0.3.2 → 0.3.3

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];
+}

package/dist/deploy/utils.d.ts

@@ -1,5 +1,5 @@
 export declare function ensureDir(absolutePath: string): void;
-export declare function copyDirectoryRecursive(sourceDir: string, targetDir: string): void;
+export declare function copyDirectoryRecursive(sourceDir: string, targetDir: string, seen?: Set<string>): void;
 export declare function copyFileIfPresent(sourceFile: string, targetFile: string): void;
 export declare function writeFileIfAllowed(targetFile: string, content: string, force: boolean): {
     written: boolean;

package/dist/deploy/utils.js

@@ -15,16 +15,45 @@ const path_1 = __importDefault(require("path"));
 function ensureDir(absolutePath) {
     fs_1.default.mkdirSync(absolutePath, { recursive: true });
 }
-function copyDirectoryRecursive(sourceDir, targetDir) {
+const SKIP_COPY_DIRECTORY_NAMES = new Set(['.cache', '.turbo', '.vite', 'coverage']);
+function copyDirectoryRecursive(sourceDir, targetDir, seen = new Set()) {
     if (!fs_1.default.existsSync(sourceDir))
         return;
+    let realSource = sourceDir;
+    try {
+        realSource = fs_1.default.realpathSync(sourceDir);
+    }
+    catch {
+        return;
+    }
+    if (seen.has(realSource))
+        return;
+    seen.add(realSource);
     ensureDir(targetDir);
     const entries = fs_1.default.readdirSync(sourceDir, { withFileTypes: true });
     for (const entry of entries) {
+        if (SKIP_COPY_DIRECTORY_NAMES.has(entry.name))
+            continue;
         const from = path_1.default.join(sourceDir, entry.name);
         const to = path_1.default.join(targetDir, entry.name);
+        if (entry.isSymbolicLink()) {
+            try {
+                const targetStat = fs_1.default.statSync(from);
+                if (targetStat.isDirectory()) {
+                    copyDirectoryRecursive(from, to, seen);
+                }
+                else if (targetStat.isFile()) {
+                    ensureDir(path_1.default.dirname(to));
+                    fs_1.default.copyFileSync(from, to);
+                }
+            }
+            catch {
+                // dangling symlink
+            }
+            continue;
+        }
         if (entry.isDirectory()) {
-            copyDirectoryRecursive(from, to);
+            copyDirectoryRecursive(from, to, seen);
         }
         else if (entry.isFile()) {
             fs_1.default.copyFileSync(from, to);

package/dist/flashpack/command.js

@@ -28,6 +28,7 @@ async function fallbackToCore(phase, port) {
     process.env.VISTA_ENGINE_VARIANT = 'flashpack';
     process.env.VISTA_FLASHPACK = 'true';
     process.env.VISTA_FLASHPACK_PIPELINE = 'js-fallback';
+    console.warn(`[flashpack] Using explicit webpack Flight SSR fallback for ${phase} (same inline-Flight contract; not renderToString).`);
     if (phase === 'build') {
         await (0, build_rsc_1.buildRSC)(false);
         return;

package/dist/flashpack/runtime.js

@@ -13,6 +13,7 @@ const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const constants_1 = require("../constants");
 const native_scanner_1 = require("../build/rsc/native-scanner");
+const app_dir_1 = require("../server/app-dir");
 function ensureDir(absolutePath) {
     fs_1.default.mkdirSync(absolutePath, { recursive: true });
 }
@@ -191,7 +192,7 @@ function prepareFlashpackRuntime(options) {
         generatedBy: 'vista-ts-bootstrap',
         timestamp: now,
     });
-    const appDir = path_1.default.join(cwd, 'app');
+    const appDir = (0, app_dir_1.resolveAppDir)(cwd);
     if ((0, native_scanner_1.isNativeAvailable)() && fs_1.default.existsSync(appDir)) {
         const nativeScan = (0, native_scanner_1.scanAppNative)(appDir);
         if (nativeScan) {

package/dist/index.d.ts

@@ -1,23 +1,23 @@
-export * from './router';
-export * from './components';
-export * from './types';
-export * from './dev-error';
-export { useRouter } from './client/router';
-export { usePathname, useSearchParams, useParams, useSelectedLayoutSegment, useSelectedLayoutSegments, } from './client/navigation';
-export { default as dynamic } from './client/dynamic';
-export { default as Script } from './client/script';
-export { default as Head, generateMetadataHead } from './client/head';
-export type { Metadata as HeadMetadata } from './client/head';
-export * from './font/index';
-export * from './metadata';
-export type { Metadata } from './metadata/types';
-export { hydrateClientComponents, initializeHydration } from './client/hydration';
-export { Client } from './components/client';
-export { RSCRouter, RSCRouterContext, useRSCRouter } from './client/rsc-router';
-export type { RSCRouterProps, RSCNavigationState, NavigationOptions } from './client/rsc-router';
-export { callServer } from './client/server-actions';
-export type { ClientManifest, ClientComponentEntry } from './build/rsc/client-manifest';
-export type { ServerManifest, ServerComponentEntry, RouteEntry } from './build/rsc/server-manifest';
-export { NextResponse } from './server/index';
-export type { VistaMiddlewareContext, VistaMiddlewareRequest, MiddlewareResult, MiddlewareConfig, MiddlewareFunction, NextFunction, } from './server/index';
-export * from './ai';
+export * from './router';
+export * from './components';
+export * from './types';
+export * from './dev-error';
+export { useRouter } from './client/router';
+export { usePathname, useSearchParams, useParams, useSelectedLayoutSegment, useSelectedLayoutSegments, } from './client/navigation';
+export { default as dynamic } from './client/dynamic';
+export { default as Script } from './client/script';
+export { default as Head, generateMetadataHead } from './client/head';
+export type { Metadata as HeadMetadata } from './client/head';
+export * from './font/index';
+export * from './metadata';
+export type { Metadata } from './metadata/types';
+export { hydrateClientComponents, initializeHydration } from './client/hydration';
+export { Client } from './components/client';
+export { RSCRouter, RSCRouterContext, useRSCRouter } from './client/rsc-router';
+export type { RSCRouterProps, RSCNavigationState, NavigationOptions } from './client/rsc-router';
+export { callServer } from './client/server-actions';
+export type { ClientManifest, ClientComponentEntry } from './build/rsc/client-manifest';
+export type { ServerManifest, ServerComponentEntry, RouteEntry } from './build/rsc/server-manifest';
+export { NextResponse } from './server/index';
+export type { VistaMiddlewareContext, VistaMiddlewareRequest, MiddlewareResult, MiddlewareConfig, MiddlewareFunction, NextFunction, } from './server/index';
+export * from './ai';