@vistagenic/vista 0.2.3 → 0.2.5

package/dist/bin/build-rsc.js

@@ -50,6 +50,53 @@ function runPostCSS(cwd, vistaDir) {
         }
     }
 }
+function hasUseClientDirective(filePath) {
+    try {
+        const source = fs_1.default.readFileSync(filePath, 'utf-8');
+        return /^\s*['"]use client['"]\s*;?/m.test(source);
+    }
+    catch {
+        return false;
+    }
+}
+function collectUseClientFiles(dir, collected) {
+    if (!fs_1.default.existsSync(dir))
+        return;
+    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const absolutePath = path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            collectUseClientFiles(absolutePath, collected);
+            continue;
+        }
+        if (!entry.isFile() || !entry.name.endsWith('.js')) {
+            continue;
+        }
+        if (hasUseClientDirective(absolutePath)) {
+            collected.add(path_1.default.resolve(absolutePath));
+        }
+    }
+}
+function resolvePackageRoot(cwd, packageName) {
+    try {
+        return path_1.default.dirname(require.resolve(`${packageName}/package.json`, { paths: [cwd] }));
+    }
+    catch {
+        return null;
+    }
+}
+function collectFrameworkClientReferences(cwd) {
+    const roots = [resolvePackageRoot(cwd, 'vista'), resolvePackageRoot(cwd, '@vistagenic/vista')].filter((value) => Boolean(value));
+    if (roots.length === 0) {
+        return [];
+    }
+    const collected = new Set();
+    for (const packageRoot of roots) {
+        collectUseClientFiles(path_1.default.join(packageRoot, 'dist', 'client'), collected);
+        collectUseClientFiles(path_1.default.join(packageRoot, 'dist', 'components'), collected);
+    }
+    return Array.from(collected);
+}
 /**
  * Generate the RSC-aware client entry file
  */
@@ -236,6 +283,15 @@ async function buildRSC(watch = false) {
             }
         }
     }
+    // Include framework-level client boundaries (e.g. vista/link) so external
+    // package client modules resolve in React Flight manifests.
+    const frameworkClientReferences = collectFrameworkClientReferences(cwd);
+    if (frameworkClientReferences.length > 0) {
+        clientReferenceFiles = Array.from(new Set([...clientReferenceFiles, ...frameworkClientReferences]));
+        if (_debug) {
+            console.log(`[Vista JS RSC] Added ${frameworkClientReferences.length} framework client references`);
+        }
+    }
     // Generate manifests
     if (_debug)
         console.log('[vista:build] Generating manifests...');
