@voltx/server 0.3.0

package/README.md

@@ -0,0 +1,92 @@
+<p align="center">
+  <strong>@voltx/server</strong><br/>
+  <em>Hono-based HTTP server with file-based routing and SSE streaming</em>
+</p>
+
+<p align="center">
+  <a href="https://www.npmjs.com/package/@voltx/server"><img src="https://img.shields.io/npm/v/@voltx/server?color=blue" alt="npm" /></a>
+  <a href="https://www.npmjs.com/package/@voltx/server"><img src="https://img.shields.io/npm/dm/@voltx/server" alt="downloads" /></a>
+  <a href="https://github.com/codewithshail/voltx/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@voltx/server" alt="license" /></a>
+</p>
+
+---
+
+The HTTP layer of the [VoltX](https://github.com/codewithshail/voltx) framework. Built on [Hono](https://hono.dev) with file-based routing (Next.js-style), CORS, logging, error handling, and static file serving out of the box.
+
+## Installation
+
+```bash
+npm install @voltx/server
+```
+
+## Quick Start
+
+```ts
+import { createServer } from "@voltx/server";
+
+const server = createServer({
+  port: 3000,
+  routesDir: "src/routes",
+  cors: true,
+  logger: true,
+});
+
+await server.start();
+// ⚡ VoltX server running at http://localhost:3000
+```
+
+## File-Based Routing
+
+Drop files in `src/routes/` and they become API endpoints automatically:
+
+```
+src/routes/index.ts           → GET /
+src/routes/api/chat.ts        → POST /api/chat
+src/routes/api/users/[id].ts  → GET /api/users/:id
+src/routes/api/[...slug].ts   → /api/* (catch-all)
+```
+
+Each file exports HTTP method handlers:
+
+```ts
+// src/routes/api/chat.ts
+import type { Context } from "@voltx/server";
+
+export async function POST(c: Context) {
+  const body = await c.req.json();
+  return c.json({ message: "Hello!" });
+}
+
+export function GET(c: Context) {
+  return c.json({ status: "ok" });
+}
+```
+
+## Features
+
+- **File-based routing** — Next.js-style, zero config
+- **Dynamic routes** — `[param]` → `:param`, `[...slug]` → catch-all
+- **Built-in middleware** — CORS, request logging, error handling
+- **Static file serving** — Serves from `public/` directory
+- **Per-route middleware** — Export `middleware` from any route file
+- **Graceful shutdown** — Clean server stop with `server.stop()`
+- **Full Hono access** — `server.app` gives you the raw Hono instance
+
+## Configuration
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `port` | `number` | `3000` | Server port |
+| `hostname` | `string` | `"0.0.0.0"` | Bind address |
+| `routesDir` | `string` | `"src/routes"` | Routes directory |
+| `staticDir` | `string` | `"public"` | Static files directory |
+| `cors` | `boolean \| object` | `true` | CORS configuration |
+| `logger` | `boolean` | `true` (dev) | Request logging |
+
+## Part of VoltX
+
+This package is part of the [VoltX](https://github.com/codewithshail/voltx) framework. See the [monorepo](https://github.com/codewithshail/voltx) for full documentation.
+
+## License
+
+[MIT](https://github.com/codewithshail/voltx/blob/main/LICENSE) — Made by the [Promptly AI Team](https://buymeacoffee.com/promptlyai)

package/dist/index.cjs

@@ -0,0 +1,286 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Hono: () => import_hono2.Hono,
+  VERSION: () => VERSION,
+  createCorsMiddleware: () => createCorsMiddleware,
+  createErrorHandler: () => createErrorHandler,
+  createLoggerMiddleware: () => createLoggerMiddleware,
+  createServer: () => createServer,
+  filePathToUrlPath: () => filePathToUrlPath,
+  registerStaticFiles: () => registerStaticFiles,
+  scanAndRegisterRoutes: () => scanAndRegisterRoutes
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/server.ts
+var import_hono = require("hono");
+var import_node_server = require("@hono/node-server");
+var import_node_path2 = require("path");
+
+// src/middleware/cors.ts
+var import_cors = require("hono/cors");
+function createCorsMiddleware(config) {
+  if (config === false) return null;
+  const opts = typeof config === "object" ? config : {};
+  return (0, import_cors.cors)({
+    origin: opts.origin ?? "*",
+    allowMethods: opts.allowMethods ?? ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
+    allowHeaders: opts.allowHeaders ?? ["Content-Type", "Authorization"],
+    exposeHeaders: opts.exposeHeaders ?? [],
+    maxAge: opts.maxAge ?? 600,
+    credentials: opts.credentials ?? false
+  });
+}
+
+// src/middleware/logger.ts
+var import_logger = require("hono/logger");
+function createLoggerMiddleware() {
+  return (0, import_logger.logger)((message, ...rest) => {
+    console.log(`[voltx] ${message}`, ...rest);
+  });
+}
+
+// src/middleware/error-handler.ts
+function createErrorHandler(customHandler) {
+  return async (err, c) => {
+    if (customHandler) {
+      try {
+        return await customHandler(err, c);
+      } catch {
+      }
+    }
+    const status = extractStatus(err);
+    const isDev = process.env.NODE_ENV !== "production";
+    console.error(`[voltx] Error ${status}:`, err.message);
+    if (isDev && err.stack) {
+      console.error(err.stack);
+    }
+    return c.json(
+      {
+        error: {
+          message: isDev ? err.message : "Internal Server Error",
+          status,
+          ...isDev && err.stack ? { stack: err.stack } : {}
+        }
+      },
+      status
+    );
+  };
+}
+function extractStatus(err) {
+  if (err && typeof err === "object") {
+    if ("status" in err && typeof err.status === "number") {
+      return err.status;
+    }
+    if ("statusCode" in err && typeof err.statusCode === "number") {
+      return err.statusCode;
+    }
+  }
+  return 500;
+}
+
+// src/router.ts
+var import_promises = require("fs/promises");
+var import_node_path = require("path");
+var import_node_url = require("url");
+var HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+var ROUTE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".mjs", ".mts"]);
+async function scanAndRegisterRoutes(app, routesDir) {
+  const entries = [];
+  const files = await collectRouteFiles(routesDir);
+  files.sort((a, b) => {
+    const pathA = filePathToUrlPath(a, routesDir);
+    const pathB = filePathToUrlPath(b, routesDir);
+    const scoreA = pathA.includes("*") ? 2 : pathA.includes(":") ? 1 : 0;
+    const scoreB = pathB.includes("*") ? 2 : pathB.includes(":") ? 1 : 0;
+    if (scoreA !== scoreB) return scoreA - scoreB;
+    return pathA.localeCompare(pathB);
+  });
+  for (const filePath of files) {
+    const urlPath = filePathToUrlPath(filePath, routesDir);
+    const routeModule = await importRouteModule(filePath);
+    if (!routeModule) continue;
+    if (routeModule.middleware) {
+      const middlewares = Array.isArray(routeModule.middleware) ? routeModule.middleware : [routeModule.middleware];
+      for (const mw of middlewares) {
+        app.use(urlPath, mw);
+      }
+    }
+    for (const method of HTTP_METHODS) {
+      const handler = routeModule[method];
+      if (typeof handler !== "function") continue;
+      app.on(method, urlPath, handler);
+      entries.push({ method, path: urlPath, handler, filePath });
+    }
+  }
+  return entries;
+}
+async function collectRouteFiles(dir) {
+  const files = [];
+  let dirEntries;
+  try {
+    dirEntries = await (0, import_promises.readdir)(dir);
+  } catch {
+    return files;
+  }
+  for (const name of dirEntries) {
+    const fullPath = (0, import_node_path.join)(dir, name);
+    const info = await (0, import_promises.stat)(fullPath);
+    if (info.isDirectory()) {
+      const nested = await collectRouteFiles(fullPath);
+      files.push(...nested);
+    } else if (info.isFile() && ROUTE_EXTENSIONS.has((0, import_node_path.extname)(name))) {
+      if (name.startsWith("_") || name.startsWith(".")) continue;
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function filePathToUrlPath(filePath, routesDir) {
+  let rel = (0, import_node_path.relative)(routesDir, filePath);
+  const ext = (0, import_node_path.extname)(rel);
+  rel = rel.slice(0, -ext.length);
+  rel = rel.replace(/\\/g, "/");
+  if (rel === "index") return "/";
+  if (rel.endsWith("/index")) {
+    rel = rel.slice(0, -"/index".length);
+  }
+  rel = rel.replace(/\[([^\]\.]+)\]/g, ":$1");
+  rel = rel.replace(/\[\.\.\.([^\]]+)\]/g, "*");
+  return "/" + rel;
+}
+async function importRouteModule(filePath) {
+  try {
+    const mod = await import((0, import_node_url.pathToFileURL)(filePath).href);
+    return mod;
+  } catch (err) {
+    console.error(`[voltx] Failed to import route: ${filePath}`, err);
+    return null;
+  }
+}
+
+// src/static.ts
+var import_serve_static = require("@hono/node-server/serve-static");
+function registerStaticFiles(app, staticDir = "public") {
+  app.use("/*", (0, import_serve_static.serveStatic)({ root: `./${staticDir}` }));
+}
+
+// src/server.ts
+function createServer(config = {}) {
+  const {
+    port = Number(process.env.PORT) || 3e3,
+    hostname = "0.0.0.0",
+    routesDir = "src/routes",
+    staticDir = "public",
+    cors = true,
+    logger: enableLogger = process.env.NODE_ENV !== "production",
+    onError,
+    onStart
+  } = config;
+  const app = new import_hono.Hono();
+  const registeredRoutes = [];
+  let httpServer = null;
+  if (enableLogger) {
+    app.use("*", createLoggerMiddleware());
+  }
+  const corsMiddleware = createCorsMiddleware(cors);
+  if (corsMiddleware) {
+    app.use("*", corsMiddleware);
+  }
+  app.onError(createErrorHandler(onError));
+  app.notFound((c) => {
+    return c.json(
+      { error: { message: "Not Found", status: 404 } },
+      404
+    );
+  });
+  const server = {
+    app,
+    async start() {
+      const absRoutesDir = (0, import_node_path2.resolve)(process.cwd(), routesDir);
+      const routes = await scanAndRegisterRoutes(app, absRoutesDir);
+      registeredRoutes.push(...routes);
+      registerStaticFiles(app, staticDir);
+      const info = {
+        port,
+        hostname,
+        url: `http://${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}`
+      };
+      httpServer = (0, import_node_server.serve)({
+        fetch: app.fetch,
+        port,
+        hostname
+      });
+      console.log(`
+  \u26A1 VoltX server running at ${info.url}
+`);
+      if (registeredRoutes.length > 0) {
+        console.log(`  Routes (${registeredRoutes.length}):`);
+        for (const route of registeredRoutes) {
+          console.log(`    ${route.method.padEnd(7)} ${route.path}`);
+        }
+        console.log();
+      }
+      onStart?.(info);
+      return info;
+    },
+    async stop() {
+      if (httpServer) {
+        await new Promise((resolve2, reject) => {
+          httpServer.close((err) => {
+            if (err) reject(err);
+            else resolve2();
+          });
+        });
+        httpServer = null;
+        console.log("\n  \u26A1 VoltX server stopped.\n");
+      }
+    },
+    async registerRoutes(dir) {
+      const absDir = (0, import_node_path2.resolve)(process.cwd(), dir);
+      const routes = await scanAndRegisterRoutes(app, absDir);
+      registeredRoutes.push(...routes);
+      return routes;
+    },
+    routes() {
+      return [...registeredRoutes];
+    }
+  };
+  return server;
+}
+
+// src/index.ts
+var import_hono2 = require("hono");
+var VERSION = "0.3.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Hono,
+  VERSION,
+  createCorsMiddleware,
+  createErrorHandler,
+  createLoggerMiddleware,
+  createServer,
+  filePathToUrlPath,
+  registerStaticFiles,
+  scanAndRegisterRoutes
+});

