@vistagenic/vista 0.2.1 → 0.2.3

package/LICENSE

@@ -0,0 +1,21 @@
+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.

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

@@ -53,7 +53,7 @@ function runPostCSS(cwd, vistaDir) {
 /**
  * Generate the RSC-aware client entry file
  */
-function generateRSCClientEntry(cwd, vistaDir) {
+function generateRSCClientEntry(cwd, vistaDir, isDev) {
     const clientEntryContent = `/**
  * Vista RSC Client Entry
  *
@@ -89,7 +89,8 @@ hydrateRoot(
   })
 );
 
-// Vista live-reload: listen for server component changes via SSE
+${isDev
+        ? `// Vista live-reload: listen for server component changes via SSE
 (function connectReload() {
   const es = new EventSource('${constants_1.SSE_ENDPOINT}');
   es.onmessage = (e) => {
@@ -108,7 +109,8 @@ hydrateRoot(
     es.close();
     setTimeout(connectReload, 3000);
   };
-})();
+})();`
+        : '// SSE live-reload disabled in production'}
 `;
     fs_1.default.writeFileSync(path_1.default.join(vistaDir, 'rsc-client.tsx'), clientEntryContent);
     if (_debug)
@@ -257,7 +259,7 @@ async function buildRSC(watch = false) {
         type: route.type,
     })));
     // Generate client entry
