vitek-plugin 0.1.0-beta → 0.1.2-beta

package/dist/adapters/vite/dev-server.d.ts

@@ -2,8 +2,7 @@
  * Adapter for integration with Vite development server
  * Thin layer that connects core → Vite
  */
-import type { Connect, ViteDevServer } from 'vite';
-import type { IncomingMessage, ServerResponse } from 'http';
+import type { ViteDevServer } from 'vite';
 import type { VitekLogger } from './logger.js';
 export interface ViteDevServerOptions {
     root: string;
@@ -16,7 +15,7 @@ export interface ViteDevServerOptions {
  * Creates middleware for Vite development server
  */
 export declare function createViteDevServerMiddleware(options: ViteDevServerOptions): {
-    middleware: (req: IncomingMessage, res: ServerResponse, next: Connect.NextFunction) => Promise<void>;
+    middleware: (req: import("http").IncomingMessage, res: import("http").ServerResponse, next: import("vite").Connect.NextFunction) => Promise<void>;
     cleanup: () => void;
     reload: () => Promise<void>;
 };

package/dist/adapters/vite/dev-server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dev-server.d.ts","sourceRoot":"","sources":["../../../src/adapters/vite/dev-server.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAsB5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,aAAa,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAoRD;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,oBAAoB;sBAUhE,eAAe,OACf,cAAc,QACb,OAAO,CAAC,YAAY;;;EAoL/B"}
+{"version":3,"file":"dev-server.d.ts","sourceRoot":"","sources":["../../../src/adapters/vite/dev-server.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,MAAM,CAAC;AAoB1C,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE/C,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,aAAa,CAAC;IAC1B,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAsPD;;GAEG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,oBAAoB;;;;EAe1E"}

package/dist/adapters/vite/dev-server.js

@@ -14,21 +14,17 @@ function isTypeScriptProject(root) {
 }
 import { watchApiDirectory } from '../../core/file-system/watch-api-dir.js';
 import { createRoute } from '../../core/routing/route-parser.js';
-import { matchRoute } from '../../core/routing/route-matcher.js';
-import { compose } from '../../core/middleware/compose.js';
-import { getApplicableMiddlewares } from '../../core/middleware/get-applicable-middlewares.js';
-import { createContext, isVitekResponse } from '../../core/context/create-context.js';
+import { createRequestHandler } from '../../core/server/request-handler.js';
 import { routesToSchema } from '../../core/types/schema.js';
 import { generateTypesFile, generateServicesFile } from '../../core/types/generate.js';
 import { API_BASE_PATH, GENERATED_TYPES_FILE, GENERATED_SERVICES_FILE } from '../../shared/constants.js';
-import { HttpError } from '../../shared/errors.js';
 /**
  * Development server state
  */
 class DevServerState {
     options;
     routes = [];
-    middlewares = []; // Loaded hierarchical middlewares
+    middlewares = [];
     watcher = null;
     constructor(options) {
         this.options = options;
@@ -47,16 +43,12 @@ class DevServerState {
         if (showReloadLog) {
             this.options.logger.info('Reloading API routes...');
         }
-        // Scan directory
         const scanResult = scanApiDirectory(this.options.apiDir);
-        // Load hierarchical middlewares
-        this.middlewares = [];
+        this.middlewares.length = 0;
         for (const middlewareInfo of scanResult.middlewares) {
             try {
-                // Convert absolute path to relative path to Vite root (format /src/api/posts/middleware.ts)
                 const relativePath = path.relative(this.options.root, middlewareInfo.path);
                 const vitePath = `/${relativePath.replace(/\\/g, '/')}`;
-                // Use Vite's ssrLoadModule to process TypeScript
                 const middlewareModule = await this.options.viteServer.ssrLoadModule(vitePath);
                 const middleware = middlewareModule.default || middlewareModule.middleware;
                 let middlewareArray = [];
@@ -79,23 +71,18 @@ class DevServerState {
         }
         const totalMiddlewareCount = this.middlewares.reduce((sum, m) => sum + m.middleware.length, 0);
         this.options.logger.middlewareLoaded(totalMiddlewareCount);
-        // Load routes
-        this.routes = [];
+        this.routes.length = 0;
         for (const parsedRoute of scanResult.routes) {
             try {
-                // Convert absolute path to relative path to Vite root (format /src/api/users/[id].get.ts)
                 const relativePath = path.relative(this.options.root, parsedRoute.file);
                 const vitePath = `/${relativePath.replace(/\\/g, '/')}`;
-                // Use Vite's ssrLoadModule to process TypeScript
                 const handlerModule = await this.options.viteServer.ssrLoadModule(vitePath);
                 const handler = handlerModule.default || handlerModule.handler || handlerModule[parsedRoute.method];
                 if (typeof handler !== 'function') {
                     this.options.logger.warn(`Route file ${parsedRoute.file} does not export a handler function`);
                     continue;
                 }
-                // Extract bodyType from file (looking for export type Body or export interface Body)
                 const bodyType = extractBodyTypeFromFile(parsedRoute.file);
-                // Extract queryType from file (looking for export type Query or export interface Query)
                 const queryType = extractQueryTypeFromFile(parsedRoute.file);
                 const route = createRoute(parsedRoute, handler, bodyType, queryType);
                 this.routes.push(route);
@@ -104,13 +91,11 @@ class DevServerState {
                 this.options.logger.error(`Failed to load route ${parsedRoute.file}: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        // Log registered routes (consolidated)
         const routesInfo = this.routes.map(r => ({
             method: r.method,
             pattern: r.pattern,
         }));
         this.options.logger.routesRegistered(routesInfo, API_BASE_PATH);
-        // Generate types
         await this.generateTypes();
     }
     /**
@@ -132,14 +117,12 @@ class DevServerState {
         try {
             const schema = routesToSchema(this.routes);
             const isTypeScript = isTypeScriptProject(this.options.root);
-            // Generate api.types.ts only if it's a TypeScript project
             if (isTypeScript) {
                 const typesPath = path.join(this.options.root, 'src', GENERATED_TYPES_FILE);
                 await generateTypesFile(typesPath, schema, API_BASE_PATH);
                 const relativeTypesPath = path.relative(this.options.root, typesPath);
                 this.options.logger.typesGenerated(`./${relativeTypesPath.replace(/\\/g, '/')}`);
             }
-            // Generate api.services.ts or api.services.js depending on the project
             const servicesFileName = isTypeScript ? GENERATED_SERVICES_FILE : 'api.services.js';
             const servicesPath = path.join(this.options.root, 'src', servicesFileName);
             await generateServicesFile(servicesPath, schema, API_BASE_PATH, isTypeScript);
@@ -177,26 +160,17 @@ function extractQueryTypeFromFile(filePath) {
     return extractTypeFromFile(filePath, 'Query');
 }
 /**
- * Helper function to extract a type from a file
- * Uses regex-based extraction (synchronous)
- *
- * Note: AST-based extraction using ts-morph would be more robust but requires:
- * 1. Making this function async
- * 2. Adding ts-morph as optional dependency
- * 3. Updating call sites to handle async
- * This can be implemented in a future version when needed.
+ * Extracts a type (Body or Query) from a route file via regex. AST-based extraction could be used in a future version.
  */
 function extractTypeFromFile(filePath, typeName) {
     try {
         const content = fs.readFileSync(filePath, 'utf-8');
-        // Look for export type {TypeName} = ...
         const typeStart = content.indexOf(`export type ${typeName}`);
         if (typeStart !== -1) {
             const afterStart = content.substring(typeStart);
             const equalsIndex = afterStart.indexOf('=');
             if (equalsIndex !== -1) {
                 const afterEquals = afterStart.substring(equalsIndex + 1).trimStart();
-                // If it starts with {, need to count braces to find the correct closing
                 if (afterEquals.startsWith('{')) {
                     let braceCount = 0;
                     let i = 0;
@@ -219,8 +193,6 @@ function extractTypeFromFile(filePath, typeName) {
                     }
                 }
                 else {
-                    // If it doesn't start with {, it's a simple type alias (e.g., string, number, etc)
-                    // Get until the first ; (but may have line breaks)
                     const semicolonIndex = afterEquals.indexOf(';');
                     if (semicolonIndex !== -1) {
                         return afterEquals.substring(0, semicolonIndex).trim();
@@ -228,7 +200,6 @@ function extractTypeFromFile(filePath, typeName) {
                 }
             }
         }
-        // Look for export interface {TypeName} { ... }
         const interfaceStart = content.indexOf(`export interface ${typeName}`);
         if (interfaceStart !== -1) {
             const afterStart = content.substring(interfaceStart);
@@ -257,8 +228,7 @@ function extractTypeFromFile(filePath, typeName) {
         }
         return undefined;
     }
-    catch (error) {
-        // If unable to read the file, return undefined
+    catch {
         return undefined;
     }
 }
@@ -267,161 +237,15 @@ function extractTypeFromFile(filePath, typeName) {
  */
 export function createViteDevServerMiddleware(options) {
     const state = new DevServerState(options);
-    // Initialize when middleware is created
     state.initialize().catch(error => {
         options.logger.error(`Failed to initialize Vitek: ${error instanceof Error ? error.message : String(error)}`);
     });
     return {
-        middleware: async (req, res, next) => {
-            // Only process requests for /api/*
-            if (!req.url?.startsWith(API_BASE_PATH)) {
-                return next();
-            }
-            const startTime = Date.now();
-            const requestMethod = req.method?.toLowerCase() || 'get';
-            const requestPath = req.url.split('?')[0]; // Path without query string
-            try {
-                // Parse URL to separate path from query string
-                const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
-                // Remove /api from path for matching
-                const routePath = url.pathname.replace(API_BASE_PATH, '') || '/';
-                const method = requestMethod;
-                // Try to match with a route
-                const match = matchRoute(state.routes, routePath, method);
-                if (!match) {
-                    const duration = Date.now() - startTime;
-                    res.statusCode = 404;
-                    res.setHeader('Content-Type', 'application/json');
-                    res.end(JSON.stringify({ error: 'Route not found' }));
-                    options.logger.request(requestMethod, requestPath, 404, duration);
-                    return;
-                }
-                // Log route match if enabled
-                options.logger.routeMatched(match.route.pattern, method);
-                // Parse query string (url was already created above)
-                const query = {};
-                url.searchParams.forEach((value, key) => {
-                    if (query[key]) {
-                        const existing = query[key];
-                        query[key] = Array.isArray(existing) ? [...existing, value] : [existing, value];
-                    }
-                    else {
-                        query[key] = value;
-                    }
-                });
-                // Parse body if present
-                let body;
-                if (['post', 'put', 'patch'].includes(method)) {
-                    body = await new Promise((resolve) => {
-                        const chunks = [];
-                        req.on('data', (chunk) => {
-                            chunks.push(chunk);
-                        });
-                        req.on('end', () => {
-                            const rawBody = Buffer.concat(chunks).toString();
-                            if (!rawBody) {
-                                resolve(undefined);
-                                return;
-                            }
-                            try {
-                                resolve(JSON.parse(rawBody));
-                            }
-                            catch {
-                                resolve(rawBody);
-                            }
-                        });
-                    });
-                }
-                // Create context
-                const context = createContext({
-                    url: req.url,
-                    method,
-                    headers: req.headers,
-                    body,
-                }, match.params, query);
-                // Note: Validation is opt-in and can be done manually in handlers using validateBody/validateQuery
-                // Automatic validation based on TypeScript types would require AST parsing (Phase 2.2)
-                // For now, validation is available as helper functions that handlers can use
-                // Get applicable middlewares for this route
-                const applicableMiddlewares = getApplicableMiddlewares(state.middlewares, match.route.pattern);
-                // Compose middlewares + handler
-                const composed = compose(applicableMiddlewares);
-                const handler = async () => {
-                    const result = await match.route.handler(context);
-                    // Handle VitekResponse format (with status and headers)
-                    if (isVitekResponse(result)) {
-                        const response = result;
-                        const statusCode = response.status || 200;
-                        // Set headers
-                        if (response.headers) {
-                            for (const [key, value] of Object.entries(response.headers)) {
-                                res.setHeader(key, value);
-                            }
-                        }
-                        // Set default Content-Type if not specified and body exists
-                        if (!response.headers || !response.headers['Content-Type']) {
-                            if (response.body !== undefined) {
-                                res.setHeader('Content-Type', 'application/json');
-                            }
-                        }
-                        res.statusCode = statusCode;
-                        // Handle different response types
-                        if (response.body === undefined) {
-                            res.end();
-                        }
-                        else if (typeof response.body === 'string') {
-                            res.end(response.body);
-                        }
-                        else {
-                            res.end(JSON.stringify(response.body));
-                        }
-                        // Log request/response
-                        const duration = Date.now() - startTime;
-                        options.logger.request(requestMethod, requestPath, statusCode, duration);
-                    }
-                    else {
-                        // Backward compatibility: plain object/primitive → JSON response with status 200
-                        res.setHeader('Content-Type', 'application/json');
-                        res.statusCode = 200;
-                        res.end(JSON.stringify(result));
-                        // Log request/response
-                        const duration = Date.now() - startTime;
-                        options.logger.request(requestMethod, requestPath, 200, duration);
-                    }
-                };
-                await composed(context, handler);
-            }
-            catch (error) {
-                const duration = Date.now() - startTime;
-                // Handle HTTP errors with proper status codes
-                if (error instanceof HttpError) {
-                    const httpError = error;
-                    options.logger.warn(`HTTP Error ${httpError.statusCode}: ${httpError.message}`);
-                    res.statusCode = httpError.statusCode;
-                    res.setHeader('Content-Type', 'application/json');
-                    res.end(JSON.stringify({
-                        error: httpError.name,
-                        message: httpError.message,
-                        code: httpError.code,
-                    }));
-                    // Log request/response
-                    options.logger.request(requestMethod, requestPath, httpError.statusCode, duration);
-                }
-                else {
-                    // Generic error handling (backward compatible)
-                    const errorMessage = error instanceof Error ? error.message : String(error);
-                    options.logger.error(`Error handling request: ${errorMessage}`);
-                    res.statusCode = 500;
-                    res.setHeader('Content-Type', 'application/json');
-                    res.end(JSON.stringify({
-                        error: 'Internal server error',
-                        message: errorMessage,
-                    }));
-                    // Log request/response
-                    options.logger.request(requestMethod, requestPath, 500, duration);
-                }
-            }
-        },
+        middleware: createRequestHandler({
+            routes: state.routes,
+            middlewares: state.middlewares,
+            logger: options.logger,
+        }),
         cleanup: () => state.cleanup(),
         reload: () => state.reload(),
     };

package/dist/build/build-api-bundle.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Builds the API bundle for preview/production
+ * Scans apiDir, generates an entry module, bundles with esbuild
+ */
+export interface BuildApiBundleOptions {
+    root: string;
+    apiDir: string;
+    outDir: string;
+}
+/**
+ * Builds the API bundle and writes it to outDir/vitek-api.mjs
+ * Returns the path to the written file, or null if skipped (no apiDir, no routes, or error)
+ */
+export declare function buildApiBundle(options: BuildApiBundleOptions): Promise<string | null>;
+export declare function getApiBundleFilename(): string;
+//# sourceMappingURL=build-api-bundle.d.ts.map

package/dist/build/build-api-bundle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-api-bundle.d.ts","sourceRoot":"","sources":["../../src/build/build-api-bundle.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAWH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAgDD;;;GAGG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAgD3F;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C"}

package/dist/build/build-api-bundle.js

@@ -0,0 +1,96 @@
+/**
+ * Builds the API bundle for preview/production
+ * Scans apiDir, generates an entry module, bundles with esbuild
+ */
+import * as path from 'path';
+import * as fs from 'fs';
+import { scanApiDirectory } from '../core/file-system/scan-api-dir.js';
+import { patternToRegex } from '../core/normalize/normalize-path.js';
+const VITEK_API_BUNDLE_FILENAME = 'vitek-api.mjs';
+/**
+ * Generates the virtual entry file content that imports all route handlers and middlewares
+ * and exports { routes, middlewares } in the shape expected by createRequestHandler
+ * entryDir: directory of the generated entry file (for relative imports)
+ */
+function generateEntryContent(scanResult, entryDir) {
+    const lines = [];
+    scanResult.routes.forEach((parsed, i) => {
+        const rel = path.relative(entryDir, parsed.file).replace(/\\/g, '/');
+        const importPath = rel.startsWith('.') ? rel : `./${rel}`;
+        lines.push(`import handler_${i} from ${JSON.stringify(importPath)};`);
+    });
+    scanResult.middlewares.forEach((mw, i) => {
+        const rel = path.relative(entryDir, mw.path).replace(/\\/g, '/');
+        const importPath = rel.startsWith('.') ? rel : `./${rel}`;
+        lines.push(`import mw_${i} from ${JSON.stringify(importPath)};`);
+    });
+    const routeEntries = scanResult.routes.map((parsed, i) => {
+        const regex = patternToRegex(parsed.pattern);
+        const regexSource = regex.source;
+        return `  { pattern: ${JSON.stringify(parsed.pattern)}, method: ${JSON.stringify(parsed.method)}, params: ${JSON.stringify(parsed.params)}, file: ${JSON.stringify(parsed.file)}, regex: new RegExp(${JSON.stringify(regexSource)}), handler: (() => { const m = handler_${i}; return typeof m === 'function' ? m : (m.default ?? m.handler ?? m[${JSON.stringify(parsed.method)}]); })() }`;
+    });
+    lines.push('');
+    lines.push('const routes = [');
+    lines.push(routeEntries.join(',\n'));
+    lines.push('];');
+    const mwEntries = scanResult.middlewares.map((mw, i) => {
+        return `  { basePattern: ${JSON.stringify(mw.basePattern)}, middleware: (() => { const m = mw_${i}; const fn = typeof m === 'function' || Array.isArray(m) ? m : (m.default ?? m.middleware); return Array.isArray(fn) ? fn : [fn]; })() }`;
+    });
+    lines.push('');
+    lines.push('const middlewares = [');
+    lines.push(mwEntries.join(',\n'));
+    lines.push('];');
+    lines.push('');
+    lines.push('export { routes, middlewares };');
+    return lines.join('\n');
+}
+/**
+ * Builds the API bundle and writes it to outDir/vitek-api.mjs
+ * Returns the path to the written file, or null if skipped (no apiDir, no routes, or error)
+ */
+export async function buildApiBundle(options) {
+    const { root, apiDir, outDir } = options;
+    if (!fs.existsSync(apiDir)) {
+        return null;
+    }
+    const scanResult = scanApiDirectory(apiDir);
+    if (scanResult.routes.length === 0 && scanResult.middlewares.length === 0) {
+        return null;
+    }
+    const tmpDir = path.join(outDir, '.vitek-tmp');
+    if (!fs.existsSync(tmpDir)) {
+        fs.mkdirSync(tmpDir, { recursive: true });
+    }
+    const tmpEntry = path.join(tmpDir, 'vitek-api-entry.mts');
+    const entryContent = generateEntryContent(scanResult, path.dirname(tmpEntry));
+    fs.writeFileSync(tmpEntry, entryContent, 'utf-8');
+    const outFile = path.join(outDir, VITEK_API_BUNDLE_FILENAME);
+    const esbuild = (await import('esbuild').catch(() => null));
+    if (!esbuild) {
+        return null;
+    }
+    try {
+        await esbuild.build({
+            entryPoints: [tmpEntry],
+            bundle: true,
+            format: 'esm',
+            platform: 'node',
+            outfile: outFile,
+            external: ['vitek-plugin'],
+        });
+        return outFile;
+    }
+    finally {
+        try {
+            fs.unlinkSync(tmpEntry);
+            if (fs.readdirSync(tmpDir).length === 0) {
+                fs.rmdirSync(tmpDir);
+            }
+        }
+        catch {
+        }
+    }
+}
+export function getApiBundleFilename() {
+    return VITEK_API_BUNDLE_FILENAME;
+}

package/dist/cli/serve.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Production server (vitek-serve): serves static assets and the API from dist/
+ * Usage: vitek-serve [--dir=dist] [--port=3000] [--host=0.0.0.0]
+ *        Also accepts space-separated: --dir dist --port 3000 --host 0.0.0.0
+ */
+export {};
+//# sourceMappingURL=serve.d.ts.map

package/dist/cli/serve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.d.ts","sourceRoot":"","sources":["../../src/cli/serve.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/cli/serve.js

@@ -0,0 +1,84 @@
+/**
+ * Production server (vitek-serve): serves static assets and the API from dist/
+ * Usage: vitek-serve [--dir=dist] [--port=3000] [--host=0.0.0.0]
+ *        Also accepts space-separated: --dir dist --port 3000 --host 0.0.0.0
+ */
+import * as http from 'http';
+import * as path from 'path';
+import * as fs from 'fs';
+import { pathToFileURL } from 'url';
+import connect from 'connect';
+import serveStatic from 'serve-static';
+import { createRequestHandler } from '../core/server/request-handler.js';
+import { API_BASE_PATH } from '../shared/constants.js';
+import { getApiBundleFilename } from '../build/build-api-bundle.js';
+function parseArgs() {
+    let dir = 'dist';
+    let port = 3000;
+    let host = '0.0.0.0';
+    const argv = process.argv.slice(2);
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith('--dir='))
+            dir = arg.slice(6);
+        else if (arg === '--dir' && argv[i + 1])
+            dir = argv[++i];
+        else if (arg.startsWith('--port='))
+            port = parseInt(arg.slice(7), 10);
+        else if (arg === '--port' && argv[i + 1])
+            port = parseInt(argv[++i], 10);
+        else if (arg.startsWith('--host='))
+            host = arg.slice(7);
+        else if (arg === '--host' && argv[i + 1])
+            host = argv[++i];
+    }
+    return { dir, port, host };
+}
+async function main() {
+    const { dir, port, host } = parseArgs();
+    const distDir = path.resolve(process.cwd(), dir);
+    if (!fs.existsSync(distDir) || !fs.statSync(distDir).isDirectory()) {
+        console.error(`[vitek-serve] Directory not found or not a directory: ${distDir}`);
+        process.exit(1);
+    }
+    const app = connect();
+    const bundlePath = path.join(distDir, getApiBundleFilename());
+    if (fs.existsSync(bundlePath)) {
+        try {
+            const bundleUrl = pathToFileURL(bundlePath).href;
+            const mod = await import(bundleUrl);
+            const apiHandler = createRequestHandler({
+                routes: mod.routes,
+                middlewares: mod.middlewares,
+            });
+            app.use(apiHandler);
+        }
+        catch (err) {
+            console.warn('[vitek-serve] Failed to load API bundle; serving static files only:', err instanceof Error ? err.message : String(err));
+        }
+    }
+    else {
+        console.log('[vitek-serve] No API bundle found; serving static files only.');
+    }
+    app.use(serveStatic(distDir, { fallthrough: true }));
+    app.use((req, res, next) => {
+        if (req.method !== 'GET' && req.method !== 'HEAD')
+            return next();
+        if (req.url?.startsWith(API_BASE_PATH))
+            return next();
+        const indexHtml = path.join(distDir, 'index.html');
+        if (!fs.existsSync(indexHtml))
+            return next();
+        res.setHeader('Content-Type', 'text/html');
+        fs.createReadStream(indexHtml).pipe(res);
+    });
+    const server = http.createServer(app);
+    server.listen(port, host, () => {
+        const base = `http://${host === '0.0.0.0' ? 'localhost' : host}:${port}`;
+        console.log(`[vitek-serve] Ready at ${base}`);
+    });
+}
+main().catch((err) => {
+    console.error('[vitek-serve]', err);
+    process.exit(1);
+});

package/dist/core/normalize/normalize-path.d.ts

@@ -9,6 +9,7 @@
  * - users/[id].get.ts -> users/:id
  * - posts/[...ids].get.ts -> posts/*ids
  * - health.get.ts -> health
+ * - execute/index.post.ts -> execute (index treated as directory index)
  */
 export declare function normalizeRoutePath(filePath: string): string;
 /**

package/dist/core/normalize/normalize-path.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalize-path.d.ts","sourceRoot":"","sources":["../../../src/core/normalize/normalize-path.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CA2B3D;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAUlE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA0BtD"}
+{"version":3,"file":"normalize-path.d.ts","sourceRoot":"","sources":["../../../src/core/normalize/normalize-path.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAKH;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAiC3D;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAUlE;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CA0BtD"}

package/dist/core/normalize/normalize-path.js

@@ -10,6 +10,7 @@ import { PARAM_PATTERN } from '../../shared/constants.js';
  * - users/[id].get.ts -> users/:id
  * - posts/[...ids].get.ts -> posts/*ids
  * - health.get.ts -> health
+ * - execute/index.post.ts -> execute (index treated as directory index)
  */
 export function normalizeRoutePath(filePath) {
     // Remove extensions (.ts, .js) and HTTP method
@@ -31,7 +32,12 @@ export function normalizeRoutePath(filePath) {
         }
         return `:${paramName}`;
     });
-    // Return without normalizing (without adding /), as it will be used in patternToRegex
+    if (path === 'index') {
+        return '';
+    }
+    if (path.endsWith('/index')) {
+        path = path.slice(0, -6);
+    }
     return path;
 }
 /**

package/dist/core/server/request-handler.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Shared request handler for API routes
+ * Used by both dev server and preview/production server
+ */
+import type { IncomingMessage, ServerResponse } from 'http';
+import type { Connect } from 'vite';
+import type { Route } from '../routing/route-types.js';
+import type { LoadedMiddleware } from '../middleware/get-applicable-middlewares.js';
+export interface RequestHandlerOptions {
+    routes: Route[];
+    middlewares: LoadedMiddleware[];
+    logger?: {
+        routeMatched?(pattern: string, method: string): void;
+        request?(method: string, path: string, statusCode: number, duration?: number): void;
+        warn?(message: string, data?: Record<string, unknown>): void;
+        error?(message: string, data?: Record<string, unknown>): void;
+    };
+}
+/**
+ * Creates a Connect-style middleware that handles /api/* requests using the given routes and middlewares.
+ */
+export declare function createRequestHandler(options: RequestHandlerOptions): (req: IncomingMessage, res: ServerResponse, next: Connect.NextFunction) => Promise<void>;
+//# sourceMappingURL=request-handler.d.ts.map

package/dist/core/server/request-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-handler.d.ts","sourceRoot":"","sources":["../../../src/core/server/request-handler.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,MAAM,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAOpC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,2BAA2B,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6CAA6C,CAAC;AAEpF,MAAM,WAAW,qBAAqB;IACpC,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,MAAM,CAAC,EAAE;QACP,YAAY,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACrD,OAAO,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;QACpF,IAAI,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;QAC7D,KAAK,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;KAC/D,CAAC;CACH;AAID;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CA+I7J"}