@@ -301,13 +357,33 @@ async function buildRSC(watch = false) {
         const clientConfig = (0, compiler_1.createClientWebpackConfig)(options);
         const clientCompiler = (0, webpack_1.default)(clientConfig);
         syncReactServerManifests(vistaDirs.root);
-        // Watch for CSS changes
+        // Watch for CSS + source changes that can affect Tailwind output.
         try {
             const chokidar = require('chokidar');
-            chokidar.watch(path_1.default.join(cwd, 'app/**/*.css'), { ignoreInitial: true }).on('change', () => {
-                if (_debug)
-                    console.log('[Vista JS RSC] CSS changed, rebuilding...');
-                runPostCSS(cwd, vistaDirs.root);
+            const styleWatchRoots = ['app', 'components', 'content', 'lib', 'ctx', 'data']
+                .map((entry) => path_1.default.join(cwd, entry))
+                .filter((entry) => fs_1.default.existsSync(entry));
+            let cssTimer = null;
+            const scheduleCSSBuild = () => {
+                if (cssTimer)
+                    clearTimeout(cssTimer);
+                cssTimer = setTimeout(() => {
+                    if (_debug)
+                        console.log('[Vista JS RSC] Style source changed, rebuilding CSS...');
+                    runPostCSS(cwd, vistaDirs.root);
+                }, 120);
+            };
+            chokidar
+                .watch(styleWatchRoots, {
+                ignoreInitial: true,
+                ignored: (watchedPath) => watchedPath.includes(`${path_1.default.sep}node_modules${path_1.default.sep}`) ||
+                    watchedPath.includes(`${path_1.default.sep}.git${path_1.default.sep}`) ||
+                    watchedPath.includes(`${path_1.default.sep}.vista${path_1.default.sep}`),
+            })
+                .on('all', (_event, changedPath) => {
+                if (/\.(?:css|[cm]?[jt]sx?|md|mdx)$/i.test(changedPath)) {
+                    scheduleCSSBuild();
+                }
             });
         }
         catch (e) {

package/dist/bin/build.js

@@ -380,13 +380,33 @@ async function buildClient(watch = false, onRebuild) {
         // In watch mode, we return the compiler for use with dev middleware
         // Initial CSS build
         runPostCSS(cwd, vistaDir);
-        // Watch for CSS changes separately (simple approach)
+        // Watch CSS + source files that may affect Tailwind output.
         const chokidar = require('chokidar');
         try {
-            chokidar.watch(path_1.default.join(cwd, 'app/**/*.css'), { ignoreInitial: true }).on('change', () => {
-                if (_debug)
-                    console.log('CSS changed, rebuilding...');
-                runPostCSS(cwd, vistaDir);
+            const styleWatchRoots = ['app', 'components', 'content', 'lib', 'ctx', 'data']
+                .map((entry) => path_1.default.join(cwd, entry))
+                .filter((entry) => fs_1.default.existsSync(entry));
+            let cssTimer = null;
+            const scheduleCSSBuild = () => {
+                if (cssTimer)
+                    clearTimeout(cssTimer);
+                cssTimer = setTimeout(() => {
+                    if (_debug)
+                        console.log('Style source changed, rebuilding CSS...');
+                    runPostCSS(cwd, vistaDir);
+                }, 120);
+            };
+            chokidar
+                .watch(styleWatchRoots, {
+                ignoreInitial: true,
+                ignored: (watchedPath) => watchedPath.includes(`${path_1.default.sep}node_modules${path_1.default.sep}`) ||
+                    watchedPath.includes(`${path_1.default.sep}.git${path_1.default.sep}`) ||
+                    watchedPath.includes(`${path_1.default.sep}.vista${path_1.default.sep}`),
+            })
+                .on('all', (_event, changedPath) => {
+                if (/\.(?:css|[cm]?[jt]sx?|md|mdx)$/i.test(changedPath)) {
+                    scheduleCSSBuild();
+                }
             });
         }
         catch (e) {

package/dist/build/manifest.js

@@ -103,11 +103,29 @@ function generateBuildManifest(vistaDir, buildId, pages = {}) {
     return manifest;
 }
 function toRegexFromPattern(pattern) {
-    const escaped = pattern
-        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-        .replace(/:([a-zA-Z0-9_]+)\*/g, '(?<$1>.+)')
-        .replace(/:([a-zA-Z0-9_]+)/g, '(?<$1>[^/]+)');
-    return `^${escaped}$`;
+    if (pattern === '/') {
+        return '^/$';
+    }
+    const normalized = pattern.startsWith('/') ? pattern.slice(1) : pattern;
+    const parts = normalized.split('/').filter(Boolean);
+    const regexParts = parts.map((part) => {
+        if (!part.startsWith(':')) {
+            return part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        }
+        const dynamicMatch = /^:([a-zA-Z0-9_]+)(\*)?(\?)?$/.exec(part);
+        if (!dynamicMatch) {
+            return part.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        }
+        const [, paramName, isCatchAll, isOptional] = dynamicMatch;
+        if (isCatchAll && isOptional) {
+            return `(?<${paramName}>.*)`;
+        }
+        if (isCatchAll) {
+            return `(?<${paramName}>.+)`;
+        }
+        return `(?<${paramName}>[^/]+)`;
+    });
+    return `^/${regexParts.join('/')}$`;
 }
 function toRouteInfo(route) {
     return {

package/dist/build/rsc/server-manifest.js

@@ -282,8 +282,8 @@ function buildRoutes(components, appDir) {
             // Static URL pattern + auto mode = static by default
             renderMode = 'static';
         }
-        else if (rt === 'dynamic' && hasStaticParams) {
-            // Dynamic URL pattern + generateStaticParams = can be statically generated
+        else if ((rt === 'dynamic' || rt === 'catch-all') && hasStaticParams) {
+            // Dynamic or catch-all URL pattern + generateStaticParams = can be statically generated
             renderMode = 'static';
         }
         routes.push({

package/dist/client/link.d.ts

@@ -17,7 +17,7 @@ export interface LinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>,
     shallow?: boolean;
     /** Force href on child element */
     passHref?: boolean;
-    /** Prefetch strategy: true = viewport+hover, 'auto' = hover-only, false/null = off */
+    /** Prefetch strategy: true = always, 'auto' = production-only (Next-like), false/null = off */
     prefetch?: boolean | 'auto' | null;
     /** Locale for internationalised routing */
     locale?: string | false;

package/dist/client/link.js

@@ -102,16 +102,31 @@ function isInternalUrl(url) {
     }
     return true;
 }
-exports.Link = react_1.default.forwardRef(({ href, as, replace, scroll = true, shallow, passHref, prefetch = true, legacyBehavior, children, onClick, onMouseEnter, onTouchStart, onNavigate, target, ...props }, ref) => {
+function resolvePrefetchBehavior(prefetch) {
+    if (prefetch === false || prefetch === null) {
+        return { viewport: false, intent: false };
+    }
+    if (prefetch === true) {
+        return { viewport: true, intent: true };
+    }
+    const isProduction = process.env.NODE_ENV === 'production';
+    return {
+        viewport: isProduction,
+        intent: isProduction,
+    };
+}
+exports.Link = react_1.default.forwardRef(({ href, as, replace, scroll = true, shallow, passHref, prefetch = 'auto', legacyBehavior, children, onClick, onMouseEnter, onTouchStart, onNavigate, target, ...props }, ref) => {
     // Try the RSC router first — if we're inside an RSCRouter, use
     // Flight-based navigation. Otherwise fall back to the legacy router.
-    const rscRouter = (0, rsc_router_1.useRSCRouter)();
-    const legacyRouter = (0, router_1.useRouter)();
-    const pathname = rscRouter ? rscRouter.pathname : (0, router_1.usePathname)();
+    const rscRouter = (0, react_1.useContext)(rsc_router_1.RSCRouterContext);
+    const legacyRouter = (0, react_1.useContext)(router_1.RouterContext);
+    const fallbackPathname = (0, router_1.usePathname)();
+    const pathname = rscRouter?.pathname ?? legacyRouter?.pathname ?? fallbackPathname;
     const linkRef = (0, react_1.useRef)(null);
     const targetPath = formatUrl(as || href);
     const [isActive, setIsActive] = (0, react_1.useState)(false);
     const internal = (0, react_1.useMemo)(() => isInternalUrl(targetPath), [targetPath]);
+    const prefetchBehavior = (0, react_1.useMemo)(() => resolvePrefetchBehavior(prefetch), [prefetch]);
     // Combine refs
     const setRefs = (0, react_1.useCallback)((node) => {
         linkRef.current = node;
@@ -133,12 +148,14 @@ exports.Link = react_1.default.forwardRef(({ href, as, replace, scroll = true, s
     }, [targetPath, pathname]);
     // Prefetch on viewport intersection (skip for external links & auto mode)
     (0, react_1.useEffect)(() => {
-        if (!prefetch || prefetch === null || prefetch === 'auto')
+        if (!prefetchBehavior.viewport)
             return;
         if (!internal)
             return;
         if (typeof window === 'undefined')
             return;
+        if (pathname === targetPath)
+            return;
         const element = linkRef.current;
         if (!element)
             return;
@@ -160,12 +177,12 @@ exports.Link = react_1.default.forwardRef(({ href, as, replace, scroll = true, s
         });
         observer.observe(element);
         return () => observer.disconnect();
-    }, [prefetch, targetPath, rscRouter, internal]);
+    }, [prefetchBehavior.viewport, targetPath, pathname, rscRouter, internal]);
     // Prefetch on hover
     const handleMouseEnter = (0, react_1.useCallback)((e) => {
         if (onMouseEnter)
             onMouseEnter(e);
-        if (prefetch !== false && prefetch !== null && internal) {
+        if (prefetchBehavior.intent && internal && pathname !== targetPath) {
             if (rscRouter) {
                 rscRouter.prefetch(targetPath);
             }
@@ -173,12 +190,12 @@ exports.Link = react_1.default.forwardRef(({ href, as, replace, scroll = true, s
                 prefetchUrl(targetPath);
             }
         }
-    }, [onMouseEnter, prefetch, targetPath, rscRouter, internal]);
+    }, [onMouseEnter, prefetchBehavior.intent, targetPath, pathname, rscRouter, internal]);
     // Prefetch on touch (mobile devices)
     const handleTouchStart = (0, react_1.useCallback)((e) => {
         if (onTouchStart)
             onTouchStart(e);
-        if (prefetch !== false && prefetch !== null && internal) {
+        if (prefetchBehavior.intent && internal && pathname !== targetPath) {
             if (rscRouter) {
                 rscRouter.prefetch(targetPath);
             }
@@ -186,7 +203,7 @@ exports.Link = react_1.default.forwardRef(({ href, as, replace, scroll = true, s
                 prefetchUrl(targetPath);
             }
         }
-    }, [onTouchStart, prefetch, targetPath, rscRouter, internal]);
+    }, [onTouchStart, prefetchBehavior.intent, targetPath, pathname, rscRouter, internal]);
     // Handle navigation
     const handleClick = (0, react_1.useCallback)((e) => {
         if (onClick)
@@ -204,6 +221,8 @@ exports.Link = react_1.default.forwardRef(({ href, as, replace, scroll = true, s
             return;
         if (!internal)
             return; // external / mailto / tel
+        if (!rscRouter && !legacyRouter)
+            return; // No router provider -> allow native navigation
         e.preventDefault();
         if (onNavigate)
             onNavigate();
@@ -216,7 +235,7 @@ exports.Link = react_1.default.forwardRef(({ href, as, replace, scroll = true, s
                 rscRouter.push(targetPath, { scroll });
             }
         }
-        else {
+        else if (legacyRouter) {
             if (replace) {
                 legacyRouter.replace(targetPath, { scroll });
             }

package/dist/server/rsc-engine.js

@@ -114,6 +114,27 @@ function resolvePort(raw, fallback) {
     }
     return value;
 }
+function normalizeModuleCachePath(filePath) {
+    return filePath.replace(/\\/g, '/').toLowerCase();
+}
+function shouldInvalidateDevModule(modulePath, cwd) {
+    const normalized = normalizeModuleCachePath(modulePath);
+    const rootPrefix = normalizeModuleCachePath(`${cwd}${path_1.default.sep}`);
+    if (!normalized.startsWith(rootPrefix))
+        return false;
+    if (normalized.includes('/node_modules/'))
+        return false;
+    if (normalized.includes(`/${constants_1.BUILD_DIR.toLowerCase()}/`))
+        return false;
+    return /\.(?:[cm]?[jt]sx?|json)$/i.test(normalized);
+}
+function clearProjectRequireCache(cwd) {
+    for (const key of Object.keys(require.cache)) {
+        if (!shouldInvalidateDevModule(key, cwd))
+            continue;
+        delete require.cache[key];
+    }
+}
 function resolveFromWorkspace(specifier, cwd) {
     const searchRoots = [
         cwd,
@@ -241,18 +262,23 @@ function cleanHotUpdateFiles(cwd) {
         }
     }
 }
-function findChunkFiles(cwd) {
+function findChunkFiles(cwd, isDev) {
     const chunksDir = path_1.default.join(cwd, constants_1.BUILD_DIR, 'static', 'chunks');
     if (!fs_1.default.existsSync(chunksDir))
         return [];
     const files = fs_1.default
         .readdirSync(chunksDir)
         .filter((name) => name.endsWith('.js') && !name.endsWith('.map') && !name.includes('.hot-update.'));
+    // In dev, avoid loading stale production artifacts left from a previous build.
+    // Production chunks end with a hash suffix like `main-1a2b3c4d.js`.
+    const normalizedFiles = isDev
+        ? files.filter((name) => !/-[0-9a-f]{8,}\.js$/i.test(name))
+        : files;
     // Load webpack runtime first, then framework, then the rest alphabetically.
     // This ensures the chunk registry (__webpack_require__) is available before
     // any deferred chunk tries to self-register.
     const priority = ['webpack.js', 'framework.js', 'vendor.js'];
-    return files.sort((a, b) => {
+    return normalizedFiles.sort((a, b) => {
         const ai = priority.indexOf(a);
         const bi = priority.indexOf(b);
         if (ai !== -1 && bi !== -1)
@@ -264,6 +290,41 @@ function findChunkFiles(cwd) {
         return a.localeCompare(b);
     });
 }
+function normalizeSSRManifest(manifest) {
+    if (!manifest || !manifest.moduleMap) {
+        return manifest;
+    }
+    const moduleMap = manifest.moduleMap;
+    const aliasEntries = [];
+    for (const [moduleKey, exportsMap] of Object.entries(moduleMap)) {
+        const normalizedExports = {};
+        for (const [exportName, rawEntry] of Object.entries(exportsMap || {})) {
+            const entry = rawEntry || {};
+            const normalizedId = String(entry.id ?? entry.specifier ?? moduleKey);
+            normalizedExports[exportName] = {
+                id: normalizedId,
+                chunks: Array.isArray(entry.chunks) ? entry.chunks : [],
+                name: entry.name || exportName,
+            };
+        }
+        moduleMap[moduleKey] = normalizedExports;
+        aliasEntries.push([moduleKey, normalizedExports]);
+        for (const normalizedEntry of Object.values(normalizedExports)) {
+            const aliasKey = String(normalizedEntry.id);
+            aliasEntries.push([aliasKey, normalizedExports]);
+        }
+    }
+    for (const [aliasKey, exportsMap] of aliasEntries) {
+        if (!moduleMap[aliasKey]) {
+            moduleMap[aliasKey] = exportsMap;
+        }
+    }
+    return manifest;
+}
+function loadSSRManifestFromDisk(absolutePath) {
+    const manifest = JSON.parse(fs_1.default.readFileSync(absolutePath, 'utf-8'));
+    return normalizeSSRManifest(manifest);
+}
 function matchPattern(pathname, pattern) {
     const patternParts = pattern.split('/').filter(Boolean);
     const pathParts = pathname.split('/').filter(Boolean);
@@ -326,14 +387,10 @@ function extractParams(pathname, route) {
     }
     return params;
 }
-async function createRouteElement(route, context, isDev, rootLayout) {
+async function createRouteElement(route, context, isDev, rootLayout, cwd) {
     const { params, searchParams, req } = context;
     if (isDev) {
-        for (const key of Object.keys(require.cache)) {
-            if (key.includes(`${path_1.default.sep}app${path_1.default.sep}`)) {
-                delete require.cache[key];
-            }
-        }
+        clearProjectRequireCache(cwd);
     }
     const PageModule = require(route.pagePath);
     const PageComponent = PageModule.default;
@@ -520,11 +577,21 @@ async function renderFlightToHTMLStream(upstreamOrigin, pathname, search, metada
     const nodeStream = stream_1.Readable.fromWeb(upstream.body);
     // 3. Decode Flight stream into a React tree
     const flightResponse = flightSSRClient.createFromNodeStream(nodeStream, ssrManifest);
-    // 4. Wrap in a component that consumes the Flight response
-    function FlightRoot() {
-        return react_1.default.use(flightResponse);
+    let element;
+    // In dev, decode the flight payload before React.use() render path.
+    // This keeps manifest mismatch errors in the request try/catch boundary
+    // instead of crashing the whole process with an uncaught exception.
+    if (isDev) {
+        const resolvedTree = await flightResponse;
+        element = react_1.default.createElement(react_1.default.Fragment, null, resolvedTree);
+    }
+    else {
+        // 4. Wrap in a component that consumes the Flight response
+        function FlightRoot() {
+            return react_1.default.use(flightResponse);
+        }
+        element = react_1.default.createElement(FlightRoot);
     }
-    const element = react_1.default.createElement(FlightRoot);
     // 5. Build script tags for client chunks
     const scripts = chunkFiles
         .map((chunk) => `<script defer src="${constants_1.STATIC_CHUNKS_PATH}${chunk}"></script>`)
@@ -669,26 +736,7 @@ function startRSCServer(options = {}) {
             ? ssrManifestLegacyPath
             : null;
     if (resolvedSSRManifestPath) {
-        ssrManifest = JSON.parse(fs_1.default.readFileSync(resolvedSSRManifestPath, 'utf-8'));
-        // Normalise SSR manifest entries: ReactFlightWebpackPlugin generates
-        // {specifier, name} but react-server-dom-webpack/client.node expects
-        // {id, chunks, name}.  Our VistaSSRManifestPatch webpack plugin handles
-        // this at build time, but in dev mode the manifest may be re-read from
-        // disk before the patch runs.  Belt-and-suspenders fix:
-        if (ssrManifest && ssrManifest.moduleMap) {
-            const moduleMap = ssrManifest.moduleMap;
-            for (const exports of Object.values(moduleMap)) {
-                for (const [exportName, entry] of Object.entries(exports)) {
-                    if (entry.specifier && !entry.id) {
-                        exports[exportName] = {
-                            id: entry.specifier,
-                            chunks: [],
-                            name: entry.name || exportName,
-                        };
-                    }
-                }
-            }
-        }
+        ssrManifest = loadSSRManifestFromDisk(resolvedSSRManifestPath);
     }
     else if (flightSSRClient) {
         // Can't use Flight SSR without the manifest
@@ -814,21 +862,71 @@ function startRSCServer(options = {}) {
         const pushSSE = (payload) => {
             sseReloadClients.forEach((c) => c.write(`data: ${payload}\n\n`));
         };
-        // Watch app/ directory — server component changes need a full page reload
-        // because they run on the upstream RSC process (which invalidates
-        // require.cache per-request, so a fresh fetch returns new content).
-        const appDir = path_1.default.join(cwd, 'app');
+        const watchExtPattern = /\.(?:[cm]?[jt]sx?|css|md|mdx|json)$/i;
+        const watchRoots = [
+            'app',
+            'components',
+            'content',
+            'lib',
+            'ctx',
+            'data',
+            'middleware.ts',
+            'vista.config.ts',
+            'content-collections.ts',
+        ]
+            .map((entry) => path_1.default.join(cwd, entry))
+            .filter((entry) => fs_1.default.existsSync(entry));
         let reloadTimer = null;
-        fsWatcher = fs_1.default.watch(appDir, { recursive: true }, (_event, filename) => {
-            if (filename && /\.[jt]sx?$/.test(filename)) {
-                if (reloadTimer)
-                    clearTimeout(reloadTimer);
-                reloadTimer = setTimeout(() => {
-                    (0, logger_1.logEvent)('File changed, reloading...');
-                    pushSSE('reload');
-                }, 120);
+        const scheduleReload = () => {
+            if (reloadTimer)
+                clearTimeout(reloadTimer);
+            reloadTimer = setTimeout(() => {
+                (0, logger_1.logEvent)('Source changed, reloading...');
+                pushSSE('reload');
+            }, 140);
+        };
+        try {
+            const chokidar = require('chokidar');
+            const watcher = chokidar.watch(watchRoots, {
+                ignoreInitial: true,
+                ignored: (watchedPath) => watchedPath.includes(`${path_1.default.sep}node_modules${path_1.default.sep}`) ||
+                    watchedPath.includes(`${path_1.default.sep}.git${path_1.default.sep}`) ||
+                    watchedPath.includes(`${path_1.default.sep}${constants_1.BUILD_DIR}${path_1.default.sep}`),
+            });
+            watcher.on('all', (_event, filePath) => {
+                if (filePath && watchExtPattern.test(filePath)) {
+                    scheduleReload();
+                }
+            });
+            fsWatcher = watcher;
+        }
+        catch {
+            const nativeWatchers = [];
+            const onChange = (_event, filePath) => {
+                if (filePath && watchExtPattern.test(filePath)) {
+                    scheduleReload();
+                }
+            };
+            for (const watchPath of watchRoots) {
+                try {
+                    const stat = fs_1.default.statSync(watchPath);
+                    if (stat.isDirectory()) {
+                        nativeWatchers.push(fs_1.default.watch(watchPath, { recursive: true }, onChange));
+                    }
+                    else {
+                        nativeWatchers.push(fs_1.default.watch(watchPath, onChange));
+                    }
+                }
+                catch {
+                    // Skip missing or unsupported watch path.
+                }
             }
-        });
+            fsWatcher = {
+                close: () => {
+                    nativeWatchers.forEach((watcher) => watcher.close());
+                },
+            };
+        }
     }
     if (isDev && options.compiler) {
         app.use((0, webpack_dev_middleware_1.default)(options.compiler, {
@@ -856,22 +954,7 @@ function startRSCServer(options = {}) {
             }
             // Reload SSR manifest on rebuild too
             if (resolvedSSRManifestPath && fs_1.default.existsSync(resolvedSSRManifestPath)) {
-                ssrManifest = JSON.parse(fs_1.default.readFileSync(resolvedSSRManifestPath, 'utf-8'));
-                // Normalise {specifier,name} → {id,chunks,name} (same as initial load)
-                if (ssrManifest && ssrManifest.moduleMap) {
-                    const mm = ssrManifest.moduleMap;
-                    for (const exports of Object.values(mm)) {
-                        for (const [expName, entry] of Object.entries(exports)) {
-                            if (entry.specifier && !entry.id) {
-                                exports[expName] = {
-                                    id: entry.specifier,
-                                    chunks: [],
-                                    name: entry.name || expName,
-                                };
-                            }
-                        }
-                    }
-                }
+                ssrManifest = loadSSRManifestFromDisk(resolvedSSRManifestPath);
             }
         });
     }
@@ -1082,17 +1165,21 @@ function startRSCServer(options = {}) {
         // ==================================================================
         if (useFlightSSR) {
             try {
+                if (isDev && resolvedSSRManifestPath && fs_1.default.existsSync(resolvedSSRManifestPath)) {
+                    try {
+                        ssrManifest = loadSSRManifestFromDisk(resolvedSSRManifestPath);
+                    }
+                    catch {
+                        // Manifest may be mid-write during compilation; keep the last good in-memory copy.
+                    }
+                }
                 // Metadata extraction: still done locally so we have <head> content
                 const rootLayout = (0, root_resolver_1.resolveRootLayout)(cwd, isDev);
                 const route = matchRoute(req.path, serverManifest.routes);
                 let metadataHtml = '';
                 if (route) {
                     if (isDev) {
-                        for (const key of Object.keys(require.cache)) {
-                            if (key.includes(`${path_1.default.sep}app${path_1.default.sep}`)) {
-                                delete require.cache[key];
-                            }
-                        }
+                        clearProjectRequireCache(cwd);
                     }
                     const PageModule = require(route.pagePath);
                     let metadata = { ...(rootLayout.metadata || {}) };
@@ -1114,7 +1201,7 @@ function startRSCServer(options = {}) {
                     metadataHtml = metadata ? generateMetadataHtml(metadata) : '';
                 }
                 // Render the page via Flight stream → SSR
-                await renderFlightToHTMLStream(upstreamOrigin, req.path, req.query ? new URLSearchParams(req.query).toString() : '', metadataHtml, findChunkFiles(cwd), rootLayout.mode, flightSSRClient, ssrManifest, res, isDev);
+                await renderFlightToHTMLStream(upstreamOrigin, req.path, req.query ? new URLSearchParams(req.query).toString() : '', metadataHtml, findChunkFiles(cwd, isDev), rootLayout.mode, flightSSRClient, ssrManifest, res, isDev);
                 return;
             }
             catch (flightError) {
@@ -1182,7 +1269,7 @@ function startRSCServer(options = {}) {
                     res
                         .status(404)
                         .type('text/html')
-                        .send(createHtmlDocument(html, '', findChunkFiles(cwd), rootLayout.mode));
+                        .send(createHtmlDocument(html, '', findChunkFiles(cwd, isDev), rootLayout.mode));
                     return;
                 }
                 res.status(404).type('text/html').send((0, not_found_page_1.getStyledNotFoundHTML)());
@@ -1190,14 +1277,14 @@ function startRSCServer(options = {}) {
             }
             const params = extractParams(req.path, route);
             const searchParams = Object.fromEntries(new URLSearchParams(req.query).entries());
-            const { element, metadata, rootMode } = await createRouteElement(route, { params, searchParams, req }, isDev, rootLayout);
+            const { element, metadata, rootMode } = await createRouteElement(route, { params, searchParams, req }, isDev, rootLayout, cwd);
             const appHtml = (0, server_1.renderToString)(element);
             const { generateMetadataHtml } = require('../metadata/generate');
             const metadataHtml = metadata ? generateMetadataHtml(metadata) : '';
             res
                 .status(200)
                 .type('text/html')
-                .send(createHtmlDocument(appHtml, metadataHtml, findChunkFiles(cwd), rootMode));
+                .send(createHtmlDocument(appHtml, metadataHtml, findChunkFiles(cwd, isDev), rootMode));
         }
         catch (error) {
             if (error?.name === 'NotFoundError') {
@@ -1214,7 +1301,7 @@ function startRSCServer(options = {}) {
                         res
                             .status(404)
                             .type('text/html')
-                            .send(createHtmlDocument(html, '', findChunkFiles(cwd), rootLayout.mode));
+                            .send(createHtmlDocument(html, '', findChunkFiles(cwd, isDev), rootLayout.mode));
                         return;
                     }
                     res.status(404).type('text/html').send((0, not_found_page_1.getStyledNotFoundHTML)());

package/dist/server/rsc-upstream.js

@@ -77,6 +77,25 @@ function resolveFromWorkspace(specifier, cwd) {
 function normalizeModulePath(filePath) {
     return filePath.replace(/\\/g, '/').toLowerCase();
 }
+function shouldInvalidateDevModule(modulePath, cwd) {
+    const normalized = normalizeModulePath(modulePath);
+    const rootPrefix = normalizeModulePath(`${cwd}${path_1.default.sep}`);
+    if (!normalized.startsWith(rootPrefix))
+        return false;
+    if (normalized.includes('/node_modules/'))
+        return false;
+    if (normalized.includes(`/${constants_1.BUILD_DIR.toLowerCase()}/`))
+        return false;
+    return /\.(?:[cm]?[jt]sx?|json)$/i.test(normalized);
+}
+function clearProjectRequireCache(cwd) {
+    for (const key of Object.keys(require.cache)) {
+        if (!shouldInvalidateDevModule(key, cwd))
+            continue;
+        delete require.cache[key];
+        clientDirectiveCache.delete(key);
+    }
+}
 function setupTypeScriptRuntime(cwd) {
     try {
         const swcPath = require.resolve('@swc-node/register', { paths: [cwd] });
@@ -174,18 +193,10 @@ function installSingleReactResolution() {
 function installClientLoadHook(cwd, createClientModuleProxy) {
     if (installedClientLoadHook)
         return;
-    const appDir = path_1.default.join(cwd, 'app');
-    const componentsDir = path_1.default.join(cwd, 'components');
-    const normalizedAppDir = normalizeModulePath(appDir);
-    const normalizedComponentsDir = normalizeModulePath(componentsDir);
     originalCompile = CjsModule.prototype._compile;
     CjsModule.prototype._compile = function (content, filename) {
-        const normalized = normalizeModulePath(filename);
-        const isInAppTree = normalized.startsWith(normalizedAppDir);
-        const isInComponentsTree = normalized.startsWith(normalizedComponentsDir);
-        if ((isInAppTree || isInComponentsTree) &&
-            /\.[jt]sx?$/.test(filename) &&
-            isClientBoundaryFile(filename, content)) {
+        const isJavaScriptModule = /\.[jt]sx?$/.test(filename);
+        if (isJavaScriptModule && isClientBoundaryFile(filename, content)) {
             const moduleId = (0, url_1.pathToFileURL)(filename).href;
             this.exports = createClientModuleProxy(moduleId);
             return;
@@ -254,16 +265,10 @@ function extractParams(pathname, route) {
     }
     return params;
 }
-async function createRouteElement(route, context, isDev) {
+async function createRouteElement(route, context, isDev, cwd) {
     const { params, searchParams, req } = context;
     if (isDev) {
-        for (const key of Object.keys(require.cache)) {
-            if (key.includes(`${path_1.default.sep}app${path_1.default.sep}`) ||
-                key.includes(`${path_1.default.sep}components${path_1.default.sep}`)) {
-                delete require.cache[key];
-                clientDirectiveCache.delete(key);
-            }
-        }
+        clearProjectRequireCache(cwd);
     }
     const PageModule = require(route.pagePath);
     const PageComponent = PageModule.default;
@@ -429,7 +434,7 @@ function startUpstream() {
             }
             const params = extractParams(pathname, route);
             const searchParams = Object.fromEntries(new URLSearchParams(req.query).entries());
-            const element = await createRouteElement(route, { params, searchParams, req }, isDev);
+            const element = await createRouteElement(route, { params, searchParams, req }, isDev, cwd);
             res.setHeader('Content-Type', 'text/x-component');
             res.setHeader('Vary', 'Accept');
             const stream = flightServer.renderToPipeableStream(element, flightManifest, {

package/dist/server/static-generator.js

@@ -181,6 +181,21 @@ async function prerenderPage(urlPath, route, params, cwd) {
     try {
         const React = require('react');
         const { renderToString } = require('react-dom/server');
+        const isAsyncComponent = (component) => {
+            return (typeof component === 'function' &&
+                component.constructor &&
+                component.constructor.name === 'AsyncFunction');
+        };
+        const renderComponent = async (component, props, child) => {
+            if (isAsyncComponent(component)) {
+                const asyncProps = child === undefined ? props : { ...props, children: child };
+                return component(asyncProps);
+            }
+            if (child === undefined) {
+                return React.createElement(component, props);
+            }
+            return React.createElement(component, props, child);
+        };
         // Load page component from webpack-built server bundle
         const pageModule = require(route.pagePath);
         const PageComponent = pageModule.default;
@@ -189,14 +204,14 @@ async function prerenderPage(urlPath, route, params, cwd) {
             return null;
         }
         // Build the element, passing params as props
-        let element = React.createElement(PageComponent, { params: params || {} });
+        let element = await renderComponent(PageComponent, { params: params || {} });
         // Wrap in layouts (outside-in)
         for (let i = route.layoutPaths.length - 1; i >= 0; i--) {
             try {
                 const layoutModule = require(route.layoutPaths[i]);
                 const LayoutComponent = layoutModule.default;
                 if (LayoutComponent) {
-                    element = React.createElement(LayoutComponent, { params: params || {}, searchParams: {} }, element);
+                    element = await renderComponent(LayoutComponent, { params: params || {}, searchParams: {} }, element);
                 }
             }
             catch {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vistagenic/vista",
-  "version": "0.2.3",
+  "version": "0.2.5",
   "description": "The React Framework for Visionaries - Rust-powered SSR with Server Components",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -132,6 +132,5 @@
     "@types/webpack": "^5.28.5",
     "@types/webpack-hot-middleware": "^2.25.9",
     "typescript": "^5.7.2"
-  },
-  "gitHead": "4a9f1db26023c01465b997f6955b3d3a57b6ac84"
+  }
 }

package/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2026 Vista.js contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.