-    generateRSCClientEntry(cwd, vistaDirs.root);
+    generateRSCClientEntry(cwd, vistaDirs.root, watch);
     // Create webpack configs
     const options = {
         cwd,

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/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;

package/dist/config.js

@@ -3,8 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultConfig = exports.defaultStructureValidationConfig = void 0;
+exports.defaultConfig = exports.defaultTypedApiConfig = exports.defaultStructureValidationConfig = void 0;
 exports.resolveStructureValidationConfig = resolveStructureValidationConfig;
+exports.resolveTypedApiConfig = resolveTypedApiConfig;
 exports.loadConfig = loadConfig;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
@@ -15,11 +16,19 @@ exports.defaultStructureValidationConfig = {
     logLevel: 'compact',
     watchDebounceMs: 120,
 };
+exports.defaultTypedApiConfig = {
+    enabled: false,
+    serialization: 'json',
+    bodySizeLimitBytes: 1024 * 1024,
+};
 exports.defaultConfig = {
     images: {},
     validation: {
         structure: { ...exports.defaultStructureValidationConfig },
     },
+    experimental: {
+        typedApi: { ...exports.defaultTypedApiConfig },
+    },
 };
 /**
  * Resolve the effective structure validation config merging user overrides.
@@ -30,6 +39,55 @@ function resolveStructureValidationConfig(config) {
         ...(config.validation?.structure ?? {}),
     };
 }
+/**
+ * Resolve and sanitize experimental typed API config.
+ */
+function resolveTypedApiConfig(config) {
+    const merged = {
+        ...exports.defaultTypedApiConfig,
+        ...(config.experimental?.typedApi ?? {}),
+    };
+    const serialization = merged.serialization === 'superjson' ? 'superjson' : 'json';
+    const parsedLimit = Number(merged.bodySizeLimitBytes);
+    const bodySizeLimitBytes = Number.isFinite(parsedLimit) && parsedLimit > 0
+        ? Math.floor(parsedLimit)
+        : exports.defaultTypedApiConfig.bodySizeLimitBytes;
+    return {
+        enabled: Boolean(merged.enabled),
+        serialization,
+        bodySizeLimitBytes,
+    };
+}
+function mergeConfig(userConfig) {
+    return {
+        ...exports.defaultConfig,
+        ...userConfig,
+        images: {
+            ...(exports.defaultConfig.images ?? {}),
+            ...(userConfig.images ?? {}),
+        },
+        server: {
+            ...(exports.defaultConfig.server ?? {}),
+            ...(userConfig.server ?? {}),
+        },
+        validation: {
+            ...(exports.defaultConfig.validation ?? {}),
+            ...(userConfig.validation ?? {}),
+            structure: {
+                ...exports.defaultStructureValidationConfig,
+                ...(userConfig.validation?.structure ?? {}),
+            },
+        },
+        experimental: {
+            ...(exports.defaultConfig.experimental ?? {}),
+            ...(userConfig.experimental ?? {}),
+            typedApi: {
+                ...exports.defaultTypedApiConfig,
+                ...(userConfig.experimental?.typedApi ?? {}),
+            },
+        },
+    };
+}
 function loadConfig(cwd = process.cwd()) {
     const tsPath = path_1.default.join(cwd, 'vista.config.ts');
     const jsPath = path_1.default.join(cwd, 'vista.config.js');
@@ -37,15 +95,15 @@ function loadConfig(cwd = process.cwd()) {
         if (fs_1.default.existsSync(tsPath)) {
             // We assume ts-node is registered by engine or bin
             const mod = require(tsPath);
-            return { ...exports.defaultConfig, ...(mod.default || mod) };
+            return mergeConfig(mod.default || mod);
         }
         else if (fs_1.default.existsSync(jsPath)) {
             const mod = require(jsPath);
-            return { ...exports.defaultConfig, ...(mod.default || mod) };
+            return mergeConfig(mod.default || mod);
         }
     }
     catch (error) {
         console.error('Error loading vista.config:', error);
     }
-    return exports.defaultConfig;
+    return mergeConfig({});
 }

package/dist/server/engine.js

@@ -25,6 +25,7 @@ const image_optimizer_1 = require("./image-optimizer");
 const static_cache_1 = require("./static-cache");
 const registry_1 = require("../font/registry");
 const not_found_page_1 = require("./not-found-page");
+const typed_api_runtime_1 = require("./typed-api-runtime");
 const logger_1 = require("./logger");
 const structure_log_1 = require("./structure-log");
 // Support CSS imports on server runtime
@@ -188,6 +189,7 @@ function startServer(port = 3003, compiler) {
     const app = (0, express_1.default)();
     const cwd = process.cwd();
     const vistaConfig = (0, config_1.loadConfig)(cwd);
+    const typedApiConfig = (0, config_1.resolveTypedApiConfig)(vistaConfig);
     const isDev = process.env.NODE_ENV !== 'production';
     const appDir = path_1.default.join(cwd, 'app');
     // Allow port override from config
@@ -408,69 +410,33 @@ function startServer(port = 3003, compiler) {
             return;
         // API ROUTES SUPPORT - Next.js App Router Style
         if (req.path.startsWith('/api/')) {
-            // Remove /api/ prefix and check for route.ts file
-            const apiRoute = req.path.substring(5); // Remove '/api/'
-            // Try route.ts pattern first (Next.js App Router style)
-            const routeTsPath = path_1.default.resolve(cwd, 'app', 'api', apiRoute, 'route.ts');
-            const routeTsxPath = path_1.default.resolve(cwd, 'app', 'api', apiRoute, 'route.tsx');
-            // Fallback to old pattern (api/path.ts)
-            const legacyPath = path_1.default.resolve(cwd, 'app', 'api', apiRoute + '.ts');
-            let apiPath = null;
-            if (fs_1.default.existsSync(routeTsPath)) {
-                apiPath = routeTsPath;
-            }
-            else if (fs_1.default.existsSync(routeTsxPath)) {
-                apiPath = routeTsxPath;
-            }
-            else if (fs_1.default.existsSync(legacyPath)) {
-                apiPath = legacyPath;
-            }
-            if (apiPath) {
+            const legacyApiPath = (0, typed_api_runtime_1.resolveLegacyApiRoutePath)(cwd, req.path);
+            if (legacyApiPath) {
                 try {
-                    delete require.cache[require.resolve(apiPath)];
-                    const apiModule = require(apiPath);
-                    // Next.js App Router style: named exports for HTTP methods
-                    const method = req.method?.toUpperCase() || 'GET';
-                    const methodHandler = apiModule[method];
-                    if (typeof methodHandler === 'function') {
-                        // Create Request-like object for App Router compatibility
-                        const request = {
-                            url: req.protocol + '://' + req.get('host') + req.originalUrl,
-                            method: req.method,
-                            headers: new Map(Object.entries(req.headers)),
-                            json: async () => req.body,
-                            text: async () => JSON.stringify(req.body),
-                            nextUrl: {
-                                pathname: req.path,
-                                searchParams: new URLSearchParams(req.query),
-                            },
-                        };
-                        const result = await methodHandler(request, { params: {} });
-                        // Handle Response object
-                        if (result && typeof result.json === 'function') {
-                            const json = await result.json();
-                            return res.status(result.status || 200).json(json);
-                        }
-                        else if (result) {
-                            return res.status(200).json(result);
-                        }
-                        return res.status(204).end();
-                    }
-                    // Fallback to default export (Pages Router style)
-                    const handler = apiModule.default;
-                    if (typeof handler === 'function') {
-                        return handler(req, res);
-                    }
-                    return res.status(405).json({ error: `Method ${method} not allowed` });
+                    await (0, typed_api_runtime_1.runLegacyApiRoute)({
+                        req,
+                        res,
+                        apiPath: legacyApiPath,
+                        isDev,
+                    });
+                    return;
                 }
-                catch (err) {
-                    console.error(`[vista:ssr] API route error: ${err?.message ?? String(err)}`);
+                catch (error) {
+                    console.error(`[vista:ssr] API route error: ${error?.message ?? String(error)}`);
                     return res.status(500).json({ error: 'Internal Server Error in API' });
                 }
             }
-            else {
-                return res.status(404).json({ error: 'API Route Not Found' });
+            const typedHandled = await (0, typed_api_runtime_1.runTypedApiRoute)({
+                req,
+                res,
+                cwd,
+                isDev,
+                config: typedApiConfig,
+            });
+            if (typedHandled) {
+                return;
             }
+            return res.status(404).json({ error: 'API Route Not Found' });
         }
         // ==================================================================
         // Static / ISR Cache Check