hono-takibi 0.9.995 → 0.9.996

package/README.md

@@ -196,7 +196,7 @@ export default defineConfig({
     template: {
       test: true,
       pathAlias: '@/',
-      framework: 'bun', // "vitest" (default) | "bun"
+      testFramework: 'bun', // "vitest" (default) | "vite-plus" | "bun"
     },
   },
 })
@@ -206,7 +206,7 @@ This generates:
 
 - `src/index.ts` - App entry point with route registrations
 - `src/handlers/*.ts` - Handler stubs for each resource
-- `src/handlers/*.test.ts` - Test files with `@faker-js/faker` mock data (imports from `vitest` or `bun:test`)
+- `src/handlers/*.test.ts` - Test files with `@faker-js/faker` mock data (imports from `vitest`, `vite-plus/test`, or `bun:test`)
 
 Re-running after updating your OpenAPI spec is safe — your hand-written handler logic and test customizations are preserved. Only new routes are added as stubs.
 
@@ -300,7 +300,7 @@ export default defineConfig({
   test: {
     output: './src/test.ts',
     import: '../index',
-    framework: 'bun', // "vitest" (default) | "bun"
+    testFramework: 'bun', // "vitest" (default) | "vite-plus" | "bun"
   },
 })
 ```
@@ -387,7 +387,7 @@ export default defineConfig({
       test: true, // Generate test files
       routeHandler: false, // false: inline .openapi() (default), true: RouteHandler exports
       pathAlias: '@/', // TypeScript path alias for imports
-      framework: 'vitest', // "vitest" (default) | "bun" — test import source
+      testFramework: 'vitest', // "vitest" (default) | "vite-plus" | "bun" — test import source
     },
 
     // Export options (OpenAPI Components Object)
@@ -528,7 +528,7 @@ export default defineConfig({
   test: {
     output: './src/test.ts',
     import: '../index', // Import path for the app instance
-    framework: 'vitest', // "vitest" (default) | "bun" — test import source
+    testFramework: 'vitest', // "vitest" (default) | "vite-plus" | "bun" — test import source
   },
 
   // Mock server generation

package/dist/config/index.d.ts

@@ -13,7 +13,7 @@ declare const ConfigSchema: z.ZodReadonly<z.ZodPipe<z.ZodObject<{
       test: z.ZodDefault<z.ZodBoolean>;
       routeHandler: z.ZodDefault<z.ZodBoolean>;
       pathAlias: z.ZodExactOptional<z.ZodString>;
-      framework: z.ZodExactOptional<z.ZodDefault<z.ZodEnum<{
+      testFramework: z.ZodExactOptional<z.ZodDefault<z.ZodEnum<{
         vitest: "vitest";
         "vite-plus": "vite-plus";
         bun: "bun";
@@ -144,7 +144,7 @@ declare const ConfigSchema: z.ZodReadonly<z.ZodPipe<z.ZodObject<{
   test: z.ZodExactOptional<z.ZodObject<{
     output: z.ZodString;
     import: z.ZodString;
-    framework: z.ZodExactOptional<z.ZodDefault<z.ZodEnum<{
+    testFramework: z.ZodExactOptional<z.ZodDefault<z.ZodEnum<{
       vitest: "vitest";
       "vite-plus": "vite-plus";
       bun: "bun";
@@ -167,7 +167,7 @@ declare const ConfigSchema: z.ZodReadonly<z.ZodPipe<z.ZodObject<{
       test: boolean;
       routeHandler: boolean;
       pathAlias?: string;
-      framework?: "vitest" | "vite-plus" | "bun";
+      testFramework?: "vitest" | "vite-plus" | "bun";
     };
     exportSchemas?: boolean;
     exportSchemasTypes?: boolean;
@@ -297,7 +297,7 @@ declare const ConfigSchema: z.ZodReadonly<z.ZodPipe<z.ZodObject<{
   test?: {
     output: string;
     import: string;
-    framework?: "vitest" | "vite-plus" | "bun";
+    testFramework?: "vitest" | "vite-plus" | "bun";
   };
   mock?: {
     output: string;
@@ -319,7 +319,7 @@ declare const ConfigSchema: z.ZodReadonly<z.ZodPipe<z.ZodObject<{
       test: boolean;
       routeHandler: boolean;
       pathAlias?: string;
-      framework?: "vitest" | "vite-plus" | "bun";
+      testFramework?: "vitest" | "vite-plus" | "bun";
     };
     exportSchemas?: boolean;
     exportSchemasTypes?: boolean;
@@ -446,7 +446,7 @@ declare const ConfigSchema: z.ZodReadonly<z.ZodPipe<z.ZodObject<{
   test?: {
     output: string;
     import: string;
-    framework?: "vitest" | "vite-plus" | "bun";
+    testFramework?: "vitest" | "vite-plus" | "bun";
   };
   mock?: {
     output: string;
@@ -480,9 +480,6 @@ declare function readConfig(): Promise<{
   readonly ok: false;
   readonly error: string;
 }>;
-/**
- * Helper to define a config with full type completion.
- */
 declare function defineConfig(config: ConfigInput): Readonly<{
   input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
   basePath?: string;
@@ -494,7 +491,7 @@ declare function defineConfig(config: ConfigInput): Readonly<{
       test?: boolean | undefined;
       routeHandler?: boolean | undefined;
       pathAlias?: string;
-      framework?: "vitest" | "vite-plus" | "bun" | undefined;
+      testFramework?: "vitest" | "vite-plus" | "bun" | undefined;
     };
     exportSchemas?: boolean;
     exportSchemasTypes?: boolean;
@@ -621,7 +618,7 @@ declare function defineConfig(config: ConfigInput): Readonly<{
   test?: {
     output: string;
     import: string;
-    framework?: "vitest" | "vite-plus" | "bun" | undefined;
+    testFramework?: "vitest" | "vite-plus" | "bun" | undefined;
   };
   mock?: {
     output: string;

package/dist/config/index.js

@@ -16,7 +16,7 @@ const ConfigSchema = z.object({
 			test: z.boolean().default(false),
 			routeHandler: z.boolean().default(false),
 			pathAlias: z.string().exactOptional(),
-			framework: z.enum([
+			testFramework: z.enum([
 				"vitest",
 				"vite-plus",
 				"bun"
@@ -147,7 +147,7 @@ const ConfigSchema = z.object({
 	test: z.object({
 		output: z.string(),
 		import: z.string(),
-		framework: z.enum([
+		testFramework: z.enum([
 			"vitest",
 			"vite-plus",
 			"bun"
@@ -250,9 +250,6 @@ async function readConfig() {
 		};
 	}
 }
-/**
-* Helper to define a config with full type completion.
-*/
 function defineConfig(config) {
 	return config;
 }

package/dist/core/docs/index.js

@@ -1,2 +1,2 @@
-import { n as makeDocs, t as docs } from "../../docs-Da_MOdAe.js";
+import { n as makeDocs, t as docs } from "../../docs-BnLvHynR.js";
 export { docs, makeDocs };

package/dist/core/rpc/index.js

@@ -1,7 +1,7 @@
-import { c as isOperationLike, f as isRecord, o as isOpenAPIPaths } from "../../guard-BabA4f3q.js";
-import { a as makeInferRequestType, s as methodPath } from "../../utils-B9bUHU9P.js";
-import { t as core } from "../../core-BlUaJE2n.js";
-import { a as parsePathItem, i as operationHasArgs, o as resolveSplitOutDir, r as makeOperationDeps, t as formatPath } from "../../hono-rpc-BOLdCVD_.js";
+import { a as makeInferRequestType, s as methodPath } from "../../utils-BqOCY-3W.js";
+import { c as isOperationLike, f as isRecord, o as isOpenAPIPaths } from "../../guard-BzaK5_qz.js";
+import { t as core } from "../../core-CaXcQRYE.js";
+import { a as parsePathItem, i as operationHasArgs, o as resolveSplitOutDir, r as makeOperationDeps, t as formatPath } from "../../hono-rpc-CvPU8S0M.js";
 import path from "node:path";
 //#region src/core/rpc/index.ts
 const makeOperationCode = (pathStr, method, item, deps, useParseResponse, hasBasePath) => {

package/dist/core/svelte-query/index.js

@@ -1,4 +1,4 @@
-import { t as makeQueryHooks } from "../../query-CArUJxE4.js";
+import { t as makeQueryHooks } from "../../query-BVXAozkk.js";
 //#region src/core/svelte-query/index.ts
 /**
 * Generates Svelte Query hooks from OpenAPI specification.

package/dist/core/swr/index.js

@@ -1,4 +1,4 @@
-import { t as makeQueryHooks } from "../../query-CArUJxE4.js";
+import { t as makeQueryHooks } from "../../query-BVXAozkk.js";
 //#region src/core/swr/index.ts
 /**
 * Generates SWR hooks from OpenAPI specification.

package/dist/core/tanstack-query/index.js

@@ -1,4 +1,4 @@
-import { t as makeQueryHooks } from "../../query-CArUJxE4.js";
+import { t as makeQueryHooks } from "../../query-BVXAozkk.js";
 //#region src/core/tanstack-query/index.ts
 /**
 * Generates TanStack Query hooks from OpenAPI specification.

package/dist/core/type/index.js

@@ -1,6 +1,6 @@
-import { b as isStringRef, g as isSchemaArray, i as isMediaWithSchema, l as isParameter, m as isRequestBody, n as isHttpMethod, s as isOperation, u as isParameterArray } from "../../guard-BabA4f3q.js";
-import { o as makeSafeKey } from "../../utils-B9bUHU9P.js";
-import { t as core } from "../../core-BlUaJE2n.js";
+import { o as makeSafeKey } from "../../utils-BqOCY-3W.js";
+import { b as isStringRef, g as isSchemaArray, i as isMediaWithSchema, l as isParameter, m as isRequestBody, n as isHttpMethod, s as isOperation, u as isParameterArray } from "../../guard-BzaK5_qz.js";
+import { t as core } from "../../core-CaXcQRYE.js";
 import path from "node:path";
 //#region src/core/type/index.ts
 /**

package/dist/core/vue-query/index.js

@@ -1,4 +1,4 @@
-import { t as makeQueryHooks } from "../../query-CArUJxE4.js";
+import { t as makeQueryHooks } from "../../query-BVXAozkk.js";
 //#region src/core/vue-query/index.ts
 /**
 * Generates Vue Query hooks from OpenAPI specification.

package/dist/{core-BlUaJE2n.js → core-CaXcQRYE.js}

@@ -61,7 +61,6 @@ async function fmt(input) {
 }
 //#endregion
 //#region src/helper/core.ts
-/** Formats code, creates directory, and writes the file. */
 async function core(code, dir, output) {
 	const [fmtResult, mkdirResult] = await Promise.all([fmt(code), mkdir(dir)]);
 	if (!fmtResult.ok) return {

package/dist/{docs-Da_MOdAe.js → docs-BnLvHynR.js}

@@ -1,4 +1,4 @@
-import { a as isOAuthFlowValue, f as isRecord, h as isResponses, m as isRequestBody, p as isRefObject, r as isMedia, v as isSecurityArray, y as isSecurityScheme } from "./guard-BabA4f3q.js";
+import { a as isOAuthFlowValue, f as isRecord, h as isResponses, m as isRequestBody, p as isRefObject, r as isMedia, v as isSecurityArray, y as isSecurityScheme } from "./guard-BzaK5_qz.js";
 import { a as writeFile, t as mkdir } from "./fsp-Bv1yR6UV.js";
 import path from "node:path";
 import { STATUS_CODES } from "node:http";

package/dist/generator/zod-openapi-hono/openapi/index.js

@@ -1,2 +1,2 @@
-import { t as zodOpenAPIHono } from "../../../openapi-BZ9b1y3X.js";
+import { t as zodOpenAPIHono } from "../../../openapi-Bq_Z1BrA.js";
 export { zodOpenAPIHono };

package/dist/{hono-rpc-BOLdCVD_.js → hono-rpc-CvPU8S0M.js}

@@ -1,4 +1,4 @@
-import { _ as isSchemaProperty, c as isOperationLike, d as isParameterObject, f as isRecord, p as isRefObject, x as isValidIdent } from "./guard-BabA4f3q.js";
+import { _ as isSchemaProperty, c as isOperationLike, d as isParameterObject, f as isRecord, p as isRefObject, x as isValidIdent } from "./guard-BzaK5_qz.js";
 import path from "node:path";
 //#region src/helper/hono-rpc.ts
 /**
@@ -30,9 +30,8 @@ function formatPath(p, hasBasePath) {
 			hasBracket: false
 		};
 	}
-	const hasTrailingSlash = p !== "/" && p.endsWith("/");
 	const segs = p.replace(/^\/+/, "").split("/").filter(Boolean);
-	if (hasTrailingSlash) segs.push("index");
+	if (p !== "/" && p.endsWith("/")) segs.push("index");
 	const honoSegs = segs.map((seg) => seg.replace(/\{([^}]+)\}/g, ":$1"));
 	const firstBracketIdx = honoSegs.findIndex((seg) => !isValidIdent(seg));
 	const hasBracket = firstBracketIdx !== -1;
@@ -68,7 +67,6 @@ function makeResolveParameter(componentsParameters) {
 function makeToParameterLikes(resolveParam) {
 	return (arr) => Array.isArray(arr) ? arr.map((x) => resolveParam(x)).filter((param) => param !== void 0) : [];
 }
-const NO_CONTENT_STATUS_CODES = [204, 205];
 /**
 * Check if operation has No Content response (204 or 205).
 */
@@ -77,10 +75,13 @@ function hasNoContentResponse(op) {
 	if (!isRecord(responses)) return false;
 	return Object.keys(responses).some((status) => {
 		const code = Number.parseInt(status, 10);
-		return !Number.isNaN(code) && NO_CONTENT_STATUS_CODES.includes(code);
+		return !Number.isNaN(code) && [204, 205].includes(code);
 	});
 }
 /**
+* All body info grouped by type.
+*/
+/**
 * Extract requestBody name from $ref.
 */
 function refRequestBodyName(refLike) {
@@ -108,9 +109,9 @@ function pickAllBodyInfoFromContent(content) {
 */
 function makePickAllBodyInfo(componentsRequestBodies) {
 	return (op) => {
-		const rb = op.requestBody;
-		if (!isRecord(rb)) return void 0;
-		const refName = refRequestBodyName(rb);
+		const requestBody = op.requestBody;
+		if (!isRecord(requestBody)) return void 0;
+		const refName = refRequestBodyName(requestBody);
 		if (refName) {
 			const resolved = componentsRequestBodies[refName];
 			if (isRecord(resolved) && isRecord(resolved.content)) return pickAllBodyInfoFromContent(resolved.content);
@@ -120,7 +121,7 @@ function makePickAllBodyInfo(componentsRequestBodies) {
 			};
 			return;
 		}
-		return pickAllBodyInfoFromContent(rb.content);
+		return pickAllBodyInfoFromContent(requestBody.content);
 	};
 }
 /**
@@ -163,9 +164,7 @@ function makeOperationDeps(clientName, componentsParameters, componentsRequestBo
 * Check if operation has arguments (parameters or body).
 */
 function operationHasArgs(item, op, deps) {
-	const pathLevelParams = deps.toParameterLikes(item.parameters);
-	const opParams = deps.toParameterLikes(op.parameters);
-	const allParams = [...pathLevelParams, ...opParams];
+	const allParams = [...deps.toParameterLikes(item.parameters), ...deps.toParameterLikes(op.parameters)];
 	const hasParams = allParams.filter((p) => p.in === "path").length > 0 || allParams.filter((p) => p.in === "query").length > 0 || allParams.filter((p) => p.in === "header").length > 0 || allParams.filter((p) => p.in === "cookie").length > 0;
 	const allBodyInfo = deps.pickAllBodyInfo(op);
 	const hasBody = allBodyInfo !== void 0 && (allBodyInfo.form.length > 0 || allBodyInfo.json.length > 0);

package/dist/index.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { readConfig } from "./config/index.js";
-import { r as setFormatOptions } from "./core-BlUaJE2n.js";
-import { _ as examples, a as takibi, c as securitySchemes, d as requestBodies, f as pathItems, g as headers, h as links, i as template, l as schemas, m as mediaTypes, n as webhooks, o as route, p as parameters, r as test, s as mock, t as parseOpenAPI, u as responses, v as callbacks } from "./openapi-D2QO8Njt.js";
-import { t as docs } from "./docs-Da_MOdAe.js";
+import { r as setFormatOptions } from "./core-CaXcQRYE.js";
+import { _ as examples, a as takibi, c as securitySchemes, d as requestBodies, f as pathItems, g as headers, h as links, i as template, l as schemas, m as mediaTypes, n as webhooks, o as route, p as parameters, r as test, s as mock, t as parseOpenAPI, u as responses, v as callbacks } from "./openapi-CSP6nmmf.js";
+import { t as docs } from "./docs-BnLvHynR.js";
 import { rpc } from "./core/rpc/index.js";
 import { svelteQuery } from "./core/svelte-query/index.js";
 import { swr } from "./core/swr/index.js";
@@ -133,13 +133,13 @@ async function honoTakibi() {
 		config["tanstack-query"] ? tanstackQuery(openAPI, config["tanstack-query"].output, config["tanstack-query"].import, config["tanstack-query"].split ?? false, config["tanstack-query"].client ?? "client") : Promise.resolve(void 0),
 		config["svelte-query"] ? svelteQuery(openAPI, config["svelte-query"].output, config["svelte-query"].import, config["svelte-query"].split ?? false, config["svelte-query"].client ?? "client") : Promise.resolve(void 0),
 		config["vue-query"] ? vueQuery(openAPI, config["vue-query"].output, config["vue-query"].import, config["vue-query"].split ?? false, config["vue-query"].client ?? "client") : Promise.resolve(void 0),
-		config.test ? test(openAPI, config.test.output, config.test.import, config.basePath ?? "/", config.test.framework) : Promise.resolve(void 0),
+		config.test ? test(openAPI, config.test.output, config.test.import, config.basePath ?? "/", config.test.testFramework) : Promise.resolve(void 0),
 		config.mock ? mock(openAPI, config.mock.output, config.basePath ?? "/", config["zod-openapi"]?.readonly) : Promise.resolve(void 0),
 		config.docs ? docs(openAPI, config.docs.output, config.docs.entry, config.basePath ?? "/", config.docs.curl, config.docs.baseUrl) : Promise.resolve(void 0),
 		(() => {
 			if (!config["zod-openapi"]?.template) return Promise.resolve(void 0);
 			if (!(config["zod-openapi"]?.output ?? config["zod-openapi"]?.routes?.output)) return Promise.resolve(void 0);
-			return template(openAPI, config["zod-openapi"]?.output ?? config["zod-openapi"]?.routes?.output ?? "src/routes/index.ts", config["zod-openapi"]?.template.test, config.basePath ?? "/", config["zod-openapi"]?.template.pathAlias, config["zod-openapi"]?.routes?.import, config["zod-openapi"]?.template.routeHandler, config["zod-openapi"]?.template.framework);
+			return template(openAPI, config["zod-openapi"]?.output ?? config["zod-openapi"]?.routes?.output ?? "src/routes/index.ts", config["zod-openapi"]?.template.test, config.basePath ?? "/", config["zod-openapi"]?.template.pathAlias, config["zod-openapi"]?.routes?.import, config["zod-openapi"]?.template.routeHandler, config["zod-openapi"]?.template.testFramework);
 		})()
 	]);
 	const values = [];

package/dist/{openapi-BZ9b1y3X.js → openapi-Bq_Z1BrA.js}

@@ -1,28 +1,219 @@
-import { f as isRecord, g as isSchemaArray, l as isParameter, p as isRefObject, r as isMedia, s as isOperation } from "./guard-BabA4f3q.js";
-import { c as normalizeTypes, d as toIdentifierPascalCase, f as uncapitalize, l as renderNamedImport, n as ensureSuffix, o as makeSafeKey, p as zodToOpenAPISchema, r as error, s as methodPath, u as requestParamsArray } from "./utils-B9bUHU9P.js";
+import { c as normalizeTypes, d as toIdentifierPascalCase, f as uncapitalize, l as renderNamedImport, n as ensureSuffix, o as makeSafeKey, p as zodToOpenAPISchema, r as error, s as methodPath, u as requestParamsArray } from "./utils-BqOCY-3W.js";
+import { f as isRecord, g as isSchemaArray, l as isParameter, p as isRefObject, r as isMedia, s as isOperation } from "./guard-BzaK5_qz.js";
 import path from "node:path";
 import ts from "typescript";
-//#region src/helper/coerce.ts
-const constraintPattern = /^(?:\.(?:min|max|gt|lt|positive|negative|nonnegative|nonpositive|multipleOf)\([^)]*\))*/;
-function pipeCoerce(coerceBase, typeBase, baseSchema) {
-	const afterType = baseSchema.slice(typeBase.length);
-	const match = afterType.match(constraintPattern);
-	const constraints = match ? match[0] : "";
-	return `${coerceBase}.pipe(${typeBase}${constraints})${afterType.slice(constraints.length)}`;
-}
-function applyNumberCoerce(baseSchema, schemaType, format) {
-	if (schemaType === "number") {
-		if (format === "float" || format === "float32") return pipeCoerce("z.coerce.number()", "z.float32()", baseSchema);
-		if (format === "float64") return pipeCoerce("z.coerce.number()", "z.float64()", baseSchema);
-		return baseSchema.replace("z.number()", "z.coerce.number()");
-	}
-	if (schemaType === "integer") {
-		if (format === "int32") return pipeCoerce("z.coerce.number()", "z.int32()", baseSchema);
-		if (format === "int64") return pipeCoerce("z.coerce.bigint()", "z.int64()", baseSchema);
-		if (format === "bigint") return baseSchema.replace("z.bigint()", "z.coerce.bigint()");
-		return pipeCoerce("z.coerce.number()", "z.int()", baseSchema);
+//#region src/helper/code.ts
+/**
+* Builds a relative module specifier from `fromFile` to a configured output.
+*
+* Computes the relative path from the directory of `fromFile` to the `target.output`,
+* stripping `.ts` extension and `/index` suffix for clean ES module import paths.
+*
+* @param fromFile - The absolute path of the source file that will import the target.
+* @param target - Configuration for the target module.
+* @param target.output - The absolute path to the output file or directory.
+* @param target.split - When true, treats output as a directory path rather than a file.
+* @returns A relative module specifier (e.g., `'../schemas'`, `'./user'`, `'.'`).
+*
+* @example
+* ```ts
+* // File to directory (strips /index)
+* makeModuleSpec('/src/routes/index.ts', { output: '/src/schemas/index.ts' })
+* // → '../schemas'
+*
+* // File to file (strips .ts extension)
+* makeModuleSpec('/src/routes/user.ts', { output: '/src/schemas/user.ts' })
+* // → '../schemas/user'
+*
+* // Split mode: same directory
+* makeModuleSpec('/src/routes/index.ts', { output: '/src/routes', split: true })
+* // → '.'
+*
+* // Ensures dot-relative prefix
+* makeModuleSpec('/src/index.ts', { output: '/src/schemas.ts' })
+* // → './schemas'
+* ```
+*/
+function makeModuleSpec(fromFile, target) {
+	const stripped = path.relative(path.dirname(fromFile), target.output).replace(/\\/g, "/").replace(/\.ts$/, "").replace(/\/index$/, "");
+	return stripped === "" ? "." : stripped.startsWith(".") ? stripped : `./${stripped}`;
+}
+/**
+* Generates a const declaration prefix with optional export.
+*
+* Combines the text and suffix, converts to PascalCase, and prepends
+* `export const ` or `const ` based on the `exportVariable` flag.
+*
+* @param exportVariable - Whether to add the `export` keyword.
+* @param text - The base name for the constant (will be converted to PascalCase).
+* @param suffix - The suffix to append to the name (added before PascalCase conversion).
+* @returns A string like `'export const UserSchema='` or `'const UserSchema='`.
+*
+* @example
+* ```ts
+* makeConst(true, 'User', 'Schema')
+* // → 'export const UserSchema='
+*
+* makeConst(false, 'post', 'Response')
+* // → 'const PostResponse='
+*
+* // Handles kebab-case input
+* makeConst(true, 'user-profile', 'Schema')
+* // → 'export const UserProfileSchema='
+* ```
+*/
+function makeConst(exportVariable, text, suffix) {
+	return `${exportVariable ? "export const " : "const "}${toIdentifierPascalCase(ensureSuffix(text, suffix))}=`;
+}
+/**
+* Generates a string of export const statements for the given value.
+*
+* Iterates over the keys of `value`, converts each key to PascalCase with the suffix,
+* and serializes the value as JSON. Multiple entries are separated by double newlines.
+*
+* @param value - Object containing values to export (keys become constant names).
+* @param suffix - Suffix to append to each export name (before PascalCase conversion).
+* @param readonly - Whether to add `as const` assertion for TypeScript readonly inference.
+* @returns A string of TypeScript export const statements separated by `\n\n`.
+*
+* @example
+* ```ts
+* // Single export
+* makeExportConst({ user: { id: 1 } }, 'Example')
+* // → 'export const UserExample={"id":1}'
+*
+* // With as const assertion
+* makeExportConst({ user: { id: 1 } }, 'Example', true)
+* // → 'export const UserExample={"id":1} as const'
+*
+* // Multiple exports
+* makeExportConst({ user: { id: 1 }, post: { title: 'Hello' } }, 'Data')
+* // → 'export const UserData={"id":1}\n\nexport const PostData={"title":"Hello"}'
+* ```
+*/
+function makeExportConst(value, suffix, readonly) {
+	const asConst = readonly ? " as const" : "";
+	return Object.keys(value).map((key) => `export const ${toIdentifierPascalCase(ensureSuffix(key, suffix))}=${JSON.stringify(value[key])}${asConst}`).join("\n\n");
+}
+/**
+* Universal import generator for OpenAPI-based Hono route files.
+*
+* Analyzes the provided code to auto-detect required imports and generates
+* import statements for `@hono/zod-openapi` and OpenAPI component references.
+*
+* **Import Detection Logic:**
+* - Detects `z.` usage to import `z` from `@hono/zod-openapi`
+* - Detects `createRoute(` usage to import `createRoute`
+* - Scans for OpenAPI component references by suffix pattern (e.g., `*Schema`, `*Response`)
+* - Excludes locally defined exports from import generation
+*
+* **OpenAPI Component Patterns** (ordered per OpenAPI 3.0 spec):
+* | Suffix | Component Type | Example |
+* |--------|---------------|---------|
+* | `*Schema` | schemas | `UserSchema` |
+* | `*ParamsSchema` | parameters | `IdParamsSchema` |
+* | `*SecurityScheme` | securitySchemes | `BearerSecurityScheme` |
+* | `*RequestBody` | requestBodies | `CreateUserRequestBody` |
+* | `*Response` | responses | `UserResponse` |
+* | `*HeaderSchema` | headers | `AuthHeaderSchema` |
+* | `*Example` | examples | `UserExample` |
+* | `*Link` | links | `GetUserLink` |
+* | `*Callback` | callbacks | `WebhookCallback` |
+*
+* @param code - The TypeScript code to analyze and prepend imports to.
+* @param fromFile - The absolute path of the file where code will be written.
+* @param components - Configuration mapping OpenAPI component types to output locations.
+* @param split - When true, uses `'..'` as fallback prefix; otherwise `'.'`.
+* @returns The code with generated import statements prepended.
+*
+* @see {@link https://swagger.io/docs/specification/v3_0/components/|OpenAPI Components}
+*
+* @example
+* ```ts
+* // Basic usage with schema reference
+* const code = 'const route = createRoute({ request: { body: UserSchema } })'
+* makeImports(code, '/src/routes/user.ts', { schemas: { output: '/src/schemas.ts' } })
+* // → "import{createRoute}from'@hono/zod-openapi'\nimport{UserSchema}from'../schemas'\n\n..."
+*
+* // With z usage
+* const code2 = 'z.string()'
+* makeImports(code2, '/src/routes/user.ts', undefined)
+* // → "import{z}from'@hono/zod-openapi'\n\n..."
+* ```
+*/
+/** Valid JavaScript identifier pattern (e.g., `UserSchema`, `_private`, `$special`) */
+const JS_IDENT = "[A-Za-z_$][A-Za-z0-9_$]*";
+/**
+* Regex patterns for OpenAPI component types.
+* Ordered per OpenAPI 3.0 specification.
+* Note: (?<!Params)(?<!Header) excludes ParamsSchema/HeaderSchema from generic Schema matches
+*
+* Hoisted to module scope to avoid re-creating RegExp objects on every call.
+*/
+const IMPORT_PATTERNS = [
+	{
+		pattern: new RegExp(`\\b(${JS_IDENT}(?<!Params)(?<!Header)(?<!MediaType)Schema)\\b`, "g"),
+		key: "schemas"
+	},
+	{
+		pattern: new RegExp(`\\b(${JS_IDENT}ParamsSchema)\\b`, "g"),
+		key: "parameters"
+	},
+	{
+		pattern: new RegExp(`\\b(${JS_IDENT}SecurityScheme)\\b`, "g"),
+		key: "securitySchemes"
+	},
+	{
+		pattern: new RegExp(`\\b(${JS_IDENT}RequestBody)\\b`, "g"),
+		key: "requestBodies"
+	},
+	{
+		pattern: new RegExp(`\\b(${JS_IDENT}Response)\\b`, "g"),
+		key: "responses"
+	},
+	{
+		pattern: new RegExp(`\\b(${JS_IDENT}HeaderSchema)\\b`, "g"),
+		key: "headers"
+	},
+	{
+		pattern: new RegExp(`\\b(${JS_IDENT}Example)\\b`, "g"),
+		key: "examples"
+	},
+	{
+		pattern: new RegExp(`\\b(${JS_IDENT}Link)\\b`, "g"),
+		key: "links"
+	},
+	{
+		pattern: new RegExp(`\\b(${JS_IDENT}Callback)\\b`, "g"),
+		key: "callbacks"
+	},
+	{
+		pattern: new RegExp(`\\b(${JS_IDENT}MediaTypeSchema)\\b`, "g"),
+		key: "mediaTypes"
 	}
-	return baseSchema;
+];
+/** Pattern to find locally exported constants */
+const EXPORT_CONST_PATTERN = new RegExp(`export\\s+const\\s+(${JS_IDENT})\\s*=`, "g");
+function makeImports(code, fromFile, components, split = false) {
+	const fallbackPrefix = split ? ".." : ".";
+	const resolvePath = (key) => {
+		const target = components?.[key];
+		return target?.import ?? (target ? makeModuleSpec(fromFile, target) : `${fallbackPrefix}/${key}`);
+	};
+	const defined = new Set(Array.from(code.matchAll(EXPORT_CONST_PATTERN), (m) => m[1]).filter(Boolean));
+	const needsCreateRoute = code.includes("createRoute(");
+	const needsZ = code.includes("z.");
+	const honoImports = [needsCreateRoute && "createRoute", needsZ && "z"].filter(Boolean);
+	return [
+		honoImports.length > 0 ? `import{${honoImports.join(",")}}from'@hono/zod-openapi'` : "",
+		...IMPORT_PATTERNS.flatMap(({ pattern, key }) => {
+			const tokens = [...new Set(Array.from(code.matchAll(pattern), (m) => m[1]))].filter((t) => Boolean(t) && !defined.has(t)).sort();
+			return tokens.length > 0 ? [renderNamedImport(tokens, resolvePath(key))] : [];
+		}),
+		"\n",
+		code,
+		""
+	].filter(Boolean).join("\n");
 }
 //#endregion
 //#region src/helper/openapi.ts
@@ -192,10 +383,9 @@ function makeCallbacks(callbacks, readonly) {
 	return Object.entries(callbacks).map(([callbackKey, pathItem]) => {
 		if (isRefObject(pathItem)) return `${JSON.stringify(callbackKey)}:${makeRef(pathItem.$ref)}`;
 		if (!isRecord(pathItem)) return void 0;
-		const pathItemRecord = pathItem;
-		const pathItemCode = makeMethodsCode(pathItemRecord);
+		const pathItemCode = makeMethodsCode(pathItem);
 		if (pathItemCode) return `${JSON.stringify(callbackKey)}:{${pathItemCode}}`;
-		const nestedCode = Object.entries(pathItemRecord).map(([pathExpr, inner]) => {
+		const nestedCode = Object.entries(pathItem).map(([pathExpr, inner]) => {
 			if (!isRecord(inner)) return void 0;
 			const code = makeMethodsCode(inner);
 			return code ? `${JSON.stringify(pathExpr)}:{${code}}` : void 0;
@@ -344,7 +534,7 @@ function makeParameters(parameters, readonly) {
 			return acc;
 		}
 		const baseSchema = zodToOpenAPI(schema, { parameters: param }, readonly);
-		const z = param.in === "query" && (schema.type === "number" || schema.type === "integer") ? applyNumberCoerce(baseSchema, schema.type, schema.format) : param.in === "query" && schema.type === "boolean" ? baseSchema.replace("boolean", "stringbool").replace(/\.default\("true"\)/g, ".default(true)").replace(/\.default\("false"\)/g, ".default(false)") : param.in === "query" && schema.type === "date" ? `z.coerce.${baseSchema.replace("z.", "")}` : param.in === "query" && (schema.type === "object" || schema.type === "array") ? baseSchema.replace(/z\.(int\d*)\(\)((?:\.(?:min|max|gt|lt|positive|negative|nonnegative|nonpositive|multipleOf)\([^)]*\))*)/g, (_, type, constraints) => `z.coerce.number().pipe(z.${type}()${constraints})`).replace(/z\.bigint\(\)/g, "z.coerce.bigint()").replace(/z\.number\(\)/g, "z.coerce.number()").replace(/z\.boolean\(\)/g, "z.stringbool()").replace(/z\.date\(\)/g, "z.coerce.date()") : baseSchema;
+		const z = param.in === "query" && (schema.type === "number" || schema.type === "integer") ? coerce(baseSchema, schema.type, schema.format) : param.in === "query" && schema.type === "boolean" ? baseSchema.replace("boolean", "stringbool").replace(/\.default\("true"\)/g, ".default(true)").replace(/\.default\("false"\)/g, ".default(false)") : param.in === "query" && schema.type === "date" ? `z.coerce.${baseSchema.replace("z.", "")}` : param.in === "query" && (schema.type === "object" || schema.type === "array") ? baseSchema.replace(/z\.(int\d*)\(\)((?:\.(?:min|max|gt|lt|positive|negative|nonnegative|nonpositive|multipleOf)\([^)]*\))*)/g, (_, type, constraints) => `z.coerce.number().pipe(z.${type}()${constraints})`).replace(/z\.bigint\(\)/g, "z.coerce.bigint()").replace(/z\.number\(\)/g, "z.coerce.number()").replace(/z\.boolean\(\)/g, "z.stringbool()").replace(/z\.date\(\)/g, "z.coerce.date()") : baseSchema;
 		acc[param.in][makeSafeKey(param.name)] = z;
 		return acc;
 	}, {});
@@ -412,7 +602,7 @@ function makeOperation(operation, readonly) {
 	].filter((v) => v !== void 0).join(",")}}`;
 }
 function makePathItem(pathItem) {
-	const additionalOpsCode = pathItem.additionalOperations ? Object.entries(pathItem.additionalOperations).map(([opName, op]) => `${JSON.stringify(opName)}:${makeOperation(op)}`).join(",") : void 0;
+	const additionalOperationsCode = pathItem.additionalOperations ? Object.entries(pathItem.additionalOperations).map(([opName, op]) => `${JSON.stringify(opName)}:${makeOperation(op)}`).join(",") : void 0;
 	return `{${[
 		pathItem.$ref ? `$ref:${makeRef(pathItem.$ref)}` : void 0,
 		pathItem.summary ? `summary:${JSON.stringify(pathItem.summary)}` : void 0,
@@ -426,7 +616,7 @@ function makePathItem(pathItem) {
 		pathItem.patch ? `patch:${makeOperation(pathItem.patch)}` : void 0,
 		pathItem.trace ? `trace:${makeOperation(pathItem.trace)}` : void 0,
 		pathItem.query ? `query:${makeOperation(pathItem.query)}` : void 0,
-		additionalOpsCode ? `additionalOperations:{${additionalOpsCode}}` : void 0,
+		additionalOperationsCode ? `additionalOperations:{${additionalOperationsCode}}` : void 0,
 		pathItem.servers ? `servers:${JSON.stringify(pathItem.servers)}` : void 0,
 		pathItem.parameters ? `parameters:${makePathParameters(pathItem.parameters)}` : void 0
 	].filter((v) => v !== void 0).join(",")}}`;
@@ -1343,218 +1533,26 @@ function ast(code) {
 	return topoSort(decls).map((d) => d.fullText).join("\n\n");
 }
 //#endregion
-//#region src/helper/code.ts
-/**
-* Builds a relative module specifier from `fromFile` to a configured output.
-*
-* Computes the relative path from the directory of `fromFile` to the `target.output`,
-* stripping `.ts` extension and `/index` suffix for clean ES module import paths.
-*
-* @param fromFile - The absolute path of the source file that will import the target.
-* @param target - Configuration for the target module.
-* @param target.output - The absolute path to the output file or directory.
-* @param target.split - When true, treats output as a directory path rather than a file.
-* @returns A relative module specifier (e.g., `'../schemas'`, `'./user'`, `'.'`).
-*
-* @example
-* ```ts
-* // File to directory (strips /index)
-* makeModuleSpec('/src/routes/index.ts', { output: '/src/schemas/index.ts' })
-* // → '../schemas'
-*
-* // File to file (strips .ts extension)
-* makeModuleSpec('/src/routes/user.ts', { output: '/src/schemas/user.ts' })
-* // → '../schemas/user'
-*
-* // Split mode: same directory
-* makeModuleSpec('/src/routes/index.ts', { output: '/src/routes', split: true })
-* // → '.'
-*
-* // Ensures dot-relative prefix
-* makeModuleSpec('/src/index.ts', { output: '/src/schemas.ts' })
-* // → './schemas'
-* ```
-*/
-function makeModuleSpec(fromFile, target) {
-	const stripped = path.relative(path.dirname(fromFile), target.output).replace(/\\/g, "/").replace(/\.ts$/, "").replace(/\/index$/, "");
-	return stripped === "" ? "." : stripped.startsWith(".") ? stripped : `./${stripped}`;
-}
-/**
-* Generates a const declaration prefix with optional export.
-*
-* Combines the text and suffix, converts to PascalCase, and prepends
-* `export const ` or `const ` based on the `exportVariable` flag.
-*
-* @param exportVariable - Whether to add the `export` keyword.
-* @param text - The base name for the constant (will be converted to PascalCase).
-* @param suffix - The suffix to append to the name (added before PascalCase conversion).
-* @returns A string like `'export const UserSchema='` or `'const UserSchema='`.
-*
-* @example
-* ```ts
-* makeConst(true, 'User', 'Schema')
-* // → 'export const UserSchema='
-*
-* makeConst(false, 'post', 'Response')
-* // → 'const PostResponse='
-*
-* // Handles kebab-case input
-* makeConst(true, 'user-profile', 'Schema')
-* // → 'export const UserProfileSchema='
-* ```
-*/
-function makeConst(exportVariable, text, suffix) {
-	return `${exportVariable ? "export const " : "const "}${toIdentifierPascalCase(ensureSuffix(text, suffix))}=`;
-}
-/**
-* Generates a string of export const statements for the given value.
-*
-* Iterates over the keys of `value`, converts each key to PascalCase with the suffix,
-* and serializes the value as JSON. Multiple entries are separated by double newlines.
-*
-* @param value - Object containing values to export (keys become constant names).
-* @param suffix - Suffix to append to each export name (before PascalCase conversion).
-* @param readonly - Whether to add `as const` assertion for TypeScript readonly inference.
-* @returns A string of TypeScript export const statements separated by `\n\n`.
-*
-* @example
-* ```ts
-* // Single export
-* makeExportConst({ user: { id: 1 } }, 'Example')
-* // → 'export const UserExample={"id":1}'
-*
-* // With as const assertion
-* makeExportConst({ user: { id: 1 } }, 'Example', true)
-* // → 'export const UserExample={"id":1} as const'
-*
-* // Multiple exports
-* makeExportConst({ user: { id: 1 }, post: { title: 'Hello' } }, 'Data')
-* // → 'export const UserData={"id":1}\n\nexport const PostData={"title":"Hello"}'
-* ```
-*/
-function makeExportConst(value, suffix, readonly) {
-	const asConst = readonly ? " as const" : "";
-	return Object.keys(value).map((key) => `export const ${toIdentifierPascalCase(ensureSuffix(key, suffix))}=${JSON.stringify(value[key])}${asConst}`).join("\n\n");
-}
-/**
-* Universal import generator for OpenAPI-based Hono route files.
-*
-* Analyzes the provided code to auto-detect required imports and generates
-* import statements for `@hono/zod-openapi` and OpenAPI component references.
-*
-* **Import Detection Logic:**
-* - Detects `z.` usage to import `z` from `@hono/zod-openapi`
-* - Detects `createRoute(` usage to import `createRoute`
-* - Scans for OpenAPI component references by suffix pattern (e.g., `*Schema`, `*Response`)
-* - Excludes locally defined exports from import generation
-*
-* **OpenAPI Component Patterns** (ordered per OpenAPI 3.0 spec):
-* | Suffix | Component Type | Example |
-* |--------|---------------|---------|
-* | `*Schema` | schemas | `UserSchema` |
-* | `*ParamsSchema` | parameters | `IdParamsSchema` |
-* | `*SecurityScheme` | securitySchemes | `BearerSecurityScheme` |
-* | `*RequestBody` | requestBodies | `CreateUserRequestBody` |
-* | `*Response` | responses | `UserResponse` |
-* | `*HeaderSchema` | headers | `AuthHeaderSchema` |
-* | `*Example` | examples | `UserExample` |
-* | `*Link` | links | `GetUserLink` |
-* | `*Callback` | callbacks | `WebhookCallback` |
-*
-* @param code - The TypeScript code to analyze and prepend imports to.
-* @param fromFile - The absolute path of the file where code will be written.
-* @param components - Configuration mapping OpenAPI component types to output locations.
-* @param split - When true, uses `'..'` as fallback prefix; otherwise `'.'`.
-* @returns The code with generated import statements prepended.
-*
-* @see {@link https://swagger.io/docs/specification/v3_0/components/|OpenAPI Components}
-*
-* @example
-* ```ts
-* // Basic usage with schema reference
-* const code = 'const route = createRoute({ request: { body: UserSchema } })'
-* makeImports(code, '/src/routes/user.ts', { schemas: { output: '/src/schemas.ts' } })
-* // → "import{createRoute}from'@hono/zod-openapi'\nimport{UserSchema}from'../schemas'\n\n..."
-*
-* // With z usage
-* const code2 = 'z.string()'
-* makeImports(code2, '/src/routes/user.ts', undefined)
-* // → "import{z}from'@hono/zod-openapi'\n\n..."
-* ```
-*/
-/** Valid JavaScript identifier pattern (e.g., `UserSchema`, `_private`, `$special`) */
-const JS_IDENT = "[A-Za-z_$][A-Za-z0-9_$]*";
-/**
-* Regex patterns for OpenAPI component types.
-* Ordered per OpenAPI 3.0 specification.
-* Note: (?<!Params)(?<!Header) excludes ParamsSchema/HeaderSchema from generic Schema matches
-*
-* Hoisted to module scope to avoid re-creating RegExp objects on every call.
-*/
-const IMPORT_PATTERNS = [
-	{
-		pattern: new RegExp(`\\b(${JS_IDENT}(?<!Params)(?<!Header)(?<!MediaType)Schema)\\b`, "g"),
-		key: "schemas"
-	},
-	{
-		pattern: new RegExp(`\\b(${JS_IDENT}ParamsSchema)\\b`, "g"),
-		key: "parameters"
-	},
-	{
-		pattern: new RegExp(`\\b(${JS_IDENT}SecurityScheme)\\b`, "g"),
-		key: "securitySchemes"
-	},
-	{
-		pattern: new RegExp(`\\b(${JS_IDENT}RequestBody)\\b`, "g"),
-		key: "requestBodies"
-	},
-	{
-		pattern: new RegExp(`\\b(${JS_IDENT}Response)\\b`, "g"),
-		key: "responses"
-	},
-	{
-		pattern: new RegExp(`\\b(${JS_IDENT}HeaderSchema)\\b`, "g"),
-		key: "headers"
-	},
-	{
-		pattern: new RegExp(`\\b(${JS_IDENT}Example)\\b`, "g"),
-		key: "examples"
-	},
-	{
-		pattern: new RegExp(`\\b(${JS_IDENT}Link)\\b`, "g"),
-		key: "links"
-	},
-	{
-		pattern: new RegExp(`\\b(${JS_IDENT}Callback)\\b`, "g"),
-		key: "callbacks"
-	},
-	{
-		pattern: new RegExp(`\\b(${JS_IDENT}MediaTypeSchema)\\b`, "g"),
-		key: "mediaTypes"
-	}
-];
-/** Pattern to find locally exported constants */
-const EXPORT_CONST_PATTERN = new RegExp(`export\\s+const\\s+(${JS_IDENT})\\s*=`, "g");
-function makeImports(code, fromFile, components, split = false) {
-	const fallbackPrefix = split ? ".." : ".";
-	const resolvePath = (key) => {
-		const target = components?.[key];
-		return target?.import ?? (target ? makeModuleSpec(fromFile, target) : `${fallbackPrefix}/${key}`);
+//#region src/helper/coerce.ts
+function coerce(baseSchema, schemaType, format) {
+	const pipeCoerce = (coerceBase, typeBase, baseSchema) => {
+		const afterType = baseSchema.slice(typeBase.length);
+		const match = afterType.match(/^(?:\.(?:min|max|gt|lt|positive|negative|nonnegative|nonpositive|multipleOf)\([^)]*\))*/);
+		const constraints = match ? match[0] : "";
+		return `${coerceBase}.pipe(${typeBase}${constraints})${afterType.slice(constraints.length)}`;
 	};
-	const defined = new Set(Array.from(code.matchAll(EXPORT_CONST_PATTERN), (m) => m[1]).filter(Boolean));
-	const needsCreateRoute = code.includes("createRoute(");
-	const needsZ = code.includes("z.");
-	const honoImports = [needsCreateRoute && "createRoute", needsZ && "z"].filter(Boolean);
-	return [
-		honoImports.length > 0 ? `import{${honoImports.join(",")}}from'@hono/zod-openapi'` : "",
-		...IMPORT_PATTERNS.flatMap(({ pattern, key }) => {
-			const tokens = [...new Set(Array.from(code.matchAll(pattern), (m) => m[1]))].filter((t) => Boolean(t) && !defined.has(t)).sort();
-			return tokens.length > 0 ? [renderNamedImport(tokens, resolvePath(key))] : [];
-		}),
-		"\n",
-		code,
-		""
-	].filter(Boolean).join("\n");
+	if (schemaType === "number") {
+		if (format === "float" || format === "float32") return pipeCoerce("z.coerce.number()", "z.float32()", baseSchema);
+		if (format === "float64") return pipeCoerce("z.coerce.number()", "z.float64()", baseSchema);
+		return baseSchema.replace("z.number()", "z.coerce.number()");
+	}
+	if (schemaType === "integer") {
+		if (format === "int32") return pipeCoerce("z.coerce.number()", "z.int32()", baseSchema);
+		if (format === "int64") return pipeCoerce("z.coerce.bigint()", "z.int64()", baseSchema);
+		if (format === "bigint") return baseSchema.replace("z.bigint()", "z.coerce.bigint()");
+		return pipeCoerce("z.coerce.number()", "z.int()", baseSchema);
+	}
+	return baseSchema;
 }
 //#endregion
 //#region src/generator/zod-to-openapi/type/index.ts
@@ -1852,15 +1850,8 @@ function makeSingleTypeString(schema, type, selfTypeName, cyclicGroup, readonly)
 	if (type === "object") return makeObjectTypeString(schema, selfTypeName, cyclicGroup, readonly);
 	return "unknown";
 }
-/**
-* Wraps a type in parentheses if it needs grouping for array syntax.
-*
-* When an inner type starts with 'readonly ' (for readonly arrays),
-* we need to wrap it in parentheses to avoid invalid syntax like
-* `readonly readonly T[][]`. Instead, we get `readonly (readonly T[])[]`.
-*/
-const wrapForArrayElement = (type) => type.startsWith("readonly ") ? `(${type})` : type;
 function makeArrayTypeString(schema, selfTypeName, cyclicGroup, readonly) {
+	const wrapForArrayElement = (type) => type.startsWith("readonly ") ? `(${type})` : type;
 	const prefix = readonly ? "readonly " : "";
 	if (!schema.items) return `${prefix}unknown[]`;
 	const items = schema.items;
@@ -1964,7 +1955,7 @@ function parametersCode(components, exportParameters, exportParametersTypes, rea
 		const meta = { parameters: { ...parameter } };
 		const schema = parameter.schema ?? getSchemaFromContent(parameter.content);
 		const baseSchema = schema ? zodToOpenAPI(schema, meta) : "z.any()";
-		const z = parameter.in === "query" && (schema?.type === "number" || schema?.type === "integer") ? applyNumberCoerce(baseSchema, schema.type, schema.format) : parameter.in === "query" && schema?.type === "boolean" ? baseSchema.replace("boolean", "stringbool") : parameter.in === "query" && schema?.type === "date" ? `z.coerce.${baseSchema.replace("z.", "")}` : parameter.in === "query" && (schema?.type === "object" || schema?.type === "array") ? baseSchema.replace(/z\.(int\d*)\(\)((?:\.(?:min|max|gt|lt|positive|negative|nonnegative|nonpositive|multipleOf)\([^)]*\))*)/g, (_, type, constraints) => `z.coerce.number().pipe(z.${type}()${constraints})`).replace(/z\.bigint\(\)/g, "z.coerce.bigint()").replace(/z\.number\(\)/g, "z.coerce.number()").replace(/z\.boolean\(\)/g, "z.stringbool()").replace(/z\.date\(\)/g, "z.coerce.date()") : baseSchema;
+		const z = parameter.in === "query" && (schema?.type === "number" || schema?.type === "integer") ? coerce(baseSchema, schema.type, schema.format) : parameter.in === "query" && schema?.type === "boolean" ? baseSchema.replace("boolean", "stringbool") : parameter.in === "query" && schema?.type === "date" ? `z.coerce.${baseSchema.replace("z.", "")}` : parameter.in === "query" && (schema?.type === "object" || schema?.type === "array") ? baseSchema.replace(/z\.(int\d*)\(\)((?:\.(?:min|max|gt|lt|positive|negative|nonnegative|nonpositive|multipleOf)\([^)]*\))*)/g, (_, type, constraints) => `z.coerce.number().pipe(z.${type}()${constraints})`).replace(/z\.bigint\(\)/g, "z.coerce.bigint()").replace(/z\.number\(\)/g, "z.coerce.number()").replace(/z\.boolean\(\)/g, "z.stringbool()").replace(/z\.date\(\)/g, "z.coerce.date()") : baseSchema;
 		return zodToOpenAPISchema(toIdentifierPascalCase(ensureSuffix(k, "ParamsSchema")), z, exportParameters, exportParametersTypes, true, readonly);
 	}).join("\n\n");
 }
