hono-takibi 0.9.52 → 0.9.60

package/dist/core/route.js

@@ -41,9 +41,9 @@ export async function route(input, output, importPath, split) {
         if (!mkdirResult.ok)
             return { ok: false, error: mkdirResult.error };
         const writeResult = await writeFile(output, fmtResult.value);
-        return writeResult.ok
-            ? { ok: true, value: `Generated route code written to ${output}` }
-            : { ok: false, error: writeResult.error };
+        if (!writeResult.ok)
+            return { ok: false, error: writeResult.error };
+        return { ok: true, value: `Generated route code written to ${output}` };
     }
     const outDir = output.replace(/\.ts$/, '');
     const blocks = extractRouteBlocks(routesSrc);
@@ -60,9 +60,9 @@ export async function route(input, output, importPath, split) {
         if (!mkdirResult.ok)
             return { ok: false, error: mkdirResult.error };
         const writeResult = await writeFile(output, fmtResult.value);
-        return writeResult.ok
-            ? { ok: true, value: `Generated route code written to ${output}` }
-            : { ok: false, error: writeResult.error };
+        if (!writeResult.ok)
+            return { ok: false, error: writeResult.error };
+        return { ok: true, value: `Generated route code written to ${output}` };
     }
     for (const { name, block } of blocks) {
         const includeZ = block.includes('z.');

package/dist/core/takibi.js

@@ -53,41 +53,46 @@ import { isHttpMethod, methodPath } from '../utils/index.js';
  * @returns A `Result` containing a success message or an error string.
  */
 export async function takibi(input, output, exportSchema, exportType, template, test, basePath) {
-    const openAPIResult = await parseOpenAPI(input);
-    if (!openAPIResult.ok)
-        return { ok: false, error: openAPIResult.error };
-    const openAPI = openAPIResult.value;
-    const honoResult = await fmt(zodOpenAPIHono(openAPI, exportSchema, exportType));
-    if (!honoResult.ok)
-        return { ok: false, error: honoResult.error };
-    const mkdirResult = await mkdir(path.dirname(output));
-    if (!mkdirResult.ok)
-        return { ok: false, error: mkdirResult.error };
-    const writeResult = await writeFile(output, honoResult.value);
-    if (!writeResult.ok)
-        return { ok: false, error: writeResult.error };
-    /** template */
-    if (template && output.includes('/')) {
-        const appResult = await fmt(app(openAPI, output, basePath));
-        if (!appResult.ok)
-            return { ok: false, error: appResult.error };
-        const dir = path.dirname(output);
-        const readdirResult = await readdir(dir);
-        if (!readdirResult.ok)
-            return { ok: false, error: readdirResult.error };
-        const target = path.join(dir, 'index.ts');
-        const writeResult = await writeFile(target, appResult.value);
+    try {
+        const openAPIResult = await parseOpenAPI(input);
+        if (!openAPIResult.ok)
+            return { ok: false, error: openAPIResult.error };
+        const openAPI = openAPIResult.value;
+        const honoResult = await fmt(zodOpenAPIHono(openAPI, exportSchema, exportType));
+        if (!honoResult.ok)
+            return { ok: false, error: honoResult.error };
+        const mkdirResult = await mkdir(path.dirname(output));
+        if (!mkdirResult.ok)
+            return { ok: false, error: mkdirResult.error };
+        const writeResult = await writeFile(output, honoResult.value);
         if (!writeResult.ok)
             return { ok: false, error: writeResult.error };
-        const zodOpenapiHonoHandlerResult = await zodOpenapiHonoHandler(openAPI, output, test);
-        if (!zodOpenapiHonoHandlerResult.ok)
-            return { ok: false, error: zodOpenapiHonoHandlerResult.error };
-        return { ok: true, value: 'Generated code and template files written' };
+        /** template */
+        if (template && output.includes('/')) {
+            const appResult = await fmt(app(openAPI, output, basePath));
+            if (!appResult.ok)
+                return { ok: false, error: appResult.error };
+            const dir = path.dirname(output);
+            const readdirResult = await readdir(dir);
+            if (!readdirResult.ok)
+                return { ok: false, error: readdirResult.error };
+            const target = path.join(dir, 'index.ts');
+            const writeResult = await writeFile(target, appResult.value);
+            if (!writeResult.ok)
+                return { ok: false, error: writeResult.error };
+            const zodOpenapiHonoHandlerResult = await zodOpenapiHonoHandler(openAPI, output, test);
+            if (!zodOpenapiHonoHandlerResult.ok)
+                return { ok: false, error: zodOpenapiHonoHandlerResult.error };
+            return { ok: true, value: 'Generated code and template files written' };
+        }
+        return {
+            ok: true,
+            value: `Generated code written to ${output}`,
+        };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
     }
-    return {
-        ok: true,
-        value: `Generated code written to ${output}`,
-    };
 }
 /**
  * Generates route handler files for a Hono app using Zod and OpenAPI.

package/dist/generator/zod-to-openapi/z/enum.js

@@ -1,24 +1,26 @@
 export function _enum(schema) {
-    /* -------------------------- helpers -------------------------- */
+    /* hasType */
     const hasType = (t) => schema.type === t || (Array.isArray(schema.type) && schema.type.some((x) => x === t));
+    /* lit */
     const lit = (v) => v === null ? 'null' : typeof v === 'string' ? `'${v}'` : String(v);
+    /* tuple */
     const tuple = (arr) => `z.tuple([${arr.map((i) => `z.literal(${lit(i)})`).join(',')}])`;
-    /* --------------------------- guard --------------------------- */
+    /* guard */
     if (!schema.enum || schema.enum.length === 0)
         return 'z.any()';
-    /* ------------------- number / integer enum ------------------- */
+    /* number / integer enum  */
     if (hasType('number') || hasType('integer')) {
         return schema.enum.length > 1
             ? `z.union([${schema.enum.map((v) => `z.literal(${v})`).join(',')}])`
             : `z.literal(${schema.enum[0]})`;
     }
-    /* ----------------------- boolean enum ------------------------ */
+    /* boolean enum */
     if (hasType('boolean')) {
         return schema.enum.length > 1
             ? `z.union([${schema.enum.map((v) => `z.literal(${v})`).join(',')}])`
             : `z.literal(${schema.enum[0]})`;
     }
-    /* ----------------------- array enum -------------------------- */
+    /* array enum */
     if (hasType('array')) {
         if (schema.enum.length === 1 && Array.isArray(schema.enum[0])) {
             return tuple(schema.enum[0]);
@@ -26,13 +28,13 @@ export function _enum(schema) {
         const parts = schema.enum.map((v) => (Array.isArray(v) ? tuple(v) : `z.literal(${lit(v)})`));
         return `z.union([${parts.join(',')}])`;
     }
-    /* ----------------------- string enum ------------------------- */
+    /* string enum */
     if (schema.enum.every((v) => typeof v === 'string')) {
         return schema.enum.length > 1
             ? `z.enum(${JSON.stringify(schema.enum)})`
             : `z.literal('${schema.enum[0]}')`;
     }
-    /* -------------------- mixed / null only ---------------------- */
+    /* mixed / null only */
     if (schema.enum.length > 1) {
         const parts = schema.enum.map((v) => `z.literal(${lit(v)})`);
         return `z.union([${parts.join(',')}])`;

package/dist/helper/wrap.js

@@ -1,10 +1,10 @@
 export function wrap(zod, schema, paramName, paramIn) {
     const formatLiteral = (v) => {
-        // boolean true or false
+        /* boolean true or false */
         if (typeof v === 'boolean') {
             return `${v}`;
         }
-        // number
+        /* number */
         if (typeof v === 'number') {
             if (schema.format === 'int64') {
                 return `${v}n`;
@@ -14,18 +14,18 @@ export function wrap(zod, schema, paramName, paramIn) {
             }
             return `${v}`;
         }
-        // date
+        /* date */
         if (schema.type === 'date' && typeof v === 'string') {
             return `new Date(${JSON.stringify(v)})`;
         }
-        // string
+        /* string */
         if (typeof v === 'string') {
             return JSON.stringify(v);
         }
-        // other
+        /* other */
         return JSON.stringify(v);
     };
-    // why schema.default !== undefined becasue schema.default === 0  // → falsy
+    /* why schema.default !== undefined becasue schema.default === 0  // → falsy */
     const s = schema.default !== undefined ? `${zod}.default(${formatLiteral(schema.default)})` : zod;
     const isNullable = schema.nullable === true ||
         (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
@@ -35,15 +35,15 @@ export function wrap(zod, schema, paramName, paramIn) {
         const required = paramIn === 'path' ? true : !!schema.required;
         openapiProps.push(`param:{in:"${paramIn}",name:${JSON.stringify(paramName)},required:${required}}`);
     }
-    // Add 'example' if defined
+    /* 'example' if defined */
     if ('example' in schema && schema.example !== undefined) {
         openapiProps.push(`example:${JSON.stringify(schema.example)}`);
     }
-    // Add 'examples' if defined
+    /* 'examples' if defined */
     if ('examples' in schema && Array.isArray(schema.examples) && schema.examples.length > 0) {
         openapiProps.push(`examples:${JSON.stringify(schema.examples)}`);
     }
-    // Add 'description' if defined
+    /* 'description' if defined */
     if ('description' in schema && schema.description !== undefined) {
         openapiProps.push(`description:${JSON.stringify(schema.description)}`);
     }

package/dist/typespec/index.js

@@ -1,5 +1,5 @@
 import path from 'node:path';
-import { compile, logDiagnostics, NodeHost } from '@typespec/compiler';
+import { compile, NodeHost } from '@typespec/compiler';
 import { getOpenAPI3 } from '@typespec/openapi3';
 /**
  * Compiles a TypeSpec (`.tsp`) file and returns the generated OpenAPI document.
@@ -32,7 +32,8 @@ export async function typeSpecToOpenAPI(input) {
             noEmit: true,
         });
         if (program.diagnostics.length) {
-            logDiagnostics(program.diagnostics, program.host.logSink);
+            // logDiagnostics(program.diagnostics, program.host.logSink)
+            console.log(JSON.stringify(program.diagnostics, null, 2));
             return {
                 ok: false,
                 error: 'TypeSpec compile failed',

package/dist/utils/index.d.ts

@@ -88,19 +88,6 @@ export declare function parseCli(args: readonly string[]): {
 /**
  * Normalize a JSON Schema `type` value into an array of type strings.
  *
- * - `undefined` → `[]`
- * - `'string'`  → `['string']`
- * - `['string','number']` → unchanged
- *
- * ```mermaid
- * graph TD
- *   A1[normalizeTypes] --> B1{is undefined}
- *   B1 -->|Yes| C1[return empty array]
- *   B1 -->|No| D1{is array}
- *   D1 -->|Yes| E1[return t]
- *   D1 -->|No| F1[return array with t]
- * ```
- *
  * @param t - JSON Schema `type` as a single value or an array of values.
  * @returns A flat array of type strings.
  */
@@ -111,41 +98,20 @@ export declare function normalizeTypes(t?: 'string' | 'number' | 'integer' | 'da
 /**
  * Generates registration code for OpenAPI `securitySchemes`.
  *
- * The code calls:
- * ```
- * app.openAPIRegistry.registerComponent('securitySchemes', name, scheme)
- * ```
- * for each entry in the provided record.
- *
- * ```mermaid
- * graph TD
- *   A[Start registerComponent] --> B[Iterate over securitySchemes]
- *   B --> C[Build registration string for each name + scheme]
- *   C --> D[Join all strings with newline]
- *   D --> E[Return final code string]
- * ```
- *
  * @param securitySchemes - Record of scheme name to scheme properties.
  * @returns Multiline string of registration statements.
  */
 export declare function registerComponent(securitySchemes: {
-    [key: string]: {
-        type?: string;
-        name?: string;
-        scheme?: string;
-        bearerFormat?: string;
+    readonly [key: string]: {
+        readonly type?: string;
+        readonly name?: string;
+        readonly scheme?: string;
+        readonly bearerFormat?: string;
     };
 }): string;
 /**
  * Checks if a value is a non-null object (e.g., a potential `$ref` object).
  *
- * ```mermaid
- * graph TD
- *   A[Start isRefObject] --> B[Check typeof value is object]
- *   B --> C[Check value is not null]
- *   C --> D[Return true or false]
- * ```
- *
  * @param value - The value to check.
  * @returns `true` if the value is a non-null object.
  *
@@ -170,16 +136,6 @@ export declare function isHttpMethod(method: string): method is 'get' | 'put' |
 /**
  * Checks if all given content types share the same schema definition.
  *
- * ```mermaid
- * graph TD
- *   A[Start isUniqueContentSchema] --> B[Create empty set]
- *   B --> C[Loop over content types]
- *   C --> D[Read schema for type]
- *   D --> E[Stringify and add to set]
- *   E --> F[After loop check size]
- *   F --> G[Return true if size is one]
- * ```
- *
  * @param contentTypes - Array of content type keys (e.g., ['application/json', 'application/xml']).
  * @param content - OpenAPI content object mapping content types to media objects.
  * @returns `true` if all specified content types refer to the same schema; otherwise `false`.
@@ -193,8 +149,8 @@ export declare function isHttpMethod(method: string): method is 'get' | 'put' |
  * ```
  */
 export declare function isUniqueContentSchema(contentTypes: readonly string[], content: {
-    [key: string]: {
-        schema: {
+    readonly [key: string]: {
+        readonly schema: {
             readonly $ref?: `#/components/schemas/${string}`;
         };
     };
@@ -202,14 +158,6 @@ export declare function isUniqueContentSchema(contentTypes: readonly string[], c
 /**
  * Extracts the type name from an OpenAPI `$ref` string.
  *
- * ```mermaid
- * graph TD
- *   A["Start refSchema"] --> B["Split $ref by slash"]
- *   B --> C["Take last segment"]
- *   C --> D["Append Schema suffix"]
- *   D --> E["Return result string"]
- * ```
- *
  * @param $ref - A reference path like `#/components/schemas/Address`.
  * @returns The extracted type name with `Schema` suffix.
  *
@@ -223,16 +171,6 @@ export declare function refSchema($ref: `#/components/schemas/${string}`): strin
 /**
  * Generates a PascalCase route name from HTTP method and path.
  *
- * ```mermaid
- * graph TD
- *   A[Start routeName] --> B[Replace special chars with space]
- *   B --> C[Trim and split by spaces]
- *   C --> D[Capitalize each segment]
- *   D --> E[Join segments into single string]
- *   E --> F[Prefix with method and suffix with Route]
- *   F --> G[Return final route name]
- * ```
- *
  * @param method - HTTP method (e.g., 'get', 'post').
  * @param path - URL path (e.g., '/users/{id}/posts').
  * @returns A route name string (e.g., 'getUsersIdPostsRoute').
@@ -244,14 +182,6 @@ export declare function methodPath(method: string, path: string): string;
 /**
  * Generates a Hono route definition as a TypeScript export string.
  *
- * ```mermaid
- * graph TD
- *   A[Start createRoute] --> B[Collect properties from args]
- *   B --> C[Join properties into one string]
- *   C --> D[Build export createRoute template]
- *   D --> E[Return final code string]
- * ```
- *
  * @param args - Route metadata and OpenAPI friendly fragments (`method`, `path`, `requestParams`, `responses`, etc.).
  * @returns A string representing an `export const <name> = createRoute({ ... })` statement.
  *
@@ -279,6 +209,7 @@ export declare function createRoute(args: {
 }): string;
 /**
  * Generates an array of Zod validator strings from OpenAPI parameter objects.
+ *
  * @param parameters - An object containing `query`, `path`, and `header` parameters.
  * @returns An array of strings like `'query:z.object({...})'` or `'params:z.object({...})'`.
  */
@@ -286,18 +217,6 @@ export declare const requestParamsArray: (parameters: Record<string, Record<stri
 /**
  * Escapes a string for safe use in TypeScript string literals.
  *
- * ```mermaid
- * graph TD
- *   A[Start escapeStringLiteral] --> B[Replace newline and tab with space]
- *   B --> C[Remove zero width and BOM characters]
- *   C --> D[Replace full width spaces with normal space]
- *   D --> E[Collapse multiple spaces into one]
- *   E --> F[Escape backslashes]
- *   F --> G[Escape single quotes]
- *   G --> H[Trim leading and trailing spaces]
- *   H --> I[Return escaped string]
- * ```
- *
  * @param text - The input text to escape.
  * @returns The escaped string.
  */
@@ -305,14 +224,8 @@ export declare function escapeStringLiteral(text: string): string;
 /**
  * Converts a string to a safe TypeScript object key.
  *
- * ```mermaid
- * graph TD
- *   A[Start getToSafeIdentifier] --> B[Check if matches identifier regex]
- *   B --> C[If matches, return string as is]
- *   B --> D[If not, wrap with JSON stringify]
- *   C --> E[Return result]
- *   D --> E[Return result]
- * ```
+ * @param text - The string to convert to a safe identifier.
+ * @returns A safe identifier string.
  *
  * @example
  * ```ts
@@ -323,19 +236,11 @@ export declare function escapeStringLiteral(text: string): string;
  * getToSafeIdentifier('if')          // → 'if'
  * ```
  */
-export declare function getToSafeIdentifier(str: string): string;
+export declare function getToSafeIdentifier(text: string): string;
 /**
- * Converts a string to a safe TypeScript identifier.
- *
- * ```mermaid
- * graph TD
- *   A[Start sanitizeIdentifier] --> B[Replace invalid characters with underscore]
- *   B --> C[Return sanitized string]
- * ```
- *
  * Replaces any character not matching `[A-Za-z0-9_$]` with `_`.
  *
- * @param str - The raw string to sanitize.
+ * @param text - The raw string to sanitize.
  * @returns A valid identifier string.
  *
  * @example
@@ -347,23 +252,10 @@ export declare function getToSafeIdentifier(str: string): string;
  * sanitizeIdentifier('valid_Name')     // → 'valid_Name'
  * ```
  */
-export declare function sanitizeIdentifier(str: string): string;
+export declare function sanitizeIdentifier(text: string): string;
 /**
  * Appends a properly escaped `.regex(/pattern/)` clause.
  *
- * Any unescaped forward-slash within the pattern is escaped so the final
- * string remains a valid JavaScript RegExp literal.
- *
- * ```mermaid
- * graph TD
- *   A["Start regex(pattern)"] --> B["Receive raw regex pattern without slashes"]
- *   B --> C["Find all '/' not preceded by '\\'"]
- *   C --> D["Escape them to '\\/'"]
- *   D --> E["Wrap pattern in '/ ... /'"]
- *   E --> F["Prefix with '.regex(' and suffix with ')' "]
- *   F --> G["Return generated string"]
- * ```
- *
  * @param pattern - A raw regex pattern **without** the surrounding slashes.
  * @returns A string like `'.regex(/^[a-z]+$/)'`.
  */

package/dist/utils/index.js

@@ -5,6 +5,7 @@ export function parseConfig(config) {
     if (!isYamlOrJsonOrTsp(c.input)) {
         return { ok: false, error: `Invalid input: ${String(c.input)} (must be .yaml | .json | .tsp)` };
     }
+    // zod-openapi
     const zo = c['zod-openapi'];
     if (zo !== undefined) {
         // boolean flags
@@ -20,15 +21,15 @@ export function parseConfig(config) {
                 error: `Invalid exportType format for zod-openapi: ${String(zo.exportType)}`,
             };
         }
-        const hasSchema = zo.schema !== undefined;
-        const hasRoute = zo.route !== undefined;
-        if (hasSchema !== hasRoute) {
+        const hs = zo.schema !== undefined;
+        const hr = zo.route !== undefined;
+        if (hs !== hr) {
             return {
                 ok: false,
                 error: "Invalid config: 'zod-openapi.schema' and 'zod-openapi.route' must be defined together (both or neither).",
             };
         }
-        if (hasSchema || hasRoute) {
+        if (hs || hr) {
             if (Object.hasOwn(zo, 'output')) {
                 return {
                     ok: false,
@@ -44,7 +45,7 @@ export function parseConfig(config) {
                 };
             }
         }
-        if (hasSchema) {
+        if (hs) {
             const s = zo.schema;
             if (!s)
                 return { ok: false, error: 'Invalid config: zod-openapi.schema is undefined' };
@@ -80,7 +81,7 @@ export function parseConfig(config) {
                 };
             }
         }
-        if (hasRoute) {
+        if (hr) {
             const r = zo.route;
             if (!r)
                 return { ok: false, error: 'Invalid config: zod-openapi.route is undefined' };
@@ -206,19 +207,6 @@ export function parseCli(args) {
 /**
  * Normalize a JSON Schema `type` value into an array of type strings.
  *
- * - `undefined` → `[]`
- * - `'string'`  → `['string']`
- * - `['string','number']` → unchanged
- *
- * ```mermaid
- * graph TD
- *   A1[normalizeTypes] --> B1{is undefined}
- *   B1 -->|Yes| C1[return empty array]
- *   B1 -->|No| D1{is array}
- *   D1 -->|Yes| E1[return t]
- *   D1 -->|No| F1[return array with t]
- * ```
- *
  * @param t - JSON Schema `type` as a single value or an array of values.
  * @returns A flat array of type strings.
  */
@@ -228,20 +216,6 @@ export function normalizeTypes(t) {
 /**
  * Generates registration code for OpenAPI `securitySchemes`.
  *
- * The code calls:
- * ```
- * app.openAPIRegistry.registerComponent('securitySchemes', name, scheme)
- * ```
- * for each entry in the provided record.
- *
- * ```mermaid
- * graph TD
- *   A[Start registerComponent] --> B[Iterate over securitySchemes]
- *   B --> C[Build registration string for each name + scheme]
- *   C --> D[Join all strings with newline]
- *   D --> E[Return final code string]
- * ```
- *
  * @param securitySchemes - Record of scheme name to scheme properties.
  * @returns Multiline string of registration statements.
  */
@@ -255,13 +229,6 @@ export function registerComponent(securitySchemes) {
 /**
  * Checks if a value is a non-null object (e.g., a potential `$ref` object).
  *
- * ```mermaid
- * graph TD
- *   A[Start isRefObject] --> B[Check typeof value is object]
- *   B --> C[Check value is not null]
- *   C --> D[Return true or false]
- * ```
- *
  * @param value - The value to check.
  * @returns `true` if the value is a non-null object.
  *
@@ -294,16 +261,6 @@ export function isHttpMethod(method) {
 /**
  * Checks if all given content types share the same schema definition.
  *
- * ```mermaid
- * graph TD
- *   A[Start isUniqueContentSchema] --> B[Create empty set]
- *   B --> C[Loop over content types]
- *   C --> D[Read schema for type]
- *   D --> E[Stringify and add to set]
- *   E --> F[After loop check size]
- *   F --> G[Return true if size is one]
- * ```
- *
  * @param contentTypes - Array of content type keys (e.g., ['application/json', 'application/xml']).
  * @param content - OpenAPI content object mapping content types to media objects.
  * @returns `true` if all specified content types refer to the same schema; otherwise `false`.
@@ -323,14 +280,6 @@ export function isUniqueContentSchema(contentTypes, content) {
 /**
  * Extracts the type name from an OpenAPI `$ref` string.
  *
- * ```mermaid
- * graph TD
- *   A["Start refSchema"] --> B["Split $ref by slash"]
- *   B --> C["Take last segment"]
- *   C --> D["Append Schema suffix"]
- *   D --> E["Return result string"]
- * ```
- *
  * @param $ref - A reference path like `#/components/schemas/Address`.
  * @returns The extracted type name with `Schema` suffix.
  *
@@ -351,16 +300,6 @@ export function refSchema($ref) {
 /**
  * Generates a PascalCase route name from HTTP method and path.
  *
- * ```mermaid
- * graph TD
- *   A[Start routeName] --> B[Replace special chars with space]
- *   B --> C[Trim and split by spaces]
- *   C --> D[Capitalize each segment]
- *   D --> E[Join segments into single string]
- *   E --> F[Prefix with method and suffix with Route]
- *   F --> G[Return final route name]
- * ```
- *
  * @param method - HTTP method (e.g., 'get', 'post').
  * @param path - URL path (e.g., '/users/{id}/posts').
  * @returns A route name string (e.g., 'getUsersIdPostsRoute').
@@ -386,14 +325,6 @@ export function methodPath(method, path) {
 /**
  * Generates a Hono route definition as a TypeScript export string.
  *
- * ```mermaid
- * graph TD
- *   A[Start createRoute] --> B[Collect properties from args]
- *   B --> C[Join properties into one string]
- *   C --> D[Build export createRoute template]
- *   D --> E[Return final code string]
- * ```
- *
  * @param args - Route metadata and OpenAPI friendly fragments (`method`, `path`, `requestParams`, `responses`, etc.).
  * @returns A string representing an `export const <name> = createRoute({ ... })` statement.
  *
@@ -423,6 +354,7 @@ export function createRoute(args) {
 }
 /**
  * Generates an array of Zod validator strings from OpenAPI parameter objects.
+ *
  * @param parameters - An object containing `query`, `path`, and `header` parameters.
  * @returns An array of strings like `'query:z.object({...})'` or `'params:z.object({...})'`.
  */
@@ -438,18 +370,6 @@ export const requestParamsArray = (parameters) => Object.entries(parameters)
 /**
  * Escapes a string for safe use in TypeScript string literals.
  *
- * ```mermaid
- * graph TD
- *   A[Start escapeStringLiteral] --> B[Replace newline and tab with space]
- *   B --> C[Remove zero width and BOM characters]
- *   C --> D[Replace full width spaces with normal space]
- *   D --> E[Collapse multiple spaces into one]
- *   E --> F[Escape backslashes]
- *   F --> G[Escape single quotes]
- *   G --> H[Trim leading and trailing spaces]
- *   H --> I[Return escaped string]
- * ```
- *
  * @param text - The input text to escape.
  * @returns The escaped string.
  */
@@ -466,14 +386,8 @@ export function escapeStringLiteral(text) {
 /**
  * Converts a string to a safe TypeScript object key.
  *
- * ```mermaid
- * graph TD
- *   A[Start getToSafeIdentifier] --> B[Check if matches identifier regex]
- *   B --> C[If matches, return string as is]
- *   B --> D[If not, wrap with JSON stringify]
- *   C --> E[Return result]
- *   D --> E[Return result]
- * ```
+ * @param text - The string to convert to a safe identifier.
+ * @returns A safe identifier string.
  *
  * @example
  * ```ts
@@ -484,21 +398,13 @@ export function escapeStringLiteral(text) {
  * getToSafeIdentifier('if')          // → 'if'
  * ```
  */
-export function getToSafeIdentifier(str) {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(str) ? str : JSON.stringify(str);
+export function getToSafeIdentifier(text) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(text) ? text : JSON.stringify(text);
 }
 /**
- * Converts a string to a safe TypeScript identifier.
- *
- * ```mermaid
- * graph TD
- *   A[Start sanitizeIdentifier] --> B[Replace invalid characters with underscore]
- *   B --> C[Return sanitized string]
- * ```
- *
  * Replaces any character not matching `[A-Za-z0-9_$]` with `_`.
  *
- * @param str - The raw string to sanitize.
+ * @param text - The raw string to sanitize.
  * @returns A valid identifier string.
  *
  * @example
@@ -510,25 +416,12 @@ export function getToSafeIdentifier(str) {
  * sanitizeIdentifier('valid_Name')     // → 'valid_Name'
  * ```
  */
-export function sanitizeIdentifier(str) {
-    return str.replace(/[^A-Za-z0-9_$]/g, '_');
+export function sanitizeIdentifier(text) {
+    return text.replace(/[^A-Za-z0-9_$]/g, '_');
 }
 /**
  * Appends a properly escaped `.regex(/pattern/)` clause.
  *
- * Any unescaped forward-slash within the pattern is escaped so the final
- * string remains a valid JavaScript RegExp literal.
- *
- * ```mermaid
- * graph TD
- *   A["Start regex(pattern)"] --> B["Receive raw regex pattern without slashes"]
- *   B --> C["Find all '/' not preceded by '\\'"]
- *   C --> D["Escape them to '\\/'"]
- *   D --> E["Wrap pattern in '/ ... /'"]
- *   E --> F["Prefix with '.regex(' and suffix with ')' "]
- *   F --> G["Return generated string"]
- * ```
- *
  * @param pattern - A raw regex pattern **without** the surrounding slashes.
  * @returns A string like `'.regex(/^[a-z]+$/)'`.
  */

package/dist/vite-plugin/index.js

@@ -75,14 +75,15 @@ const deleteAllTsShallow = async (dir) => listTsShallow(dir).then((files) => Pro
 const pruneDir = async (dir, expected) => fsp
     .stat(dir)
     .then((st) => st.isDirectory()
-    ? fsp.readdir(dir, { withFileTypes: true }).then((ents) => {
+    ? fsp.readdir(dir, { withFileTypes: true }).then(async (ents) => {
         const targets = ents
             .filter((e) => e.isFile() && e.name.endsWith('.ts') && !expected.has(e.name))
             .map((e) => path.join(dir, e.name));
-        return Promise.all(targets.map((f) => fsp
+        const res = await Promise.all(targets.map((f) => fsp
             .unlink(f)
             .then(() => f)
-            .catch(() => null))).then((res) => res.filter((x) => x !== null));
+            .catch(() => null)));
+        return res.filter((x) => x !== null);
     })
     : [])
     .catch(() => []);
@@ -151,9 +152,6 @@ const extractRouteBlocks = (src) => {
         return { name: h.name, block: src.slice(start, end).trim() };
     });
 };
-/* ──────────────────────────────────────────────────────────────
- * Split-mode filename calculators (no `as` cast)
- * ────────────────────────────────────────────────────────────── */
 const computeRpcSplitFiles = async (input) => {
     const spec = await parseOpenAPI(input);
     if (!spec.ok)
@@ -194,9 +192,6 @@ const computeSchemaSplitFiles = async (input) => {
         acc.add('index.ts');
     return acc;
 };
-/* ──────────────────────────────────────────────────────────────
- * Debounce (no `let`)
- * ────────────────────────────────────────────────────────────── */
 const debounce = (ms, fn) => {
     const bucket = new WeakMap();
     const wrapped = () => {
@@ -207,36 +202,38 @@ const debounce = (ms, fn) => {
     };
     return wrapped;
 };
-/* ──────────────────────────────────────────────────────────────
- * Run generators for a given config（parseConfig 済み前提）
- * ────────────────────────────────────────────────────────────── */
 const runAllWithConf = async (c) => {
     const jobs = [];
     const zo = c['zod-openapi'];
     if (zo) {
         const exportType = zo.exportType === true;
         const exportSchema = zo.exportSchema !== false;
-        const hasSchema = !!zo.schema;
-        const hasRoute = !!zo.route;
+        const hs = !!zo.schema;
+        const hr = !!zo.route;
         // top-level zod-openapi (non-split)
-        if (!(hasSchema || hasRoute)) {
+        if (!(hs || hr)) {
             const runZo = async () => {
-                const spec = await parseOpenAPI(c.input);
-                if (!spec.ok)
-                    return `✗ zod-openapi: ${spec.error}`;
-                const code = await fmt(zodOpenAPIHono(spec.value, exportSchema, exportType));
-                if (!code.ok)
-                    return `✗ zod-openapi fmt: ${code.error}`;
-                const outputMaybe = zo.output;
-                if (typeof outputMaybe !== 'string') {
-                    return `✗ zod-openapi: Invalid output format for zod-openapi: ${String(outputMaybe)}`;
+                try {
+                    const spec = await parseOpenAPI(c.input);
+                    if (!spec.ok)
+                        return `✗ zod-openapi: ${spec.error}`;
+                    const code = await fmt(zodOpenAPIHono(spec.value, exportSchema, exportType));
+                    if (!code.ok)
+                        return `✗ zod-openapi fmt: ${code.error}`;
+                    const outputMaybe = zo.output;
+                    if (typeof outputMaybe !== 'string') {
+                        return `✗ zod-openapi: Invalid output format for zod-openapi: ${String(outputMaybe)}`;
+                    }
+                    const out = toAbs(outputMaybe);
+                    const mk = await mkdir(path.dirname(out));
+                    if (!mk.ok)
+                        return `✗ zod-openapi mkdir: ${mk.error}`;
+                    const wr = await writeFile(out, code.value);
+                    return wr.ok ? `✓ zod-openapi -> ${out}` : `✗ zod-openapi write: ${wr.error}`;
+                }
+                catch (e) {
+                    return `✗ zod-openapi: ${e instanceof Error ? e.message : String(e)}`;
                 }
-                const out = toAbs(outputMaybe);
-                const mk = await mkdir(path.dirname(out));
-                if (!mk.ok)
-                    return `✗ zod-openapi mkdir: ${mk.error}`;
-                const wr = await writeFile(out, code.value);
-                return wr.ok ? `✓ zod-openapi -> ${out}` : `✗ zod-openapi write: ${wr.error}`;
             };
             jobs.push(runZo());
         }

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.52",
+  "version": "0.9.60",
   "type": "module",
   "license": "MIT",
   "keywords": [
@@ -46,26 +46,25 @@
     }
   },
   "dependencies": {
-    "@apidevtools/swagger-parser": "^12.0.0",
-    "@typespec/compiler": "^1.3.0",
-    "@typespec/openapi3": "^1.3.0",
+    "@apidevtools/swagger-parser": "^12.1.0",
+    "@typespec/compiler": "^1.5.0",
+    "@typespec/openapi3": "^1.5.0",
     "prettier": "^3.6.2",
-    "tsx": "^4.20.4"
+    "tsx": "^4.20.6"
   },
   "devDependencies": {
-    "@hono/zod-openapi": "1.1.0",
-    "@types/node": "^22.16.5",
-    "@typespec/http": "^1.3.0",
-    "@typespec/rest": "^0.73.0",
-    "@typespec/versioning": "^0.73.0",
-    "@vitest/coverage-v8": "^3.2.4",
-    "typescript": "^5.8.3",
-    "vite": "^7.0.6",
-    "vitest": "^3.2.4",
-    "zod": "^4.0.15"
+    "@hono/zod-openapi": "1.1.4",
+    "@types/node": "^24.9.1",
+    "@typespec/http": "^1.5.0",
+    "@typespec/rest": "^0.75.0",
+    "@typespec/versioning": "^0.75.0",
+    "@vitest/coverage-v8": "^4.0.3",
+    "typescript": "^5.9.3",
+    "vite": "^7.1.12",
+    "vitest": "^4.0.3",
+    "zod": "^4.1.12"
   },
   "scripts": {
-    "takibis": "pnpm build && tsx exec.ts",
     "dev": "vite --host",
     "deps": "rm -rf node_modules && pnpm install",
     "build": "rm -rf ./dist/* && tsc",