@vistagenic/vista 0.1.0-alpha.1

package/dist/build/rsc/client-reference-plugin.js

@@ -0,0 +1,185 @@
+"use strict";
+/**
+ * Vista Client Reference Plugin
+ *
+ * Webpack plugin that transforms server component imports in the client bundle.
+ *
+ * When a client bundle imports a server component, this plugin:
+ * 1. Replaces the import with a client reference proxy
+ * 2. The proxy throws an error if used on the client (server components can't run on client)
+ * 3. For valid patterns (passing server component as children), the reference works
+ *
+ * This ensures:
+ * - Server code never leaks to the client bundle
+ * - Server components contribute 0kb to client JavaScript
+ * - Clear error messages when misusing server components
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClientReferencePlugin = void 0;
+const webpack_1 = __importDefault(require("webpack"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Virtual module that provides server component proxies
+ * These proxies throw helpful errors when server components are incorrectly used client-side
+ */
+const SERVER_COMPONENT_PROXY = `
+// Vista Server Component Proxy
+// This module is injected when a client bundle tries to import a server component
+
+export function createServerComponentProxy(id, name) {
+    const proxy = function ServerComponentProxy(props) {
+        throw new Error(
+            \`[Vista] Cannot render server component "\${name}" on the client.\n\` +
+            \`Server components can only be rendered on the server.\n\n\` +
+            \`To fix this:\n\` +
+            \`1. If you need interactivity, add 'client load' at the top of the component file\n\` +
+            \`2. If passing as children, ensure the parent is a client component\n\` +
+            \`\nComponent ID: \${id}\`
+        );
+    };
+    
+    proxy.$$typeof = Symbol.for('vista.server.reference');
+    proxy.$$id = id;
+    proxy.$$name = name;
+    
+    return proxy;
+}
+
+export default createServerComponentProxy;
+`;
+/**
+ * Check if a file is a client component by reading 'client load' directive
+ */
+function isClientComponent(filePath) {
+    try {
+        const content = fs_1.default.readFileSync(filePath, 'utf-8');
+        const trimmed = content.trim();
+        return trimmed.startsWith("'client load'") || trimmed.startsWith('"client load"');
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Client Reference Plugin
+ *
+ * Transforms imports of server components in the client bundle
+ */
+class ClientReferencePlugin {
+    appDir;
+    clientManifestPath;
+    clientManifest = null;
+    constructor(options) {
+        this.appDir = options.appDir;
+        this.clientManifestPath = options.clientManifestPath;
+    }
+    apply(compiler) {
+        const pluginName = 'VistaClientReferencePlugin';
+        // Load client manifest
+        compiler.hooks.beforeCompile.tap(pluginName, () => {
+            this.loadManifest();
+        });
+        // Provide virtual module for server component proxies
+        compiler.hooks.normalModuleFactory.tap(pluginName, (nmf) => {
+            nmf.hooks.beforeResolve.tap(pluginName, (resolveData) => {
+                if (!resolveData)
+                    return;
+                // Check if this is importing a server component from client code
+                const request = resolveData.request;
+                if (request === 'vista/server-component-proxy') {
+                    // Virtual module - allow it to continue
+                    return;
+                }
+            });
+            nmf.hooks.afterResolve.tap(pluginName, (resolveData) => {
+                if (!resolveData || !resolveData.createData)
+                    return;
+                const resourcePath = resolveData.createData.resource;
+                if (!resourcePath)
+                    return;
+                // Check if this is a file in the app directory
+                if (!resourcePath.startsWith(this.appDir))
+                    return;
+                // Check if this is a TypeScript/JavaScript file
+                if (!/\.[jt]sx?$/.test(resourcePath))
+                    return;
+                // Check if this is a server component (NOT a client component)
+                if (!isClientComponent(resourcePath)) {
+                    // This is a server component being imported in client bundle
+                    // We need to replace it with a proxy
+                    // Mark it for replacement (use any to add custom properties)
+                    resolveData.createData.vistaServerComponent = true;
+                    resolveData.createData.vistaComponentId = this.getComponentId(resourcePath);
+                }
+            });
+        });
+        // Transform the module content for server components
+        compiler.hooks.compilation.tap(pluginName, (compilation) => {
+            // Add the server component proxy to the beginning of affected modules
+            compilation.hooks.succeedModule.tap(pluginName, (module) => {
+                if (module.vistaServerComponent) {
+                    // This module is a server component - it should be replaced with a proxy
+                    // In practice, we handle this via the loader
+                }
+            });
+        });
+        // Add a loader to handle server component replacement
+        compiler.options.module?.rules?.push({
+            test: /\.[jt]sx?$/,
+            include: this.appDir,
+            enforce: 'pre',
+            use: [
+                {
+                    loader: require.resolve('./server-component-loader'),
+                    options: {
+                        appDir: this.appDir,
+                        clientManifestPath: this.clientManifestPath,
+                    },
+                },
+            ],
+        });
+        // Generate client reference manifest for runtime
+        compiler.hooks.emit.tap(pluginName, (compilation) => {
+            if (this.clientManifest) {
+                const runtimeManifest = this.generateRuntimeManifest();
+                const manifestSource = JSON.stringify(runtimeManifest, null, 2);
+                compilation.emitAsset('client-reference-manifest.json', new webpack_1.default.sources.RawSource(manifestSource));
+            }
+        });
+    }
+    loadManifest() {
+        try {
+            if (fs_1.default.existsSync(this.clientManifestPath)) {
+                const content = fs_1.default.readFileSync(this.clientManifestPath, 'utf-8');
+                this.clientManifest = JSON.parse(content);
+            }
+        }
+        catch (e) {
+            console.warn('[Vista] Failed to load client manifest:', e);
+        }
+    }
+    getComponentId(filePath) {
+        const relative = path_1.default.relative(this.appDir, filePath);
+        return `server:${relative.replace(/\\/g, '/').replace(/\.[jt]sx?$/, '')}`;
+    }
+    generateRuntimeManifest() {
+        if (!this.clientManifest)
+            return {};
+        return {
+            clientModules: Object.keys(this.clientManifest.clientModules).reduce((acc, key) => {
+                const entry = this.clientManifest.clientModules[key];
+                acc[key] = {
+                    id: entry.id,
+                    chunks: [entry.chunkName],
+                    name: entry.exports[0] || 'default',
+                };
+                return acc;
+            }, {}),
+        };
+    }
+}
+exports.ClientReferencePlugin = ClientReferencePlugin;

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

@@ -0,0 +1,36 @@
+/**
+ * RSC Webpack Compiler
+ *
+ * Creates separate webpack configurations for:
+ * 1. Server Bundle (.vista/server/) - All app code for SSR
+ * 2. Client Bundle (.vista/static/) - Only 'client load' components
+ */
+import webpack from 'webpack';
+import { VistaDirs } from '../manifest';
+export interface RSCCompilerOptions {
+    cwd: string;
+    isDev: boolean;
+    vistaDirs: VistaDirs;
+    buildId: string;
+}
+/**
+ * Create Server-Side Webpack Configuration
+ *
+ * Builds ALL components for server-side rendering.
+ * Output goes to .vista/server/ and is NEVER sent to the client.
+ */
+export declare function createServerWebpackConfig(options: RSCCompilerOptions): webpack.Configuration;
+/**
+ * Create Client-Side Webpack Configuration (RSC-aware)
+ *
+ * ONLY bundles components marked with 'client load'.
+ * Server components are replaced with client references.
+ */
+export declare function createClientWebpackConfig(options: RSCCompilerOptions): webpack.Configuration;
+/**
+ * Run both server and client builds
+ */
+export declare function runRSCBuild(cwd: string, isDev: boolean): Promise<{
+    serverCompiler: webpack.Compiler;
+    clientCompiler: webpack.Compiler;
+}>;

package/dist/build/rsc/compiler.js

@@ -0,0 +1,311 @@
+"use strict";
+/**
+ * RSC Webpack Compiler
+ *
+ * Creates separate webpack configurations for:
+ * 1. Server Bundle (.vista/server/) - All app code for SSR
+ * 2. Client Bundle (.vista/static/) - Only 'client load' components
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createServerWebpackConfig = createServerWebpackConfig;
+exports.createClientWebpackConfig = createClientWebpackConfig;
+exports.runRSCBuild = runRSCBuild;
+const path_1 = __importDefault(require("path"));
+const webpack_1 = __importDefault(require("webpack"));
+const fs_1 = __importDefault(require("fs"));
+const manifest_1 = require("../manifest");
+const client_reference_plugin_1 = require("./client-reference-plugin");
+const client_manifest_1 = require("./client-manifest");
+const server_manifest_1 = require("./server-manifest");
+// Find module path (handles monorepo hoisting)
+const findModulePath = (moduleName, cwd) => {
+    const localPath = path_1.default.resolve(cwd, 'node_modules', moduleName);
+    if (fs_1.default.existsSync(localPath)) {
+        return localPath;
+    }
+    try {
+        return path_1.default.dirname(require.resolve(`${moduleName}/package.json`, { paths: [cwd] }));
+    }
+    catch {
+        return path_1.default.dirname(require.resolve(`${moduleName}/package.json`));
+    }
+};
+/**
+ * Create Server-Side Webpack Configuration
+ *
+ * Builds ALL components for server-side rendering.
+ * Output goes to .vista/server/ and is NEVER sent to the client.
+ */
+function createServerWebpackConfig(options) {
+    const { cwd, isDev, vistaDirs, buildId } = options;
+    // Generate server manifest first
+    const serverManifest = (0, server_manifest_1.generateServerManifest)(cwd, path_1.default.join(cwd, 'app'));
+    fs_1.default.writeFileSync(path_1.default.join(vistaDirs.server, 'server-manifest.json'), JSON.stringify(serverManifest, null, 2));
+    return {
+        mode: isDev ? 'development' : 'production',
+        name: 'server',
+        target: 'node',
+        // Entry: All pages and layouts for SSR
+        entry: () => {
+            const entries = {};
+            const appDir = path_1.default.join(cwd, 'app');
+            // Scan for all page.tsx, layout.tsx files
+            function scanDir(dir, prefix = '') {
+                if (!fs_1.default.existsSync(dir))
+                    return;
+                const items = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                for (const item of items) {
+                    if (item.isDirectory()) {
+                        if (!item.name.startsWith('.') && item.name !== 'node_modules') {
+                            scanDir(path_1.default.join(dir, item.name), prefix + item.name + '/');
+                        }
+                    }
+                    else if (item.isFile()) {
+                        const ext = path_1.default.extname(item.name);
+                        const base = path_1.default.basename(item.name, ext);
+                        if (['.tsx', '.ts', '.jsx', '.js'].includes(ext)) {
+                            if (['page', 'layout', 'loading', 'error', 'not-found', 'root', 'index'].includes(base)) {
+                                const entryName = (prefix + base).replace(/\//g, '_') || 'root';
+                                entries[entryName] = path_1.default.join(dir, item.name);
+                            }
+                        }
+                    }
+                }
+            }
+            scanDir(appDir);
+            return entries;
+        },
+        output: {
+            path: path_1.default.join(vistaDirs.server, 'app'),
+            filename: '[name].js',
+            libraryTarget: 'commonjs2',
+            clean: !isDev,
+        },
+        externals: [
+            // Don't bundle node_modules on server
+            ({ request }, callback) => {
+                if (request &&
+                    !request.startsWith('.') &&
+                    !request.startsWith('/') &&
+                    !path_1.default.isAbsolute(request)) {
+                    // External - don't bundle
+                    return callback(null, 'commonjs ' + request);
+                }
+                callback();
+            },
+        ],
+        cache: isDev ? (0, manifest_1.getWebpackCacheConfig)(vistaDirs.root, buildId, 'server-development') : false,
+        resolve: {
+            extensions: ['.tsx', '.ts', '.jsx', '.js'],
+            modules: [path_1.default.resolve(cwd, 'node_modules'), 'node_modules'],
+        },
+        module: {
+            rules: [
+                {
+                    test: /\.[jt]sx?$/,
+                    exclude: /node_modules/,
+                    use: {
+                        loader: 'swc-loader',
+                        options: {
+                            jsc: {
+                                parser: {
+                                    syntax: 'typescript',
+                                    tsx: true,
+                                },
+                                transform: {
+                                    react: {
+                                        runtime: 'automatic',
+                                    },
+                                },
+                                target: 'es2020',
+                            },
+                            module: {
+                                type: 'commonjs',
+                            },
+                        },
+                    },
+                },
+                {
+                    test: /\.css$/,
+                    use: 'null-loader', // CSS handled separately
+                },
+            ],
+        },
+        plugins: [
+            new webpack_1.default.DefinePlugin({
+                'process.env.NODE_ENV': JSON.stringify(isDev ? 'development' : 'production'),
+                __VISTA_BUILD_ID__: JSON.stringify(buildId),
+                __VISTA_SERVER__: 'true',
+            }),
+        ],
+        devtool: isDev ? 'source-map' : false,
+        stats: 'minimal',
+    };
+}
+/**
+ * Create Client-Side Webpack Configuration (RSC-aware)
+ *
+ * ONLY bundles components marked with 'client load'.
+ * Server components are replaced with client references.
+ */
+function createClientWebpackConfig(options) {
+    const { cwd, isDev, vistaDirs, buildId } = options;
+    // Generate client manifest
+    const clientManifest = (0, client_manifest_1.generateClientManifest)(cwd, path_1.default.join(cwd, 'app'));
+    fs_1.default.writeFileSync(path_1.default.join(vistaDirs.root, 'client-manifest.json'), JSON.stringify(clientManifest, null, 2));
+    const reactPath = findModulePath('react', cwd);
+    const reactDomPath = findModulePath('react-dom', cwd);
+    // Entry: Only client components
+    const clientEntry = path_1.default.join(vistaDirs.root, 'rsc-client.tsx');
+    return {
+        mode: isDev ? 'development' : 'production',
+        name: 'client',
+        target: 'web',
+        entry: isDev
+            ? ['webpack-hot-middleware/client?reload=true&overlay=true', clientEntry]
+            : clientEntry,
+        output: {
+            path: vistaDirs.chunks,
+            filename: isDev ? 'main.js' : 'main-[contenthash:8].js',
+            chunkFilename: isDev ? '[name].js' : '[name]-[contenthash:8].js',
+            publicPath: '/_vista/static/chunks/',
+            clean: !isDev,
+        },
+        cache: isDev ? (0, manifest_1.getWebpackCacheConfig)(vistaDirs.root, buildId, 'client-rsc-development') : false,
+        resolve: {
+            extensions: ['.tsx', '.ts', '.jsx', '.js'],
+            alias: {
+                react: reactPath,
+                'react-dom': reactDomPath,
+                'react/jsx-runtime': path_1.default.join(reactPath, 'jsx-runtime'),
+                'react/jsx-dev-runtime': path_1.default.join(reactPath, 'jsx-dev-runtime'),
+            },
+            modules: [path_1.default.resolve(cwd, 'node_modules'), 'node_modules'],
+        },
+        optimization: {
+            splitChunks: {
+                chunks: 'all',
+                cacheGroups: {
+                    framework: {
+                        name: 'framework',
+                        test: /[\\/]node_modules[\\/](react|react-dom|scheduler)[\\/]/,
+                        priority: 40,
+                        chunks: 'all',
+                        enforce: true,
+                    },
+                    vendor: {
+                        name: 'vendor',
+                        test: /[\\/]node_modules[\\/]/,
+                        priority: 30,
+                        chunks: 'all',
+                    },
+                },
+            },
+            runtimeChunk: {
+                name: 'webpack',
+            },
+            moduleIds: isDev ? 'named' : 'deterministic',
+            chunkIds: isDev ? 'named' : 'deterministic',
+        },
+        module: {
+            rules: [
+                {
+                    test: /\.[jt]sx?$/,
+                    exclude: /node_modules/,
+                    use: {
+                        loader: 'swc-loader',
+                        options: {
+                            jsc: {
+                                parser: {
+                                    syntax: 'typescript',
+                                    tsx: true,
+                                    dynamicImport: true,
+                                },
+                                transform: {
+                                    react: {
+                                        runtime: 'automatic',
+                                        development: isDev,
+                                        refresh: isDev,
+                                    },
+                                },
+                                target: 'es2020',
+                            },
+                            module: {
+                                type: 'es6',
+                            },
+                        },
+                    },
+                },
+                {
+                    test: /\.css$/,
+                    use: 'null-loader',
+                },
+            ],
+        },
+        plugins: [
+            // Replace server component imports with client references
+            new client_reference_plugin_1.ClientReferencePlugin({
+                appDir: path_1.default.join(cwd, 'app'),
+                clientManifestPath: path_1.default.join(vistaDirs.root, 'client-manifest.json'),
+            }),
+            new webpack_1.default.DefinePlugin({
+                'process.env.NODE_ENV': JSON.stringify(isDev ? 'development' : 'production'),
+                __VISTA_BUILD_ID__: JSON.stringify(buildId),
+                __VISTA_SERVER__: 'false',
+            }),
+            ...(isDev ? [new webpack_1.default.HotModuleReplacementPlugin()] : []),
+        ],
+        devtool: isDev ? 'eval-cheap-module-source-map' : 'source-map',
+        stats: 'minimal',
+    };
+}
+/**
+ * Run both server and client builds
+ */
+async function runRSCBuild(cwd, isDev) {
+    const { createVistaDirectories, getBuildId } = await Promise.resolve().then(() => __importStar(require('../manifest')));
+    const vistaDirs = createVistaDirectories(cwd);
+    const buildId = getBuildId(vistaDirs.root, !isDev);
+    const options = { cwd, isDev, vistaDirs, buildId };
+    const serverConfig = createServerWebpackConfig(options);
+    const clientConfig = createClientWebpackConfig(options);
+    const serverCompiler = (0, webpack_1.default)(serverConfig);
+    const clientCompiler = (0, webpack_1.default)(clientConfig);
+    return { serverCompiler, clientCompiler };
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Vista RSC (React Server Components) Build System
+ *
+ * This module implements the True RSC Architecture:
+ * 1. Server components render on the server and contribute 0kb to client bundle
+ * 2. Client components are marked with 'client load' and hydrate on the browser
+ * 3. Strict separation ensures server secrets never leak to client
+ *
+ * Performance: Uses Rust-powered native scanning when available
+ */
+export * from './compiler';
+export * from './client-manifest';
+export * from './server-manifest';
+export * from './rsc-renderer';
+export * from './client-reference-plugin';
+export * from './native-scanner';

package/dist/build/rsc/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Vista RSC (React Server Components) Build System
+ *
+ * This module implements the True RSC Architecture:
+ * 1. Server components render on the server and contribute 0kb to client bundle
+ * 2. Client components are marked with 'client load' and hydrate on the browser
+ * 3. Strict separation ensures server secrets never leak to client
+ *
+ * Performance: Uses Rust-powered native scanning when available
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./compiler"), exports);
+__exportStar(require("./client-manifest"), exports);
+__exportStar(require("./server-manifest"), exports);
+__exportStar(require("./rsc-renderer"), exports);
+__exportStar(require("./client-reference-plugin"), exports);
+__exportStar(require("./native-scanner"), exports);