@vistagenic/vista 0.2.2 → 0.2.4

package/bin/vista.js

@@ -1,12 +1,20 @@
 #!/usr/bin/env node
 
-const command = process.argv[2];
-const flags = process.argv.slice(3);
-
-// RSC is the default mode (like Next.js App Router)
-// Use --legacy to fall back to traditional SSR mode
-const useLegacy = flags.includes('--legacy') || process.env.VISTA_LEGACY === 'true';
-const useRSC = !useLegacy;
+const command = process.argv[2];
+const flags = process.argv.slice(3);
+
+if (command === 'g' || command === 'generate') {
+  const { runGenerateCommand } = require('../dist/bin/generate');
+  runGenerateCommand(flags).then((code) => {
+    if (code !== 0) process.exit(code);
+  });
+  return;
+}
+
+// RSC is the default mode (like Next.js App Router)
+// Use --legacy to fall back to traditional SSR mode
+const useLegacy = flags.includes('--legacy') || process.env.VISTA_LEGACY === 'true';
+const useRSC = !useLegacy;
 
 // Mark startup time for "Ready in Xms" display
 const { markStartTime } = require('../dist/server/logger');
@@ -85,16 +93,18 @@ if (command === 'dev') {
   console.log('Usage: vista <command> [options]');
   console.log('');
   console.log('Commands:');
-  console.log('  dev     Start development server with HMR');
-  console.log('  build   Create production build');
-  console.log('  start   Start production server');
-  console.log('');
-  console.log('Options:');
-  console.log('  --legacy   Use traditional SSR mode (instead of RSC)');
-  console.log('');
-  console.log('Examples:');
-  console.log('  vista dev            # Start dev server (RSC mode)');
-  console.log('  vista dev --legacy   # Start dev server with legacy SSR');
-  console.log('  vista build          # Production build with RSC');
-  console.log('');
-}
+  console.log('  dev     Start development server with HMR');
+  console.log('  build   Create production build');
+  console.log('  start   Start production server');
+  console.log('  g       Generate typed API scaffolds (api-init, router, procedure)');
+  console.log('');
+  console.log('Options:');
+  console.log('  --legacy   Use traditional SSR mode (instead of RSC)');
+  console.log('');
+  console.log('Examples:');
+  console.log('  vista dev            # Start dev server (RSC mode)');
+  console.log('  vista dev --legacy   # Start dev server with legacy SSR');
+  console.log('  vista build          # Production build with RSC');
+  console.log('  vista g api-init     # Generate typed API starter files');
+  console.log('');
+}

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/bin/generate.d.ts

@@ -0,0 +1,7 @@
+interface RunGenerateOptions {
+    cwd?: string;
+    log?: (message: string) => void;
+    error?: (message: string) => void;
+}
+export declare function runGenerateCommand(args: string[], options?: RunGenerateOptions): Promise<number>;
+export {};

