@vistagenic/vista 0.2.10 → 0.2.13

package/dist/bin/flashpack-runner.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const build_rsc_1 = require("./build-rsc");
+const rsc_engine_1 = require("../server/rsc-engine");
+function parseCliArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+function normalizePhase(raw) {
+    const value = String(raw || '')
+        .trim()
+        .toLowerCase();
+    if (value === 'dev' || value === 'development')
+        return 'dev';
+    if (value === 'start')
+        return 'start';
+    return 'build';
+}
+async function main() {
+    const phase = normalizePhase(parseCliArg('--phase'));
+    const rawPort = parseCliArg('--port') || process.env.PORT || '3003';
+    const port = Number(rawPort) || 3003;
+    process.env.VISTA_ENGINE = 'flashpack';
+    process.env.VISTA_ENGINE_VARIANT = 'flashpack';
+    process.env.VISTA_FLASHPACK = 'true';
+    process.env.VISTA_FLASHPACK_PIPELINE = process.env.VISTA_FLASHPACK_PIPELINE || 'rust-cli';
+    if (phase === 'build') {
+        await (0, build_rsc_1.buildRSC)(false);
+        return;
+    }
+    if (phase === 'dev') {
+        const buildResult = await (0, build_rsc_1.buildRSC)(true);
+        (0, rsc_engine_1.startRSCServer)({
+            port,
+            compiler: buildResult.clientCompiler,
+        });
+        return;
+    }
+    const standaloneServerPath = path_1.default.join(process.cwd(), '.vista', 'standalone', 'server.js');
+    if (fs_1.default.existsSync(standaloneServerPath)) {
+        const standalone = require(standaloneServerPath);
+        const startStandaloneServer = standalone.startStandaloneServer || standalone.default || standalone;
+        startStandaloneServer({
+            port,
+            engine: 'flashpack',
+        });
+        return;
+    }
+    (0, rsc_engine_1.startRSCServer)({ port });
+}
+main().catch((error) => {
+    console.error(error && error.stack ? error.stack : error);
+    process.exit(1);
+});

package/dist/bin/server-component-plugin.d.ts

@@ -1,17 +1,19 @@
 /**
  * Vista Server Component Webpack Plugin
  *
- * Checks for server component violations on every webpack compilation.
- * Fails the build if client hooks are used without 'use client' directive.
+ * Checks for server/client boundary violations and invalid route segment
+ * config on every webpack compilation.
  */
 import type { Compiler } from 'webpack';
 export declare class VistaServerComponentPlugin {
     private appDir;
+    private componentsDir?;
+    private cacheComponentsEnabled;
     constructor(options: {
         appDir: string;
+        componentsDir?: string;
+        cacheComponentsEnabled?: boolean;
     });
     apply(compiler: Compiler): void;
-    private checkServerComponents;
-    private scanDirectory;
 }
 export default VistaServerComponentPlugin;

package/dist/bin/server-component-plugin.js

