@vistagenic/vista 0.1.0-alpha.1

package/dist/build/rsc/native-scanner.d.ts

@@ -0,0 +1,123 @@
+/**
+ * Vista RSC Native Scanner
+ *
+ * Uses Rust-powered native bindings for blazing fast component scanning.
+ * Falls back to TypeScript implementation if native module unavailable.
+ */
+export interface NapiScannedComponent {
+    absolutePath: string;
+    relativePath: string;
+    isClient: boolean;
+    directiveLine: number;
+    componentType: string;
+    exports: string[];
+    clientHooksUsed: string[];
+    hasMetadata: boolean;
+    hasGenerateMetadata: boolean;
+}
+export interface NapiServerComponentError {
+    file: string;
+    message: string;
+    hooks: string[];
+}
+export interface NapiScanResult {
+    clientComponents: NapiScannedComponent[];
+    serverComponents: NapiScannedComponent[];
+    pages: NapiScannedComponent[];
+    layouts: NapiScannedComponent[];
+    apiRoutes: NapiScannedComponent[];
+    errors: NapiServerComponentError[];
+    totalFiles: number;
+    scanTimeMs: number;
+}
+export interface NapiClientModuleEntry {
+    id: string;
+    path: string;
+    absolutePath: string;
+    chunkName: string;
+    exports: string[];
+    asyncLoad: boolean;
+}
+export interface NapiClientManifest {
+    buildId: string;
+    clientModules: NapiClientModuleEntry[];
+}
+export interface NapiRouteEntry {
+    pattern: string;
+    pagePath: string;
+    layoutPaths: string[];
+    loadingPath: string | null;
+    errorPath: string | null;
+    routeType: string;
+}
+export interface NapiServerModuleEntry {
+    id: string;
+    path: string;
+    absolutePath: string;
+    componentType: string;
+    hasMetadata: boolean;
+    hasGenerateMetadata: boolean;
+}
+export interface NapiServerManifest {
+    buildId: string;
+    serverModules: NapiServerModuleEntry[];
+    routes: NapiRouteEntry[];
+}
+/**
+ * Check if native module is available
+ */
+export declare function isNativeAvailable(): boolean;
+/**
+ * Scan app directory using Rust native code
+ * Returns null if native module is not available
+ */
+export declare function scanAppNative(appDir: string): NapiScanResult | null;
+/**
+ * Generate client manifest using Rust native code
+ */
+export declare function generateClientManifestNative(appDir: string, buildId: string): NapiClientManifest | null;
+/**
+ * Generate server manifest using Rust native code
+ */
+export declare function generateServerManifestNative(appDir: string, buildId: string): NapiServerManifest | null;
+/**
+ * Generate unique mount ID for client component
+ */
+export declare function generateMountIdNative(): string | null;
+/**
+ * Reset mount ID counter (call at start of each request)
+ */
+export declare function resetMountCounterNative(): boolean;
+/**
+ * Convert NAPI scan result to internal format
+ */
+export declare function convertScanResult(result: NapiScanResult): {
+    clientComponents: {
+        absolutePath: string;
+        relativePath: string;
+        isClient: boolean;
+        directiveLine: number;
+        componentType: string;
+        exports: string[];
+        clientHooksUsed: string[];
+        hasMetadata: boolean;
+        hasGenerateMetadata: boolean;
+    }[];
+    serverComponents: {
+        absolutePath: string;
+        relativePath: string;
+        isClient: boolean;
+        directiveLine: number;
+        componentType: string;
+        exports: string[];
+        clientHooksUsed: any[];
+        hasMetadata: boolean;
+        hasGenerateMetadata: boolean;
+    }[];
+    pages: NapiScannedComponent[];
+    layouts: NapiScannedComponent[];
+    apiRoutes: NapiScannedComponent[];
+    errors: NapiServerComponentError[];
+    totalFiles: number;
+    scanTimeMs: number;
+};

package/dist/build/rsc/native-scanner.js