package/dist/index.d.cts

@@ -0,0 +1,150 @@
+import * as hono from 'hono';
+import { Context, Hono } from 'hono';
+export { Context, Hono } from 'hono';
+
+interface ServerConfig {
+    /** Port to listen on (default: 3000) */
+    port?: number;
+    /** Hostname to bind to (default: "0.0.0.0") */
+    hostname?: string;
+    /** Directory to scan for file-based routes (default: "src/routes") */
+    routesDir?: string;
+    /** Directory for static files (default: "public") */
+    staticDir?: string;
+    /** Enable CORS (default: true in dev) */
+    cors?: boolean | CorsConfig;
+    /** Enable request logging (default: true in dev) */
+    logger?: boolean;
+    /** Custom error handler */
+    onError?: (err: Error, c: Context) => Response | Promise<Response>;
+    /** Called when server starts */
+    onStart?: (info: ServerInfo) => void;
+}
+interface CorsConfig {
+    /** Allowed origins (default: "*") */
+    origin?: string | string[];
+    /** Allowed HTTP methods */
+    allowMethods?: string[];
+    /** Allowed headers */
+    allowHeaders?: string[];
+    /** Exposed headers */
+    exposeHeaders?: string[];
+    /** Max age for preflight cache (seconds) */
+    maxAge?: number;
+    /** Allow credentials */
+    credentials?: boolean;
+}
+interface ServerInfo {
+    port: number;
+    hostname: string;
+    url: string;
+}
+/** HTTP methods that route files can export */
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+/** A route handler function — receives Hono Context, returns Response */
+type RouteHandler = (c: Context) => Response | Promise<Response>;
+/** What a route file can export */
+interface RouteModule {
+    GET?: RouteHandler;
+    POST?: RouteHandler;
+    PUT?: RouteHandler;
+    DELETE?: RouteHandler;
+    PATCH?: RouteHandler;
+    HEAD?: RouteHandler;
+    OPTIONS?: RouteHandler;
+    /** Middleware that runs before all handlers in this route */
+    middleware?: MiddlewareHandler | MiddlewareHandler[];
+}
+/** Middleware handler (Hono-style) */
+type MiddlewareHandler = (c: Context, next: () => Promise<void>) => Promise<void | Response>;
+/** A registered route entry */
+interface RouteEntry {
+    /** HTTP method */
+    method: HttpMethod;
+    /** URL path pattern (e.g., "/api/users/:id") */
+    path: string;
+    /** Handler function */
+    handler: RouteHandler;
+    /** Source file path (for debugging) */
+    filePath: string;
+}
+interface VoltxServer {
+    /** The underlying Hono app instance */
+    app: Hono;
+    /** Start listening for requests */
+    start(): Promise<ServerInfo>;
+    /** Stop the server */
+    stop(): Promise<void>;
+    /** Register routes from a directory (file-based routing) */
+    registerRoutes(routesDir: string): Promise<RouteEntry[]>;
+    /** Get all registered routes */
+    routes(): RouteEntry[];
+}
+
+/**
+ * Create a VoltX server instance.
+ *
+ * @example
+ * ```ts
+ * import { createServer } from "@voltx/server";
+ *
+ * const server = createServer({
+ *   port: 3000,
+ *   routesDir: "src/routes",
+ *   cors: true,
+ *   logger: true,
+ * });
+ *
+ * await server.start();
+ * ```
+ */
+declare function createServer(config?: ServerConfig): VoltxServer;
+
+/**
+ * Scan a directory for route files and register them on a Hono app.
+ *
+ * @param app - Hono app instance
+ * @param routesDir - Absolute path to the routes directory
+ * @returns Array of registered route entries
+ */
+declare function scanAndRegisterRoutes(app: Hono, routesDir: string): Promise<RouteEntry[]>;
+/**
+ * Convert a file path to a URL path.
+ *
+ * Examples:
+ *   routes/index.ts           → /
+ *   routes/api/chat.ts        → /api/chat
+ *   routes/api/users/[id].ts  → /api/users/:id
+ *   routes/api/[...slug].ts   → /api/*
+ */
+declare function filePathToUrlPath(filePath: string, routesDir: string): string;
+
+/**
+ * Register static file serving on a Hono app.
+ *
+ * @param app - Hono app instance
+ * @param staticDir - Relative path to the static files directory (default: "public")
+ */
+declare function registerStaticFiles(app: Hono, staticDir?: string): void;
+
+/**
+ * Create CORS middleware from VoltX config.
+ * Wraps Hono's built-in CORS middleware with sensible defaults.
+ */
+declare function createCorsMiddleware(config?: boolean | CorsConfig): hono.MiddlewareHandler | null;
+
+/**
+ * Create request logger middleware.
+ * Wraps Hono's built-in logger with VoltX prefix.
+ */
+declare function createLoggerMiddleware(): hono.MiddlewareHandler;
+
+/**
+ * Default error handler for VoltX server.
+ * Returns JSON error responses with appropriate status codes.
+ */
+declare function createErrorHandler(customHandler?: (err: Error, c: Context) => Response | Promise<Response>): (err: Error, c: Context) => Promise<Response>;
+
+declare const VERSION = "0.3.0";
+
+export { type CorsConfig, type HttpMethod, type MiddlewareHandler, type RouteEntry, type RouteHandler, type RouteModule, type ServerConfig, type ServerInfo, VERSION, type VoltxServer, createCorsMiddleware, createErrorHandler, createLoggerMiddleware, createServer, filePathToUrlPath, registerStaticFiles, scanAndRegisterRoutes };

