hono-route-docs 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gabriel Augusto
+
+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/README.md

@@ -0,0 +1,295 @@
+# hono-route-docs
+
+Fluent router API with automatic OpenAPI 3.1 schema generation for [Hono](https://hono.dev). **Zero dependencies** beyond Hono itself. UI-agnostic — use [Scalar](https://scalar.com), [Swagger UI](https://swagger.io/tools/swagger-ui/), or any OpenAPI viewer.
+
+## Features
+
+- **Pure Hono** — No dependency on `@hono/zod-openapi` or any validation library
+- **Fluent Router API** — Chainable `get`, `post`, `put`, `patch`, `delete` methods
+- **Auto-generated OpenAPI 3.1 spec** — Built-in registry generates the full spec as JSON
+- **UI-agnostic** — Use Scalar, Swagger UI, RapiDoc, or anything else
+- **Sub-router support** — Mount sub-routers with inherited tags, security, and doc options
+- **Auto path params** — `:id` is automatically added to the OpenAPI spec as `{id}`
+- **Schema-agnostic** — Pass raw JSON Schema, or convert from Zod/Valibot/TypeBox/etc.
+
+## Installation
+
+```bash
+npm install hono-route-docs
+# or
+bun add hono-route-docs
+# or
+pnpm add hono-route-docs
+```
+
+## Quick Start
+
+```ts
+import { Hono } from 'hono';
+import { createRouter } from 'hono-route-docs';
+
+const app = new Hono();
+const { router, get, route, doc } = createRouter();
+
+get('/health', { summary: 'Health Check' }, c => {
+  return c.json({ status: 'ok' });
+});
+
+app.route('/api', router);
+
+app.get(
+  '/openapi.json',
+  doc({
+    title: 'My API',
+    version: '1.0.0',
+    prefix: '/api',
+  }),
+);
+
+import { Scalar } from '@scalar/hono-api-reference';
+
+app.get('/docs', Scalar({ url: '/openapi.json' }));
+
+export default { port: 3000, fetch: app.fetch };
+```
+
+## API
+
+### `createRouter()`
+
+Creates a fluent router instance. Returns:
+
+| Property   | Description                                         |
+| ---------- | --------------------------------------------------- |
+| `router`   | The underlying `Hono` instance                      |
+| `route()`  | Mount a sub-router with optional doc options        |
+| `get()`    | Register a GET route                                |
+| `post()`   | Register a POST route                               |
+| `put()`    | Register a PUT route                                |
+| `patch()`  | Register a PATCH route                              |
+| `delete()` | Register a DELETE route                             |
+| `doc()`    | Returns a handler that serves the OpenAPI JSON spec |
+
+All HTTP methods accept:
+
+```ts
+method(path, handler);
+method(path, options, handler);
+```
+
+### `DocOptions`
+
+Uses raw OpenAPI field names — no dependency on any validation library:
+
+```ts
+type DocOptions = {
+  tags?: string[];
+  summary?: string;
+  description?: string;
+  deprecated?: boolean;
+  security?: Record<string, string[]>[];
+  parameters?: OpenAPIParameter[];
+  requestBody?: OpenAPIRequestBody;
+  responses?: Record<string, OpenAPIResponse>;
+};
+```
+
+### `openAPIDoc(router, config)`
+
+Standalone function to create a handler that serves the spec:
+
+```ts
+import { openAPIDoc } from 'hono-route-docs';
+
+app.get(
+  '/openapi.json',
+  openAPIDoc(router, {
+    title: 'My API',
+    version: '1.0.0',
+    prefix: '/api',
+    description: 'Optional description',
+    servers: [{ url: 'https://api.example.com' }],
+    components: {
+      securitySchemes: {
+        bearerAuth: { type: 'http', scheme: 'bearer' },
+      },
+    },
+  }),
+);
+```
+
+### `generateSpec(registry, config)`
+
+Low-level function to generate the spec object (useful for testing or custom endpoints):
+
+```ts
+import { generateSpec, getRegistry } from 'hono-route-docs';
+
+const spec = generateSpec(getRegistry(router)!, config);
+```
+
+## Sub-Routers
+
+```ts
+import { createRouter } from 'hono-route-docs';
+
+const { router, get, post } = createRouter();
+
+get('/', { summary: 'List users' }, c => c.json([]));
+
+post(
+  '/',
+  {
+    summary: 'Create user',
+    requestBody: {
+      required: true,
+      content: {
+        'application/json': {
+          schema: {
+            type: 'object',
+            properties: {
+              name: { type: 'string' },
+              email: { type: 'string', format: 'email' },
+            },
+            required: ['name', 'email'],
+          },
+        },
+      },
+    },
+    responses: { 201: { description: 'User created' } },
+  },
+  c => c.json({ id: 1 }, 201),
+);
+
+get('/:id', { summary: 'Get user' }, c => c.json({ id: c.req.param('id') }));
+
+export default router;
+```
+
+```ts
+import { createRouter } from 'hono-route-docs';
+import usersRouter from './users/routes';
+
+const { router, route } = createRouter();
+
+route('/users', usersRouter, { tags: ['Users'] });
+
+export default router;
+```
+
+## Using with Zod / Valibot / TypeBox
+
+The base entry point accepts raw JSON Schema. Use any converter you like:
+
+```ts
+import { z } from 'zod';
+
+const UserSchema = z.object({ name: z.string(), email: z.string().email() });
+
+post(
+  '/users',
+  {
+    requestBody: {
+      content: {
+        'application/json': { schema: z.toJSONSchema(UserSchema) },
+      },
+    },
+  },
+  handler,
+);
+```
+
+## Adapter: Zod (`/zod`)
+
+Uses `@hono/zod-openapi` under the hood. Accepts Zod schemas directly in `request` and `responses`.
+
+```bash
+npm install @hono/zod-openapi zod
+```
+
+```ts
+import { createRouter, openAPIDoc } from 'hono-route-docs/zod';
+import { z } from 'zod';
+
+const { router, get, post } = createRouter();
+
+get(
+  '/hello',
+  {
+    tags: ['Hello'],
+    summary: 'Say hello',
+    request: {
+      query: z.object({
+        name: z.string().optional(),
+        page: z.coerce.number().default(1),
+      }),
+    },
+    responses: {
+      200: { description: 'Greeting' },
+    },
+  },
+  c => c.json({ message: 'Hello!' }),
+);
+```
+
+## Adapter: Standard Schema (`/standard`)
+
+Uses [`hono-openapi`](https://github.com/rhinobase/hono-openapi) under the hood. Works with **any** [Standard Schema](https://standardschema.dev/)–compliant validation library: Zod, Valibot, ArkType, TypeBox, Effect, etc.
+
+```bash
+npm install hono-openapi @hono/standard-validator
+```
+
+```ts
+import { createRouter, openAPIDoc, resolver } from 'hono-route-docs/standard';
+import * as v from 'valibot'; // or zod, arktype, typebox, etc.
+
+const { router, get } = createRouter();
+
+get(
+  '/hello',
+  {
+    tags: ['Hello'],
+    summary: 'Say hello',
+    request: {
+      query: v.object({ name: v.optional(v.string()) }),
+    },
+    responses: {
+      200: {
+        description: 'Greeting',
+        content: {
+          'application/json': { schema: resolver(v.string()) },
+        },
+      },
+    },
+  },
+  c => {
+    const { name } = c.req.valid('query');
+    return c.text(`Hello ${name ?? 'World'}!`);
+  },
+);
+
+const app = new Hono();
+
+app.route('/api', router);
+app.get(
+  '/openapi.json',
+  openAPIDoc(router, {
+    title: 'My API',
+    version: '1.0.0',
+    prefix: '/api',
+  }),
+);
+```
+
+## Entry points summary
+
+| Entry point                | Install                                   | Schemas                                                      |
+| -------------------------- | ----------------------------------------- | ------------------------------------------------------------ |
+| `hono-route-docs`          | `hono`                                    | Raw JSON Schema                                              |
+| `hono-route-docs/zod`      | `+ @hono/zod-openapi zod`                 | Zod schemas                                                  |
+| `hono-route-docs/standard` | `+ hono-openapi @hono/standard-validator` | Any Standard Schema (Zod, Valibot, ArkType, TypeBox, Effect) |
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,170 @@
+'use strict';
+
+var hono = require('hono');
+
+// src/router.ts
+
+// src/registry.ts
+var REGISTRY = /* @__PURE__ */ Symbol.for("hono-openapi-registry");
+var RouteRegistry = class {
+  entries = [];
+  add(entry) {
+    this.entries.push(entry);
+  }
+  merge(prefix, other, opts) {
+    for (const entry of other.entries) {
+      const merged = {
+        ...entry,
+        path: prefix + (entry.path === "/" ? "" : entry.path)
+      };
+      if (opts) {
+        const hasOwnTags = entry.tags && entry.tags.length > 0;
+        if (opts.tags && !hasOwnTags) merged.tags = opts.tags;
+        if (opts.summary && !entry.summary) merged.summary = opts.summary;
+        if (opts.description && !entry.description) merged.description = opts.description;
+        if (opts.security && !entry.security) merged.security = opts.security;
+        if (opts.deprecated !== void 0 && entry.deprecated === void 0)
+          merged.deprecated = opts.deprecated;
+      }
+      this.entries.push(merged);
+    }
+  }
+};
+function getRegistry(router) {
+  return router?.[REGISTRY];
+}
+
+// src/spec.ts
+function honoPathToOpenAPI(path) {
+  return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, "{$1}");
+}
+function extractPathParams(path) {
+  const params = [];
+  const regex = /:([a-zA-Z_][a-zA-Z0-9_]*)/g;
+  let match;
+  while ((match = regex.exec(path)) !== null) {
+    params.push({
+      name: match[1],
+      in: "path",
+      required: true,
+      schema: { type: "string" }
+    });
+  }
+  return params;
+}
+function generateSpec(registry, config) {
+  const paths = {};
+  const prefix = config.prefix ?? "";
+  for (const entry of registry.entries) {
+    const rawPath = prefix + entry.path;
+    const fullPath = honoPathToOpenAPI(rawPath);
+    if (!paths[fullPath]) paths[fullPath] = {};
+    const operation = {};
+    if (entry.tags && entry.tags.length > 0) operation.tags = entry.tags;
+    if (entry.summary) operation.summary = entry.summary;
+    if (entry.description) operation.description = entry.description;
+    if (entry.deprecated) operation.deprecated = entry.deprecated;
+    if (entry.security) operation.security = entry.security;
+    if (entry.requestBody) operation.requestBody = entry.requestBody;
+    const autoParams = extractPathParams(rawPath);
+    const userParams = entry.parameters ?? [];
+    const autoParamNames = new Set(userParams.map((p) => p.name));
+    const mergedParams = [...userParams, ...autoParams.filter((p) => !autoParamNames.has(p.name))];
+    if (mergedParams.length > 0) operation.parameters = mergedParams;
+    operation.responses = entry.responses;
+    paths[fullPath][entry.method] = operation;
+  }
+  const spec = {
+    openapi: "3.1.0",
+    info: {
+      title: config.title,
+      version: config.version
+    },
+    paths
+  };
+  if (config.description) spec.info.description = config.description;
+  if (config.servers) spec.servers = config.servers;
+  if (config.components) spec.components = config.components;
+  if (config.security) spec.security = config.security;
+  return spec;
+}
+function openAPIDoc(router, config) {
+  const registry = getRegistry(router);
+  return (c) => {
+    if (!registry) {
+      return c.json({
+        openapi: "3.1.0",
+        info: { title: config.title, version: config.version },
+        paths: {}
+      });
+    }
+    return c.json(generateSpec(registry, config));
+  };
+}
+
+// src/router.ts
+function createRouter() {
+  const router = new hono.Hono();
+  const registry = new RouteRegistry();
+  router[REGISTRY] = registry;
+  function addRoute(method, path, handlerOrOpts, maybeHandler) {
+    const hasOptions = typeof handlerOrOpts !== "function";
+    const options = hasOptions ? handlerOrOpts : {};
+    const handler = hasOptions ? maybeHandler : handlerOrOpts;
+    router[method](path, handler);
+    registry.add({
+      method,
+      path,
+      tags: options.tags,
+      summary: options.summary,
+      description: options.description,
+      deprecated: options.deprecated,
+      security: options.security,
+      parameters: options.parameters,
+      requestBody: options.requestBody,
+      responses: options.responses ?? {
+        200: { description: "Successful response" }
+      }
+    });
+  }
+  const self = {
+    router,
+    route: (path, subRouter, opts) => {
+      const subRegistry = getRegistry(subRouter);
+      if (subRegistry) {
+        registry.merge(path, subRegistry, opts);
+      }
+      router.route(path, subRouter);
+      return self;
+    },
+    get: (path, handlerOrOpts, handler) => {
+      addRoute("get", path, handlerOrOpts, handler);
+      return self;
+    },
+    post: (path, handlerOrOpts, handler) => {
+      addRoute("post", path, handlerOrOpts, handler);
+      return self;
+    },
+    put: (path, handlerOrOpts, handler) => {
+      addRoute("put", path, handlerOrOpts, handler);
+      return self;
+    },
+    patch: (path, handlerOrOpts, handler) => {
+      addRoute("patch", path, handlerOrOpts, handler);
+      return self;
+    },
+    delete: (path, handlerOrOpts, handler) => {
+      addRoute("delete", path, handlerOrOpts, handler);
+      return self;
+    },
+    doc: (config) => openAPIDoc(router, config)
+  };
+  return self;
+}
+
+exports.createRouter = createRouter;
+exports.generateSpec = generateSpec;
+exports.getRegistry = getRegistry;
+exports.openAPIDoc = openAPIDoc;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/registry.ts","../src/spec.ts","../src/router.ts"],"names":["Hono"],"mappings":"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","file":"index.cjs","sourcesContent":["import type { DocOptions, HttpMethod } from './types';\n\nexport const REGISTRY = Symbol.for('hono-openapi-registry');\n\nexport interface RouteEntry {\n  method: HttpMethod;\n  path: string;\n  tags?: string[];\n  summary?: string;\n  description?: string;\n  deprecated?: boolean;\n  security?: Record<string, string[]>[];\n  parameters?: any[];\n  requestBody?: any;\n  responses?: Record<string, any>;\n}\n\nexport class RouteRegistry {\n  readonly entries: RouteEntry[] = [];\n\n  add(entry: RouteEntry): void {\n    this.entries.push(entry);\n  }\n\n  merge(prefix: string, other: RouteRegistry, opts?: DocOptions): void {\n    for (const entry of other.entries) {\n      const merged: RouteEntry = {\n        ...entry,\n        path: prefix + (entry.path === '/' ? '' : entry.path),\n      };\n\n      if (opts) {\n        const hasOwnTags = entry.tags && entry.tags.length > 0;\n\n        if (opts.tags && !hasOwnTags) merged.tags = opts.tags;\n        if (opts.summary && !entry.summary) merged.summary = opts.summary;\n        if (opts.description && !entry.description) merged.description = opts.description;\n        if (opts.security && !entry.security) merged.security = opts.security;\n        if (opts.deprecated !== undefined && entry.deprecated === undefined)\n          merged.deprecated = opts.deprecated;\n      }\n\n      this.entries.push(merged);\n    }\n  }\n}\n\nexport function getRegistry(router: any): RouteRegistry | undefined {\n  return router?.[REGISTRY];\n}\n","import { RouteRegistry, getRegistry } from './registry';\n\nexport interface SpecConfig {\n  title: string;\n  version: string;\n  description?: string;\n  prefix?: string;\n  servers?: { url: string; description?: string }[];\n  components?: Record<string, any>;\n  security?: Record<string, string[]>[];\n}\n\nfunction honoPathToOpenAPI(path: string): string {\n  return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');\n}\n\nfunction extractPathParams(path: string): any[] {\n  const params: any[] = [];\n  const regex = /:([a-zA-Z_][a-zA-Z0-9_]*)/g;\n  let match: RegExpExecArray | null;\n  while ((match = regex.exec(path)) !== null) {\n    params.push({\n      name: match[1],\n      in: 'path',\n      required: true,\n      schema: { type: 'string' },\n    });\n  }\n  return params;\n}\n\nexport function generateSpec(registry: RouteRegistry, config: SpecConfig): Record<string, any> {\n  const paths: Record<string, any> = {};\n  const prefix = config.prefix ?? '';\n\n  for (const entry of registry.entries) {\n    const rawPath = prefix + entry.path;\n    const fullPath = honoPathToOpenAPI(rawPath);\n\n    if (!paths[fullPath]) paths[fullPath] = {};\n\n    const operation: Record<string, any> = {};\n\n    if (entry.tags && entry.tags.length > 0) operation.tags = entry.tags;\n    if (entry.summary) operation.summary = entry.summary;\n    if (entry.description) operation.description = entry.description;\n    if (entry.deprecated) operation.deprecated = entry.deprecated;\n    if (entry.security) operation.security = entry.security;\n    if (entry.requestBody) operation.requestBody = entry.requestBody;\n\n    const autoParams = extractPathParams(rawPath);\n    const userParams = entry.parameters ?? [];\n    const autoParamNames = new Set(userParams.map((p: any) => p.name));\n    const mergedParams = [...userParams, ...autoParams.filter(p => !autoParamNames.has(p.name))];\n    if (mergedParams.length > 0) operation.parameters = mergedParams;\n\n    operation.responses = entry.responses;\n\n    paths[fullPath][entry.method] = operation;\n  }\n\n  const spec: Record<string, any> = {\n    openapi: '3.1.0',\n    info: {\n      title: config.title,\n      version: config.version,\n    },\n    paths,\n  };\n\n  if (config.description) spec.info.description = config.description;\n  if (config.servers) spec.servers = config.servers;\n  if (config.components) spec.components = config.components;\n  if (config.security) spec.security = config.security;\n\n  return spec;\n}\n\nexport function openAPIDoc(router: any, config: SpecConfig) {\n  const registry = getRegistry(router);\n  return (c: any) => {\n    if (!registry) {\n      return c.json({\n        openapi: '3.1.0',\n        info: { title: config.title, version: config.version },\n        paths: {},\n      });\n    }\n    return c.json(generateSpec(registry, config));\n  };\n}\n","import { Hono } from 'hono';\nimport { RouteRegistry, REGISTRY, getRegistry } from './registry';\nimport { openAPIDoc } from './spec';\nimport type { DocOptions, Handler, HttpMethod, RouterInstance } from './types';\n\nexport function createRouter(): RouterInstance {\n  const router = new Hono();\n  const registry = new RouteRegistry();\n  (router as any)[REGISTRY] = registry;\n\n  function addRoute(\n    method: HttpMethod,\n    path: string,\n    handlerOrOpts: Handler | DocOptions,\n    maybeHandler?: Handler,\n  ) {\n    const hasOptions = typeof handlerOrOpts !== 'function';\n    const options: DocOptions = hasOptions ? (handlerOrOpts as DocOptions) : {};\n    const handler: Handler = hasOptions ? maybeHandler! : (handlerOrOpts as Handler);\n\n    router[method](path, handler as any);\n\n    registry.add({\n      method,\n      path,\n      tags: options.tags,\n      summary: options.summary,\n      description: options.description,\n      deprecated: options.deprecated,\n      security: options.security,\n      parameters: options.parameters,\n      requestBody: options.requestBody,\n      responses: options.responses ?? {\n        200: { description: 'Successful response' },\n      },\n    });\n  }\n\n  const self: RouterInstance = {\n    router,\n    route: (path: string, subRouter: any, opts?: DocOptions) => {\n      const subRegistry = getRegistry(subRouter);\n      if (subRegistry) {\n        registry.merge(path, subRegistry, opts);\n      }\n      router.route(path, subRouter);\n      return self;\n    },\n    get: (path: string, handlerOrOpts: Handler | DocOptions, handler?: Handler) => {\n      addRoute('get', path, handlerOrOpts, handler);\n      return self;\n    },\n    post: (path: string, handlerOrOpts: Handler | DocOptions, handler?: Handler) => {\n      addRoute('post', path, handlerOrOpts, handler);\n      return self;\n    },\n    put: (path: string, handlerOrOpts: Handler | DocOptions, handler?: Handler) => {\n      addRoute('put', path, handlerOrOpts, handler);\n      return self;\n    },\n    patch: (path: string, handlerOrOpts: Handler | DocOptions, handler?: Handler) => {\n      addRoute('patch', path, handlerOrOpts, handler);\n      return self;\n    },\n    delete: (path: string, handlerOrOpts: Handler | DocOptions, handler?: Handler) => {\n      addRoute('delete', path, handlerOrOpts, handler);\n      return self;\n    },\n    doc: config => openAPIDoc(router, config),\n  };\n\n  return self;\n}\n"]}

package/dist/index.d.cts

@@ -0,0 +1,6 @@
+import { R as RouterInstance } from './types-CguT4Ne5.cjs';
+export { D as DocOptions, H as Handler, a as HttpMethod, O as OpenAPIParameter, b as OpenAPIRequestBody, c as OpenAPIResponse, d as RouteEntry, S as SpecConfig, g as generateSpec, e as getRegistry, o as openAPIDoc } from './types-CguT4Ne5.cjs';
+
+declare function createRouter(): RouterInstance;
+
+export { RouterInstance, createRouter };

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import { R as RouterInstance } from './types-CguT4Ne5.js';
+export { D as DocOptions, H as Handler, a as HttpMethod, O as OpenAPIParameter, b as OpenAPIRequestBody, c as OpenAPIResponse, d as RouteEntry, S as SpecConfig, g as generateSpec, e as getRegistry, o as openAPIDoc } from './types-CguT4Ne5.js';
+
+declare function createRouter(): RouterInstance;
+
+export { RouterInstance, createRouter };

package/dist/index.js

@@ -0,0 +1,165 @@
+import { Hono } from 'hono';
+
+// src/router.ts
+
+// src/registry.ts
+var REGISTRY = /* @__PURE__ */ Symbol.for("hono-openapi-registry");
+var RouteRegistry = class {
+  entries = [];
+  add(entry) {
+    this.entries.push(entry);
+  }
+  merge(prefix, other, opts) {
+    for (const entry of other.entries) {
+      const merged = {
+        ...entry,
+        path: prefix + (entry.path === "/" ? "" : entry.path)
+      };
+      if (opts) {
+        const hasOwnTags = entry.tags && entry.tags.length > 0;
+        if (opts.tags && !hasOwnTags) merged.tags = opts.tags;
+        if (opts.summary && !entry.summary) merged.summary = opts.summary;
+        if (opts.description && !entry.description) merged.description = opts.description;
+        if (opts.security && !entry.security) merged.security = opts.security;
+        if (opts.deprecated !== void 0 && entry.deprecated === void 0)
+          merged.deprecated = opts.deprecated;
+      }
+      this.entries.push(merged);
+    }
+  }
+};
+function getRegistry(router) {
+  return router?.[REGISTRY];
+}
+
+// src/spec.ts
+function honoPathToOpenAPI(path) {
+  return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, "{$1}");
+}
+function extractPathParams(path) {
+  const params = [];
+  const regex = /:([a-zA-Z_][a-zA-Z0-9_]*)/g;
+  let match;
+  while ((match = regex.exec(path)) !== null) {
+    params.push({
+      name: match[1],
+      in: "path",
+      required: true,
+      schema: { type: "string" }
+    });
+  }
+  return params;
+}
+function generateSpec(registry, config) {
+  const paths = {};
+  const prefix = config.prefix ?? "";
+  for (const entry of registry.entries) {
+    const rawPath = prefix + entry.path;
+    const fullPath = honoPathToOpenAPI(rawPath);
+    if (!paths[fullPath]) paths[fullPath] = {};
+    const operation = {};
+    if (entry.tags && entry.tags.length > 0) operation.tags = entry.tags;
+    if (entry.summary) operation.summary = entry.summary;
+    if (entry.description) operation.description = entry.description;
+    if (entry.deprecated) operation.deprecated = entry.deprecated;
+    if (entry.security) operation.security = entry.security;
+    if (entry.requestBody) operation.requestBody = entry.requestBody;
+    const autoParams = extractPathParams(rawPath);
+    const userParams = entry.parameters ?? [];
+    const autoParamNames = new Set(userParams.map((p) => p.name));
+    const mergedParams = [...userParams, ...autoParams.filter((p) => !autoParamNames.has(p.name))];
+    if (mergedParams.length > 0) operation.parameters = mergedParams;
+    operation.responses = entry.responses;
+    paths[fullPath][entry.method] = operation;
+  }
+  const spec = {
+    openapi: "3.1.0",
+    info: {
+      title: config.title,
+      version: config.version
+    },
+    paths
+  };
+  if (config.description) spec.info.description = config.description;
+  if (config.servers) spec.servers = config.servers;
+  if (config.components) spec.components = config.components;
+  if (config.security) spec.security = config.security;
+  return spec;
+}
+function openAPIDoc(router, config) {
+  const registry = getRegistry(router);
+  return (c) => {
+    if (!registry) {
+      return c.json({
+        openapi: "3.1.0",
+        info: { title: config.title, version: config.version },
+        paths: {}
+      });
+    }
+    return c.json(generateSpec(registry, config));
+  };
+}
+
+// src/router.ts
+function createRouter() {
+  const router = new Hono();
+  const registry = new RouteRegistry();
+  router[REGISTRY] = registry;
+  function addRoute(method, path, handlerOrOpts, maybeHandler) {
+    const hasOptions = typeof handlerOrOpts !== "function";
+    const options = hasOptions ? handlerOrOpts : {};
+    const handler = hasOptions ? maybeHandler : handlerOrOpts;
+    router[method](path, handler);
+    registry.add({
+      method,
+      path,
+      tags: options.tags,
+      summary: options.summary,
+      description: options.description,
+      deprecated: options.deprecated,
+      security: options.security,
+      parameters: options.parameters,
+      requestBody: options.requestBody,
+      responses: options.responses ?? {
+        200: { description: "Successful response" }
+      }
+    });
+  }
+  const self = {
+    router,
+    route: (path, subRouter, opts) => {
+      const subRegistry = getRegistry(subRouter);
+      if (subRegistry) {
+        registry.merge(path, subRegistry, opts);
+      }
+      router.route(path, subRouter);
+      return self;
+    },
+    get: (path, handlerOrOpts, handler) => {
+      addRoute("get", path, handlerOrOpts, handler);
+      return self;
+    },
+    post: (path, handlerOrOpts, handler) => {
+      addRoute("post", path, handlerOrOpts, handler);
+      return self;
+    },
+    put: (path, handlerOrOpts, handler) => {
+      addRoute("put", path, handlerOrOpts, handler);
+      return self;
+    },
+    patch: (path, handlerOrOpts, handler) => {
+      addRoute("patch", path, handlerOrOpts, handler);
+      return self;
+    },
+    delete: (path, handlerOrOpts, handler) => {
+      addRoute("delete", path, handlerOrOpts, handler);
+      return self;
+    },
+    doc: (config) => openAPIDoc(router, config)
+  };
+  return self;
+}
+
+export { createRouter, generateSpec, getRegistry, openAPIDoc };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map