@@ -2,8 +2,8 @@
 /**
  * Vista Server Component Webpack Plugin
  *
- * Checks for server component violations on every webpack compilation.
- * Fails the build if client hooks are used without 'use client' directive.
+ * Checks for server/client boundary violations and invalid route segment
+ * config on every webpack compilation.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -40,94 +40,47 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VistaServerComponentPlugin = void 0;
-const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
-// Client-only hooks and APIs that require 'use client' directive
-const CLIENT_HOOKS = [
-    'useState', 'useEffect', 'useLayoutEffect', 'useReducer', 'useRef',
-    'useImperativeHandle', 'useCallback', 'useMemo', 'useContext',
-    'useDebugValue', 'useDeferredValue', 'useTransition', 'useId',
-    'useSyncExternalStore', 'useInsertionEffect',
-];
-function hasClientDirective(source) {
-    const trimmed = source.trim();
-    return trimmed.startsWith("'use client'") || trimmed.startsWith('"use client"');
-}
-function detectClientHooks(source) {
-    const usedHooks = [];
-    for (const hook of CLIENT_HOOKS) {
-        const regex = new RegExp(`\\b${hook}\\s*[(<]`, 'g');
-        if (regex.test(source)) {
-            usedHooks.push(hook);
-        }
-    }
-    // Check for event handlers
-    if (/\bon[A-Z][a-zA-Z]*\s*=/g.test(source)) {
-        usedHooks.push('event handlers');
-    }
-    return [...new Set(usedHooks)];
-}
+const module_boundary_validator_1 = require("../server/module-boundary-validator");
 class VistaServerComponentPlugin {
     appDir;
+    componentsDir;
+    cacheComponentsEnabled;
     constructor(options) {
         this.appDir = options.appDir;
+        this.componentsDir = options.componentsDir;
+        this.cacheComponentsEnabled = Boolean(options.cacheComponentsEnabled);
     }
     apply(compiler) {
         // Use afterCompile hook so we can add errors to compilation
         compiler.hooks.afterCompile.tap('VistaServerComponentPlugin', (compilation) => {
-            const errors = this.checkServerComponents();
+            const errors = (0, module_boundary_validator_1.validateModuleBoundaries)({
+                appDir: this.appDir,
+                extraRoots: this.componentsDir ? [this.componentsDir] : [],
+                cacheComponentsEnabled: this.cacheComponentsEnabled,
+            }).issues;
             if (errors.length > 0) {
                 console.log('');
-                console.log('\x1b[41m\x1b[37m ERROR \x1b[0m \x1b[31mServer Component Error\x1b[0m');
+                console.log('\x1b[41m\x1b[37m ERROR \x1b[0m \x1b[31mServer/Segment Validation Error\x1b[0m');
                 console.log('');
                 for (const error of errors) {
-                    console.log(`\x1b[31m✗\x1b[0m ${error.file}`);
-                    console.log(`  You're using \x1b[33m${error.hooks.join(', ')}\x1b[0m in a Server Component.`);
-                    console.log('');
-                    console.log(`  \x1b[36mTo fix:\x1b[0m Add \x1b[33m'use client'\x1b[0m at the top of your file:`);
-                    console.log('');
-                    console.log(`    \x1b[32m'use client';\x1b[0m`);
+                    const relativeFile = path.relative(this.appDir, error.filePath);
+                    console.log(`\x1b[31m✗\x1b[0m ${relativeFile}`);
+                    console.log(`  ${error.message}`);
                     console.log('');
+                    if (error.fix) {
+                        console.log(`  \x1b[36mTo fix:\x1b[0m ${error.fix}`);
+                        console.log('');
+                    }
                     // Add webpack error so it shows in overlay
                     const WebpackError = require('webpack').WebpackError;
-                    const err = new WebpackError(`Server Component Error: ${error.file}\n` +
-                        `You're using ${error.hooks.join(', ')} in a Server Component.\n` +
-                        `Add 'use client' at the top of your file to make it a Client Component.`);
-                    err.file = error.file;
+                    const err = new WebpackError(`${error.message}\n${error.fix ? `Fix: ${error.fix}` : ''}`.trim());
+                    err.file = relativeFile;
                     compilation.errors.push(err);
                 }
             }
         });
     }
-    checkServerComponents() {
-        const errors = [];
-        this.scanDirectory(this.appDir, errors);
-        return errors;
-    }
-    scanDirectory(dir, errors) {
-        if (!fs.existsSync(dir))
-            return;
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
-                    this.scanDirectory(fullPath, errors);
-                }
-            }
-            else if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name)) {
-                const source = fs.readFileSync(fullPath, 'utf-8');
-                const isClient = hasClientDirective(source);
-                const clientHooks = detectClientHooks(source);
-                if (!isClient && clientHooks.length > 0) {
-                    errors.push({
-                        file: path.relative(this.appDir, fullPath),
-                        hooks: clientHooks
-                    });
-                }
-            }
-        }
-    }
 }
 exports.VistaServerComponentPlugin = VistaServerComponentPlugin;
 exports.default = VistaServerComponentPlugin;

package/dist/bin/webpack.config.d.ts

@@ -1,6 +1,9 @@
 import webpack from 'webpack';
+import type { VistaEngineVariant } from '../config';
 export interface WebpackConfigOptions {
     cwd: string;
     isDev: boolean;
+    engineVariant?: VistaEngineVariant;
+    cacheComponentsEnabled?: boolean;
 }
 export declare function createWebpackConfig(options: WebpackConfigOptions): webpack.Configuration;

package/dist/bin/webpack.config.js

@@ -12,8 +12,9 @@ const server_component_plugin_1 = require("./server-component-plugin");
 const vista_flight_plugin_1 = require("../build/webpack/plugins/vista-flight-plugin");
 const constants_1 = require("../constants");
 function createWebpackConfig(options) {
-    const { cwd, isDev } = options;
+    const { cwd, isDev, engineVariant = 'default', cacheComponentsEnabled = false } = options;
     const vistaDir = path_1.default.join(cwd, constants_1.BUILD_DIR);
+    const flashDir = path_1.default.join(cwd, constants_1.FLASH_DIR);
     const entryPoint = path_1.default.join(vistaDir, 'client.tsx');
     // Find React - check local node_modules first, then traverse up for monorepo hoisting
     const findModulePath = (moduleName) => {
@@ -56,7 +57,9 @@ function createWebpackConfig(options) {
         cache: isDev
             ? {
                 type: 'filesystem',
-                cacheDirectory: path_1.default.join(cwd, 'node_modules', '.cache', 'vista-webpack'),
+                cacheDirectory: engineVariant === 'flashpack'
+                    ? path_1.default.join(flashDir, 'cache', 'webpack')
+                    : path_1.default.join(cwd, 'node_modules', '.cache', 'vista-webpack'),
                 buildDependencies: {
                     config: [__filename],
                 },
@@ -143,7 +146,11 @@ function createWebpackConfig(options) {
         },
         plugins: [
             // Server Component enforcement - runs on every compile
-            new server_component_plugin_1.VistaServerComponentPlugin({ appDir: path_1.default.join(cwd, 'app') }),
+            new server_component_plugin_1.VistaServerComponentPlugin({
+                appDir: path_1.default.join(cwd, 'app'),
+                componentsDir: path_1.default.join(cwd, 'components'),
+                cacheComponentsEnabled,
+            }),
             // Vista Flight Plugin - RSC bundle separation and manifest
             new vista_flight_plugin_1.VistaFlightPlugin({ appDir: path_1.default.join(cwd, 'app'), dev: isDev }),
             ...(isDev
@@ -156,6 +163,8 @@ function createWebpackConfig(options) {
                 : []),
             new webpack_1.default.DefinePlugin({
                 'process.env.NODE_ENV': JSON.stringify(isDev ? 'development' : 'production'),
+                'process.env.VISTA_ENGINE': JSON.stringify(engineVariant),
+                'process.env.VISTA_ENGINE_VARIANT': JSON.stringify(engineVariant),
             }),
             new mini_css_extract_plugin_1.default({
                 filename: isDev ? 'modules.css' : 'modules-[contenthash:8].css',

package/dist/build/manifest.d.ts

@@ -3,6 +3,8 @@
  *
  * Generates build manifests, BUILD_ID, and manages .vista output structure.
  */
