hono-takibi 0.9.99994 → 0.9.99995

package/README.md

@@ -200,7 +200,6 @@ export default app
 ```ts
 export default defineConfig({
   input: 'openapi.yaml',
-  output: './src/index.ts',
   template: { define: true },
 })
 ```
@@ -221,7 +220,7 @@ export const getUsersIdRoute = defineOpenAPIRoute({
 })
 ```
 
-Component schemas go to `components/index.ts` (override with `components.output`). Set `template.output` to change the route directory (default `./src/routes`).
+The app entry defaults to `src/index.ts` (override with `output`, which must be an `index.ts` path such as `./server/index.ts`). Route files always go to `routes/` next to the app entry, and component schemas to `components/index.ts` (override with `components.output`). When `output` is omitted, `components.output` also anchors the layout: `components: { output: './server/components/index.ts' }` puts the app entry at `server/index.ts` and routes at `server/routes/`.
 
 ## Client Library Integrations
 
@@ -305,7 +304,7 @@ export default defineConfig({
 
 ## Full Config Reference
 
-Some options are mutually exclusive: `output` ↔ `routes`, `components.output` ↔ per-type components, `template.define` ↔ `routeHandler`.
+Some options are mutually exclusive: `output` ↔ `routes`, `template.define` ↔ `routes`, `components.output` ↔ per-type components, `template.define` ↔ `routeHandler`.
 
 ```ts
 import { defineConfig } from 'hono-takibi/config'