@@ -0,0 +1,165 @@
+"use strict";
+/**
+ * Vista RSC Native Scanner
+ *
+ * Uses Rust-powered native bindings for blazing fast component scanning.
+ * Falls back to TypeScript implementation if native module unavailable.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNativeAvailable = isNativeAvailable;
+exports.scanAppNative = scanAppNative;
+exports.generateClientManifestNative = generateClientManifestNative;
+exports.generateServerManifestNative = generateServerManifestNative;
+exports.generateMountIdNative = generateMountIdNative;
+exports.resetMountCounterNative = resetMountCounterNative;
+exports.convertScanResult = convertScanResult;
+const path_1 = __importDefault(require("path"));
+let nativeModule = null;
+let nativeLoadError = null;
+/**
+ * Try to load the native Rust module
+ */
+function loadNativeModule() {
+    if (nativeModule !== null)
+        return nativeModule;
+    if (nativeLoadError !== null)
+        return null;
+    // Try multiple paths since we might be running from src or dist
+    const possiblePaths = [
+        // From compiled dist/build/rsc/native-scanner.js
+        path_1.default.resolve(__dirname, '../../../../../crates/vista-napi'),
+        // From source src/build/rsc/native-scanner.ts
+        path_1.default.resolve(__dirname, '../../../../crates/vista-napi'),
+        // From workspace root
+        path_1.default.resolve(process.cwd(), '../crates/vista-napi'),
+        // Try @aspect-build/vista-napi as npm package
+        '@aspect-build/vista-napi',
+    ];
+    for (const modulePath of possiblePaths) {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            nativeModule = require(modulePath);
+            console.log('[Vista RSC] Using Rust-powered scanner');
+            return nativeModule;
+        }
+        catch {
+            // Continue trying other paths
+        }
+    }
+    nativeLoadError = new Error('Native module not found');
+    console.warn('⚠ Native module unavailable, using TypeScript fallback');
+    return null;
+}
+/**
+ * Check if native module is available
+ */
+function isNativeAvailable() {
+    return loadNativeModule() !== null;
+}
+/**
+ * Scan app directory using Rust native code
+ * Returns null if native module is not available
+ */
+function scanAppNative(appDir) {
+    const native = loadNativeModule();
+    if (!native)
+        return null;
+    try {
+        const startTime = performance.now();
+        const result = native.rscScanApp(appDir);
+        const scanTime = performance.now() - startTime;
+        console.log(`🦀 Native scan completed in ${scanTime.toFixed(2)}ms (${result.totalFiles} files)`);
+        return result;
+    }
+    catch (e) {
+        console.error('Native scan failed:', e);
+        return null;
+    }
+}
+/**
+ * Generate client manifest using Rust native code
+ */
+function generateClientManifestNative(appDir, buildId) {
+    const native = loadNativeModule();
+    if (!native)
+        return null;
+    try {
+        return native.rscGenerateClientManifest(appDir, buildId);
+    }
+    catch (e) {
+        console.error('Native client manifest generation failed:', e);
+        return null;
+    }
+}
+/**
+ * Generate server manifest using Rust native code
+ */
+function generateServerManifestNative(appDir, buildId) {
+    const native = loadNativeModule();
+    if (!native)
+        return null;
+    try {
+        return native.rscGenerateServerManifest(appDir, buildId);
+    }
+    catch (e) {
+        console.error('Native server manifest generation failed:', e);
+        return null;
+    }
+}
+/**
+ * Generate unique mount ID for client component
+ */
+function generateMountIdNative() {
+    const native = loadNativeModule();
+    if (!native)
+        return null;
+    return native.rscGenerateMountId();
+}
+/**
+ * Reset mount ID counter (call at start of each request)
+ */
+function resetMountCounterNative() {
+    const native = loadNativeModule();
+    if (!native)
+        return false;
+    native.rscResetMountCounter();
+    return true;
+}
+/**
+ * Convert NAPI scan result to internal format
+ */
+function convertScanResult(result) {
+    return {
+        clientComponents: result.clientComponents.map((c) => ({
+            absolutePath: c.absolutePath,
+            relativePath: c.relativePath,
+            isClient: c.isClient,
+            directiveLine: c.directiveLine,
+            componentType: c.componentType,
+            exports: c.exports,
+            clientHooksUsed: c.clientHooksUsed,
+            hasMetadata: c.hasMetadata,
+            hasGenerateMetadata: c.hasGenerateMetadata,
+        })),
+        serverComponents: result.serverComponents.map((c) => ({
+            absolutePath: c.absolutePath,
+            relativePath: c.relativePath,
+            isClient: false,
+            directiveLine: 0,
+            componentType: c.componentType,
+            exports: c.exports,
+            clientHooksUsed: [],
+            hasMetadata: c.hasMetadata,
+            hasGenerateMetadata: c.hasGenerateMetadata,
+        })),
+        pages: result.pages,
+        layouts: result.layouts,
+        apiRoutes: result.apiRoutes,
+        errors: result.errors,
+        totalFiles: result.totalFiles,
+        scanTimeMs: result.scanTimeMs,
+    };
+}