+import type { VistaEngineVariant } from '../config';
+import type { ImageConfig } from '../image/image-config';
 /**
  * Generate a unique build ID based on timestamp and random bytes.
  */
@@ -14,6 +16,7 @@ export declare function getBuildId(vistaDir: string, forceNew?: boolean): string
 export interface VistaDirs {
     root: string;
     cache: string;
+    imageCache: string;
     server: string;
     static: string;
     chunks: string;
@@ -48,6 +51,10 @@ export interface ArtifactManifest {
         requiredServerFiles: string;
         reactClientManifest: string;
         reactServerManifest: string;
+        serverManifest?: string;
+        runtimeManifest?: string;
+        fileTrace?: string;
+        standaloneServer?: string;
     };
 }
 /**
@@ -61,10 +68,16 @@ interface RouteLike {
 }
 export declare function generateAppPathRoutesManifest(vistaDir: string, routes?: RouteLike[]): Record<string, string>;
 export declare function generatePrerenderManifest(vistaDir: string): void;
-export declare function generateRequiredServerFilesManifest(cwd: string, vistaDir: string): void;
+export declare function generateRequiredServerFilesManifest(cwd: string, vistaDir: string, extraFiles?: string[], appDir?: string): void;
 export declare function ensureJsonFile(vistaDir: string, relativePath: string, fallback?: unknown): void;
-export declare function writeArtifactManifest(vistaDir: string, buildId: string): ArtifactManifest;
+export declare function writeArtifactManifest(vistaDir: string, buildId: string, extraManifestEntries?: Partial<ArtifactManifest['manifests']>): ArtifactManifest;
 export declare function writeCanonicalVistaArtifacts(cwd: string, vistaDir: string, buildId: string, routes?: RouteLike[]): ArtifactManifest;
+interface WriteReservedVistaArtifactsOptions {
+    buildId: string;
+    engineVariant?: VistaEngineVariant;
+    imagesConfig?: Partial<ImageConfig> | undefined;
+}
+export declare function writeReservedVistaArtifacts(vistaDir: string, options: WriteReservedVistaArtifactsOptions): void;
 export interface RouteInfo {
     page: string;
     regex: string;
@@ -109,7 +122,7 @@ export declare function generateServerComponentsManifest(vistaDir: string, serve
 /**
  * Get Webpack cache configuration for persistent caching.
  */