@@ -2522,4 +2513,4 @@ function zodOpenAPIHono(openapi, options) {
 	].filter((s) => s.length > 0).join("\n\n")}`;
 }
 //#endregion
-export { zodToOpenAPI as _, schemasCode as a, pathItemsCode as c, makeSplitSchemaFile as d, makeConst as f, ast as g, analyzeCircularSchemas as h, componentsCode as i, parametersCode as l, makeImports as m, webhookCode as n, responsesCode as o, makeExportConst as p, routeCode as r, requestBodiesCode as s, zodOpenAPIHono as t, headersCode as u, makeCallback as v, makeRef as y };
+export { makeConst as _, schemasCode as a, pathItemsCode as c, makeSplitSchemaFile as d, analyzeCircularSchemas as f, makeRef as g, makeCallback as h, componentsCode as i, parametersCode as l, zodToOpenAPI as m, webhookCode as n, responsesCode as o, ast as p, routeCode as r, requestBodiesCode as s, zodOpenAPIHono as t, headersCode as u, makeExportConst as v, makeImports as y };

package/dist/{openapi-D2QO8Njt.js → openapi-CSP6nmmf.js}

@@ -1,7 +1,7 @@
-import { i as isMediaWithSchema, n as isHttpMethod, p as isRefObject, s as isOperation, t as isContentBody, v as isSecurityArray, y as isSecurityScheme } from "./guard-BabA4f3q.js";
-import { d as toIdentifierPascalCase, f as uncapitalize, i as makeBarrel, l as renderNamedImport, n as ensureSuffix, p as zodToOpenAPISchema, s as methodPath } from "./utils-B9bUHU9P.js";
-import { _ as zodToOpenAPI, a as schemasCode, c as pathItemsCode, d as makeSplitSchemaFile, f as makeConst, g as ast, h as analyzeCircularSchemas, i as componentsCode, l as parametersCode, m as makeImports, n as webhookCode, o as responsesCode, p as makeExportConst, r as routeCode, s as requestBodiesCode, t as zodOpenAPIHono, u as headersCode, v as makeCallback, y as makeRef } from "./openapi-BZ9b1y3X.js";
-import { n as fmt, t as core } from "./core-BlUaJE2n.js";
+import { d as toIdentifierPascalCase, f as uncapitalize, i as makeBarrel, l as renderNamedImport, n as ensureSuffix, p as zodToOpenAPISchema, s as methodPath } from "./utils-BqOCY-3W.js";
+import { _ as makeConst, a as schemasCode, c as pathItemsCode, d as makeSplitSchemaFile, f as analyzeCircularSchemas, g as makeRef, h as makeCallback, i as componentsCode, l as parametersCode, m as zodToOpenAPI, n as webhookCode, o as responsesCode, p as ast, r as routeCode, s as requestBodiesCode, t as zodOpenAPIHono, u as headersCode, v as makeExportConst, y as makeImports } from "./openapi-Bq_Z1BrA.js";
+import { i as isMediaWithSchema, n as isHttpMethod, p as isRefObject, s as isOperation, t as isContentBody, v as isSecurityArray, y as isSecurityScheme } from "./guard-BzaK5_qz.js";
+import { n as fmt, t as core } from "./core-CaXcQRYE.js";
 import { a as writeFile, i as unlink, n as readFile, r as readdir, t as mkdir } from "./fsp-Bv1yR6UV.js";
 import path from "node:path";
 import { Project } from "ts-morph";
@@ -1600,7 +1600,7 @@ const TEST_IMPORT_SOURCE = {
 	"vite-plus": "vite-plus/test",
 	bun: "bun:test"
 };
-function makeTestFile(spec, appImportPath = "./app", basePath = "/", framework = "vitest") {
+function makeTestFile(spec, appImportPath = "./app", basePath = "/", testFramework = "vitest") {
 	const testCases = extractTestCases(spec);
 	const apiTitle = spec.info?.title || "API";
 	const usedSchemaNames = new Set(testCases.flatMap((tc) => tc.usedSchemaRefs));
@@ -1616,7 +1616,7 @@ function makeTestFile(spec, appImportPath = "./app", basePath = "/", framework =
 	}).join("");
 	const body = `${mockFunctions ? `${mockFunctions}\n\n` : ""}describe('${escapeString(apiTitle)}',()=>{${tagDescribes}})\n`;
 	const fakerImport = body.includes("faker.") ? `\nimport{faker}from'@faker-js/faker'` : "";
-	return `${`import{describe,it,expect}from'${TEST_IMPORT_SOURCE[framework]}'${fakerImport}\nimport app from'${appImportPath}'\n`}\n${body}`;
+	return `${`import{describe,it,expect}from'${TEST_IMPORT_SOURCE[testFramework]}'${fakerImport}\nimport app from'${appImportPath}'\n`}\n${body}`;
 }
 /**
 * Extract the first path segment from an API path.
@@ -1626,7 +1626,7 @@ function getPathFirstSegment(path) {
 	const sanitized = (path.replace(/^\/+/, "").split("/")[0] ?? "").replace(/\{([^}]+)\}/g, "$1").replace(/[^0-9A-Za-z._-]/g, "_").replace(/^[._-]+|[._-]+$/g, "").replace(/__+/g, "_").replace(/[-._](\w)/g, (_, c) => c.toUpperCase());
 	return sanitized === "" ? "__root" : sanitized;
 }
-function makeHandlerTestCode(spec, handlerPath, _routeNames, importFrom, basePath = "/", framework = "vitest") {
+function makeHandlerTestCode(spec, handlerPath, _routeNames, importFrom, basePath = "/", testFramework = "vitest") {
 	const handlerFileName = handlerPath.split("/").pop()?.replace(/\.ts$/, "") ?? "";
 	const relevantCases = extractTestCases(spec).filter((tc) => {
 		return getPathFirstSegment(tc.path) === handlerFileName;
@@ -1636,7 +1636,7 @@ function makeHandlerTestCode(spec, handlerPath, _routeNames, importFrom, basePat
 	const testCasesCode = relevantCases.map((tc) => makeTestCase(tc, basePath, spec.components?.schemas)).join("");
 	const body = `${mockFunctions ? `${mockFunctions}\n\n` : ""}describe('${handlerFileName.charAt(0).toUpperCase() + handlerFileName.slice(1)}',()=>{${testCasesCode}})\n`;
 	const fakerImport = body.includes("faker.") ? `\nimport{faker}from'@faker-js/faker'` : "";
-	return `${`import{describe,it,expect}from'${TEST_IMPORT_SOURCE[framework]}'${fakerImport}\nimport app from'${importFrom}'\n`}\n${body}`;
+	return `${`import{describe,it,expect}from'${TEST_IMPORT_SOURCE[testFramework]}'${fakerImport}\nimport app from'${importFrom}'\n`}\n${body}`;
 }
 //#endregion
 //#region src/merge/index.ts
@@ -1989,6 +1989,16 @@ function mergeTestFile(existingCode, generatedCode) {
 	const newBlocks = [...generatedBlocks.entries()].filter(([route]) => !existingRoutes.has(route)).map(([, block]) => block.text);
 	const { existingFile, generatedFile } = createSourcePair(existingCode, generatedCode);
 	const mergedImports = mergeImports(existingFile, generatedFile);
+	const TEST_FRAMEWORK_MODULES = new Set([
+		"vitest",
+		"bun:test",
+		"vite-plus/test"
+	]);
+	const generatedTestModule = generatedFile.getImportDeclarations().map((d) => d.getModuleSpecifierValue()).find((spec) => TEST_FRAMEWORK_MODULES.has(spec));
+	const filteredImports = generatedTestModule ? mergedImports.filter((line) => {
+		const spec = line.match(/from\s+'([^']+)'/)?.[1] ?? "";
+		return !TEST_FRAMEWORK_MODULES.has(spec) || spec === generatedTestModule;
+	}) : mergedImports;
 	const bodyStart = getBodyStart(existingFile);
 	const bodyWithStaleRemoved = applyRangeOps(existingCode, bodyStart, staleRanges.filter(([start]) => start >= bodyStart).map(([start, end]) => [
 		start,
@@ -1997,7 +2007,7 @@ function mergeTestFile(existingCode, generatedCode) {
 	])).replace(/\n{3,}/g, "\n\n");
 	const existingMocks = extractMockFunctions(existingCode);
 	const bodyWithRemovals = insertMissingMocks(bodyWithStaleRemoved, [...extractMockFunctions(generatedCode).entries()].filter(([name]) => !existingMocks.has(name)).map(([, block]) => block.text));
-	if (newBlocks.length === 0) return `${[mergedImports.length > 0 ? mergedImports.join("\n") : "", bodyWithRemovals.trim()].filter(Boolean).join("\n\n")}\n`;
+	if (newBlocks.length === 0) return `${[filteredImports.length > 0 ? filteredImports.join("\n") : "", bodyWithRemovals.trim()].filter(Boolean).join("\n\n")}\n`;
 	const lines = bodyWithRemovals.split("\n");
 	const insertLineIndex = lines.findLastIndex((line) => /^\s*\}\s*\)\s*;?\s*$/.test(line));
 	const body = (insertLineIndex !== -1 ? [
@@ -2010,7 +2020,7 @@ function mergeTestFile(existingCode, generatedCode) {
 		"",
 		...newBlocks
 	]).join("\n").trim();
-	return `${[mergedImports.length > 0 ? mergedImports.join("\n") : "", body].filter(Boolean).join("\n\n")}\n`;
+	return `${[filteredImports.length > 0 ? filteredImports.join("\n") : "", body].filter(Boolean).join("\n\n")}\n`;
 }
 /**
 * Syncs barrel file (index.ts) with the generated version.
@@ -2153,7 +2163,7 @@ async function removeStaleFiles(handlerPath, generatedFileNames) {
 * @param test - Whether to generate corresponding test files.
 * @returns A `Result` indicating success or error with message.
 */
-async function zodOpenAPIHonoHandler(openapi, output, test = false, pathAlias = void 0, routeImport = void 0, routeHandler = false, basePath = "/", framework = "vitest") {
+async function zodOpenAPIHonoHandler(openapi, output, test = false, pathAlias = void 0, routeImport = void 0, routeHandler = false, basePath = "/", testFramework = "vitest") {
 	const paths = openapi.paths;
 	const handlers = makeMergedHandlers(Object.entries(paths).flatMap(([path, pathItem]) => Object.entries(pathItem).filter((entry) => isHttpMethod(entry[0]) && isOperation(entry[1])).map(([method]) => routeHandler ? makeStubHandlerInfo(path, method) : makeInlineStubHandlerInfo(path, method))));
 	const { handlerPath, importFrom, testImportFrom } = makePaths(output, pathAlias, routeImport);
@@ -2182,7 +2192,7 @@ async function zodOpenAPIHonoHandler(openapi, output, test = false, pathAlias =
 			error: writeResult.error
 		};
 		if (test) {
-			const testContent = makeHandlerTestCode(openapi, `${handlerPath}/${handler.fileName}`, [...handler.routeNames], testImportFrom, basePath, framework);
+			const testContent = makeHandlerTestCode(openapi, `${handlerPath}/${handler.fileName}`, [...handler.routeNames], testImportFrom, basePath, testFramework);
 			if (testContent) {
 				const testFmtResult = await fmt(testContent);
 				const testCode = testFmtResult.ok ? testFmtResult.value : testContent;
@@ -2309,10 +2319,10 @@ function app(openapi, output, basePath, pathAlias, routeImport = void 0, routeHa
 *
 * Used by the CLI and vite-plugin when `template` is configured.
 */
-async function template(openAPI, output, test, basePath, pathAlias, routeImport, routeHandler, framework = "vitest") {
+async function template(openAPI, output, test, basePath, pathAlias, routeImport, routeHandler, testFramework = "vitest") {
 	const dir = output.endsWith("/index.ts") ? path.dirname(path.dirname(output)) : path.dirname(output);
 	const target = path.join(dir, "index.ts");
-	const [appFmtResult, stubHandlersResult] = await Promise.all([fmt(app(openAPI, output, basePath, pathAlias, routeImport, routeHandler)), zodOpenAPIHonoHandler(openAPI, output, test, pathAlias, routeImport, routeHandler, basePath, framework)]);
+	const [appFmtResult, stubHandlersResult] = await Promise.all([fmt(app(openAPI, output, basePath, pathAlias, routeImport, routeHandler)), zodOpenAPIHonoHandler(openAPI, output, test, pathAlias, routeImport, routeHandler, basePath, testFramework)]);
 	if (!appFmtResult.ok) return {
 		ok: false,
 		error: appFmtResult.error
@@ -2340,8 +2350,8 @@ async function template(openAPI, output, test, basePath, pathAlias, routeImport,
 }
 //#endregion
 //#region src/core/test/index.ts
-async function test(openAPI, output, importPath, basePath = "/", framework = "vitest") {
-	const testCode = makeTestFile(openAPI, importPath, basePath, framework);
+async function test(openAPI, output, importPath, basePath = "/", testFramework = "vitest") {
+	const testCode = makeTestFile(openAPI, importPath, basePath, testFramework);
 	const [fmtResult, mkdirResult, existingResult] = await Promise.all([
 		fmt(testCode),
 		mkdir(path.dirname(output)),

package/dist/{query-CArUJxE4.js → query-BVXAozkk.js}

@@ -1,7 +1,7 @@
-import { c as isOperationLike, f as isRecord, o as isOpenAPIPaths } from "./guard-BabA4f3q.js";
-import { d as toIdentifierPascalCase, s as methodPath, t as capitalize } from "./utils-B9bUHU9P.js";
-import { t as core } from "./core-BlUaJE2n.js";
-import { a as parsePathItem, i as operationHasArgs, n as hasNoContentResponse, o as resolveSplitOutDir, r as makeOperationDeps, t as formatPath } from "./hono-rpc-BOLdCVD_.js";
+import { d as toIdentifierPascalCase, s as methodPath, t as capitalize } from "./utils-BqOCY-3W.js";
+import { c as isOperationLike, f as isRecord, o as isOpenAPIPaths } from "./guard-BzaK5_qz.js";
+import { t as core } from "./core-CaXcQRYE.js";
+import { a as parsePathItem, i as operationHasArgs, n as hasNoContentResponse, o as resolveSplitOutDir, r as makeOperationDeps, t as formatPath } from "./hono-rpc-CvPU8S0M.js";
 import path from "node:path";
 //#region src/helper/query.ts
 /**

package/dist/vite-plugin/index.js

@@ -1,8 +1,8 @@
 import { parseConfig } from "../config/index.js";
-import { f as isRecord } from "../guard-BabA4f3q.js";
-import { r as setFormatOptions } from "../core-BlUaJE2n.js";
-import { _ as examples, a as takibi, c as securitySchemes, d as requestBodies, f as pathItems, g as headers, h as links, i as template, l as schemas, m as mediaTypes, n as webhooks, o as route, p as parameters, r as test, s as mock, t as parseOpenAPI, u as responses, v as callbacks } from "../openapi-D2QO8Njt.js";
-import { t as docs } from "../docs-Da_MOdAe.js";
+import { f as isRecord } from "../guard-BzaK5_qz.js";
+import { r as setFormatOptions } from "../core-CaXcQRYE.js";
+import { _ as examples, a as takibi, c as securitySchemes, d as requestBodies, f as pathItems, g as headers, h as links, i as template, l as schemas, m as mediaTypes, n as webhooks, o as route, p as parameters, r as test, s as mock, t as parseOpenAPI, u as responses, v as callbacks } from "../openapi-CSP6nmmf.js";
+import { t as docs } from "../docs-BnLvHynR.js";
 import { rpc } from "../core/rpc/index.js";
 import { svelteQuery } from "../core/svelte-query/index.js";
 import { swr } from "../core/swr/index.js";
@@ -13,13 +13,6 @@ import path from "node:path";
 import fsp from "node:fs/promises";
 //#region src/vite-plugin/index.ts
 /**
-* Type guard for configuration objects.
-*
-* @param value - Value to check
-* @returns True if value is a valid configuration object
-*/
-const isConfiguration = (value) => typeof value === "object" && value !== null;
-/**
 * Converts a relative path to an absolute path.
 *
 * @param relativePath - Relative path
@@ -52,7 +45,7 @@ const readConfigurationWithHotReload = async (server) => {
 		} else server.moduleGraph.invalidateAll();
 		const loadedModule = await server.ssrLoadModule(`${absoluteConfigPath}?t=${String(Date.now())}`);
 		const defaultExport = isRecord(loadedModule) ? Reflect.get(loadedModule, "default") : void 0;
-		if (!isConfiguration(defaultExport)) return {
+		if (!(typeof defaultExport === "object" && defaultExport !== null)) return {
 			ok: false,
 			error: "Config must export default object"
 		};
@@ -72,20 +65,6 @@ const readConfigurationWithHotReload = async (server) => {
 	}
 };
 /**
-* Lists TypeScript files in a directory (shallow, non-recursive).
-*
-* @param directoryPath - Directory path to scan
-* @returns Promise resolving to array of absolute file paths
-*/
-const listTypeScriptFilesShallow = async (directoryPath) => fsp.stat(directoryPath).then((fileStats) => fileStats.isDirectory() ? fsp.readdir(directoryPath, { withFileTypes: true }).then((directoryEntries) => directoryEntries.filter((entry) => entry.isFile() && entry.name.endsWith(".ts")).map((entry) => path.join(directoryPath, entry.name))) : []).catch(() => []);
-/**
-* Deletes specified TypeScript files.
-*
-* @param filePaths - Array of file paths to delete
-* @returns Promise resolving to array of deleted file paths
-*/
-const deleteTypeScriptFiles = async (filePaths) => Promise.all(filePaths.map((filePath) => fsp.unlink(filePath).then(() => filePath).catch(() => null))).then((results) => results.filter((result) => result !== null));
-/**
 * Creates a debounced version of a function.
 *
 * Delays invocation until after the specified milliseconds have elapsed
@@ -120,7 +99,11 @@ const runAllGenerationTasks = async (config) => {
 	*/
 	const runSplitAwareJob = async (name, output, isSplit, generate) => {
 		const absOutput = toAbsolutePath(output);
-		if (isSplit) await deleteTypeScriptFiles(await listTypeScriptFilesShallow(absOutput));
+		if (isSplit) {
+			const listTypeScriptFilesShallow = async (directoryPath) => fsp.stat(directoryPath).then((fileStats) => fileStats.isDirectory() ? fsp.readdir(directoryPath, { withFileTypes: true }).then((directoryEntries) => directoryEntries.filter((entry) => entry.isFile() && entry.name.endsWith(".ts")).map((entry) => path.join(directoryPath, entry.name))) : []).catch(() => []);
+			const deleteTypeScriptFiles = async (filePaths) => Promise.all(filePaths.map((filePath) => fsp.unlink(filePath).then(() => filePath).catch(() => null))).then((results) => results.filter((result) => result !== null));
+			await deleteTypeScriptFiles(await listTypeScriptFilesShallow(absOutput));
+		}
 		const result = await generate(absOutput);
 		if (!result.ok) return `❌ ${name}: ${result.error}`;
 		return `✅ ${name}${isSplit ? "(split)" : ""} -> ${absOutput}`;
@@ -233,7 +216,7 @@ const runAllGenerationTasks = async (config) => {
 		if (!config.test) return void 0;
 		return (async () => {
 			const outputPath = toAbsolutePath(config.test?.output ?? "");
-			const result = await test(openAPI, outputPath, config.test?.import ?? "", config.basePath ?? "/", config.test?.framework);
+			const result = await test(openAPI, outputPath, config.test?.import ?? "", config.basePath ?? "/", config.test?.testFramework);
 			return result.ok ? `✅ test -> ${outputPath}` : `❌ test: ${result.error}`;
 		})();
 	};
@@ -261,7 +244,7 @@ const runAllGenerationTasks = async (config) => {
 		return (async () => {
 			const absPath = toAbsolutePath(routeOutputPath);
 			if (!isTypeScriptFile(absPath)) return `❌ template: Invalid output format: ${absPath}`;
-			const result = await template(openAPI, absPath, tmpl.test, config.basePath ?? "/", tmpl.pathAlias, config["zod-openapi"]?.routes?.import, tmpl.routeHandler, tmpl.framework);
+			const result = await template(openAPI, absPath, tmpl.test, config.basePath ?? "/", tmpl.pathAlias, config["zod-openapi"]?.routes?.import, tmpl.routeHandler, tmpl.testFramework);
 			return result.ok ? `✅ template -> ${absPath}` : `❌ template: ${result.error}`;
 		})();
 	};
@@ -294,17 +277,6 @@ const runAllGenerationTasks = async (config) => {
 	return Promise.all(generationJobs).then((logs) => ({ logs }));
 };
 /**
-* Checks if a file path matches input file patterns.
-*
-* @param filePath - Absolute path to check
-* @param inputDirectory - Directory containing input files
-* @returns True if the file is an input file (yaml/json/tsp)
-*/
-const isInputFile = (filePath, inputDirectory) => {
-	if (!filePath.startsWith(inputDirectory)) return false;
-	return filePath.endsWith(".yaml") || filePath.endsWith(".json") || filePath.endsWith(".tsp");
-};
-/**
 * Adds glob patterns to the Vite file watcher.
 *
 * Watches the input file and related files (.yaml, .json, .tsp) in the
@@ -376,37 +348,6 @@ const extractOutputPaths = (config) => {
 		config.docs?.output
 	].filter((outputPath) => outputPath !== void 0).map(toAbsolutePath);
 };
-/**
-* Cleans up output paths that exist in previous config but not in current config.
-*
-* When an output path is removed from the configuration, this function
-* removes the corresponding file or directory completely.
-*
-* @param previousConfiguration - Previous configuration
-* @param currentConfiguration - Current configuration
-* @returns Array of cleaned up paths
-*/
-const cleanupStaleOutputs = async (previousConfiguration, currentConfiguration) => {
-	const previousPaths = new Set(extractOutputPaths(previousConfiguration));
-	const currentPaths = new Set(extractOutputPaths(currentConfiguration));
-	const stalePaths = [...previousPaths].filter((stalePath) => !currentPaths.has(stalePath));
-	return (await Promise.all(stalePaths.map(async (stalePath) => {
-		const fileStats = await fsp.stat(stalePath).catch(() => null);
-		if (!fileStats) return null;
-		if (fileStats.isDirectory()) {
-			await fsp.rm(stalePath, {
-				recursive: true,
-				force: true
-			}).catch(() => {});
-			return stalePath;
-		}
-		if (fileStats.isFile() && (stalePath.endsWith(".ts") || stalePath.endsWith(".md"))) {
-			await fsp.unlink(stalePath).catch(() => {});
-			return stalePath;
-		}
-		return null;
-	}))).filter((result) => result !== null);
-};
 function honoTakibiVite() {
 	const pluginState = {
 		current: null,
@@ -431,6 +372,27 @@ function honoTakibiVite() {
 			return;
 		}
 		if (pluginState.current) {
+			const cleanupStaleOutputs = async (previousConfiguration, currentConfiguration) => {
+				const previousPaths = new Set(extractOutputPaths(previousConfiguration));
+				const currentPaths = new Set(extractOutputPaths(currentConfiguration));
+				const stalePaths = [...previousPaths].filter((stalePath) => !currentPaths.has(stalePath));
+				return (await Promise.all(stalePaths.map(async (stalePath) => {
+					const fileStats = await fsp.stat(stalePath).catch(() => null);
+					if (!fileStats) return null;
+					if (fileStats.isDirectory()) {
+						await fsp.rm(stalePath, {
+							recursive: true,
+							force: true
+						}).catch(() => {});
+						return stalePath;
+					}
+					if (fileStats.isFile() && (stalePath.endsWith(".ts") || stalePath.endsWith(".md"))) {
+						await fsp.unlink(stalePath).catch(() => {});
+						return stalePath;
+					}
+					return null;
+				}))).filter((result) => result !== null);
+			};
 			const cleanedPaths = await cleanupStaleOutputs(pluginState.current, nextConfiguration.value);
 			for (const cleanedPath of cleanedPaths) console.log(`✅ cleanup: ${cleanedPath}`);
 		}
@@ -467,7 +429,7 @@ function honoTakibiVite() {
 						await handleConfigurationChange(server);
 						return;
 					}
-					if (pluginState.inputDirectory && isInputFile(absoluteChangedPath, pluginState.inputDirectory)) debouncedRunGeneration();
+					if (pluginState.inputDirectory && absoluteChangedPath.startsWith(pluginState.inputDirectory) && (absoluteChangedPath.endsWith(".yaml") || absoluteChangedPath.endsWith(".json") || absoluteChangedPath.endsWith(".tsp"))) debouncedRunGeneration();
 				});
 				await runGenerationAndReload(server);
 			})().catch((error) => console.error("❌ watch error:", error));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono-takibi",
-  "version": "0.9.995",
+  "version": "0.9.996",
   "description": "Hono Takibi is a code generator from OpenAPI to @hono/zod-openapi",
   "keywords": [
     "hono",
@@ -72,18 +72,18 @@
     "@apidevtools/swagger-parser": "^12.1.0",
     "@typespec/compiler": "^1.10.0",
     "@typespec/openapi3": "^1.10.0",
-    "oxfmt": "^0.42.0",
+    "oxfmt": "^0.43.0",
     "ts-morph": "^27.0.2",
     "tsx": "^4.21.0",
     "typescript": "^6.0.2",
     "zod": "^4.3.6"
   },
   "devDependencies": {
-    "@types/node": "^25.5.0",
+    "@types/node": "^25.5.2",
     "@typespec/http": "^1.10.0",
     "@typespec/rest": "^0.80.0",
     "@typespec/versioning": "^0.80.0",
-    "tsdown": "0.21.5"
+    "tsdown": "0.21.7"
   },
   "scripts": {
     "dev": "vite --host",