package/dist/bin/generate.js

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runGenerateCommand = runGenerateCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function toKebabCase(value) {
+    return value
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+function toPascalCase(value) {
+    return toKebabCase(value)
+        .split('-')
+        .filter(Boolean)
+        .map((segment) => segment[0].toUpperCase() + segment.slice(1))
+        .join('');
+}
+function toCamelCase(value) {
+    const pascal = toPascalCase(value);
+    return pascal ? pascal[0].toLowerCase() + pascal.slice(1) : '';
+}
+function ensureDirectory(targetDir) {
+    fs_1.default.mkdirSync(targetDir, { recursive: true });
+}
+function writeFileIfMissing(baseDir, relativePath, content) {
+    const absolutePath = path_1.default.join(baseDir, relativePath);
+    if (fs_1.default.existsSync(absolutePath)) {
+        return { path: absolutePath, created: false };
+    }
+    ensureDirectory(path_1.default.dirname(absolutePath));
+    fs_1.default.writeFileSync(absolutePath, content, 'utf8');
+    return { path: absolutePath, created: true };
+}
+function findMatchingBrace(source, openBraceIndex) {
+    let depth = 0;
+    for (let i = openBraceIndex; i < source.length; i++) {
+        const char = source[i];
+        if (char === '{')
+            depth++;
+        if (char === '}')
+            depth--;
+        if (depth === 0)
+            return i;
+    }
+    return -1;
+}
+function insertTypedApiConfigIntoObject(source, objectStartIndex) {
+    const openBraceIndex = source.indexOf('{', objectStartIndex);
+    if (openBraceIndex < 0) {
+        return null;
+    }
+    const closeBraceIndex = findMatchingBrace(source, openBraceIndex);
+    if (closeBraceIndex < 0) {
+        return null;
+    }
+    const before = source.slice(0, closeBraceIndex);
+    const after = source.slice(closeBraceIndex);
+    const insertion = `\n  experimental: {\n    typedApi: {\n      enabled: true,\n    },\n  },`;
+    return `${before}${insertion}${after}`;
+}
+function ensureTypedApiEnabledInConfig(cwd) {
+    const tsPath = path_1.default.join(cwd, 'vista.config.ts');
+    const jsPath = path_1.default.join(cwd, 'vista.config.js');
+    if (!fs_1.default.existsSync(tsPath) && !fs_1.default.existsSync(jsPath)) {
+        const configSource = [
+            'const config = {',
+            '  experimental: {',
+            '    typedApi: {',
+            '      enabled: true,',
+            '    },',
+            '  },',
+            '};',
+            '',
+            'export default config;',
+            '',
+        ].join('\n');
+        fs_1.default.writeFileSync(tsPath, configSource, 'utf8');
+        return 'created';
+    }
+    const targetPath = fs_1.default.existsSync(tsPath) ? tsPath : jsPath;
+    const source = fs_1.default.readFileSync(targetPath, 'utf8');
+    if (/\btypedApi\b/.test(source) && /\benabled\s*:\s*true\b/.test(source)) {
+        return 'unchanged';
+    }
+    const constConfigIndex = source.indexOf('const config');
+    if (constConfigIndex >= 0) {
+        const updated = insertTypedApiConfigIntoObject(source, constConfigIndex);
+        if (updated) {
+            fs_1.default.writeFileSync(targetPath, updated, 'utf8');
+            return 'updated';
+        }
+    }
+    const exportDefaultIndex = source.indexOf('export default');
+    if (exportDefaultIndex >= 0) {
+        const updated = insertTypedApiConfigIntoObject(source, exportDefaultIndex);
+        if (updated) {
+            fs_1.default.writeFileSync(targetPath, updated, 'utf8');
+            return 'updated';
+        }
+    }
+    return 'manual';
+}
+function renderApiInitEntrypoint() {
+    return [
+        "import { vstack } from 'vista/stack';",
+        "import { createRootRouter } from './routers';",
+        '',
+        'const v = vstack.init();',
+        '',
+        'export const router = createRootRouter(v);',
+        '',
+    ].join('\n');
+}
+function renderRootRouter() {
+    return [
+        "import type { VStackInstance } from 'vista/stack';",
+        "import { healthProcedure } from '../procedures/health';",
+        '',
+        'export function createRootRouter(v: VStackInstance<any, any>) {',
+        '  return v.router({',
+        '    health: healthProcedure(v),',
+        '  });',
+        '}',
+        '',
+    ].join('\n');
+}
+function renderProcedure(name, method) {
+    const safeName = toCamelCase(name);
+    const functionName = `${safeName}Procedure`;
+    const procedureMethod = method === 'post' ? 'mutation' : 'query';
+    const sampleResult = method === 'post'
+        ? "    ok: true,\n    message: 'Mutation executed',"
+        : "    ok: true,\n    message: 'Query executed',";
+    return [
+        "import type { VStackInstance } from 'vista/stack';",
+        '',
+        `export function ${functionName}(v: VStackInstance<any, any>) {`,
+        `  return v.procedure.${procedureMethod}(() => ({`,
+        sampleResult,
+        '  }));',
+        '}',
+        '',
+    ].join('\n');
+}
+function renderRouter(name) {
+    const pascal = toPascalCase(name);
+    const camel = toCamelCase(name);
+    return [
+        "import type { VStackInstance } from 'vista/stack';",
+        '',
+        `export function create${pascal}Router(v: VStackInstance<any, any>) {`,
+        '  return v.router({',
+        `    ${camel}: v.procedure.query(() => ({`,
+        `      route: '${toKebabCase(name)}',`,
+        "      ok: true,",
+        '    })),',
+        '  });',
+        '}',
+        '',
+    ].join('\n');
+}
+function printGenerateUsage(log) {
+    log('Vista generator usage:');
+    log('  vista g api-init');
+    log('  vista g router <name>');
+    log('  vista g procedure <name> [get|post]');
+}
+async function runGenerateCommand(args, options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const log = options.log ?? console.log;
+    const error = options.error ?? console.error;
+    const command = (args[0] || '').toLowerCase();
+    if (!command || !['api-init', 'router', 'procedure'].includes(command)) {
+        printGenerateUsage(log);
+        return 1;
+    }
+    if (command === 'api-init') {
+        const writes = [
+            writeFileIfMissing(cwd, path_1.default.join('app', 'api', 'typed.ts'), renderApiInitEntrypoint()),
+            writeFileIfMissing(cwd, path_1.default.join('app', 'api', 'routers', 'index.ts'), renderRootRouter()),
+            writeFileIfMissing(cwd, path_1.default.join('app', 'api', 'procedures', 'health.ts'), renderProcedure('health', 'get')),
+        ];
+        const configState = ensureTypedApiEnabledInConfig(cwd);
+        writes.forEach((result) => {
+            const relativePath = path_1.default.relative(cwd, result.path).replace(/\\/g, '/');
+            log(`${result.created ? 'created' : 'skipped'} ${relativePath}`);
+        });
+        if (configState === 'created') {
+            log('created vista.config.ts with experimental.typedApi.enabled = true');
+        }
+        else if (configState === 'updated') {
+            log('updated vista.config.* to enable experimental typed API');
+        }
+        else if (configState === 'unchanged') {
+            log('typed API config already enabled');
+        }
+        else {
+            error('Could not update vista.config automatically. Please enable experimental.typedApi.enabled manually.');
+            return 1;
+        }
+        return 0;
+    }
+    if (command === 'router') {
+        const rawName = args[1];
+        if (!rawName) {
+            error('Missing router name. Example: vista g router users');
+            return 1;
+        }
+        const safeName = toKebabCase(rawName);
+        if (!safeName) {
+            error(`Invalid router name "${rawName}".`);
+            return 1;
+        }
+        const result = writeFileIfMissing(cwd, path_1.default.join('app', 'api', 'routers', `${safeName}.ts`), renderRouter(safeName));
+        const relativePath = path_1.default.relative(cwd, result.path).replace(/\\/g, '/');
+        log(`${result.created ? 'created' : 'skipped'} ${relativePath}`);
+        return 0;
+    }
+    if (command === 'procedure') {
+        const rawName = args[1];
+        if (!rawName) {
+            error('Missing procedure name. Example: vista g procedure list-users get');
+            return 1;
+        }
+        const methodArg = (args[2] || 'get').toLowerCase();
+        if (methodArg !== 'get' && methodArg !== 'post') {
+            error(`Invalid procedure method "${methodArg}". Use "get" or "post".`);
+            return 1;
+        }
+        const safeName = toKebabCase(rawName);
+        if (!safeName) {
+            error(`Invalid procedure name "${rawName}".`);
+            return 1;
+        }
+        const result = writeFileIfMissing(cwd, path_1.default.join('app', 'api', 'procedures', `${safeName}.ts`), renderProcedure(safeName, methodArg));
+        const relativePath = path_1.default.relative(cwd, result.path).replace(/\\/g, '/');
+        log(`${result.created ? 'created' : 'skipped'} ${relativePath}`);
+        return 0;
+    }
+    printGenerateUsage(log);
+    return 1;
+}

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/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/config.d.ts

@@ -1,6 +1,7 @@
 import { ImageConfig } from './image/image-config';
 export type ValidationMode = 'strict' | 'warn';
 export type ValidationLogLevel = 'compact' | 'verbose';
+export type TypedApiSerialization = 'json' | 'superjson';
 export interface StructureValidationConfig {
     /** Enable structure validation. Default: true */
     enabled?: boolean;
@@ -13,6 +14,17 @@ export interface StructureValidationConfig {
     /** Debounce interval for watch events in ms. Default: 120 */
     watchDebounceMs?: number;
 }
+export interface TypedApiExperimentalConfig {
+    /** Enable typed API runtime. Default: false */
+    enabled?: boolean;
+    /** Request/response serialization mode. Default: 'json' */
+    serialization?: TypedApiSerialization;
+    /** Maximum request body size for typed API endpoints in bytes. Default: 1MB */
+    bodySizeLimitBytes?: number;
+}
+export interface ExperimentalConfig {
+    typedApi?: TypedApiExperimentalConfig;
+}
 export interface VistaConfig {
     images?: ImageConfig;
     react?: any;
@@ -22,11 +34,18 @@ export interface VistaConfig {
     validation?: {
         structure?: StructureValidationConfig;
     };
+    experimental?: ExperimentalConfig;
 }
 export declare const defaultStructureValidationConfig: Required<StructureValidationConfig>;
+export declare const defaultTypedApiConfig: Required<TypedApiExperimentalConfig>;
 export declare const defaultConfig: VistaConfig;
 /**
  * Resolve the effective structure validation config merging user overrides.
  */
 export declare function resolveStructureValidationConfig(config: VistaConfig): Required<StructureValidationConfig>;
+export type ResolvedTypedApiConfig = Required<TypedApiExperimentalConfig>;
+/**
+ * Resolve and sanitize experimental typed API config.
+ */
+export declare function resolveTypedApiConfig(config: VistaConfig): ResolvedTypedApiConfig;
 export declare function loadConfig(cwd?: string): VistaConfig;