package/dist/build/rsc/rsc-renderer.d.ts

@@ -0,0 +1,99 @@
+/**
+ * Vista RSC Renderer
+ *
+ * Renders React Server Components to an RSC Payload format.
+ * This is the core of the "Zero Bundle Size Server Components" feature.
+ *
+ * RSC Payload Format:
+ * - Server components render to a special streaming format
+ * - Client component references are serialized as "holes" to be filled client-side
+ * - The client receives a stream of instructions + HTML
+ */
+import type { ClientManifest } from './client-manifest';
+import type { ServerManifest, RouteEntry } from './server-manifest';
+export interface RSCPayload {
+    /** The rendered HTML for server components */
+    html: string;
+    /** Client component references to hydrate */
+    clientReferences: ClientReference[];
+    /** Data passed to client for hydration */
+    data: Record<string, any>;
+    /** Flight data for streaming (if enabled) */
+    flight?: string;
+}
+export interface ClientReference {
+    /** Unique ID matching client manifest */
+    id: string;
+    /** DOM element ID where component should mount */
+    mountId: string;
+    /** Props to pass to the client component */
+    props: Record<string, any>;
+    /** Chunk URL to load */
+    chunkUrl: string;
+    /** Export name to use (usually 'default') */
+    exportName: string;
+}
+export interface RSCRenderContext {
+    /** Client manifest for resolving client components */
+    clientManifest: ClientManifest;
+    /** Server manifest for component metadata */
+    serverManifest: ServerManifest;
+    /** Current route being rendered */
+    route: RouteEntry;
+    /** URL parameters */
+    params: Record<string, string>;
+    /** Search params */
+    searchParams: Record<string, string>;
+    /** Request metadata */
+    request: {
+        url: string;
+        method: string;
+        headers: Record<string, string>;
+    };
+}
+/**
+ * Reset mount ID counter (call at start of each request)
+ */
+export declare function resetMountIdCounter(): void;
+/**
+ * RSC Renderer class
+ * Handles rendering a route with proper server/client component separation
+ */
+export declare class RSCRenderer {
+    private clientManifest;
+    private serverManifest;
+    private clientReferences;
+    private cwd;
+    constructor(options: {
+        clientManifest: ClientManifest;
+        serverManifest: ServerManifest;
+        cwd: string;
+    });
+    /**
+     * Render a route to RSC Payload
+     */
+    render(context: RSCRenderContext): Promise<RSCPayload>;
+    /**
+     * Render a route with nested layouts
+     */
+    private renderRoute;
+    /**
+     * Require a component with cache clearing in dev
+     */
+    private requireComponent;
+    /**
+     * Check if a component is a client component
+     */
+    private isClientComponent;
+}
+/**
+ * Create an RSC renderer instance
+ */
+export declare function createRSCRenderer(cwd: string): RSCRenderer | null;
+/**
+ * Generate the client-side hydration script
+ *
+ * This just sets the data - the actual hydration is handled by rsc-client.tsx
+ * which is bundled and has all client components pre-imported.
+ */
+export declare function generateHydrationScript(payload: RSCPayload): string;

package/dist/build/rsc/rsc-renderer.js

