hono-takibi 0.9.72 → 0.9.73

package/dist/core/rpc/index.js

@@ -60,8 +60,8 @@ const formatPath = (p) => {
         };
     }
     const segs = p.replace(/^\/+/, '').split('/').filter(Boolean);
-    // Convert {param} to :param
-    const honoSegs = segs.map((seg) => seg.startsWith('{') && seg.endsWith('}') ? `:${seg.slice(1, -1)}` : seg);
+    // Convert {param} to :param (handles both full segments like {id} and partial like {Sid}.json)
+    const honoSegs = segs.map((seg) => seg.replace(/\{([^}]+)\}/g, ':$1'));
     // Find the first segment that needs bracket notation
     const firstBracketIdx = honoSegs.findIndex((seg) => !isValidIdent(seg));
     const hasBracket = firstBracketIdx !== -1;
@@ -130,24 +130,15 @@ const refRequestBodyName = (refLike) => {
 const pickAllBodyInfoFromContent = (content) => {
     if (!isRecord(content))
         return undefined;
-    const formInfos = [];
-    const jsonInfos = [];
     const formContentTypes = ['multipart/form-data', 'application/x-www-form-urlencoded'];
-    for (const [ct, mediaObj] of Object.entries(content)) {
-        if (!(isRecord(mediaObj) && hasSchemaProp(mediaObj) && isRecord(mediaObj.schema)))
-            continue;
-        const info = { contentType: ct };
-        // Extract base content type (before semicolon) for matching
-        // e.g., "multipart/form-data; boundary=..." -> "multipart/form-data"
-        const baseContentType = ct.split(';')[0].trim();
-        if (formContentTypes.includes(baseContentType)) {
-            formInfos.push(info);
-        }
-        else {
-            // All other content types go to json
-            jsonInfos.push(info);
-        }
-    }
+    const isFormContentType = (ct) => formContentTypes.includes(ct.split(';')[0].trim());
+    const validEntries = Object.entries(content).filter(([_, mediaObj]) => isRecord(mediaObj) && hasSchemaProp(mediaObj) && isRecord(mediaObj.schema));
+    const formInfos = validEntries
+        .filter(([ct]) => isFormContentType(ct))
+        .map(([ct]) => ({ contentType: ct }));
+    const jsonInfos = validEntries
+        .filter(([ct]) => !isFormContentType(ct))
+        .map(([ct]) => ({ contentType: ct }));
     if (formInfos.length === 0 && jsonInfos.length === 0)
         return undefined;
     return { form: formInfos, json: jsonInfos };
@@ -207,11 +198,18 @@ const generateOperationCode = (pathStr, method, item, deps) => {
         : `${deps.client}${runtimePath}${methodAccess}(undefined,options)`;
     const summary = typeof op.summary === 'string' ? op.summary : '';
     const description = typeof op.description === 'string' ? op.description : '';
+    // Format multiline description with JSDoc prefix on each line
+    const formatJsDocLines = (text) => text
+        .trimEnd()
+        .split('\n')
+        .map((line) => ` * ${line}`);
+    // Escape /* in path to avoid oxfmt regex parsing issue (/* looks like /regex/)
+    const safePathStr = pathStr.replace(/\/\*/g, '/[*]');
     const docs = [
         '/**',
-        ` * ${method.toUpperCase()} ${pathStr}`,
-        ...(summary ? [' *', ` * ${summary.trimEnd()}`] : []),
-        ...(description ? [' *', ` * ${description.trimEnd()}`] : []),
+        ` * ${method.toUpperCase()} ${safePathStr}`,
+        ...(summary ? [' *', ...formatJsDocLines(summary)] : []),
+        ...(description ? [' *', ...formatJsDocLines(description)] : []),
         ' */',
     ].join('\n');
     const func = `export async function ${funcName}(${argSig}){return await ${call}}`;

package/dist/core/type/index.js

@@ -136,13 +136,17 @@ function makePathParams(openApiPath) {
     return Array.from(openApiPath.matchAll(/\{([^}]+)\}/g)).map((m) => m[1]);
 }
 function makeParamPart(params, components) {
-    const props = params.map((p) => `${p.name}:${makeSchemaTypeString(makeParameterSchema(p), components, new Set())}`);
+    const props = params.map((p) => {
+        const safeKey = makeSafeKey(p.name);
+        return `${safeKey}:${makeSchemaTypeString(makeParameterSchema(p), components, new Set())}`;
+    });
     return props.length > 0 ? `{param:{${props.join(';')}}}` : undefined;
 }
 function makeQueryPart(params, components) {
     const props = params.map((p) => {
         const typeStr = makeSchemaTypeString(makeParameterSchema(p), components, new Set());
-        return p.required ? `${p.name}:${typeStr}` : `${p.name}?:${typeStr}|undefined`;
+        const safeKey = makeSafeKey(p.name);
+        return p.required ? `${safeKey}:${typeStr}` : `${safeKey}?:${typeStr}|undefined`;
     });
     return props.length > 0 ? `{query:{${props.join(';')}}}` : undefined;
 }

package/dist/utils/index.js

@@ -80,14 +80,14 @@ export function isHttpMethod(method) {
  * methodPath('get', '/users/{id}/posts') // 'getUsersIdPosts'
  */
 export function methodPath(method, path) {
-    // 1. api_path: `/user/createWithList`
-    // 2. replace(/[\/{}-]/g, ' ') -> ` user createWithList`
-    // 3. trim() -> `user createWithList`
-    // 4. split(/\s+/) -> `['user', 'createWithList']`
+    // 1. api_path: `/user/createWithList` or `/applications/@me`
+    // 2. replace(/[^A-Za-z0-9]/g, ' ') -> ` user createWithList` or ` applications  me`
+    // 3. trim() -> `user createWithList` or `applications  me`
+    // 4. split(/\s+/) -> `['user', 'createWithList']` or `['applications', 'me']`
     // 5. map((str) => `${str.charAt(0).toUpperCase()}${str.slice(1)}`) -> `['User', 'CreateWithList']`
-    // 6. join('') -> `UserCreateWithList`
+    // 6. join('') -> `UserCreateWithList` or `ApplicationsMe`
     const apiPath = path
-        .replace(/[/{}._-]/g, ' ')
+        .replace(/[^A-Za-z0-9]/g, ' ')
         .trim()
         .split(/\s+/)
         .map((str) => `${str.charAt(0).toUpperCase()}${str.slice(1)}`)

package/dist/vite-plugin/index.d.ts

@@ -1,42 +1 @@
-/**
- * Creates a Vite plugin for hono-takibi code generation.
- *
- * This plugin automatically regenerates TypeScript code from OpenAPI
- * specifications during development. It watches for changes in:
- * - The OpenAPI spec file (yaml/json/tsp)
- * - The hono-takibi.config.ts configuration file
- *
- * ```mermaid
- * sequenceDiagram
- *   participant V as Vite
- *   participant P as Plugin
- *   participant C as Config
- *   participant G as Generator
- *
- *   V->>P: configureServer()
- *   P->>C: loadConfigHot()
- *   C-->>P: config
- *   P->>G: runAllWithConf()
- *   G-->>P: logs
- *   P->>V: hot reload
- *
- *   Note over V,G: On file change
- *   V->>P: handleHotUpdate()
- *   P->>G: runAllWithConf()
- *   G-->>P: logs
- *   P->>V: full-reload
- * ```
- *
- * @returns Vite plugin object
- *
- * @example
- * ```ts
- * // vite.config.ts
- * import { honoTakibiVite } from 'hono-takibi/vite-plugin'
- *
- * export default defineConfig({
- *   plugins: [honoTakibiVite()]
- * })
- * ```
- */
 export declare function honoTakibiVite(): any;

package/dist/vite-plugin/index.js

@@ -165,13 +165,14 @@ const runAllWithConf = async (config) => {
     if (!openAPIResult.ok)
         return { logs: [`✗ parseOpenAPI: ${openAPIResult.error}`] };
     const openAPI = openAPIResult.value;
-    const jobs = [];
-    // zod-openapi top-level output (non-split)
-    if (config['zod-openapi'] &&
-        !(config['zod-openapi'].components?.schemas || config['zod-openapi'].routes) &&
-        config['zod-openapi'].output) {
+    // Job makers - each returns undefined if not applicable
+    const makeZodOpenAPIJob = () => {
+        if (!(config['zod-openapi'] &&
+            !(config['zod-openapi'].components?.schemas || config['zod-openapi'].routes) &&
+            config['zod-openapi'].output))
+            return undefined;
         const out = toAbs(config['zod-openapi'].output);
-        const runZodOpenAPI = async () => {
+        return (async () => {
             if (!isTsFile(out))
                 return `✗ zod-openapi: Invalid output format: ${out}`;
             const result = await takibi(openAPI, out, false, false, '/', {
@@ -189,187 +190,202 @@ const runAllWithConf = async (config) => {
                 exportCallbacks: config['zod-openapi']?.exportCallbacks ?? false,
             });
             return result.ok ? `✓ zod-openapi -> ${out}` : `✗ zod-openapi: ${result.error}`;
-        };
-        jobs.push(runZodOpenAPI());
-    }
-    // components.schemas
-    if (config['zod-openapi']?.components?.schemas) {
-        const schemasConfig = config['zod-openapi'].components.schemas;
-        const runSchema = async () => {
-            if (schemasConfig.split === true) {
-                const outDir = toAbs(schemasConfig.output);
+        })();
+    };
+    const makeSchemaJob = () => {
+        const cfg = config['zod-openapi']?.components?.schemas;
+        if (!cfg)
+            return undefined;
+        return (async () => {
+            if (cfg.split === true) {
+                const outDir = toAbs(cfg.output);
                 const removed = await deleteAllTsShallow(outDir);
-                const schemaResult = await schemas(openAPI.components?.schemas, outDir, true, schemasConfig.exportTypes === true);
+                const schemaResult = await schemas(openAPI.components?.schemas, outDir, true, cfg.exportTypes === true);
                 if (!schemaResult.ok)
                     return `✗ schemas(split): ${schemaResult.error}`;
                 return removed.length > 0
                     ? `✓ schemas(split) -> ${outDir}/*.ts (cleaned ${removed.length})`
                     : `✓ schemas(split) -> ${outDir}/*.ts`;
             }
-            const out = toAbs(schemasConfig.output);
-            const schemaResult = await schemas(openAPI.components?.schemas, out, false, schemasConfig.exportTypes === true);
+            const out = toAbs(cfg.output);
+            const schemaResult = await schemas(openAPI.components?.schemas, out, false, cfg.exportTypes === true);
             return schemaResult.ok ? `✓ schemas -> ${out}` : `✗ schemas: ${schemaResult.error}`;
-        };
-        jobs.push(runSchema());
-    }
-    // components.parameters
-    if (config['zod-openapi']?.components?.parameters) {
-        const parametersConfig = config['zod-openapi'].components.parameters;
-        const runParameters = async () => {
-            const outDir = toAbs(parametersConfig.output);
-            if (parametersConfig.split === true)
+        })();
+    };
+    const makeParametersJob = () => {
+        const cfg = config['zod-openapi']?.components?.parameters;
+        if (!cfg)
+            return undefined;
+        return (async () => {
+            const outDir = toAbs(cfg.output);
+            if (cfg.split === true)
                 await deleteAllTsShallow(outDir);
-            const parameterResult = await parameters(openAPI.components?.parameters, outDir, parametersConfig.split === true, parametersConfig.exportTypes === true, config['zod-openapi']?.components);
+            const parameterResult = await parameters(openAPI.components?.parameters, outDir, cfg.split === true, cfg.exportTypes === true, config['zod-openapi']?.components);
             return parameterResult.ok
-                ? `✓ parameters${parametersConfig.split === true ? '(split)' : ''} -> ${outDir}`
+                ? `✓ parameters${cfg.split === true ? '(split)' : ''} -> ${outDir}`
                 : `✗ parameters: ${parameterResult.error}`;
-        };
-        jobs.push(runParameters());
-    }
-    // components.headers
-    if (config['zod-openapi']?.components?.headers) {
-        const headersConfig = config['zod-openapi'].components.headers;
-        const runHeaders = async () => {
-            const outDir = toAbs(headersConfig.output);
-            if (headersConfig.split === true)
+        })();
+    };
+    const makeHeadersJob = () => {
+        const cfg = config['zod-openapi']?.components?.headers;
+        if (!cfg)
+            return undefined;
+        return (async () => {
+            const outDir = toAbs(cfg.output);
+            if (cfg.split === true)
                 await deleteAllTsShallow(outDir);
-            const headersResult = await headers(openAPI.components?.headers, outDir, headersConfig.split === true, headersConfig.exportTypes === true, config['zod-openapi']?.components);
+            const headersResult = await headers(openAPI.components?.headers, outDir, cfg.split === true, cfg.exportTypes === true, config['zod-openapi']?.components);
             return headersResult.ok
-                ? `✓ headers${headersConfig.split === true ? '(split)' : ''} -> ${outDir}`
+                ? `✓ headers${cfg.split === true ? '(split)' : ''} -> ${outDir}`
                 : `✗ headers: ${headersResult.error}`;
-        };
-        jobs.push(runHeaders());
-    }
-    // components.examples
-    if (config['zod-openapi']?.components?.examples) {
-        const examplesConfig = config['zod-openapi'].components.examples;
-        const runExamples = async () => {
-            const outDir = toAbs(examplesConfig.output);
-            if (examplesConfig.split === true)
+        })();
+    };
+    const makeExamplesJob = () => {
+        const cfg = config['zod-openapi']?.components?.examples;
+        if (!cfg)
+            return undefined;
+        return (async () => {
+            const outDir = toAbs(cfg.output);
+            if (cfg.split === true)
                 await deleteAllTsShallow(outDir);
-            const examplesResult = await examples(openAPI.components?.examples, outDir, examplesConfig.split === true);
+            const examplesResult = await examples(openAPI.components?.examples, outDir, cfg.split === true);
             return examplesResult.ok
-                ? `✓ examples${examplesConfig.split === true ? '(split)' : ''} -> ${outDir}`
+                ? `✓ examples${cfg.split === true ? '(split)' : ''} -> ${outDir}`
                 : `✗ examples: ${examplesResult.error}`;
-        };
-        jobs.push(runExamples());
-    }
-    // components.links
-    if (config['zod-openapi']?.components?.links) {
-        const linksConfig = config['zod-openapi'].components.links;
-        const runLinks = async () => {
-            const outDir = toAbs(linksConfig.output);
-            if (linksConfig.split === true)
+        })();
+    };
+    const makeLinksJob = () => {
+        const cfg = config['zod-openapi']?.components?.links;
+        if (!cfg)
+            return undefined;
+        return (async () => {
+            const outDir = toAbs(cfg.output);
+            if (cfg.split === true)
                 await deleteAllTsShallow(outDir);
-            const linksResult = await links(openAPI.components?.links, outDir, linksConfig.split === true);
+            const linksResult = await links(openAPI.components?.links, outDir, cfg.split === true);
             return linksResult.ok
-                ? `✓ links${linksConfig.split === true ? '(split)' : ''} -> ${outDir}`
+                ? `✓ links${cfg.split === true ? '(split)' : ''} -> ${outDir}`
                 : `✗ links: ${linksResult.error}`;
-        };
-        jobs.push(runLinks());
-    }
-    // components.callbacks
-    if (config['zod-openapi']?.components?.callbacks) {
-        const callbacksConfig = config['zod-openapi'].components.callbacks;
-        const runCallbacks = async () => {
-            const outDir = toAbs(callbacksConfig.output);
-            if (callbacksConfig.split === true)
+        })();
+    };
+    const makeCallbacksJob = () => {
+        const cfg = config['zod-openapi']?.components?.callbacks;
+        if (!cfg)
+            return undefined;
+        return (async () => {
+            const outDir = toAbs(cfg.output);
+            if (cfg.split === true)
                 await deleteAllTsShallow(outDir);
-            const callbacksResult = await callbacks(openAPI.components?.callbacks, outDir, callbacksConfig.split === true);
+            const callbacksResult = await callbacks(openAPI.components?.callbacks, outDir, cfg.split === true);
             return callbacksResult.ok
-                ? `✓ callbacks${callbacksConfig.split === true ? '(split)' : ''} -> ${outDir}`
+                ? `✓ callbacks${cfg.split === true ? '(split)' : ''} -> ${outDir}`
                 : `✗ callbacks: ${callbacksResult.error}`;
-        };
-        jobs.push(runCallbacks());
-    }
-    // components.securitySchemes
-    if (config['zod-openapi']?.components?.securitySchemes) {
-        const securitySchemesConfig = config['zod-openapi'].components.securitySchemes;
-        const runSecuritySchemes = async () => {
-            const outDir = toAbs(securitySchemesConfig.output);
-            if (securitySchemesConfig.split === true)
+        })();
+    };
+    const makeSecuritySchemesJob = () => {
+        const cfg = config['zod-openapi']?.components?.securitySchemes;
+        if (!cfg)
+            return undefined;
+        return (async () => {
+            const outDir = toAbs(cfg.output);
+            if (cfg.split === true)
                 await deleteAllTsShallow(outDir);
-            const securitySchemesResult = await securitySchemes(openAPI.components?.securitySchemes, outDir, securitySchemesConfig.split === true);
+            const securitySchemesResult = await securitySchemes(openAPI.components?.securitySchemes, outDir, cfg.split === true);
             return securitySchemesResult.ok
-                ? `✓ securitySchemes${securitySchemesConfig.split === true ? '(split)' : ''} -> ${outDir}`
+                ? `✓ securitySchemes${cfg.split === true ? '(split)' : ''} -> ${outDir}`
                 : `✗ securitySchemes: ${securitySchemesResult.error}`;
-        };
-        jobs.push(runSecuritySchemes());
-    }
-    // components.requestBodies
-    if (config['zod-openapi']?.components?.requestBodies) {
-        const requestBodiesConfig = config['zod-openapi'].components.requestBodies;
-        const runRequestBodies = async () => {
-            const outDir = toAbs(requestBodiesConfig.output);
-            if (requestBodiesConfig.split === true)
+        })();
+    };
+    const makeRequestBodiesJob = () => {
+        const cfg = config['zod-openapi']?.components?.requestBodies;
+        if (!cfg)
+            return undefined;
+        return (async () => {
+            const outDir = toAbs(cfg.output);
+            if (cfg.split === true)
                 await deleteAllTsShallow(outDir);
-            const requestBodiesResult = await requestBodies(openAPI.components?.requestBodies, outDir, requestBodiesConfig.split === true, config['zod-openapi']?.components);
+            const requestBodiesResult = await requestBodies(openAPI.components?.requestBodies, outDir, cfg.split === true, config['zod-openapi']?.components);
             return requestBodiesResult.ok
-                ? `✓ requestBodies${requestBodiesConfig.split === true ? '(split)' : ''} -> ${outDir}`
+                ? `✓ requestBodies${cfg.split === true ? '(split)' : ''} -> ${outDir}`
                 : `✗ requestBodies: ${requestBodiesResult.error}`;
-        };
-        jobs.push(runRequestBodies());
-    }
-    // components.responses
-    if (config['zod-openapi']?.components?.responses) {
-        const responsesConfig = config['zod-openapi'].components.responses;
-        const runResponses = async () => {
-            const outDir = toAbs(responsesConfig.output);
-            if (responsesConfig.split === true)
+        })();
+    };
+    const makeResponsesJob = () => {
+        const cfg = config['zod-openapi']?.components?.responses;
+        if (!cfg)
+            return undefined;
+        return (async () => {
+            const outDir = toAbs(cfg.output);
+            if (cfg.split === true)
                 await deleteAllTsShallow(outDir);
-            const responsesResult = await responses(openAPI.components?.responses, outDir, responsesConfig.split === true, config['zod-openapi']?.components);
+            const responsesResult = await responses(openAPI.components?.responses, outDir, cfg.split === true, config['zod-openapi']?.components);
             return responsesResult.ok
-                ? `✓ responses${responsesConfig.split === true ? '(split)' : ''} -> ${outDir}`
+                ? `✓ responses${cfg.split === true ? '(split)' : ''} -> ${outDir}`
                 : `✗ responses: ${responsesResult.error}`;
-        };
-        jobs.push(runResponses());
-    }
-    // zod-openapi.routes
-    if (config['zod-openapi']?.routes) {
-        const routesConfig = config['zod-openapi'].routes;
-        const runRoutes = async () => {
-            const out = toAbs(routesConfig.output);
-            if (routesConfig.split === true)
+        })();
+    };
+    const makeRoutesJob = () => {
+        const cfg = config['zod-openapi']?.routes;
+        if (!cfg)
+            return undefined;
+        return (async () => {
+            const out = toAbs(cfg.output);
+            if (cfg.split === true)
                 await deleteAllTsShallow(out);
-            const routeResult = await route(openAPI, { output: out, split: routesConfig.split ?? false }, config['zod-openapi']?.components);
+            const routeResult = await route(openAPI, { output: out, split: cfg.split ?? false }, config['zod-openapi']?.components);
             return routeResult.ok
-                ? `✓ routes${routesConfig.split === true ? '(split)' : ''} -> ${out}`
+                ? `✓ routes${cfg.split === true ? '(split)' : ''} -> ${out}`
                 : `✗ routes: ${routeResult.error}`;
-        };
-        jobs.push(runRoutes());
-    }
-    // type
-    if (config.type) {
-        const typeConfig = config.type;
-        const out = toAbs(typeConfig.output);
-        const runType = async () => {
+        })();
+    };
+    const makeTypeJob = () => {
+        const cfg = config.type;
+        if (!cfg)
+            return undefined;
+        return (async () => {
+            const out = toAbs(cfg.output);
             if (!isTsFile(out))
                 return `✗ type: Invalid output format: ${out}`;
             const typeResult = await type(openAPI, out);
             return typeResult.ok ? `✓ type -> ${out}` : `✗ type: ${typeResult.error}`;
-        };
-        jobs.push(runType());
-    }
-    // rpc
-    if (config.rpc) {
-        const rpcConfig = config.rpc;
-        const runRpc = async () => {
-            if (rpcConfig.split === true) {
-                const outDir = toAbs(rpcConfig.output);
+        })();
+    };
+    const makeRpcJob = () => {
+        const cfg = config.rpc;
+        if (!cfg)
+            return undefined;
+        return (async () => {
+            if (cfg.split === true) {
+                const outDir = toAbs(cfg.output);
                 const removed = await deleteAllTsShallow(outDir);
-                const rpcResult = await rpc(openAPI, outDir, rpcConfig.import, true);
+                const rpcResult = await rpc(openAPI, outDir, cfg.import, true);
                 if (!rpcResult.ok)
                     return `✗ rpc(split): ${rpcResult.error}`;
                 return removed.length > 0
                     ? `✓ rpc(split) -> ${outDir}/*.ts (cleaned ${removed.length})`
                     : `✓ rpc(split) -> ${outDir}/*.ts`;
             }
-            const out = toAbs(rpcConfig.output);
-            const rpcResult = await rpc(openAPI, out, rpcConfig.import, false);
+            const out = toAbs(cfg.output);
+            const rpcResult = await rpc(openAPI, out, cfg.import, false);
             return rpcResult.ok ? `✓ rpc -> ${out}` : `✗ rpc: ${rpcResult.error}`;
-        };
-        jobs.push(runRpc());
-    }
+        })();
+    };
+    // Build jobs array immutably - filter out undefined
+    const jobs = [
+        makeZodOpenAPIJob(),
+        makeSchemaJob(),
+        makeParametersJob(),
+        makeHeadersJob(),
+        makeExamplesJob(),
+        makeLinksJob(),
+        makeCallbacksJob(),
+        makeSecuritySchemesJob(),
+        makeRequestBodiesJob(),
+        makeResponsesJob(),
+        makeRoutesJob(),
+        makeTypeJob(),
+        makeRpcJob(),
+    ].filter((job) => job !== undefined);
     return Promise.all(jobs).then((logs) => ({ logs }));
 };
 /* ──────────────────────────────────────────────────────────────
@@ -438,9 +454,52 @@ const addInputGlobs = (server, absInput) => {
  * })
  * ```
  */
+/**
+ * Extracts all output paths from a configuration.
+ */
+const extractOutputPaths = (conf) => [
+    conf['zod-openapi']?.output,
+    conf['zod-openapi']?.components?.schemas?.output,
+    conf['zod-openapi']?.components?.parameters?.output,
+    conf['zod-openapi']?.components?.headers?.output,
+    conf['zod-openapi']?.components?.examples?.output,
+    conf['zod-openapi']?.components?.links?.output,
+    conf['zod-openapi']?.components?.callbacks?.output,
+    conf['zod-openapi']?.components?.securitySchemes?.output,
+    conf['zod-openapi']?.components?.requestBodies?.output,
+    conf['zod-openapi']?.components?.responses?.output,
+    conf['zod-openapi']?.routes?.output,
+    conf.type?.output,
+    conf.rpc?.output,
+]
+    .filter((p) => p !== undefined)
+    .map(toAbs);
+/**
+ * Cleans up output paths that exist in previous config but not in current config.
+ */
+const cleanupStaleOutputs = async (prev, curr) => {
+    const prevPaths = new Set(extractOutputPaths(prev));
+    const currPaths = new Set(extractOutputPaths(curr));
+    const stalePaths = [...prevPaths].filter((p) => !currPaths.has(p));
+    const results = await Promise.all(stalePaths.map(async (p) => {
+        const stat = await fsp.stat(p).catch(() => null);
+        if (!stat)
+            return null;
+        if (stat.isDirectory()) {
+            const removed = await deleteAllTsShallow(p);
+            return removed.length > 0 ? `${p}/*.ts (${removed.length} files)` : null;
+        }
+        if (stat.isFile() && p.endsWith('.ts')) {
+            await fsp.unlink(p).catch(() => { });
+            return p;
+        }
+        return null;
+    }));
+    return results.filter((r) => r !== null);
+};
 // biome-ignore lint: plugin returns any for Vite compatibility
 export function honoTakibiVite() {
-    const state = { current: null };
+    const state = { current: null, previous: null };
     const absConfig = path.resolve(process.cwd(), 'hono-takibi.config.ts');
     const run = async () => {
         if (!state.current)
@@ -460,6 +519,13 @@ export function honoTakibiVite() {
             console.error(`[hono-takibi] ✗ config: ${next.error}`);
             return;
         }
+        // Cleanup stale outputs from previous config
+        if (state.current) {
+            const cleaned = await cleanupStaleOutputs(state.current, next.value);
+            for (const p of cleaned)
+                console.log(`[hono-takibi] ✓ cleanup: ${p}`);
+        }
+        state.previous = state.current;
         state.current = next.value;
         addInputGlobs(server, toAbs(state.current.input));
         await runAndReload(server);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hono-takibi",
   "description": "Hono Takibi is a CLI tool that generates Hono routes from OpenAPI specifications.",
-  "version": "0.9.72",
+  "version": "0.9.73",
   "type": "module",
   "license": "MIT",
   "keywords": [