@@ -313,7 +312,7 @@ import { defineConfig } from 'hono-takibi/config'
 export default defineConfig({
   input: 'openapi.yaml',
 
-  output: './src/routes.ts', // single-file mode; with template.define, the app entry (required)
+  output: './src/routes.ts', // single-file mode; with template.define, the app entry (an index.ts path, default ./src/index.ts)
   basePath: '/api',
   readonly: true,
   // format: {}, // oxfmt FormatConfig
@@ -322,7 +321,6 @@ export default defineConfig({
     test: true,
     routeHandler: false, // true: RouteHandler exports
     define: false, // true: defineOpenAPIRoute output
-    // output: './src/routes', // define mode dir (default ./src/routes)
     pathAlias: '@/',
     testFramework: 'vitest', // "vitest" | "vite-plus" | "bun"
   },

package/dist/config/index.d.ts

@@ -10,7 +10,6 @@ declare const ConfigSchema: z.ZodReadonly<z.ZodObject<{
   format: z.ZodExactOptional<z.ZodCustom<FormatConfig, FormatConfig>>;
   template: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
     define: z.ZodLiteral<true>;
-    output: z.ZodDefault<z.ZodString>;
     test: z.ZodDefault<z.ZodBoolean>;
     pathAlias: z.ZodExactOptional<z.ZodString>;
     testFramework: z.ZodExactOptional<z.ZodDefault<z.ZodEnum<{
@@ -21,7 +20,6 @@ declare const ConfigSchema: z.ZodReadonly<z.ZodObject<{
   }, z.core.$strip>>, z.ZodReadonly<z.ZodObject<{
     define: z.ZodDefault<z.ZodOptional<z.ZodLiteral<false>>>;
     routeHandler: z.ZodDefault<z.ZodBoolean>;
-    output: z.ZodExactOptional<z.ZodString>;
     test: z.ZodDefault<z.ZodBoolean>;
     pathAlias: z.ZodExactOptional<z.ZodString>;
     testFramework: z.ZodExactOptional<z.ZodDefault<z.ZodEnum<{
@@ -330,7 +328,6 @@ declare function parseConfig(config: unknown): {
     format?: FormatConfig;
     template?: Readonly<{
       define: true;
-      output: string;
       test: boolean;
       pathAlias?: string;
       testFramework?: "vitest" | "vite-plus" | "bun";
@@ -338,7 +335,6 @@ declare function parseConfig(config: unknown): {
       define: false;
       routeHandler: boolean;
       test: boolean;
-      output?: string;
       pathAlias?: string;
       testFramework?: "vitest" | "vite-plus" | "bun";
     }>;
@@ -625,7 +621,6 @@ declare function readConfig(): Promise<{
     format?: FormatConfig;
     template?: Readonly<{
       define: true;
-      output: string;
       test: boolean;
       pathAlias?: string;
       testFramework?: "vitest" | "vite-plus" | "bun";
@@ -633,7 +628,6 @@ declare function readConfig(): Promise<{
       define: false;
       routeHandler: boolean;
       test: boolean;
-      output?: string;
       pathAlias?: string;
       testFramework?: "vitest" | "vite-plus" | "bun";
     }>;
@@ -902,14 +896,12 @@ declare function defineConfig(config: z.input<typeof ConfigSchema>): Readonly<{
   format?: FormatConfig;
   template?: Readonly<{
     define: true;
-    output?: string | undefined;
     test?: boolean | undefined;
     pathAlias?: string;
     testFramework?: "vitest" | "vite-plus" | "bun" | undefined;
   }> | Readonly<{
     define?: false | undefined;
     routeHandler?: boolean | undefined;
-    output?: string;
     test?: boolean | undefined;
     pathAlias?: string;
     testFramework?: "vitest" | "vite-plus" | "bun" | undefined;

package/dist/config/index.js

@@ -1,3 +1,4 @@
+import { i as deriveAppEntry } from "../utils-B5PbMfWs.js";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
@@ -64,7 +65,6 @@ const ConfigSchema = z.object({
 	format: z.custom(() => true).exactOptional(),
 	template: z.discriminatedUnion("define", [z.object({
 		define: z.literal(true),
-		output: z.string().regex(/^(?!.*\.ts$).+/, { error: "template.output must be a directory, not a .ts file" }).default("src/routes"),
 		test: z.boolean().default(false),
 		pathAlias: z.string().exactOptional(),
 		testFramework: z.enum([
@@ -75,7 +75,6 @@ const ConfigSchema = z.object({
 	}).readonly(), z.object({
 		define: z.literal(false).optional().default(false),
 		routeHandler: z.boolean().default(false),
-		output: z.string().regex(/^(?!.*\.ts$).+/, { error: "template.output must be a directory, not a .ts file" }).exactOptional(),
 		test: z.boolean().default(false),
 		pathAlias: z.string().exactOptional(),
 		testFramework: z.enum([
@@ -174,7 +173,28 @@ const ConfigSchema = z.object({
 		entry: z.string().exactOptional(),
 		baseUrl: z.string().exactOptional()
 	}).readonly()]).exactOptional()
-}).readonly().refine((v) => !(v.output && v.routes), { message: "output and routes are mutually exclusive. Use output for single-file mode, or routes for separate route output." }).refine((v) => !(v.template?.define && !v.output), { message: "template.define requires output (the app entry file, e.g. ./src/index.ts)." });
+}).readonly().refine((v) => !(v.output && v.routes), { message: "output and routes are mutually exclusive. Use output for single-file mode, or routes for separate route output." }).refine((v) => !(v.template?.define === true && v.routes), { message: "template.define and routes are mutually exclusive. define derives routes/ next to the app entry (output, default src/index.ts)." }).refine((v) => !(v.template?.define === true && v.output !== void 0 && !(v.output === "index.ts" || v.output.endsWith("/index.ts"))), { message: "with template.define, output is the app entry and must be an index.ts file (e.g. ./src/index.ts), or omitted to default to src/index.ts. Other names collide with the derived routes/ directory." }).refine((v) => !(v.template?.define === true && v.components !== void 0 && [
+	"schemas",
+	"responses",
+	"parameters",
+	"examples",
+	"requestBodies",
+	"headers",
+	"securitySchemes",
+	"links",
+	"callbacks",
+	"pathItems",
+	"mediaTypes"
+].some((k) => v.components?.[k] !== void 0)), { message: "with template.define, per-type component outputs (components.schemas, components.responses, ...) are not supported. Use components.output for a single components file." }).refine((v) => {
+	if (v.template?.define !== true || v.components?.output === void 0) return true;
+	const normalize = (p) => p.replace(/^\.\//, "");
+	const componentsOutput = normalize(v.components.output);
+	const appEntry = normalize(v.output ?? deriveAppEntry(componentsOutput));
+	if (!appEntry.endsWith("index.ts")) return true;
+	const baseDir = appEntry === "index.ts" ? "" : appEntry.slice(0, -9);
+	const routesDir = baseDir === "" ? "routes" : `${baseDir}/routes`;
+	return componentsOutput !== appEntry && !componentsOutput.startsWith(`${routesDir}/`);
+}, { message: "with template.define, components.output must not point at the app entry or inside the derived routes/ directory (it would be overwritten). Choose another path, e.g. src/components/index.ts." });
 function parseConfig(config) {
 	const result = ConfigSchema.safeParse(config);
 	if (!result.success) {

package/dist/core/docs/index.js

@@ -1,2 +1,2 @@
-import { t as docs } from "../../docs-380Wcu6a.js";
+import { t as docs } from "../../docs-DbknIWmx.js";
 export { docs };

package/dist/core/hooks/index.js

@@ -1,2 +1,2 @@
-import { t as hooks } from "../../hooks-CkiatAe9.js";
+import { t as hooks } from "../../hooks-CCw7jm8g.js";
 export { hooks };

package/dist/core/rpc/index.js

@@ -1,6 +1,7 @@
+import { f as methodPath, u as makeInferRequestType } from "../../utils-B5PbMfWs.js";
 import { t as emit } from "../../emit-CFR63U4L.js";
-import { A as makeInferRequestType, M as methodPath, c as isOperationLike, f as isRecord, o as isOpenAPIPaths } from "../../guard-zvkMUVYD.js";
-import { a as parsePathItem, i as operationHasArgs, o as resolveSplitOutDir, r as makeOperationDeps, t as formatPath } from "../../rpc-CepeggWU.js";
+import { c as isOperationLike, f as isRecord, o as isOpenAPIPaths } from "../../guard-BSZ8ezEv.js";
+import { a as parsePathItem, i as operationHasArgs, o as resolveSplitOutDir, r as makeOperationDeps, t as formatPath } from "../../rpc-BzPo2tZf.js";
 import path from "node:path";
 //#region src/core/rpc/index.ts
 /**

package/dist/core/type/index.js

@@ -1,5 +1,6 @@
+import { d as makeSafeKey, g as statusCodeToNumber } from "../../utils-B5PbMfWs.js";
 import { t as emit } from "../../emit-CFR63U4L.js";
-import { I as statusCodeToNumber, g as isSchemaArray, i as isMediaWithSchema, j as makeSafeKey, l as isParameter, m as isRequestBody, n as isHttpMethod, s as isOperation, u as isParameterArray, x as isStringRef } from "../../guard-zvkMUVYD.js";
+import { g as isSchemaArray, i as isMediaWithSchema, l as isParameter, m as isRequestBody, n as isHttpMethod, s as isOperation, u as isParameterArray, x as isStringRef } from "../../guard-BSZ8ezEv.js";
 import path from "node:path";
 //#region src/core/type/index.ts
 /**

package/dist/{docs-380Wcu6a.js → docs-DbknIWmx.js}

@@ -1,5 +1,6 @@
+import { s as escapeHtml } from "./utils-B5PbMfWs.js";
 import { a as writeFile, t as mkdir } from "./fsp-BXry-Hx5.js";
-import { D as escapeHtml, a as isOAuthFlowValue, b as isSecurityScheme, f as isRecord, h as isResponses, m as isRequestBody, p as isRefObject, r as isMedia, y as isSecurityArray } from "./guard-zvkMUVYD.js";
+import { a as isOAuthFlowValue, b as isSecurityScheme, f as isRecord, h as isResponses, m as isRequestBody, p as isRefObject, r as isMedia, y as isSecurityArray } from "./guard-BSZ8ezEv.js";
 import path from "node:path";
 import { STATUS_CODES } from "node:http";
 //#region src/generator/docs/index.ts

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

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

package/dist/guard-BSZ8ezEv.js

@@ -0,0 +1,83 @@
+//#region src/guard/index.ts
+function isRecord(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isHttpMethod(method) {
+	return method === "get" || method === "put" || method === "post" || method === "delete" || method === "patch" || method === "options" || method === "head" || method === "trace";
+}
+function isValidIdent(str) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(str);
+}
+function isOpenAPIPaths(v) {
+	if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+	return Object.values(v).every((entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry));
+}
+function isRefObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v) && "$ref" in v && typeof v.$ref === "string";
+}
+function isStringRef(v) {
+	return "$ref" in v && typeof v.$ref === "string";
+}
+function isParameterObject(v) {
+	if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+	if (!("name" in v) || typeof v.name !== "string") return false;
+	if (!("in" in v)) return false;
+	const pos = v.in;
+	return pos === "path" || pos === "query" || pos === "header" || pos === "cookie";
+}
+function isParameter(v) {
+	return typeof v === "object" && v !== null && "name" in v && "in" in v && ("schema" in v || "content" in v);
+}
+function isParameterArray(v) {
+	return Array.isArray(v);
+}
+function isOperationLike(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v) && "responses" in v;
+}
+function isOperation(v) {
+	return typeof v === "object" && v !== null && "responses" in v;
+}
+function isSchemaProperty(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v) && "schema" in v;
+}
+function isSchemaArray(v) {
+	return Array.isArray(v);
+}
+/**
+* JSON Schema 2020-12 §4.3.2 / §10.3.1.2 type guard for schema-vs-boolean
+* discrimination. `items`, `additionalProperties`, `unevaluatedItems`, and
+* `unevaluatedProperties` may be either an object schema or a boolean schema
+* (`true` = pass-through, `false` = reject). This narrows the union to the
+* object form so callers can recurse without `as` casts.
+*/
+function isSchemaObject(v) {
+	return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function isMediaWithSchema(v) {
+	return typeof v === "object" && v !== null && "schema" in v;
+}
+function isMedia(v) {
+	return typeof v === "object" && v !== null && "schema" in v;
+}
+function isRequestBody(v) {
+	return typeof v === "object" && v !== null && ("content" in v || "required" in v || "description" in v);
+}
+function isContentBody(v) {
+	return typeof v === "object" && v !== null && !("$ref" in v);
+}
+function isSecurityScheme(v) {
+	return typeof v === "object" && v !== null && !("$ref" in v);
+}
+function isSecurityArray(v) {
+	return Array.isArray(v);
+}
+function isResponses(v) {
+	if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+	return "$ref" in v || "description" in v || "content" in v || "headers" in v || "links" in v;
+}
+function isOAuthFlowValue(v) {
+	if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
+	return "authorizationUrl" in v || "tokenUrl" in v || "scopes" in v;
+}
+//#endregion
+export { isValidIdent as S, isSchemaObject as _, isOAuthFlowValue as a, isSecurityScheme as b, isOperationLike as c, isParameterObject as d, isRecord as f, isSchemaArray as g, isResponses as h, isMediaWithSchema as i, isParameter as l, isRequestBody as m, isHttpMethod as n, isOpenAPIPaths as o, isRefObject as p, isMedia as r, isOperation as s, isContentBody as t, isParameterArray as u, isSchemaProperty as v, isStringRef as x, isSecurityArray as y };

package/dist/{hooks-CkiatAe9.js → hooks-CCw7jm8g.js}

@@ -1,6 +1,7 @@
+import { _ as toIdentifierPascalCase, f as methodPath, n as capitalize } from "./utils-B5PbMfWs.js";
 import { t as emit } from "./emit-CFR63U4L.js";
-import { L as toIdentifierPascalCase, M as methodPath, c as isOperationLike, f as isRecord, o as isOpenAPIPaths, w as capitalize } from "./guard-zvkMUVYD.js";
-import { a as parsePathItem, i as operationHasArgs, n as hasNoContentResponse, o as resolveSplitOutDir, r as makeOperationDeps, t as formatPath } from "./rpc-CepeggWU.js";
+import { c as isOperationLike, f as isRecord, o as isOpenAPIPaths } from "./guard-BSZ8ezEv.js";
+import { a as parsePathItem, i as operationHasArgs, n as hasNoContentResponse, o as resolveSplitOutDir, r as makeOperationDeps, t as formatPath } from "./rpc-BzPo2tZf.js";
 import path from "node:path";
 //#region src/helper/query.ts
 function makeHookName(method, pathStr, prefix) {
@@ -313,7 +314,7 @@ function makeSWRHeader(importPath, clientName, hasQuery, hasMutation, hasAnyArgs
 		lines.push("import useSWRMutation from'swr/mutation'");
 		lines.push("import type{SWRMutationConfiguration}from'swr/mutation'");
 	}
-	const honoTypeImports = ["ClientRequestOptions", ...hasAnyArgs ? ["InferRequestType"] : []];
+	const honoTypeImports = ["ClientRequestOptions", ...hasAnyArgs || hasInfiniteQuery ? ["InferRequestType"] : []];
 	lines.push(`import type{${honoTypeImports.join(",")}}from'hono/client'`);
 	lines.push("import{parseResponse}from'hono/client'");
 	lines.push(`import{${clientName}}from'${importPath}'`);
@@ -515,7 +516,7 @@ function makeHeader(importPath, clientName, hasQuery, hasMutation, hasAnyArgs, c
 		...hasMutation ? [config.useMutationOptionsType] : []
 	];
 	const needsVueImports = config.isVueQuery && hasQueryWithArgs;
-	const honoTypeImports = ["ClientRequestOptions", ...hasAnyArgs ? ["InferRequestType"] : []];
+	const honoTypeImports = ["ClientRequestOptions", ...hasAnyArgs || hasInfiniteQuery ? ["InferRequestType"] : []];
 	return `${[
 		...queryImports.length > 0 ? [`import{${queryImports.join(",")}}from'${config.packageName}'`] : [],
 		...typeImports.length > 0 ? [`import type{${typeImports.join(",")}}from'${config.packageName}'`] : [],

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { readConfig } from "./config/index.js";
 import { r as setFormatOptions } from "./emit-CFR63U4L.js";
-import { n as parseOpenAPI, r as takibi, t as makeJob } from "./shared-n3ZMLfl9.js";
+import { n as parseOpenAPI, r as takibi, t as makeJob } from "./shared-B-TUm7Fa.js";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
 //#region src/cli/index.ts

package/dist/{openapi-8ZYAMj_e.js → openapi-BlTDQFFF.js}

@@ -1,4 +1,5 @@
-import { C as baseError, E as error, F as requestParamsArray, L as toIdentifierPascalCase, M as methodPath, N as normalizeTypes, O as escapeRegexLiteral, P as renderNamedImport, R as uncapitalize, T as ensureSuffix, _ as isSchemaObject, f as isRecord, g as isSchemaArray, j as makeSafeKey, l as isParameter, p as isRefObject, r as isMedia, s as isOperation, z as zodToOpenAPISchema } from "./guard-zvkMUVYD.js";
+import { _ as toIdentifierPascalCase, a as ensureSuffix, c as escapeRegexLiteral, d as makeSafeKey, f as methodPath, h as requestParamsArray, m as renderNamedImport, o as error, p as normalizeTypes, r as cyclicNodes, t as baseError, v as uncapitalize, y as zodToOpenAPISchema } from "./utils-B5PbMfWs.js";
+import { _ as isSchemaObject, f as isRecord, g as isSchemaArray, l as isParameter, p as isRefObject, r as isMedia, s as isOperation } from "./guard-BSZ8ezEv.js";
 import path from "node:path";
 import ts from "typescript";
 //#region src/helper/code.ts
@@ -1634,108 +1635,33 @@ function getChildren(node) {
 	return semanticChildren;
 }
 function collectIdentifiers(node) {
+	const identifiers = [];
 	const visit = (n) => {
-		const current = ts.isIdentifier(n) ? [n.text] : [];
-		const children = getChildren(n).flatMap(visit);
-		return [...current, ...children];
+		if (ts.isIdentifier(n)) identifiers.push(n.text);
+		for (const child of getChildren(n)) visit(child);
 	};
-	return visit(node);
-}
-function extractIdentifiers(code, varNames) {
-	const allIdentifiers = collectIdentifiers(makeSourceFile(code));
-	return [...new Set(allIdentifiers.filter((id) => varNames.has(id)))];
-}
-function createInitialState() {
-	return {
-		indices: /* @__PURE__ */ new Map(),
-		lowLinks: /* @__PURE__ */ new Map(),
-		onStack: /* @__PURE__ */ new Set(),
-		stack: [],
-		sccs: [],
-		index: 0
-	};
-}
-function popStackUntil(stack, onStack, name) {
-	const idx = stack.lastIndexOf(name);
-	if (idx === -1) return {
-		scc: [],
-		newStack: stack,
-		newOnStack: onStack
-	};
-	const scc = stack.slice(idx);
-	return {
-		scc,
-		newStack: stack.slice(0, idx),
-		newOnStack: new Set([...onStack].filter((n) => !scc.includes(n)))
-	};
-}
-function tarjanConnect(name, deps, var2name, state) {
-	const currentIndex = state.index;
-	const indices = new Map(state.indices).set(name, currentIndex);
-	const lowLinks = new Map(state.lowLinks).set(name, currentIndex);
-	const stack = [...state.stack, name];
-	const onStack = /* @__PURE__ */ new Set([...state.onStack, name]);
-	const initialState = {
-		...state,
-		indices,
-		lowLinks,
-		stack,
-		onStack,
-		index: currentIndex + 1
-	};
-	const afterDeps = (deps.get(name) ?? []).reduce((s, depVar) => {
-		const depName = var2name.get(depVar);
-		if (depName === void 0) return s;
-		if (!s.indices.has(depName)) {
-			const afterConnect = tarjanConnect(depName, deps, var2name, s);
-			const newLowLink = Math.min(afterConnect.lowLinks.get(name) ?? 0, afterConnect.lowLinks.get(depName) ?? 0);
-			const updatedLowLinks = new Map(afterConnect.lowLinks).set(name, newLowLink);
-			return {
-				...afterConnect,
-				lowLinks: updatedLowLinks
-			};
-		}
-		if (s.onStack.has(depName)) {
-			const newLowLink = Math.min(s.lowLinks.get(name) ?? 0, s.indices.get(depName) ?? 0);
-			const updatedLowLinks = new Map(s.lowLinks).set(name, newLowLink);
-			return {
-				...s,
-				lowLinks: updatedLowLinks
-			};
-		}
-		return s;
-	}, initialState);
-	if (afterDeps.lowLinks.get(name) === afterDeps.indices.get(name)) {
-		const { scc, newStack, newOnStack } = popStackUntil(afterDeps.stack, afterDeps.onStack, name);
-		return {
-			...afterDeps,
-			stack: newStack,
-			onStack: newOnStack,
-			sccs: [...afterDeps.sccs, scc]
-		};
-	}
-	return afterDeps;
+	visit(node);
+	return identifiers;
 }
 function findCyclicSchemas(names, deps) {
-	const name2var = new Map(names.map((n) => [n, toIdentifierPascalCase(ensureSuffix(n, "Schema"))]));
 	const var2name = new Map(names.map((n) => [toIdentifierPascalCase(ensureSuffix(n, "Schema")), n]));
-	const finalState = names.reduce((state, n) => state.indices.has(n) ? state : tarjanConnect(n, deps, var2name, state), createInitialState());
-	return new Set(finalState.sccs.flatMap((scc) => {
-		if (scc.length > 1) return [...scc];
-		const single = scc[0];
-		if (!single) return [];
-		const selfVar = name2var.get(single);
-		return selfVar && (deps.get(single) ?? []).includes(selfVar) ? [single] : [];
-	}));
+	return cyclicNodes(new Map(names.map((n) => [n, (deps.get(n) ?? []).map((v) => var2name.get(v)).filter((x) => x !== void 0)])));
 }
 function analyzeCircularSchemas(schemas, schemaNames, readonly) {
 	const varNameSet = new Set(schemaNames.map((n) => toIdentifierPascalCase(ensureSuffix(n, "Schema"))));
 	const varNameToName = new Map(schemaNames.map((n) => [toIdentifierPascalCase(ensureSuffix(n, "Schema")), n]));
 	const zSchemaMap = new Map(schemaNames.map((n) => [n, zodToOpenAPI(schemas[n], void 0, readonly === true ? { readonly: true } : void 0)]));
+	const batchedSource = makeSourceFile(schemaNames.map((n) => `const ${toIdentifierPascalCase(ensureSuffix(n, "Schema"))} = ${zSchemaMap.get(n)}`).join("\n"));
+	const initializerIdentifiers = new Map(batchedSource.statements.flatMap((statement) => {
+		if (!ts.isVariableStatement(statement)) return [];
+		const declaration = statement.declarationList.declarations[0];
+		if (!(declaration && ts.isIdentifier(declaration.name) && declaration.initializer)) return [];
+		return [[declaration.name.text, collectIdentifiers(declaration.initializer)]];
+	}));
 	const depsMap = new Map(schemaNames.map((n) => {
-		const code = zSchemaMap.get(n) ?? "";
 		const selfVar = toIdentifierPascalCase(ensureSuffix(n, "Schema"));
-		return [n, extractIdentifiers(code, varNameSet).filter((v) => v !== selfVar)];
+		const identifiers = initializerIdentifiers.get(selfVar) ?? [];
+		return [n, [...new Set(identifiers.filter((id) => varNameSet.has(id)))].filter((v) => v !== selfVar)];
 	}));
 	const cyclicSchemas = findCyclicSchemas(schemaNames, depsMap);
 	const extendedCyclicSchemas = /* @__PURE__ */ new Set([...cyclicSchemas, ...[...cyclicSchemas].flatMap((n) => (depsMap.get(n) ?? []).map((v) => varNameToName.get(v)).filter((x) => x !== void 0))]);
@@ -1799,27 +1725,24 @@ function topoSort(decls) {
 	const makeKey = (kind, name) => `${kind}:${name}`;
 	const map = new Map(decls.map((d) => [makeKey(d.kind, d.name), d]));
 	const findByName = (name) => map.get(makeKey("variable", name)) ?? map.get(makeKey("type", name)) ?? map.get(makeKey("interface", name));
-	const visit = (key, state) => {
-		if (state.perm.has(key) || state.temp.has(key)) return state;
+	const sorted = [];
+	const perm = /* @__PURE__ */ new Set();
+	const temp = /* @__PURE__ */ new Set();
+	const visit = (key) => {
+		if (perm.has(key) || temp.has(key)) return;
 		const decl = map.get(key);
-		if (!decl) return state;
-		const withTemp = {
-			...state,
-			temp: /* @__PURE__ */ new Set([...state.temp, key])
-		};
-		const afterRefs = decl.refs.map((ref) => findByName(ref)).filter((d) => d !== void 0).reduce((s, d) => visit(makeKey(d.kind, d.name), s), withTemp);
-		return {
-			sorted: [...afterRefs.sorted, decl],
-			perm: /* @__PURE__ */ new Set([...afterRefs.perm, key]),
-			temp: new Set([...afterRefs.temp].filter((t) => t !== key))
-		};
-	};
-	const initial = {
-		sorted: [],
-		perm: /* @__PURE__ */ new Set(),
-		temp: /* @__PURE__ */ new Set()
+		if (!decl) return;
+		temp.add(key);
+		for (const ref of decl.refs) {
+			const found = findByName(ref);
+			if (found) visit(makeKey(found.kind, found.name));
+		}
+		temp.delete(key);
+		perm.add(key);
+		sorted.push(decl);
 	};
-	return decls.reduce((state, d) => visit(makeKey(d.kind, d.name), state), initial).sorted;
+	for (const decl of decls) visit(makeKey(decl.kind, decl.name));
+	return sorted;
 }
 function ast(code) {
 	const decls = parseStatements(makeSourceFile(code));
@@ -2365,6 +2288,7 @@ function componentsCode(components, options) {
 function routeCode(openapi, readonly) {
 	const routeEntries = (openapi, readonly) => {
 		const makeEntry = (path, method, operation, readonly) => {
+			const request = makeRequest(operation.parameters, operation.requestBody, readonly);
 			const properties = [
 				`method:${JSON.stringify(method)}`,
 				`path:${JSON.stringify(path)}`,
@@ -2373,7 +2297,7 @@ function routeCode(openapi, readonly) {
 				operation.description ? `description:${JSON.stringify(operation.description)}` : void 0,
 				operation.externalDocs ? `externalDocs:${JSON.stringify(operation.externalDocs)}` : void 0,
 				operation.operationId ? `operationId:${JSON.stringify(operation.operationId)}` : void 0,
-				makeRequest(operation.parameters, operation.requestBody, readonly) ? `request:${makeRequest(operation.parameters, operation.requestBody, readonly)}` : void 0,
+				request ? `request:${request}` : void 0,
 				operation.responses ? `responses:${makeOperationResponses(operation.responses, readonly)}` : void 0,
 				operation.callbacks ? `callbacks:{${makeCallbacks(operation.callbacks, readonly)}}` : void 0,
 				operation.deprecated ? `deprecated:${JSON.stringify(operation.deprecated)}` : void 0,

package/dist/{rpc-CepeggWU.js → rpc-BzPo2tZf.js}

@@ -1,4 +1,4 @@
-import { S as isValidIdent, c as isOperationLike, d as isParameterObject, f as isRecord, p as isRefObject, v as isSchemaProperty } from "./guard-zvkMUVYD.js";
+import { S as isValidIdent, c as isOperationLike, d as isParameterObject, f as isRecord, p as isRefObject, v as isSchemaProperty } from "./guard-BSZ8ezEv.js";
 import path from "node:path";
 //#region src/helper/rpc.ts
 function makeEscaped(s) {

package/dist/{shared-n3ZMLfl9.js → shared-B-TUm7Fa.js}

@@ -1,9 +1,10 @@
+import { _ as toIdentifierPascalCase, a as ensureSuffix, c as escapeRegexLiteral, f as methodPath, g as statusCodeToNumber, i as deriveAppEntry, l as makeBarrel, m as renderNamedImport, r as cyclicNodes, v as uncapitalize, y as zodToOpenAPISchema } from "./utils-B5PbMfWs.js";
 import { n as fmt, t as emit } from "./emit-CFR63U4L.js";
 import { a as writeFile, i as unlink, n as readFile, r as readdir, t as mkdir } from "./fsp-BXry-Hx5.js";
-import { I as statusCodeToNumber, L as toIdentifierPascalCase, M as methodPath, O as escapeRegexLiteral, P as renderNamedImport, R as uncapitalize, T as ensureSuffix, b as isSecurityScheme, i as isMediaWithSchema, k as makeBarrel, l as isParameter, n as isHttpMethod, p as isRefObject, s as isOperation, t as isContentBody, y as isSecurityArray, z as zodToOpenAPISchema } from "./guard-zvkMUVYD.js";
-import { S as makeModuleSpec, _ as makeRef, a as responsesCode, b as makeExportConst, c as headersCode, d as ast, f as zodToOpenAPI, g as makePathItem, h as makeOperationResponses, i as schemasCode, l as makeSplitSchemaFile, m as makeCallbacks, n as routeCode, o as requestBodiesCode, p as makeCallback, r as componentsCode, s as parametersCode, t as zodOpenAPIHono, u as analyzeCircularSchemas, v as makeRequest, x as makeImports, y as makeConst } from "./openapi-8ZYAMj_e.js";
-import { t as hooks } from "./hooks-CkiatAe9.js";
-import { t as docs } from "./docs-380Wcu6a.js";
+import { S as makeModuleSpec, _ as makeRef, a as responsesCode, b as makeExportConst, c as headersCode, d as ast, f as zodToOpenAPI, g as makePathItem, h as makeOperationResponses, i as schemasCode, l as makeSplitSchemaFile, m as makeCallbacks, n as routeCode, o as requestBodiesCode, p as makeCallback, r as componentsCode, s as parametersCode, t as zodOpenAPIHono, u as analyzeCircularSchemas, v as makeRequest, x as makeImports, y as makeConst } from "./openapi-BlTDQFFF.js";
+import { b as isSecurityScheme, i as isMediaWithSchema, l as isParameter, n as isHttpMethod, p as isRefObject, s as isOperation, t as isContentBody, y as isSecurityArray } from "./guard-BSZ8ezEv.js";
+import { t as hooks } from "./hooks-CCw7jm8g.js";
+import { t as docs } from "./docs-DbknIWmx.js";
 import { rpc } from "./core/rpc/index.js";
 import { type } from "./core/type/index.js";
 import path from "node:path";
@@ -652,7 +653,9 @@ function schemaToFaker(schema, propertyName, options = {}) {
 	if (schema.format && FORMAT_TO_FAKER[schema.format]) return FORMAT_TO_FAKER[schema.format];
 	if (propertyName && PROPERTY_NAME_TO_FAKER[propertyName]) {
 		const hint = PROPERTY_NAME_TO_FAKER[propertyName];
-		if (!(hint.includes("faker.number.") && schema.type === "string")) return hint;
+		const isNumberHint = hint.includes("faker.number.");
+		const hasStringConstraint = schema.pattern !== void 0 || schema.minLength !== void 0 || schema.maxLength !== void 0;
+		if (!(schema.type === "string" && (isNumberHint || hasStringConstraint))) return hint;
 	}
 	if (schema.type && typeof schema.type === "string" && TYPE_TO_FAKER[schema.type]) {
 		if (schema.type === "string") {
@@ -708,34 +711,7 @@ function topologicalSort(refs, schemas) {
 	return result;
 }
 function detectCircularSchemas$1(schemas) {
-	const circular = /* @__PURE__ */ new Set();
-	for (const name of Object.keys(schemas)) {
-		const schema = schemas[name];
-		if (!schema) continue;
-		for (const dep of collectRefs(schema)) {
-			if (dep === name) {
-				circular.add(name);
-				break;
-			}
-			const visited = /* @__PURE__ */ new Set();
-			const stack = [dep];
-			while (stack.length > 0) {
-				const current = stack[stack.length - 1];
-				stack.length -= 1;
-				if (current === void 0) break;
-				if (current === name) {
-					circular.add(name);
-					break;
-				}
-				if (visited.has(current)) continue;
-				visited.add(current);
-				const s = schemas[current];
-				if (s) for (const r of collectRefs(s)) stack.push(r);
-			}
-			if (circular.has(name)) break;
-		}
-	}
-	return circular;
+	return cyclicNodes(new Map(Object.entries(schemas).map(([name, schema]) => [name, [...collectRefs(schema)]])));
 }
 function collectSchemaRefs$1(node, refs) {
 	if (Array.isArray(node)) {
@@ -1014,22 +990,24 @@ function makeMock(openapi, basePath, options = {}) {
 	const routes = routeCode(filteredOpenapi, readonlyOption);
 	const appSetup = routeMetas.map(({ routeId }) => `.openapi(${routeId}Route, ${routeId}RouteHandler)`).join("");
 	const handlersJoined = handlers.join("\n\n");
+	const mockFunctionsJoined = mockFunctions.join("\n\n");
+	const bigIntSerializer = `${mockFunctionsJoined}\n${handlersJoined}`.includes("faker.number.bigInt(") ? `if(typeof BigInt.prototype.toJSON!=='function'){Object.defineProperty(BigInt.prototype,'toJSON',{value(this:bigint){return this.toString()},writable:true,configurable:true})}` : "";
 	const needsCookieImport = handlersJoined.includes("getCookie(c,");
 	const imports = `import { OpenAPIHono, createRoute, z, type RouteHandler } from '@hono/zod-openapi'
 ${locale ? `import { faker } from '@faker-js/faker/locale/${locale}'` : `import { faker } from '@faker-js/faker'`}${needsCookieImport ? `\nimport { getCookie } from 'hono/cookie'` : ""}`;
 	const delayMiddleware = delayMiddlewareCode(delay);
-	const appCode = `const app = new OpenAPIHono()${basePath !== "/" ? `.basePath('${basePath}')` : ""}${delayMiddleware}
-
-export const api = app${appSetup}
-
-export default app`;
 	return [
 		imports,
+		bigIntSerializer,
 		components,
 		routes,
-		mockFunctions.join("\n\n"),
+		mockFunctionsJoined,
 		handlersJoined,
-		appCode
+		`const app = new OpenAPIHono()${basePath !== "/" ? `.basePath('${basePath}')` : ""}${delayMiddleware}
+
+export const api = app${appSetup}
+
+export default app`
 	].filter((s) => s.length > 0).join("\n\n");
 }
 //#endregion
@@ -1302,20 +1280,8 @@ function shallowRefs(schema) {
 		...compositeRefs
 	];
 }
-function reachesSelf(start, target, schemas, visited = /* @__PURE__ */ new Set()) {
-	if (start === target) return true;
-	if (visited.has(start)) return false;
-	visited.add(start);
-	const schema = schemas[start];
-	if (!schema) return false;
-	return shallowRefs(schema).some((dep) => reachesSelf(dep, target, schemas, visited));
-}
 function detectCircularSchemas(schemas) {
-	return new Set(Object.keys(schemas).filter((name) => {
-		const schema = schemas[name];
-		if (!schema) return false;
-		return shallowRefs(schema).some((dep) => reachesSelf(dep, name, schemas));
-	}));
+	return cyclicNodes(new Map(Object.entries(schemas).map(([name, schema]) => [name, shallowRefs(schema)])));
 }
 function topologicalOrder(usedSchemaNames, schemas) {
 	const visit = (name, visited, visiting) => {
@@ -1333,10 +1299,10 @@ function topologicalOrder(usedSchemaNames, schemas) {
 	const visited = /* @__PURE__ */ new Set();
 	return [...usedSchemaNames].flatMap((name) => visit(name, visited, /* @__PURE__ */ new Set()));
 }
-function makeMockFunctions(spec, usedSchemaNames) {
+function makeMockFunctions(spec, usedSchemaNames, circularSchemas) {
 	if (!spec.components?.schemas || usedSchemaNames.size === 0) return "";
 	const schemas = spec.components.schemas;
-	const circular = detectCircularSchemas(schemas);
+	const circular = circularSchemas ?? detectCircularSchemas(schemas);
 	return topologicalOrder(usedSchemaNames, schemas).map((name) => {
 		const returnType = circular.has(name) ? ": any" : "";
 		return `function mock${name.replace(/\./g, "")}()${returnType} {\n  return ${schemaToFaker(schemas[name])}\n}`;
@@ -1442,11 +1408,17 @@ 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 = "/", testFramework = "vitest") {
+function makeHandlerTestContext(spec) {
+	return {
+		testCases: extractTestCases(spec),
+		circularSchemas: detectCircularSchemas(spec.components?.schemas ?? {})
+	};
+}
+function makeHandlerTestCode(spec, handlerPath, _routeNames, importFrom, basePath = "/", testFramework = "vitest", context = makeHandlerTestContext(spec)) {
 	const handlerFileName = path.basename(handlerPath, ".ts");
-	const relevantCases = extractTestCases(spec).filter((testCase) => getPathFirstSegment(testCase.path) === handlerFileName);
+	const relevantCases = context.testCases.filter((testCase) => getPathFirstSegment(testCase.path) === handlerFileName);
 	if (relevantCases.length === 0) return "";
-	const mockFunctions = makeMockFunctions(spec, new Set(relevantCases.flatMap((testCase) => testCase.usedSchemaRefs)));
+	const mockFunctions = makeMockFunctions(spec, new Set(relevantCases.flatMap((testCase) => testCase.usedSchemaRefs)), context.circularSchemas);
 	const testCasesCode = relevantCases.map((testCase) => makeTestCase(testCase, basePath, spec.components?.schemas)).join("");
 	const body = `${mockFunctions ? `${mockFunctions}\n\n` : ""}describe(${quoteSingle(handlerFileName.charAt(0).toUpperCase() + handlerFileName.slice(1))},()=>{${testCasesCode}})\n`;
 	const fakerImport = body.includes("faker.") ? `\nimport{faker}from'@faker-js/faker'` : "";
@@ -2059,11 +2031,11 @@ function makeHandlerFileName(path) {
 function makeTestFileName(fileName) {
 	return `${path.basename(fileName, ".ts")}.test.ts`;
 }
-function makePaths(output, pathAlias, routeImport, handlerDir) {
+function makePaths(output, pathAlias, routeImport) {
 	const isDot = output === "." || output === "./";
 	const isIndexFile = !isDot && output.endsWith("/index.ts");
 	const baseDir = isDot ? "." : isIndexFile ? output.match(/^(.*)\/[^/]+\/index\.ts$/)?.[1] ?? "." : output.match(/^(.*)\/[^/]+\.ts$/)?.[1] ?? ".";
-	const handlerPath = handlerDir ?? (baseDir === "." ? "handlers" : `${baseDir}/handlers`);
+	const handlerPath = baseDir === "." ? "handlers" : `${baseDir}/handlers`;
 	const routeModuleName = isIndexFile ? output.match(/([^/]+)\/index\.ts$/)?.[1] ?? "index" : output.endsWith(".ts") ? path.basename(output, ".ts") : "index";
 	const aliasPrefix = pathAlias?.endsWith("/") ? pathAlias.slice(0, -1) : pathAlias;
 	return {
@@ -2161,10 +2133,11 @@ 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, routeImport, routeHandler = false, basePath = "/", testFramework = "vitest", handlerDir) {
+async function zodOpenAPIHonoHandler(openapi, output, test = false, pathAlias, routeImport, 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, handlerDir);
+	const { handlerPath, importFrom, testImportFrom } = makePaths(output, pathAlias, routeImport);
+	const handlerTestContext = test ? makeHandlerTestContext(openapi) : void 0;
 	const mkdirResult = await mkdir(handlerPath);
 	if (!mkdirResult.ok) return {
 		ok: false,
@@ -2189,8 +2162,8 @@ async function zodOpenAPIHonoHandler(openapi, output, test = false, pathAlias, r
 			ok: false,
 			error: writeResult.error
 		};
-		if (test) {
-			const testContent = makeHandlerTestCode(openapi, `${handlerPath}/${handler.fileName}`, [...handler.routeNames], testImportFrom, basePath, testFramework);
+		if (handlerTestContext) {
+			const testContent = makeHandlerTestCode(openapi, `${handlerPath}/${handler.fileName}`, [...handler.routeNames], testImportFrom, basePath, testFramework, handlerTestContext);
 			if (testContent) {
 				const testFmtResult = await fmt(testContent);
 				const testCode = testFmtResult.ok ? testFmtResult.value : testContent;
@@ -2258,7 +2231,7 @@ async function zodOpenAPIHonoHandler(openapi, output, test = false, pathAlias, r
 * @param componentsOutput - The components module path schemas are imported from.
 * @returns A `Result` indicating success or error with message.
 */
-async function defineOpenAPIRouteHandler(openapi, output, componentsOutput, test = false, pathAlias, basePath = "/", testFramework = "vitest", readonly, handlerDir) {
+async function defineOpenAPIRouteHandler(openapi, output, componentsOutput, test = false, pathAlias, basePath = "/", testFramework = "vitest", readonly) {
 	const handlers = defineEntries(openapi, readonly).reduce((acc, entry) => {
 		const fileName = makeHandlerFileName(entry.path);
 		const prev = acc.get(fileName);
@@ -2270,7 +2243,7 @@ async function defineOpenAPIRouteHandler(openapi, output, componentsOutput, test
 		});
 	}, /* @__PURE__ */ new Map());
 	const baseDir = path.dirname(output);
-	const handlerPath = handlerDir ?? (baseDir === "." ? "handlers" : `${baseDir}/handlers`);
+	const handlerPath = baseDir === "." ? "routes" : `${baseDir}/routes`;
 	const aliasPrefix = pathAlias?.endsWith("/") ? pathAlias.slice(0, -1) : pathAlias;
 	const testImportFrom = aliasPrefix ?? makeModuleSpec(`${handlerPath}/handler.ts`, { output });
 	const componentsModulePath = componentsOutput.endsWith("/index.ts") ? path.dirname(componentsOutput) : componentsOutput.replace(/\.ts$/, "");
@@ -2291,6 +2264,7 @@ async function defineOpenAPIRouteHandler(openapi, output, componentsOutput, test
 		output: componentsOutput,
 		...componentsImport ? { import: componentsImport } : {}
 	}]));
+	const handlerTestContext = test ? makeHandlerTestContext(openapi) : void 0;
 	const mkdirResult = await mkdir(handlerPath);
 	if (!mkdirResult.ok) return {
 		ok: false,
@@ -2316,8 +2290,8 @@ async function defineOpenAPIRouteHandler(openapi, output, componentsOutput, test
 			ok: false,
 			error: writeResult.error
 		};
-		if (test) {
-			const testContent = makeHandlerTestCode(openapi, `${handlerPath}/${handler.fileName}`, [...handler.routeNames], testImportFrom, basePath, testFramework);
+		if (handlerTestContext) {
+			const testContent = makeHandlerTestCode(openapi, `${handlerPath}/${handler.fileName}`, [...handler.routeNames], testImportFrom, basePath, testFramework, handlerTestContext);
 			if (testContent) {
 				const testFmtResult = await fmt(testContent);
 				const testCode = testFmtResult.ok ? testFmtResult.value : testContent;
@@ -2449,12 +2423,13 @@ function app(openapi, output, basePath, pathAlias, routeImport, routeHandler = f
 }
 //#endregion
 //#region src/core/template/define.ts
-async function defineTemplate(openAPI, output, componentsOutput, test, basePath, pathAlias, routeImport, handlerDir, testFramework = "vitest", readonly) {
+async function defineTemplate(openAPI, output, componentsOutput, test, basePath, pathAlias, routeImport, testFramework = "vitest", readonly) {
 	const target = output.endsWith(".ts") ? output : path.join(output, "index.ts");
-	const baseDir = path.dirname(output);
+	const baseDir = path.dirname(target);
+	const handlerDir = baseDir === "." ? "routes" : `${baseDir}/routes`;
 	const aliasPrefix = pathAlias?.endsWith("/") ? pathAlias.slice(0, -1) : pathAlias;
-	const handlerImport = aliasPrefix ? `${aliasPrefix}/${path.relative(baseDir, handlerDir).replaceAll("\\", "/")}` : makeModuleSpec(output, { output: handlerDir });
-	const [appFmtResult, handlersResult] = await Promise.all([fmt(app(openAPI, output, basePath, pathAlias, routeImport, false, true, handlerImport)), defineOpenAPIRouteHandler(openAPI, output, componentsOutput, test, pathAlias, basePath, testFramework, readonly, handlerDir)]);
+	const handlerImport = aliasPrefix ? `${aliasPrefix}/routes` : makeModuleSpec(target, { output: handlerDir });
+	const [appFmtResult, handlersResult] = await Promise.all([fmt(app(openAPI, output, basePath, pathAlias, routeImport, false, true, handlerImport)), defineOpenAPIRouteHandler(openAPI, target, componentsOutput, test, pathAlias, basePath, testFramework, readonly)]);
 	if (!appFmtResult.ok) return {
 		ok: false,
 		error: appFmtResult.error
@@ -2482,12 +2457,10 @@ async function defineTemplate(openAPI, output, componentsOutput, test, basePath,
 }
 //#endregion
 //#region src/core/template/index.ts
-async function template(openAPI, output, test, basePath, pathAlias, routeImport, routeHandler, testFramework = "vitest", handlerDir) {
+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 aliasPrefix = pathAlias?.endsWith("/") ? pathAlias.slice(0, -1) : pathAlias;
-	const handlerImport = handlerDir ? aliasPrefix ? `${aliasPrefix}/${path.relative(dir, handlerDir).replaceAll("\\", "/")}` : makeModuleSpec(path.join(dir, "index.ts"), { output: handlerDir }) : void 0;
-	const [appFmtResult, stubHandlersResult] = await Promise.all([fmt(app(openAPI, output, basePath, pathAlias, routeImport, routeHandler, false, handlerImport)), zodOpenAPIHonoHandler(openAPI, output, test, pathAlias, routeImport, routeHandler, basePath, testFramework, handlerDir)]);
+	const [appFmtResult, stubHandlersResult] = await Promise.all([fmt(app(openAPI, output, basePath, pathAlias, routeImport, routeHandler, false)), zodOpenAPIHonoHandler(openAPI, output, test, pathAlias, routeImport, routeHandler, basePath, testFramework)]);
 	if (!appFmtResult.ok) return {
 		ok: false,
 		error: appFmtResult.error
@@ -2694,8 +2667,7 @@ async function parseOpenAPI(input) {
 //#region src/shared/index.ts
 function makeJob(openAPI, config) {
 	const defineOn = config.template?.define === true;
-	const appOutput = config.output ?? config.routes?.output;
-	const defineHandlerDir = defineOn ? config.template?.output : void 0;
+	const appOutput = config.output ?? (defineOn ? config.components?.output ? deriveAppEntry(config.components.output) : "src/index.ts" : config.routes?.output);
 	const componentsOutput = config.components?.output ?? (defineOn && appOutput ? `${path.dirname(appOutput)}/components/index.ts` : void 0);
 	const componentKinds = [
 		"schemas",
@@ -2891,16 +2863,16 @@ function makeJob(openAPI, config) {
 			split: false,
 			run: (output) => docs(openAPI, output, config.docs?.entry, config.basePath, config.docs?.curl, config.docs?.baseUrl)
 		} : void 0,
-		config.template && defineOn && appOutput && componentsOutput && defineHandlerDir ? {
+		config.template && defineOn && appOutput && componentsOutput ? {
 			name: "template",
 			output: appOutput,
 			split: false,
-			run: (output) => defineTemplate(openAPI, output, componentsOutput, config.template?.test ?? false, config.basePath, config.template?.pathAlias, config.routes?.import, defineHandlerDir, config.template?.testFramework, config.readonly)
+			run: (output) => defineTemplate(openAPI, output, componentsOutput, config.template?.test ?? false, config.basePath, config.template?.pathAlias, config.routes?.import, config.template?.testFramework, config.readonly)
 		} : config.template && !defineOn && appOutput ? {
 			name: "template",
 			output: appOutput,
 			split: false,
-			run: (output) => template(openAPI, output, config.template?.test ?? false, config.basePath, config.template?.pathAlias, config.routes?.import, config.template?.define === false ? config.template.routeHandler : false, config.template?.testFramework, config.template?.output)
+			run: (output) => template(openAPI, output, config.template?.test ?? false, config.basePath, config.template?.pathAlias, config.routes?.import, config.template?.define === false ? config.template.routeHandler : false, config.template?.testFramework)
 		} : void 0
 	].filter((job) => job !== void 0);
 }

package/dist/{guard-zvkMUVYD.js → utils-B5PbMfWs.js}

@@ -234,6 +234,27 @@ function makeBarrel(value) {
 	return `${Object.keys(value).sort().map((k) => `export * from './${k.charAt(0).toLowerCase() + k.slice(1)}'`).join("\n")}\n`;
 }
 /**
+* Derives the define-mode app entry from a components output path.
+*
+* The path is read as `<anchor>/<module>` where module is either a flat
+* `.ts` file or a `<dir>/index.ts` pair; the app entry is `<anchor>/index.ts`.
+*
+* @param componentsOutput - The components output path (a `.ts` file).
+* @returns The derived app entry path.
+*
+* @example
+* ```ts
+* deriveAppEntry('./server/components/index.ts') // → './server/index.ts'
+* deriveAppEntry('server/components.ts') // → 'server/index.ts'
+* deriveAppEntry('components/index.ts') // → 'index.ts'
+* ```
+*/
+function deriveAppEntry(componentsOutput) {
+	const container = componentsOutput.endsWith("/index.ts") ? componentsOutput.slice(0, -9) : componentsOutput;
+	const anchor = container.includes("/") ? container.slice(0, container.lastIndexOf("/")) : "";
+	return anchor === "" || anchor === "." ? "index.ts" : `${anchor}/index.ts`;
+}
+/**
 * Formats an error message argument using the Zod v4 unified `error` parameter.
 *
 * @param message - The error message string
@@ -272,87 +293,56 @@ function makeInferRequestType(clientName, pathResult, method) {
 	const { runtimePath, typeofPrefix, bracketSuffix, hasBracket } = pathResult;
 	return hasBracket ? `InferRequestType<typeof ${clientName}${typeofPrefix}${bracketSuffix}['$${method}']>` : `InferRequestType<typeof ${clientName}${runtimePath}.$${method}>`;
 }
-//#endregion
-//#region src/guard/index.ts
-function isRecord(v) {
-	return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function isHttpMethod(method) {
-	return method === "get" || method === "put" || method === "post" || method === "delete" || method === "patch" || method === "options" || method === "head" || method === "trace";
-}
-function isValidIdent(str) {
-	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(str);
-}
-function isOpenAPIPaths(v) {
-	if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
-	return Object.values(v).every((entry) => typeof entry === "object" && entry !== null && !Array.isArray(entry));
-}
-function isRefObject(v) {
-	return typeof v === "object" && v !== null && !Array.isArray(v) && "$ref" in v && typeof v.$ref === "string";
-}
-function isStringRef(v) {
-	return "$ref" in v && typeof v.$ref === "string";
-}
-function isParameterObject(v) {
-	if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
-	if (!("name" in v) || typeof v.name !== "string") return false;
-	if (!("in" in v)) return false;
-	const pos = v.in;
-	return pos === "path" || pos === "query" || pos === "header" || pos === "cookie";
-}
-function isParameter(v) {
-	return typeof v === "object" && v !== null && "name" in v && "in" in v && ("schema" in v || "content" in v);
-}
-function isParameterArray(v) {
-	return Array.isArray(v);
-}
-function isOperationLike(v) {
-	return typeof v === "object" && v !== null && !Array.isArray(v) && "responses" in v;
-}
-function isOperation(v) {
-	return typeof v === "object" && v !== null && "responses" in v;
-}
-function isSchemaProperty(v) {
-	return typeof v === "object" && v !== null && !Array.isArray(v) && "schema" in v;
-}
-function isSchemaArray(v) {
-	return Array.isArray(v);
-}
-/**
-* JSON Schema 2020-12 §4.3.2 / §10.3.1.2 type guard for schema-vs-boolean
-* discrimination. `items`, `additionalProperties`, `unevaluatedItems`, and
-* `unevaluatedProperties` may be either an object schema or a boolean schema
-* (`true` = pass-through, `false` = reject). This narrows the union to the
-* object form so callers can recurse without `as` casts.
-*/
-function isSchemaObject(v) {
-	return typeof v === "object" && v !== null && !Array.isArray(v);
-}
-function isMediaWithSchema(v) {
-	return typeof v === "object" && v !== null && "schema" in v;
-}
-function isMedia(v) {
-	return typeof v === "object" && v !== null && "schema" in v;
-}
-function isRequestBody(v) {
-	return typeof v === "object" && v !== null && ("content" in v || "required" in v || "description" in v);
-}
-function isContentBody(v) {
-	return typeof v === "object" && v !== null && !("$ref" in v);
-}
-function isSecurityScheme(v) {
-	return typeof v === "object" && v !== null && !("$ref" in v);
-}
-function isSecurityArray(v) {
-	return Array.isArray(v);
-}
-function isResponses(v) {
-	if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
-	return "$ref" in v || "description" in v || "content" in v || "headers" in v || "links" in v;
-}
-function isOAuthFlowValue(v) {
-	if (typeof v !== "object" || v === null || Array.isArray(v)) return false;
-	return "authorizationUrl" in v || "tokenUrl" in v || "scopes" in v;
+function cyclicNodes(deps) {
+	const indices = /* @__PURE__ */ new Map();
+	const lowLinks = /* @__PURE__ */ new Map();
+	const onStack = /* @__PURE__ */ new Set();
+	const stack = [];
+	const result = /* @__PURE__ */ new Set();
+	const open = (node) => {
+		const index = indices.size;
+		indices.set(node, index);
+		lowLinks.set(node, index);
+		stack.push(node);
+		onStack.add(node);
+	};
+	const close = (node) => {
+		if (lowLinks.get(node) !== indices.get(node)) return;
+		const sccStart = stack.lastIndexOf(node);
+		const scc = stack.slice(sccStart);
+		stack.length = sccStart;
+		for (const member of scc) onStack.delete(member);
+		if (scc.length > 1 || (deps.get(node) ?? []).includes(node)) for (const member of scc) result.add(member);
+	};
+	const connect = (root) => {
+		open(root);
+		const frames = [{
+			node: root,
+			depIndex: 0
+		}];
+		while (frames.length > 0) {
+			const frame = frames[frames.length - 1];
+			if (frame === void 0) return;
+			const dep = (deps.get(frame.node) ?? [])[frame.depIndex];
+			if (dep === void 0) {
+				close(frame.node);
+				frames.length -= 1;
+				const parent = frames[frames.length - 1];
+				if (parent) lowLinks.set(parent.node, Math.min(lowLinks.get(parent.node) ?? 0, lowLinks.get(frame.node) ?? 0));
+				continue;
+			}
+			frame.depIndex += 1;
+			if (!indices.has(dep)) {
+				open(dep);
+				frames.push({
+					node: dep,
+					depIndex: 0
+				});
+			} else if (onStack.has(dep)) lowLinks.set(frame.node, Math.min(lowLinks.get(frame.node) ?? 0, indices.get(dep) ?? 0));
+		}
+	};
+	for (const node of deps.keys()) if (!indices.has(node)) connect(node);
+	return result;
 }
 //#endregion
-export { makeInferRequestType as A, baseError as C, escapeHtml as D, error as E, requestParamsArray as F, statusCodeToNumber as I, toIdentifierPascalCase as L, methodPath as M, normalizeTypes as N, escapeRegexLiteral as O, renderNamedImport as P, uncapitalize as R, isValidIdent as S, ensureSuffix as T, isSchemaObject as _, isOAuthFlowValue as a, isSecurityScheme as b, isOperationLike as c, isParameterObject as d, isRecord as f, isSchemaArray as g, isResponses as h, isMediaWithSchema as i, makeSafeKey as j, makeBarrel as k, isParameter as l, isRequestBody as m, isHttpMethod as n, isOpenAPIPaths as o, isRefObject as p, isMedia as r, isOperation as s, isContentBody as t, isParameterArray as u, isSchemaProperty as v, capitalize as w, isStringRef as x, isSecurityArray as y, zodToOpenAPISchema as z };
+export { toIdentifierPascalCase as _, ensureSuffix as a, escapeRegexLiteral as c, makeSafeKey as d, methodPath as f, statusCodeToNumber as g, requestParamsArray as h, deriveAppEntry as i, makeBarrel as l, renderNamedImport as m, capitalize as n, error as o, normalizeTypes as p, cyclicNodes as r, escapeHtml as s, baseError as t, makeInferRequestType as u, uncapitalize as v, zodToOpenAPISchema as y };

package/dist/vite-plugin/index.js

@@ -1,9 +1,10 @@
 import { parseConfig } from "../config/index.js";
 import { r as setFormatOptions } from "../emit-CFR63U4L.js";
-import { f as isRecord } from "../guard-zvkMUVYD.js";
-import { n as parseOpenAPI, t as makeJob } from "../shared-n3ZMLfl9.js";
+import { f as isRecord } from "../guard-BSZ8ezEv.js";
+import { n as parseOpenAPI, t as makeJob } from "../shared-B-TUm7Fa.js";
 import path from "node:path";
 import fsp from "node:fs/promises";
+import crypto from "node:crypto";
 //#region src/vite-plugin/index.ts
 async function readConfigurationWithHotReload(server) {
 	const absoluteConfigPath = path.resolve(process.cwd(), "hono-takibi.config.ts");
@@ -53,28 +54,97 @@ function debounce(delayMilliseconds, callback) {
 	};
 	return wrappedFunction;
 }
+function isWatchedInputFile(filePath) {
+	return filePath.endsWith(".yaml") || filePath.endsWith(".json") || filePath.endsWith(".tsp");
+}
+async function listWatchedInputFiles(directory) {
+	const entries = await fsp.readdir(directory, { withFileTypes: true }).catch(() => []);
+	return (await Promise.all(entries.map((entry) => {
+		const entryPath = path.join(directory, entry.name);
+		if (entry.isDirectory()) return entry.name === "node_modules" || entry.name.startsWith(".") ? Promise.resolve([]) : listWatchedInputFiles(entryPath);
+		return Promise.resolve(entry.isFile() && isWatchedInputFile(entryPath) ? [entryPath] : []);
+	}))).flat();
+}
+/**
+* Hashes the contents of all watched input files under the input directory.
+*
+* Returns null when the set cannot be read reliably, so callers treat
+* "unknown" as "changed" and regenerate.
+*/
+async function hashWatchedInputs(directory) {
+	const files = [...await listWatchedInputFiles(directory)].sort();
+	if (files.length === 0) return null;
+	const contents = await Promise.all(files.map(async (file) => ({
+		file,
+		content: await fsp.readFile(file, "utf-8").catch(() => null)
+	})));
+	if (contents.some((entry) => entry.content === null)) return null;
+	const hash = crypto.createHash("sha256");
+	for (const entry of contents) {
+		hash.update(entry.file);
+		hash.update("\0");
+		hash.update(entry.content ?? "");
+		hash.update("\0");
+	}
+	return hash.digest("hex");
+}
+async function listOutputFiles(target) {
+	const stats = await fsp.stat(target).catch(() => null);
+	if (!stats) return [];
+	if (stats.isFile()) return [{
+		file: target,
+		mtimeMs: stats.mtimeMs
+	}];
+	if (!stats.isDirectory()) return [];
+	const entries = await fsp.readdir(target, { withFileTypes: true }).catch(() => []);
+	return (await Promise.all(entries.map((entry) => listOutputFiles(path.join(target, entry.name))))).flat();
+}
+/**
+* Snapshots mtimes of all files under the job output paths.
+*
+* `writeFile` skips identical content, so an unchanged mtime means the file
+* was not rewritten. For `.ts` outputs the sibling split directory
+* (`dir/name/` derived from `dir/name.ts`) is included as well.
+*/
+async function snapshotOutputs(outputPaths) {
+	const targets = [...new Set(outputPaths.flatMap((outputPath) => [outputPath, ...outputPath.endsWith(".ts") ? [path.join(path.dirname(outputPath), path.basename(outputPath, ".ts"))] : []]))];
+	const collected = await Promise.all(targets.map((target) => listOutputFiles(target)));
+	return new Map(collected.flat().map((entry) => [entry.file, entry.mtimeMs]));
+}
+function sameOutputSnapshot(before, after) {
+	return before.size === after.size && [...before].every(([file, mtimeMs]) => after.get(file) === mtimeMs);
+}
 /**
 * Runs all code generation tasks in parallel based on the provided configuration.
 *
 * @param config - Parsed configuration object
-* @returns Promise resolving to object containing log messages
+* @returns Promise resolving to object containing log messages and whether any output file changed
 */
 async function runAllGenerationTasks(config) {
 	if (config.format) setFormatOptions(config.format);
 	const openAPIResult = await parseOpenAPI(config.input);
-	if (!openAPIResult.ok) return { logs: [`❌ parseOpenAPI: ${openAPIResult.error}`] };
+	if (!openAPIResult.ok) return {
+		logs: [`❌ parseOpenAPI: ${openAPIResult.error}`],
+		changed: false
+	};
 	const openAPI = openAPIResult.value;
 	const cleanupSplitOutput = async (absOutput) => {
 		if (!(await fsp.stat(absOutput).catch(() => null))?.isDirectory()) return;
 		const entries = await fsp.readdir(absOutput, { withFileTypes: true }).catch(() => []);
 		await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith(".ts")).map((entry) => fsp.unlink(path.join(absOutput, entry.name)).catch(() => void 0)));
 	};
-	return { logs: await Promise.all(makeJob(openAPI, config).map(async (job) => {
-		const absOutput = path.resolve(process.cwd(), job.output);
-		if (job.split) await cleanupSplitOutput(absOutput);
-		const result = await job.run(absOutput);
-		return result.ok ? `✅ ${job.name}${job.split ? "(split)" : ""} -> ${absOutput}` : `❌ ${job.name}: ${result.error}`;
-	})) };
+	const jobs = makeJob(openAPI, config);
+	const outputPaths = jobs.map((job) => path.resolve(process.cwd(), job.output));
+	const beforeSnapshot = await snapshotOutputs(outputPaths);
+	return {
+		logs: await Promise.all(jobs.map(async (job) => {
+			const absOutput = path.resolve(process.cwd(), job.output);
+			if (job.split) await cleanupSplitOutput(absOutput);
+			const result = await job.run(absOutput);
+			return result.ok ? `✅ ${job.name}${job.split ? "(split)" : ""} -> ${absOutput}` : `❌ ${job.name}: ${result.error}`;
+		})),
+		changed: !sameOutputSnapshot(beforeSnapshot, await snapshotOutputs(outputPaths))
+	};
 }
 /**
 * Adds glob patterns to the Vite file watcher.
@@ -97,6 +167,9 @@ function addInputGlobsToWatcher(server, absoluteInputPath) {
 	server.watcher.add(watchPatterns);
 	return inputDirectory;
 }
+async function allOutputsExist(config) {
+	return (await Promise.all(extractOutputPaths(config).map((outputPath) => fsp.stat(outputPath).catch(() => null)))).every((stat) => stat !== null);
+}
 function extractOutputPaths(config) {
 	return [
 		config.output,
@@ -131,18 +204,36 @@ function honoTakibiVite() {
 	const pluginState = {
 		current: null,
 		previous: null,
-		inputDirectory: null
+		inputDirectory: null,
+		lastInputHash: null,
+		runQueue: Promise.resolve()
 	};
 	const absoluteConfigFilePath = path.resolve(process.cwd(), "hono-takibi.config.ts");
 	const runGeneration = async () => {
-		if (!pluginState.current) return;
+		if (!pluginState.current) return false;
 		console.log("🔥 hono-takibi");
-		const { logs } = await runAllGenerationTasks(pluginState.current);
+		const { logs, changed } = await runAllGenerationTasks(pluginState.current);
 		for (const logMessage of logs) console.log(logMessage);
+		return changed;
 	};
 	const runGenerationAndReload = async (server) => {
-		await runGeneration();
-		if (server) server.ws.send({ type: "full-reload" });
+		const changed = await runGeneration();
+		if (server && changed) server.ws.send({ type: "full-reload" });
+	};
+	const runIfInputsChanged = async (server) => {
+		if (!pluginState.inputDirectory || !pluginState.current) return;
+		const inputHash = await hashWatchedInputs(pluginState.inputDirectory);
+		if (inputHash !== null && inputHash === pluginState.lastInputHash && await allOutputsExist(pluginState.current)) {
+			console.log("⏭️ input unchanged - skipped regeneration");
+			return;
+		}
+		pluginState.lastInputHash = inputHash;
+		await runGenerationAndReload(server);
+	};
+	const enqueueRun = (task) => {
+		const queued = pluginState.runQueue.then(task).catch((error) => console.error("❌ run error:", error));
+		pluginState.runQueue = queued;
+		return queued;
 	};
 	const handleConfigurationChange = async (server) => {
 		const nextConfiguration = await readConfigurationWithHotReload(server);
@@ -177,7 +268,9 @@ function honoTakibiVite() {
 		}
 		pluginState.previous = pluginState.current;
 		pluginState.current = nextConfiguration.value;
-		pluginState.inputDirectory = addInputGlobsToWatcher(server, path.resolve(process.cwd(), pluginState.current.input));
+		const inputDirectory = addInputGlobsToWatcher(server, path.resolve(process.cwd(), pluginState.current.input));
+		pluginState.inputDirectory = inputDirectory;
+		pluginState.lastInputHash = await hashWatchedInputs(inputDirectory);
 		await runGenerationAndReload(server);
 	};
 	return {
@@ -185,7 +278,7 @@ function honoTakibiVite() {
 		handleHotUpdate(context) {
 			if (path.resolve(context.file) === path.resolve(process.cwd(), "hono-takibi.config.ts")) {
 				console.log("config changed (hot-update)");
-				handleConfigurationChange(context.server).catch((error) => console.error("❌ hot-update error:", error));
+				enqueueRun(() => handleConfigurationChange(context.server));
 				return [];
 			}
 		},
@@ -198,19 +291,21 @@ function honoTakibiVite() {
 					return;
 				}
 				pluginState.current = initialConfiguration.value;
-				pluginState.inputDirectory = addInputGlobsToWatcher(server, path.resolve(process.cwd(), pluginState.current.input));
+				const inputDirectory = addInputGlobsToWatcher(server, path.resolve(process.cwd(), pluginState.current.input));
+				pluginState.inputDirectory = inputDirectory;
+				pluginState.lastInputHash = await hashWatchedInputs(inputDirectory);
 				server.watcher.add(absoluteConfigFilePath);
-				const debouncedRunGeneration = debounce(200, () => void runGenerationAndReload(server));
+				const debouncedRunGeneration = debounce(200, () => void enqueueRun(() => runIfInputsChanged(server)));
 				server.watcher.on("all", async (_eventType, filePath) => {
 					const absoluteChangedPath = path.resolve(filePath);
 					if (absoluteChangedPath === absoluteConfigFilePath) {
 						console.log("config changed (watch)");
-						await handleConfigurationChange(server);
+						await enqueueRun(() => handleConfigurationChange(server));
 						return;
 					}
-					if (pluginState.inputDirectory && absoluteChangedPath.startsWith(pluginState.inputDirectory) && (absoluteChangedPath.endsWith(".yaml") || absoluteChangedPath.endsWith(".json") || absoluteChangedPath.endsWith(".tsp"))) debouncedRunGeneration();
+					if (pluginState.inputDirectory && absoluteChangedPath.startsWith(pluginState.inputDirectory) && isWatchedInputFile(absoluteChangedPath)) debouncedRunGeneration();
 				});
-				await runGenerationAndReload(server);
+				await enqueueRun(() => runGenerationAndReload(server));
 			})().catch((e) => console.error("❌ watch error:", e));
 		}
 	};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hono-takibi",
-  "version": "0.9.99994",
+  "version": "0.9.99995",
   "description": "Hono Takibi is a code generator from OpenAPI to @hono/zod-openapi",
   "keywords": [
     "hono",
@@ -57,17 +57,21 @@
     "@apidevtools/swagger-parser": "^12.1.0",
     "@typespec/compiler": "^1.13.0",
     "@typespec/openapi3": "^1.13.0",
-    "oxfmt": "^0.56.0",
+    "oxfmt": "^0.57.0",
     "ts-morph": "^28.0.0",
     "typescript": "^6.0.3",
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "@faker-js/faker": "^10.5.0",
+    "@hono/zod-openapi": "^1.4.0",
     "@types/node": "^26.0.1",
     "@typespec/http": "^1.13.0",
     "@typespec/rest": "^0.83.0",
     "@typespec/versioning": "^0.83.0",
-    "tsdown": "0.22.3"
+    "hono": "^4.12.27",
+    "tsdown": "0.22.3",
+    "zod": "^4.0.0"
   },
   "scripts": {
     "build": "tsdown"