@@ -0,0 +1,269 @@
+"use strict";
+/**
+ * Vista RSC Renderer
+ *
+ * Renders React Server Components to an RSC Payload format.
+ * This is the core of the "Zero Bundle Size Server Components" feature.
+ *
+ * RSC Payload Format:
+ * - Server components render to a special streaming format
+ * - Client component references are serialized as "holes" to be filled client-side
+ * - The client receives a stream of instructions + HTML
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RSCRenderer = void 0;
+exports.resetMountIdCounter = resetMountIdCounter;
+exports.createRSCRenderer = createRSCRenderer;
+exports.generateHydrationScript = generateHydrationScript;
+const react_1 = __importDefault(require("react"));
+const server_1 = require("react-dom/server");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+// Import RSC module system for client component interception
+let rscModuleSystem = null;
+try {
+    rscModuleSystem = require('../../server/rsc-module-system');
+}
+catch {
+    // Module system not available (during build)
+}
+// Counter for generating unique mount IDs
+let mountIdCounter = 0;
+/**
+ * Reset mount ID counter (call at start of each request)
+ */
+function resetMountIdCounter() {
+    mountIdCounter = 0;
+}
+/**
+ * Generate a unique mount ID for a client component
+ */
+function generateMountId() {
+    return `__vista_cc_${++mountIdCounter}`;
+}
+/**
+ * Check if a component module is a client component
+ */
+function isClientComponent(modulePath, manifest) {
+    return modulePath in manifest.pathToId;
+}
+/**
+ * Create a client component placeholder
+ * This renders a marker div that will be hydrated on the client
+ */
+function createClientComponentPlaceholder(entry, props, children) {
+    const mountId = generateMountId();
+    // Create the reference for hydration
+    const reference = {
+        id: entry.id,
+        mountId,
+        props: serializeProps(props),
+        chunkUrl: `/_vista/static/chunks/${entry.chunkName}.js`,
+        exportName: 'default',
+    };
+    // Create placeholder element
+    // Children are rendered server-side if they're server components
+    const element = react_1.default.createElement('div', {
+        'data-vista-cc': entry.id,
+        'data-vista-mount': mountId,
+        id: mountId,
+        suppressHydrationWarning: true,
+    }, children);
+    return { element, reference };
+}
+/**
+ * Serialize props for client-side hydration
+ * Handles Date, undefined, functions, etc.
+ */
+function serializeProps(props) {
+    const serialized = {};
+    for (const [key, value] of Object.entries(props)) {
+        if (key === 'children') {
+            // Children are handled separately
+            continue;
+        }
+        if (typeof value === 'function') {
+            // Functions can't be serialized - skip or warn
+            console.warn(`[Vista RSC] Cannot serialize function prop "${key}" to client`);
+            continue;
+        }
+        if (value instanceof Date) {
+            serialized[key] = { __type: 'Date', value: value.toISOString() };
+        }
+        else if (value === undefined) {
+            serialized[key] = { __type: 'undefined' };
+        }
+        else if (react_1.default.isValidElement(value)) {
+            // React elements need special handling
+            serialized[key] = { __type: 'ReactElement', rendered: true };
+        }
+        else {
+            serialized[key] = value;
+        }
+    }
+    return serialized;
+}
+/**
+ * RSC Renderer class
+ * Handles rendering a route with proper server/client component separation
+ */
+class RSCRenderer {
+    clientManifest;
+    serverManifest;
+    clientReferences = [];
+    cwd;
+    constructor(options) {
+        this.clientManifest = options.clientManifest;
+        this.serverManifest = options.serverManifest;
+        this.cwd = options.cwd;
+    }
+    /**
+     * Render a route to RSC Payload
+     */
+    async render(context) {
+        // Reset counters
+        resetMountIdCounter();
+        this.clientReferences = [];
+        // Reset RSC module system state (for client component interception)
+        if (rscModuleSystem) {
+            rscModuleSystem.resetRSCState();
+        }
+        const { route, params, searchParams } = context;
+        // Load and render layouts + page
+        const element = await this.renderRoute(route, params, searchParams);
+        // Render to HTML string
+        const html = (0, server_1.renderToString)(element);
+        // Collect client references from module system (intercepted requires)
+        let collectedReferences = this.clientReferences;
+        if (rscModuleSystem) {
+            const moduleReferences = rscModuleSystem.getClientReferences();
+            collectedReferences = [...collectedReferences, ...moduleReferences];
+        }
+        return {
+            html,
+            clientReferences: collectedReferences,
+            data: {
+                params,
+                searchParams,
+                route: route.pattern,
+            },
+        };
+    }
+    /**
+     * Render a route with nested layouts
+     */
+    async renderRoute(route, params, searchParams) {
+        // Load the page component
+        const PageModule = this.requireComponent(route.pagePath);
+        const PageComponent = PageModule.default;
+        // Fetch page metadata if exists
+        let metadata = {};
+        if (PageModule.metadata) {
+            metadata = { ...metadata, ...PageModule.metadata };
+        }
+        if (typeof PageModule.generateMetadata === 'function') {
+            try {
+                const dynamicMeta = await PageModule.generateMetadata({ params, searchParams });
+                metadata = { ...metadata, ...dynamicMeta };
+            }
+            catch (e) {
+                console.error('[Vista RSC] generateMetadata error:', e);
+            }
+        }
+        // Create page element
+        let pageElement = react_1.default.createElement(PageComponent, {
+            params,
+            searchParams,
+        });
+        // Check if page is a client component
+        if (this.isClientComponent(route.pagePath)) {
+            const entry = this.clientManifest.clientModules[this.clientManifest.pathToId[route.pagePath]];
+            const { element, reference } = createClientComponentPlaceholder(entry, {
+                params,
+                searchParams,
+            });
+            this.clientReferences.push(reference);
+            pageElement = element;
+        }
+        // Wrap in layouts (innermost to outermost)
+        let wrappedElement = pageElement;
+        for (let i = route.layoutPaths.length - 1; i >= 0; i--) {
+            const layoutPath = route.layoutPaths[i];
+            const LayoutModule = this.requireComponent(layoutPath);
+            const LayoutComponent = LayoutModule.default;
+            if (this.isClientComponent(layoutPath)) {
+                // Client component layout
+                const entry = this.clientManifest.clientModules[this.clientManifest.pathToId[layoutPath]];
+                const { element, reference } = createClientComponentPlaceholder(entry, { params, searchParams }, wrappedElement);
+                this.clientReferences.push(reference);
+                wrappedElement = element;
+            }
+            else {
+                // Server component layout
+                wrappedElement = react_1.default.createElement(LayoutComponent, { params, searchParams }, wrappedElement);
+            }
+        }
+        return wrappedElement;
+    }
+    /**
+     * Require a component with cache clearing in dev
+     */
+    requireComponent(componentPath) {
+        // Clear cache in development
+        if (process.env.NODE_ENV !== 'production') {
+            delete require.cache[require.resolve(componentPath)];
+        }
+        return require(componentPath);
+    }
+    /**
+     * Check if a component is a client component
+     */
+    isClientComponent(componentPath) {
+        return componentPath in this.clientManifest.pathToId;
+    }
+}
+exports.RSCRenderer = RSCRenderer;
+/**
+ * Create an RSC renderer instance
+ */
+function createRSCRenderer(cwd) {
+    const clientManifestPath = path_1.default.join(cwd, '.vista', 'client-manifest.json');
+    const serverManifestPath = path_1.default.join(cwd, '.vista', 'server', 'server-manifest.json');
+    if (!fs_1.default.existsSync(clientManifestPath) || !fs_1.default.existsSync(serverManifestPath)) {
+        console.warn('[Vista RSC] Manifests not found. Run build first.');
+        return null;
+    }
+    try {
+        const clientManifest = JSON.parse(fs_1.default.readFileSync(clientManifestPath, 'utf-8'));
+        const serverManifest = JSON.parse(fs_1.default.readFileSync(serverManifestPath, 'utf-8'));
+        return new RSCRenderer({
+            clientManifest,
+            serverManifest,
+            cwd,
+        });
+    }
+    catch (e) {
+        console.error('[Vista RSC] Failed to load manifests:', e);
+        return null;
+    }
+}
+/**
+ * Generate the client-side hydration script
+ *
+ * This just sets the data - the actual hydration is handled by rsc-client.tsx
+ * which is bundled and has all client components pre-imported.
+ */
+function generateHydrationScript(payload) {
+    const references = JSON.stringify(payload.clientReferences);
+    const data = JSON.stringify(payload.data);
+    return `
+<script>
+    window.__VISTA_RSC_DATA__ = ${data};
+    window.__VISTA_CLIENT_REFERENCES__ = ${references};
+    console.log('[Vista RSC] Client references:', ${references.length > 2 ? references.length : 0});
+</script>
+`;
+}

package/dist/build/rsc/server-component-loader.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Vista Server Component Loader
+ *
+ * Webpack loader that transforms server component imports in client bundles.
+ *
+ * When a server component is imported in a client bundle:
+ * 1. The loader detects if the file has 'client load' directive
+ * 2. If NOT a client component, replace the module with a proxy
+ * 3. The proxy provides helpful error messages when misused
+ */
+import type { LoaderContext } from 'webpack';
+export interface ServerComponentLoaderOptions {
+    appDir: string;
+    clientManifestPath: string;
+}
+/**
+ * Server Component Loader
+ */
+export default function serverComponentLoader(this: LoaderContext<ServerComponentLoaderOptions>, source: string): string;