package/dist/index.d.ts

@@ -0,0 +1,150 @@
+import * as hono from 'hono';
+import { Context, Hono } from 'hono';
+export { Context, Hono } from 'hono';
+
+interface ServerConfig {
+    /** Port to listen on (default: 3000) */
+    port?: number;
+    /** Hostname to bind to (default: "0.0.0.0") */
+    hostname?: string;
+    /** Directory to scan for file-based routes (default: "src/routes") */
+    routesDir?: string;
+    /** Directory for static files (default: "public") */
+    staticDir?: string;
+    /** Enable CORS (default: true in dev) */
+    cors?: boolean | CorsConfig;
+    /** Enable request logging (default: true in dev) */
+    logger?: boolean;
+    /** Custom error handler */
+    onError?: (err: Error, c: Context) => Response | Promise<Response>;
+    /** Called when server starts */
+    onStart?: (info: ServerInfo) => void;
+}
+interface CorsConfig {
+    /** Allowed origins (default: "*") */
+    origin?: string | string[];
+    /** Allowed HTTP methods */
+    allowMethods?: string[];
+    /** Allowed headers */
+    allowHeaders?: string[];
+    /** Exposed headers */
+    exposeHeaders?: string[];
+    /** Max age for preflight cache (seconds) */
+    maxAge?: number;
+    /** Allow credentials */
+    credentials?: boolean;
+}
+interface ServerInfo {
+    port: number;
+    hostname: string;
+    url: string;
+}
+/** HTTP methods that route files can export */
+type HttpMethod = "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS";
+/** A route handler function — receives Hono Context, returns Response */
+type RouteHandler = (c: Context) => Response | Promise<Response>;
+/** What a route file can export */
+interface RouteModule {
+    GET?: RouteHandler;
+    POST?: RouteHandler;
+    PUT?: RouteHandler;
+    DELETE?: RouteHandler;
+    PATCH?: RouteHandler;
+    HEAD?: RouteHandler;
+    OPTIONS?: RouteHandler;
+    /** Middleware that runs before all handlers in this route */
+    middleware?: MiddlewareHandler | MiddlewareHandler[];
+}
+/** Middleware handler (Hono-style) */
+type MiddlewareHandler = (c: Context, next: () => Promise<void>) => Promise<void | Response>;
+/** A registered route entry */
+interface RouteEntry {
+    /** HTTP method */
+    method: HttpMethod;
+    /** URL path pattern (e.g., "/api/users/:id") */
+    path: string;
+    /** Handler function */
+    handler: RouteHandler;
+    /** Source file path (for debugging) */
+    filePath: string;
+}
+interface VoltxServer {
+    /** The underlying Hono app instance */
+    app: Hono;
+    /** Start listening for requests */
+    start(): Promise<ServerInfo>;
+    /** Stop the server */
+    stop(): Promise<void>;
+    /** Register routes from a directory (file-based routing) */
+    registerRoutes(routesDir: string): Promise<RouteEntry[]>;
+    /** Get all registered routes */
+    routes(): RouteEntry[];
+}
+
+/**
+ * Create a VoltX server instance.
+ *
+ * @example
+ * ```ts
+ * import { createServer } from "@voltx/server";
+ *
+ * const server = createServer({
+ *   port: 3000,
+ *   routesDir: "src/routes",
+ *   cors: true,
+ *   logger: true,
+ * });
+ *
+ * await server.start();
+ * ```
+ */
+declare function createServer(config?: ServerConfig): VoltxServer;
+
+/**
+ * Scan a directory for route files and register them on a Hono app.
+ *
+ * @param app - Hono app instance
+ * @param routesDir - Absolute path to the routes directory
+ * @returns Array of registered route entries
+ */
+declare function scanAndRegisterRoutes(app: Hono, routesDir: string): Promise<RouteEntry[]>;
+/**
+ * Convert a file path to a URL path.
+ *
+ * Examples:
+ *   routes/index.ts           → /
+ *   routes/api/chat.ts        → /api/chat
+ *   routes/api/users/[id].ts  → /api/users/:id
+ *   routes/api/[...slug].ts   → /api/*
+ */
+declare function filePathToUrlPath(filePath: string, routesDir: string): string;
+
+/**
+ * Register static file serving on a Hono app.
+ *
+ * @param app - Hono app instance
+ * @param staticDir - Relative path to the static files directory (default: "public")
+ */
+declare function registerStaticFiles(app: Hono, staticDir?: string): void;
+
+/**
+ * Create CORS middleware from VoltX config.
+ * Wraps Hono's built-in CORS middleware with sensible defaults.
+ */
+declare function createCorsMiddleware(config?: boolean | CorsConfig): hono.MiddlewareHandler | null;
+
+/**
+ * Create request logger middleware.
+ * Wraps Hono's built-in logger with VoltX prefix.
+ */
+declare function createLoggerMiddleware(): hono.MiddlewareHandler;
+
+/**
+ * Default error handler for VoltX server.
+ * Returns JSON error responses with appropriate status codes.
+ */
+declare function createErrorHandler(customHandler?: (err: Error, c: Context) => Response | Promise<Response>): (err: Error, c: Context) => Promise<Response>;
+
+declare const VERSION = "0.3.0";
+
+export { type CorsConfig, type HttpMethod, type MiddlewareHandler, type RouteEntry, type RouteHandler, type RouteModule, type ServerConfig, type ServerInfo, VERSION, type VoltxServer, createCorsMiddleware, createErrorHandler, createLoggerMiddleware, createServer, filePathToUrlPath, registerStaticFiles, scanAndRegisterRoutes };