-export declare function getWebpackCacheConfig(vistaDir: string, buildId: string, name: string): {
+export declare function getWebpackCacheConfig(vistaDir: string, buildId: string, name: string, engineVariant?: VistaEngineVariant, cwd?: string): {
     type: "filesystem";
     version: string;
     cacheDirectory: string;
@@ -122,4 +135,5 @@ export declare function getWebpackCacheConfig(vistaDir: string, buildId: string,
  * Clean old cache entries (keeps last N builds).
  */
 export declare function cleanOldCache(vistaDir: string, keepBuilds?: number): void;
+export declare function pruneEmptyVistaDirectories(vistaDir: string): void;
 export {};

package/dist/build/manifest.js

@@ -18,11 +18,13 @@ exports.generateRequiredServerFilesManifest = generateRequiredServerFilesManifes
 exports.ensureJsonFile = ensureJsonFile;
 exports.writeArtifactManifest = writeArtifactManifest;
 exports.writeCanonicalVistaArtifacts = writeCanonicalVistaArtifacts;
+exports.writeReservedVistaArtifacts = writeReservedVistaArtifacts;
 exports.generateRoutesManifest = generateRoutesManifest;
 exports.generateClientComponentsManifest = generateClientComponentsManifest;
 exports.generateServerComponentsManifest = generateServerComponentsManifest;
 exports.getWebpackCacheConfig = getWebpackCacheConfig;
 exports.cleanOldCache = cleanOldCache;
+exports.pruneEmptyVistaDirectories = pruneEmptyVistaDirectories;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const crypto_1 = __importDefault(require("crypto"));
@@ -62,6 +64,7 @@ function createVistaDirectories(cwd, mode = 'legacy') {
     const dirs = {
         root,
         cache: path_1.default.join(root, 'cache'),
+        imageCache: path_1.default.join(root, 'cache', 'images'),
         server: path_1.default.join(root, 'server'),
         static: path_1.default.join(root, 'static'),
         chunks: path_1.default.join(root, 'static', 'chunks'),
@@ -71,19 +74,9 @@ function createVistaDirectories(cwd, mode = 'legacy') {
     // Always create root
     fs_1.default.mkdirSync(root, { recursive: true });
     if (mode === 'rsc') {
-        // RSC mode: create only currently-used directories.
-        // Keep css/media paths reserved in `dirs` for future use, but do not
-        // create empty folders unless the build actually emits files there.
-        [dirs.root, dirs.cache, dirs.server, dirs.static, dirs.chunks].forEach((dir) => {
+        [dirs.root, dirs.cache, dirs.imageCache, dirs.server, dirs.static, dirs.chunks, dirs.media].forEach((dir) => {
             fs_1.default.mkdirSync(dir, { recursive: true });
         });
-        // Cache subdirectories
-        fs_1.default.mkdirSync(path_1.default.join(dirs.cache, 'webpack'), { recursive: true });
-        fs_1.default.mkdirSync(path_1.default.join(dirs.cache, 'swc'), { recursive: true });
-        fs_1.default.mkdirSync(path_1.default.join(dirs.cache, 'images'), { recursive: true });
-        // Server subdirectories
-        fs_1.default.mkdirSync(path_1.default.join(dirs.server, 'app'), { recursive: true });
-        fs_1.default.mkdirSync(path_1.default.join(dirs.server, 'chunks'), { recursive: true });
     }
     // Legacy mode: only root dir is created — webpack outputs directly into .vista/
     return dirs;
@@ -159,18 +152,21 @@ function generatePrerenderManifest(vistaDir) {
     };
     fs_1.default.writeFileSync(path_1.default.join(vistaDir, 'prerender-manifest.json'), JSON.stringify(manifest, null, 2));
 }
-function generateRequiredServerFilesManifest(cwd, vistaDir) {
+function generateRequiredServerFilesManifest(cwd, vistaDir, extraFiles = [], appDir = cwd) {
+    const files = Array.from(new Set([
+        `${constants_1.BUILD_DIR}/BUILD_ID`,
+        `${constants_1.BUILD_DIR}/build-manifest.json`,
+        `${constants_1.BUILD_DIR}/routes-manifest.json`,
+        `${constants_1.BUILD_DIR}/app-path-routes-manifest.json`,
+        `${constants_1.BUILD_DIR}/server/server-manifest.json`,
+        ...extraFiles,
+    ]));
     const manifest = {
         version: 1,
         config: {},
-        appDir: cwd,
-        relativeAppDir: '.',
-        files: [
-            `${constants_1.BUILD_DIR}/BUILD_ID`,
-            `${constants_1.BUILD_DIR}/build-manifest.json`,
-            `${constants_1.BUILD_DIR}/routes-manifest.json`,
-            `${constants_1.BUILD_DIR}/app-path-routes-manifest.json`,
-        ],
+        appDir,
+        relativeAppDir: path_1.default.relative(cwd, appDir) || '.',
+        files,
     };
     fs_1.default.writeFileSync(path_1.default.join(vistaDir, 'required-server-files.json'), JSON.stringify(manifest, null, 2));
 }
@@ -180,7 +176,7 @@ function ensureJsonFile(vistaDir, relativePath, fallback = {}) {
         fs_1.default.writeFileSync(absolutePath, JSON.stringify(fallback, null, 2));
     }
 }
-function writeArtifactManifest(vistaDir, buildId) {
+function writeArtifactManifest(vistaDir, buildId, extraManifestEntries = {}) {
     const artifactManifest = {
         schemaVersion: 1,
         buildId,
@@ -194,6 +190,7 @@ function writeArtifactManifest(vistaDir, buildId) {
             requiredServerFiles: 'required-server-files.json',
             reactClientManifest: 'react-client-manifest.json',
             reactServerManifest: 'react-server-manifest.json',
+            ...extraManifestEntries,
         },
     };
     fs_1.default.writeFileSync(path_1.default.join(vistaDir, 'artifact-manifest.json'), JSON.stringify(artifactManifest, null, 2));
@@ -212,6 +209,59 @@ function writeCanonicalVistaArtifacts(cwd, vistaDir, buildId, routes = []) {
     ensureJsonFile(vistaDir, 'react-server-manifest.json', {});
     return writeArtifactManifest(vistaDir, buildId);
 }
+function writeReservedVistaArtifacts(vistaDir, options) {
+    const engineVariant = options.engineVariant || 'default';
+    const generatedAt = new Date().toISOString();
+    const cacheDir = path_1.default.join(vistaDir, 'cache');
+    const imageCacheDir = path_1.default.join(cacheDir, 'images');
+    const mediaDir = path_1.default.join(vistaDir, 'static', 'media');
+    fs_1.default.mkdirSync(cacheDir, { recursive: true });
+    fs_1.default.mkdirSync(imageCacheDir, { recursive: true });
+    fs_1.default.mkdirSync(mediaDir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(cacheDir, 'cache-manifest.json'), JSON.stringify({
+        schemaVersion: 1,
+        buildId: options.buildId,
+        generatedAt,
+        engine: engineVariant,
+        activeCacheRoot: engineVariant === 'flashpack' ? '.flash/cache' : '.vista/cache/webpack',
+        directories: {
+            localCache: '.vista/cache',
+            webpack: engineVariant === 'flashpack' ? '.flash/cache/webpack' : '.vista/cache/webpack',
+            images: '.vista/cache/images',
+        },
+        notes: [
+            engineVariant === 'flashpack'
+                ? 'Flashpack stores its hot build cache in .flash while .vista/cache keeps framework metadata.'
+                : 'Default engine stores framework metadata here and may add webpack cache artifacts during rebuilds.',
+        ],
+    }, null, 2));
+    fs_1.default.writeFileSync(path_1.default.join(imageCacheDir, 'manifest.json'), JSON.stringify({
+        schemaVersion: 1,
+        buildId: options.buildId,
+        generatedAt,
+        endpoint: constants_1.IMAGE_ENDPOINT,
+        cacheDirectory: '.vista/cache/images',
+        config: options.imagesConfig || {},
+        behavior: {
+            optimization: 'on-demand',
+            staticImportsEmitInto: '.vista/static/media',
+            publicReferencesStayIn: 'public/',
+        },
+    }, null, 2));
+    const emittedMedia = fs_1.default
+        .readdirSync(mediaDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && entry.name !== 'media-manifest.json')
+        .map((entry) => entry.name)
+        .sort();
+    fs_1.default.writeFileSync(path_1.default.join(mediaDir, 'media-manifest.json'), JSON.stringify({
+        schemaVersion: 1,
+        buildId: options.buildId,
+        generatedAt,
+        mediaDirectory: '.vista/static/media',
+        emittedFiles: emittedMedia,
+        note: 'This directory is reserved for emitted media assets. Public file references are served from public/ and may leave this list empty.',
+    }, null, 2));
+}
 /**
  * Generate routes-manifest.json from route tree.
  */
@@ -257,11 +307,14 @@ function generateServerComponentsManifest(vistaDir, serverModules = {}) {
 /**
  * Get Webpack cache configuration for persistent caching.
  */
-function getWebpackCacheConfig(vistaDir, buildId, name) {
+function getWebpackCacheConfig(vistaDir, buildId, name, engineVariant = 'default', cwd = process.cwd()) {
+    const cacheDirectory = engineVariant === 'flashpack'
+        ? path_1.default.join(cwd, constants_1.FLASH_DIR, 'cache', 'webpack')
+        : path_1.default.join(vistaDir, 'cache', 'webpack');
     return {
         type: 'filesystem',
         version: buildId,
-        cacheDirectory: path_1.default.join(vistaDir, 'cache', 'webpack'),
+        cacheDirectory,
         name: name,
         buildDependencies: {
             config: [__filename],
@@ -289,3 +342,26 @@ function cleanOldCache(vistaDir, keepBuilds = 5) {
         fs_1.default.rmSync(entry.path, { recursive: true, force: true });
     });
 }
+function pruneEmptyVistaDirectories(vistaDir) {
+    if (!fs_1.default.existsSync(vistaDir))
+        return;
+    const prune = (absolutePath) => {
+        const entries = fs_1.default.readdirSync(absolutePath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const childPath = path_1.default.join(absolutePath, entry.name);
+            prune(childPath);
+        }
+        // Never remove the root .vista directory itself.
+        if (absolutePath === vistaDir)
+            return false;
+        const remaining = fs_1.default.readdirSync(absolutePath);
+        if (remaining.length === 0) {
+            fs_1.default.rmdirSync(absolutePath);
+            return true;
+        }
+        return false;
+    };
+    prune(vistaDir);
+}

package/dist/build/rsc/compiler.d.ts

@@ -7,11 +7,13 @@
  */
 import webpack from 'webpack';
 import { VistaDirs } from '../manifest';
+import type { VistaEngineVariant } from '../../config';
 export interface RSCCompilerOptions {
     cwd: string;
     isDev: boolean;
     vistaDirs: VistaDirs;
     buildId: string;
+    engineVariant?: VistaEngineVariant;
     clientReferenceFiles?: string[];
 }
 /**

package/dist/build/rsc/compiler.js

@@ -19,6 +19,7 @@ const fs_1 = __importDefault(require("fs"));
 const manifest_1 = require("../manifest");
 const client_manifest_1 = require("./client-manifest");
 const server_manifest_1 = require("./server-manifest");
+const react_client_reference_manifest_1 = require("./react-client-reference-manifest");
 const constants_1 = require("../../constants");
 // Find module path (handles monorepo hoisting)
 const findModulePath = (moduleName, cwd) => {
@@ -59,7 +60,7 @@ function resolveFromWorkspace(specifier, cwd) {
  * Output goes to .vista/server/ and is NEVER sent to the client.
  */
 function createServerWebpackConfig(options) {
-    const { cwd, isDev, vistaDirs, buildId } = options;
+    const { cwd, isDev, vistaDirs, buildId, engineVariant = 'default' } = options;
     const swcLoaderPath = resolveFromWorkspace('swc-loader', cwd);
     const nullLoaderPath = resolveFromWorkspace('null-loader', cwd);
     const cssLoaderPath = resolveFromWorkspace('css-loader', cwd);
@@ -119,7 +120,9 @@ function createServerWebpackConfig(options) {
                 callback();
             },
         ],
-        cache: isDev ? (0, manifest_1.getWebpackCacheConfig)(vistaDirs.root, buildId, 'server-development') : false,
+        cache: isDev
+            ? (0, manifest_1.getWebpackCacheConfig)(vistaDirs.root, buildId, 'server-development', engineVariant, cwd)
+            : false,
         resolve: {
             extensions: ['.tsx', '.ts', '.jsx', '.js'],
             modules: [path_1.default.resolve(cwd, 'node_modules'), 'node_modules'],
@@ -175,6 +178,8 @@ function createServerWebpackConfig(options) {
         plugins: [
             new webpack_1.default.DefinePlugin({
                 'process.env.NODE_ENV': JSON.stringify(isDev ? 'development' : 'production'),
+                'process.env.VISTA_ENGINE': JSON.stringify(engineVariant),
+                'process.env.VISTA_ENGINE_VARIANT': JSON.stringify(engineVariant),
                 [constants_1.BUILD_ID_DEFINE]: JSON.stringify(buildId),
                 [constants_1.SERVER_DEFINE]: 'true',
             }),
@@ -190,7 +195,7 @@ function createServerWebpackConfig(options) {
  * Server components are replaced with client references.
  */
 function createClientWebpackConfig(options) {
-    const { cwd, isDev, vistaDirs, buildId, clientReferenceFiles = [] } = options;
+    const { cwd, isDev, vistaDirs, buildId, engineVariant = 'default', clientReferenceFiles = [] } = options;
     const swcLoaderPath = resolveFromWorkspace('swc-loader', cwd);
     const nullLoaderPath = resolveFromWorkspace('null-loader', cwd);
     const cssLoaderPath = resolveFromWorkspace('css-loader', cwd);
@@ -343,14 +348,26 @@ function createClientWebpackConfig(options) {
             // and preloadModule with the chunks array).
             {
                 apply(compiler) {
-                    compiler.hooks.make.tap('VistaSSRManifestPatch', (compilation) => {
+                    compiler.hooks.make.tap('VistaFlightManifestPatch', (compilation) => {
                         compilation.hooks.processAssets.tap({
-                            name: 'VistaSSRManifestPatch',
+                            name: 'VistaFlightManifestPatch',
                             // Run after the Flight plugin (REPORT stage) has emitted assets
                             stage: webpack_1.default.Compilation.PROCESS_ASSETS_STAGE_REPORT + 1,
                         }, () => {
+                            const clientAssetName = '../../react-client-manifest.json';
                             const ssrAssetName = '../../react-server-manifest.json';
+                            const clientAsset = compilation.getAsset(clientAssetName);
                             const ssrAsset = compilation.getAsset(ssrAssetName);
+                            if (clientAsset) {
+                                try {
+                                    const manifest = JSON.parse(clientAsset.source.source().toString());
+                                    const normalized = (0, react_client_reference_manifest_1.normalizeReactClientReferenceManifest)(manifest);
+                                    compilation.updateAsset(clientAssetName, new webpack_1.default.sources.RawSource(JSON.stringify(normalized, null, 2), false));
+                                }
+                                catch {
+                                    // If parsing fails, leave the asset as-is
+                                }
+                            }
                             if (!ssrAsset)
                                 return;
                             try {
@@ -372,6 +389,7 @@ function createClientWebpackConfig(options) {
                                             }
                                         }
                                     }
+                                    (0, react_client_reference_manifest_1.normalizeReactServerConsumerManifest)(manifest);
                                     compilation.updateAsset(ssrAssetName, new webpack_1.default.sources.RawSource(JSON.stringify(manifest, null, 2), false));
                                 }
                             }
@@ -384,6 +402,8 @@ function createClientWebpackConfig(options) {
             },
             new webpack_1.default.DefinePlugin({
                 'process.env.NODE_ENV': JSON.stringify(isDev ? 'development' : 'production'),
+                'process.env.VISTA_ENGINE': JSON.stringify(engineVariant),
+                'process.env.VISTA_ENGINE_VARIANT': JSON.stringify(engineVariant),
                 [constants_1.BUILD_ID_DEFINE]: JSON.stringify(buildId),
                 [constants_1.SERVER_DEFINE]: 'false',
             }),

package/dist/build/rsc/react-client-reference-manifest.d.ts

@@ -0,0 +1,22 @@
+export interface ReactClientReferenceManifestEntry {
+    id: string | number;
+    chunks: Array<string | number>;
+    name: string;
+}
+export type ReactClientReferenceManifest = Record<string, ReactClientReferenceManifestEntry>;
+export interface ReactServerConsumerManifestEntry {
+    specifier?: string;
+    id?: string | number;
+    chunks?: Array<string | number>;
+    name?: string;
+}
+export interface ReactServerConsumerManifest {
+    moduleLoading?: {
+        prefix: string;
+        crossOrigin: string | null;
+    };
+    moduleMap?: Record<string, Record<string, ReactServerConsumerManifestEntry>>;
+    serverModuleMap?: Record<string, unknown>;
+}
+export declare function normalizeReactClientReferenceManifest(input: ReactClientReferenceManifest): ReactClientReferenceManifest;
+export declare function normalizeReactServerConsumerManifest(input: ReactServerConsumerManifest): ReactServerConsumerManifest;