package/dist/index.js

@@ -0,0 +1,251 @@
+// src/server.ts
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import { resolve } from "path";
+
+// src/middleware/cors.ts
+import { cors as honoCors } from "hono/cors";
+function createCorsMiddleware(config) {
+  if (config === false) return null;
+  const opts = typeof config === "object" ? config : {};
+  return honoCors({
+    origin: opts.origin ?? "*",
+    allowMethods: opts.allowMethods ?? ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
+    allowHeaders: opts.allowHeaders ?? ["Content-Type", "Authorization"],
+    exposeHeaders: opts.exposeHeaders ?? [],
+    maxAge: opts.maxAge ?? 600,
+    credentials: opts.credentials ?? false
+  });
+}
+
+// src/middleware/logger.ts
+import { logger as honoLogger } from "hono/logger";
+function createLoggerMiddleware() {
+  return honoLogger((message, ...rest) => {
+    console.log(`[voltx] ${message}`, ...rest);
+  });
+}
+
+// src/middleware/error-handler.ts
+function createErrorHandler(customHandler) {
+  return async (err, c) => {
+    if (customHandler) {
+      try {
+        return await customHandler(err, c);
+      } catch {
+      }
+    }
+    const status = extractStatus(err);
+    const isDev = process.env.NODE_ENV !== "production";
+    console.error(`[voltx] Error ${status}:`, err.message);
+    if (isDev && err.stack) {
+      console.error(err.stack);
+    }
+    return c.json(
+      {
+        error: {
+          message: isDev ? err.message : "Internal Server Error",
+          status,
+          ...isDev && err.stack ? { stack: err.stack } : {}
+        }
+      },
+      status
+    );
+  };
+}
+function extractStatus(err) {
+  if (err && typeof err === "object") {
+    if ("status" in err && typeof err.status === "number") {
+      return err.status;
+    }
+    if ("statusCode" in err && typeof err.statusCode === "number") {
+      return err.statusCode;
+    }
+  }
+  return 500;
+}
+
+// src/router.ts
+import { readdir, stat } from "fs/promises";
+import { join, relative, extname } from "path";
+import { pathToFileURL } from "url";
+var HTTP_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"];
+var ROUTE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".js", ".mjs", ".mts"]);
+async function scanAndRegisterRoutes(app, routesDir) {
+  const entries = [];
+  const files = await collectRouteFiles(routesDir);
+  files.sort((a, b) => {
+    const pathA = filePathToUrlPath(a, routesDir);
+    const pathB = filePathToUrlPath(b, routesDir);
+    const scoreA = pathA.includes("*") ? 2 : pathA.includes(":") ? 1 : 0;
+    const scoreB = pathB.includes("*") ? 2 : pathB.includes(":") ? 1 : 0;
+    if (scoreA !== scoreB) return scoreA - scoreB;
+    return pathA.localeCompare(pathB);
+  });
+  for (const filePath of files) {
+    const urlPath = filePathToUrlPath(filePath, routesDir);
+    const routeModule = await importRouteModule(filePath);
+    if (!routeModule) continue;
+    if (routeModule.middleware) {
+      const middlewares = Array.isArray(routeModule.middleware) ? routeModule.middleware : [routeModule.middleware];
+      for (const mw of middlewares) {
+        app.use(urlPath, mw);
+      }
+    }
+    for (const method of HTTP_METHODS) {
+      const handler = routeModule[method];
+      if (typeof handler !== "function") continue;
+      app.on(method, urlPath, handler);
+      entries.push({ method, path: urlPath, handler, filePath });
+    }
+  }
+  return entries;
+}
+async function collectRouteFiles(dir) {
+  const files = [];
+  let dirEntries;
+  try {
+    dirEntries = await readdir(dir);
+  } catch {
+    return files;
+  }
+  for (const name of dirEntries) {
+    const fullPath = join(dir, name);
+    const info = await stat(fullPath);
+    if (info.isDirectory()) {
+      const nested = await collectRouteFiles(fullPath);
+      files.push(...nested);
+    } else if (info.isFile() && ROUTE_EXTENSIONS.has(extname(name))) {
+      if (name.startsWith("_") || name.startsWith(".")) continue;
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function filePathToUrlPath(filePath, routesDir) {
+  let rel = relative(routesDir, filePath);
+  const ext = extname(rel);
+  rel = rel.slice(0, -ext.length);
+  rel = rel.replace(/\\/g, "/");
+  if (rel === "index") return "/";
+  if (rel.endsWith("/index")) {
+    rel = rel.slice(0, -"/index".length);
+  }
+  rel = rel.replace(/\[([^\]\.]+)\]/g, ":$1");
+  rel = rel.replace(/\[\.\.\.([^\]]+)\]/g, "*");
+  return "/" + rel;
+}
+async function importRouteModule(filePath) {
+  try {
+    const mod = await import(pathToFileURL(filePath).href);
+    return mod;
+  } catch (err) {
+    console.error(`[voltx] Failed to import route: ${filePath}`, err);
+    return null;
+  }
+}
+
+// src/static.ts
+import { serveStatic } from "@hono/node-server/serve-static";
+function registerStaticFiles(app, staticDir = "public") {
+  app.use("/*", serveStatic({ root: `./${staticDir}` }));
+}
+
+// src/server.ts
+function createServer(config = {}) {
+  const {
+    port = Number(process.env.PORT) || 3e3,
+    hostname = "0.0.0.0",
+    routesDir = "src/routes",
+    staticDir = "public",
+    cors = true,
+    logger: enableLogger = process.env.NODE_ENV !== "production",
+    onError,
+    onStart
+  } = config;
+  const app = new Hono();
+  const registeredRoutes = [];
+  let httpServer = null;
+  if (enableLogger) {
+    app.use("*", createLoggerMiddleware());
+  }
+  const corsMiddleware = createCorsMiddleware(cors);
+  if (corsMiddleware) {
+    app.use("*", corsMiddleware);
+  }
+  app.onError(createErrorHandler(onError));
+  app.notFound((c) => {
+    return c.json(
+      { error: { message: "Not Found", status: 404 } },
+      404
+    );
+  });
+  const server = {
+    app,
+    async start() {
+      const absRoutesDir = resolve(process.cwd(), routesDir);
+      const routes = await scanAndRegisterRoutes(app, absRoutesDir);
+      registeredRoutes.push(...routes);
+      registerStaticFiles(app, staticDir);
+      const info = {
+        port,
+        hostname,
+        url: `http://${hostname === "0.0.0.0" ? "localhost" : hostname}:${port}`
+      };
+      httpServer = serve({
+        fetch: app.fetch,
+        port,
+        hostname
+      });
+      console.log(`
+  \u26A1 VoltX server running at ${info.url}
+`);
+      if (registeredRoutes.length > 0) {
+        console.log(`  Routes (${registeredRoutes.length}):`);
+        for (const route of registeredRoutes) {
+          console.log(`    ${route.method.padEnd(7)} ${route.path}`);
+        }
+        console.log();
+      }
+      onStart?.(info);
+      return info;
+    },
+    async stop() {
+      if (httpServer) {
+        await new Promise((resolve2, reject) => {
+          httpServer.close((err) => {
+            if (err) reject(err);
+            else resolve2();
+          });
+        });
+        httpServer = null;
+        console.log("\n  \u26A1 VoltX server stopped.\n");
+      }
+    },
+    async registerRoutes(dir) {
+      const absDir = resolve(process.cwd(), dir);
+      const routes = await scanAndRegisterRoutes(app, absDir);
+      registeredRoutes.push(...routes);
+      return routes;
+    },
+    routes() {
+      return [...registeredRoutes];
+    }
+  };
+  return server;
+}
+
+// src/index.ts
+import { Hono as Hono2 } from "hono";
+var VERSION = "0.3.0";
+export {
+  Hono2 as Hono,
+  VERSION,
+  createCorsMiddleware,
+  createErrorHandler,
+  createLoggerMiddleware,
+  createServer,
+  filePathToUrlPath,
+  registerStaticFiles,
+  scanAndRegisterRoutes
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@voltx/server",
+  "version": "0.3.0",
+  "description": "VoltX Server — Hono-based HTTP server with file-based routing, SSE streaming, and static file serving",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "hono": "^4.7.0",
+    "@hono/node-server": "^1.14.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.7.0"
+  },
+  "keywords": ["voltx", "server", "hono", "http", "routing", "file-based", "sse", "streaming", "middleware"],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/codewithshail/voltx.git",
+    "directory": "packages/server"
+  },
+  "homepage": "https://voltx.co.in",
+  "author": "Promptly AI Team"
+}