hono-takibi 0.9.60 → 0.9.61

package/dist/cli/index.js

@@ -5,6 +5,7 @@ import { route } from '../core/route.js';
 import { rpc } from '../core/rpc.js';
 import { schema } from '../core/schema.js';
 import { takibi } from '../core/takibi.js';
+import { type } from '../core/type.js';
 // import { honoRpcWithSWR } from '../generator/swr/index.js'
 import { parseCli } from '../utils/index.js';
 /**
@@ -104,13 +105,17 @@ export async function honoTakibi() {
         : undefined;
     if (routeResult && !routeResult.ok)
         return { ok: false, error: routeResult.error };
+    /** type */
+    const typeResult = c.type ? await type(c.input, c.type.output) : undefined;
+    if (typeResult && !typeResult.ok)
+        return { ok: false, error: typeResult.error };
     /** rpc */
     const rpcResult = c.rpc
         ? await rpc(c.input, c.rpc.output, c.rpc.import, c.rpc.split ?? false)
         : undefined;
     if (rpcResult && !rpcResult.ok)
         return { ok: false, error: rpcResult.error };
-    const results = [takibiResult?.value, rpcResult?.value].filter((v) => Boolean(v));
+    const results = [takibiResult?.value, typeResult?.value, rpcResult?.value].filter((v) => v !== undefined);
     return {
         ok: true,
         value: results.join('\n'),

package/dist/config/index.d.ts

@@ -15,6 +15,9 @@ type Config = {
             readonly split?: boolean;
         };
     };
+    readonly type?: {
+        readonly output: `${string}.ts`;
+    };
     readonly rpc?: {
         readonly output: string | `${string}.ts`;
         readonly import: string;

package/dist/core/rpc.js

@@ -139,14 +139,7 @@ const createResolveParameter = (componentsParameters) => (p) => {
     const cand = name ? componentsParameters[name] : undefined;
     return isParameterObject(cand) ? cand : undefined;
 };
-const createToParameterLikes = (resolveParam) => (arr) => Array.isArray(arr)
-    ? arr.reduce((acc, x) => {
-        const r = resolveParam(x);
-        if (r)
-            acc.push(r);
-        return acc;
-    }, [])
-    : [];
+const createToParameterLikes = (resolveParam) => (arr) => Array.isArray(arr) ? arr.map((x) => resolveParam(x)).filter((param) => param !== undefined) : [];
 const isOperationLike = (v) => isRecord(v) && 'responses' in v;
 const HTTP_METHODS = [
     'get',
@@ -183,16 +176,14 @@ const pickBodySchema = (op) => {
 };
 /* ─────────────────────────────── Args builders ─────────────────────────────── */
 const createBuildParamsType = (tsTypeFromSchema) => (pathParams, queryParams) => {
-    const parts = [];
-    if (pathParams.length) {
-        const inner = pathParams.map((p) => `${p.name}:${tsTypeFromSchema(p.schema)}`).join(',');
-        parts.push(`path:{${inner}}`);
-    }
-    if (queryParams.length) {
-        const inner = queryParams.map((p) => `${p.name}:${tsTypeFromSchema(p.schema)}`).join(',');
-        parts.push(`query:{${inner}}`);
-    }
-    return parts.length ? `{${parts.join(',')}}` : '';
+    const pathPart = pathParams.length === 0
+        ? []
+        : [`path:{${pathParams.map((p) => `${p.name}:${tsTypeFromSchema(p.schema)}`).join(',')}}`];
+    const queryPart = queryParams.length === 0
+        ? []
+        : [`query:{${queryParams.map((p) => `${p.name}:${tsTypeFromSchema(p.schema)}`).join(',')}}`];
+    const parts = [...pathPart, ...queryPart];
+    return parts.length === 0 ? '' : `{${parts.join(',')}}`;
 };
 const buildArgSignature = (paramsType, bodyType) => paramsType && bodyType
     ? `params:${paramsType},body:${bodyType}`
@@ -203,14 +194,11 @@ const buildArgSignature = (paramsType, bodyType) => paramsType && bodyType
             : '';
 /** pass path/query as-is (keep numbers/arrays) */
 const buildClientArgs = (pathParams, queryParams, hasBody) => {
-    const pieces = [];
-    if (pathParams.length)
-        pieces.push('param:params.path');
-    if (queryParams.length)
-        pieces.push('query:params.query');
-    if (hasBody)
-        pieces.push('json:body');
-    return pieces.length ? `{${pieces.join(',')}}` : '';
+    const paramPiece = pathParams.length ? ['param:params.path'] : [];
+    const queryPiece = queryParams.length ? ['query:params.query'] : [];
+    const bodyPiece = hasBody ? ['json:body'] : [];
+    const pieces = [...paramPiece, ...queryPiece, ...bodyPiece];
+    return pieces.length === 0 ? '' : `{${pieces.join(',')}}`;
 };
 /* ─────────────────────────────── Single-operation generator ─────────────────────────────── */
 const generateOperationCode = (pathStr, method, item, deps) => {
@@ -246,6 +234,25 @@ const generateOperationCode = (pathStr, method, item, deps) => {
     const func = `export async function ${funcName}(${argSig}){return await ${call}}`;
     return `${docs}\n${func}`;
 };
+const buildOperationCodes = (paths, deps) => Object.entries(paths)
+    .filter((entry) => isRecord(entry[1]))
+    .flatMap(([p, rawItem]) => {
+    const pathItem = {
+        parameters: rawItem.parameters,
+        get: isOperationLike(rawItem.get) ? rawItem.get : undefined,
+        put: isOperationLike(rawItem.put) ? rawItem.put : undefined,
+        post: isOperationLike(rawItem.post) ? rawItem.post : undefined,
+        delete: isOperationLike(rawItem.delete) ? rawItem.delete : undefined,
+        options: isOperationLike(rawItem.options) ? rawItem.options : undefined,
+        head: isOperationLike(rawItem.head) ? rawItem.head : undefined,
+        patch: isOperationLike(rawItem.patch) ? rawItem.patch : undefined,
+        trace: isOperationLike(rawItem.trace) ? rawItem.trace : undefined,
+    };
+    return HTTP_METHODS.map((method) => {
+        const code = generateOperationCode(p, method, pathItem, deps);
+        return code ? { funcName: methodPath(method, p), code } : null;
+    }).filter((item) => item !== null);
+});
 /* ─────────────────────────────── Split ─────────────────────────────── */
 const resolveSplitOutDir = (output) => {
     const looksLikeFile = output.endsWith('.ts');
@@ -268,7 +275,6 @@ export async function rpc(input, output, importPath, split) {
     const client = 'client';
     const s = `import { client } from '${importPath}'`;
     const header = s.length ? `${s}\n\n` : '';
-    const combinedOut = [];
     const pathsMaybe = openAPI.paths;
     if (!isOpenAPIPaths(pathsMaybe)) {
         return { ok: false, error: 'Invalid OpenAPI paths' };
@@ -279,60 +285,19 @@ export async function rpc(input, output, importPath, split) {
     const componentsParameters = openAPI.components?.parameters ?? {};
     const resolveParameter = createResolveParameter(componentsParameters);
     const toParameterLikes = createToParameterLikes(resolveParameter);
-    // Split-mode: prepare an index file exports collector.
-    const splitExports = new Set();
-    // Iterate paths and generate per-operation code
-    for (const p in pathsMaybe) {
-        const rawItem = pathsMaybe[p];
-        if (!isRecord(rawItem))
-            continue;
-        const pathItem = {
-            parameters: rawItem.parameters,
-            get: isOperationLike(rawItem.get) ? rawItem.get : undefined,
-            put: isOperationLike(rawItem.put) ? rawItem.put : undefined,
-            post: isOperationLike(rawItem.post) ? rawItem.post : undefined,
-            delete: isOperationLike(rawItem.delete) ? rawItem.delete : undefined,
-            options: isOperationLike(rawItem.options) ? rawItem.options : undefined,
-            head: isOperationLike(rawItem.head) ? rawItem.head : undefined,
-            patch: isOperationLike(rawItem.patch) ? rawItem.patch : undefined,
-            trace: isOperationLike(rawItem.trace) ? rawItem.trace : undefined,
-        };
-        for (const method of HTTP_METHODS) {
-            const code = generateOperationCode(p, method, pathItem, {
-                client,
-                tsTypeFromSchema,
-                toParameterLikes,
-            });
-            if (!code)
-                continue;
-            if (split) {
-                // One file per RPC function: <funcName>.ts
-                const funcName = methodPath(method, p);
-                const fileSrc = `${header}${code}\n`;
-                const fmtResult = await fmt(fileSrc);
-                if (!fmtResult.ok)
-                    return { ok: false, error: fmtResult.error };
-                const { outDir } = resolveSplitOutDir(output);
-                const filePath = path.join(outDir, `${funcName}.ts`);
-                const mkdirResult = await mkdir(path.dirname(filePath));
-                if (!mkdirResult.ok)
-                    return { ok: false, error: mkdirResult.error };
-                const writeResult = await writeFile(filePath, fmtResult.value);
-                if (!writeResult.ok)
-                    return { ok: false, error: writeResult.error };
-                splitExports.add(`export * from './${funcName}'`);
-            }
-            else {
-                combinedOut.push(code);
-            }
-        }
-    }
+    const deps = {
+        client,
+        tsTypeFromSchema,
+        toParameterLikes,
+    };
+    const operationCodes = buildOperationCodes(pathsMaybe, deps);
     // Non-split: write single file
     if (!split) {
         const mkdirResult = await mkdir(path.dirname(output));
         if (!mkdirResult.ok)
             return { ok: false, error: mkdirResult.error };
-        const code = `${header}${combinedOut.join('\n\n')}${combinedOut.length ? '\n' : ''}`;
+        const body = operationCodes.map(({ code }) => code).join('\n\n');
+        const code = `${header}${body}${operationCodes.length ? '\n' : ''}`;
         const fmtResult = await fmt(code);
         if (!fmtResult.ok)
             return { ok: false, error: fmtResult.error };
@@ -341,9 +306,23 @@ export async function rpc(input, output, importPath, split) {
             return { ok: false, error: writeResult.error };
         return { ok: true, value: `Generated rpc code written to ${output}` };
     }
-    // Split: write index.ts (barrel)
+    // Split: write each file + index.ts (barrel)
     const { outDir, indexPath } = resolveSplitOutDir(output);
-    const index = `${Array.from(splitExports).sort().join('\n')}\n`;
+    for (const { funcName, code } of operationCodes) {
+        const fileSrc = `${header}${code}\n`;
+        const fmtResult = await fmt(fileSrc);
+        if (!fmtResult.ok)
+            return { ok: false, error: fmtResult.error };
+        const filePath = path.join(outDir, `${funcName}.ts`);
+        const mkdirResult = await mkdir(path.dirname(filePath));
+        if (!mkdirResult.ok)
+            return { ok: false, error: mkdirResult.error };
+        const writeResult = await writeFile(filePath, fmtResult.value);
+        if (!writeResult.ok)
+            return { ok: false, error: writeResult.error };
+    }
+    const exportLines = Array.from(new Set(operationCodes.map(({ funcName }) => `export * from './${funcName}'`))).sort();
+    const index = `${exportLines.join('\n')}\n`;
     const fmtResult = await fmt(index);
     if (!fmtResult.ok)
         return { ok: false, error: fmtResult.error };
@@ -353,5 +332,8 @@ export async function rpc(input, output, importPath, split) {
     const writeResult = await writeFile(indexPath, fmtResult.value);
     if (!writeResult.ok)
         return { ok: false, error: writeResult.error };
-    return { ok: true, value: `Generated rpc code written to ${outDir}/*.ts (index.ts included)` };
+    return {
+        ok: true,
+        value: `Generated rpc code written to ${outDir}/*.ts (index.ts included)`,
+    };
 }

package/dist/core/takibi.d.ts

@@ -30,9 +30,9 @@
  *   Y --> Z["writeResult2 = writeFile(target, appResult.value)"]
  *   Z --> ZA{"writeResult2.ok ?"}
  *   ZA -->|No| ZB["return { ok:false, error: writeResult2.error }"]
- *   ZA -->|Yes| ZC["handlerResult = zodOpenapiHonoHandler(openAPI, output, test)"]
- *   ZC --> ZD{"handlerResult.ok ?"}
- *   ZD -->|No| ZE["return { ok:false, error: handlerResult.error }"]
+ *   ZA -->|Yes| ZC["zodOpenAPIHonoHandlerResult = zodOpenAPIHonoHandler(openAPI, output, test)"]
+ *   ZC --> ZD{"zodOpenAPIHonoHandlerResult.ok ?"}
+ *   ZD -->|No| ZE["return { ok:false, error: zodOpenAPIHonoHandlerResult.error }"]
  *   ZD -->|Yes| ZF["return { ok:true, value: 'Generated code and template files written' }"]
  * ```
  *

package/dist/core/takibi.js

@@ -37,9 +37,9 @@ import { isHttpMethod, methodPath } from '../utils/index.js';
  *   Y --> Z["writeResult2 = writeFile(target, appResult.value)"]
  *   Z --> ZA{"writeResult2.ok ?"}
  *   ZA -->|No| ZB["return { ok:false, error: writeResult2.error }"]
- *   ZA -->|Yes| ZC["handlerResult = zodOpenapiHonoHandler(openAPI, output, test)"]
- *   ZC --> ZD{"handlerResult.ok ?"}
- *   ZD -->|No| ZE["return { ok:false, error: handlerResult.error }"]
+ *   ZA -->|Yes| ZC["zodOpenAPIHonoHandlerResult = zodOpenAPIHonoHandler(openAPI, output, test)"]
+ *   ZC --> ZD{"zodOpenAPIHonoHandlerResult.ok ?"}
+ *   ZD -->|No| ZE["return { ok:false, error: zodOpenAPIHonoHandlerResult.error }"]
  *   ZD -->|Yes| ZF["return { ok:true, value: 'Generated code and template files written' }"]
  * ```
  *
@@ -80,9 +80,9 @@ export async function takibi(input, output, exportSchema, exportType, template,
             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 };
+            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 {
@@ -102,7 +102,7 @@ export async function takibi(input, output, exportSchema, exportType, template,
  * @param test - Whether to generate corresponding empty test files.
  * @returns A `Result` indicating success or error with message.
  */
-async function zodOpenapiHonoHandler(openapi, output, test) {
+async function zodOpenAPIHonoHandler(openapi, output, test) {
     const paths = openapi.paths;
     const handlers = Object.entries(paths).flatMap(([p, pathItem]) => Object.entries(pathItem)
         .filter(([m]) => isHttpMethod(m))

package/dist/core/type.d.ts

@@ -0,0 +1,7 @@
+export declare function type(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: `${string}.ts`): Promise<{
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/core/type.js

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import ts from 'typescript';
+import { fmt } from '../format/index.js';
+import { mkdir, writeFile } from '../fsp/index.js';
+import { zodOpenAPIHono } from '../generator/zod-openapi-hono/openapi/index.js';
+import { parseOpenAPI } from '../openapi/index.js';
+import { isHttpMethod, methodPath } from '../utils/index.js';
+export async function type(input, output) {
+    try {
+        const openAPIResult = await parseOpenAPI(input);
+        if (!openAPIResult.ok)
+            return { ok: false, error: openAPIResult.error };
+        const openAPI = openAPIResult.value;
+        const hono = zodOpenAPIHono(openAPI, false, false);
+        const paths = openAPI.paths;
+        const routes = Object.entries(paths).flatMap(([p, pathItem]) => Object.entries(pathItem)
+            .filter(([m]) => isHttpMethod(m))
+            .map(([method]) => {
+            const routeId = methodPath(method, p);
+            return `export const ${routeId}RouteHandler:RouteHandler<typeof ${routeId}Route>=async(c)=>{}`;
+        }));
+        const getRouteMaps = (openapi) => {
+            const openapiPaths = openapi.paths;
+            const routeMappings = Object.entries(openapiPaths).flatMap(([path, pathItem]) => {
+                return Object.entries(pathItem).flatMap(([method]) => {
+                    if (!isHttpMethod(method)) {
+                        return [];
+                    }
+                    const base = methodPath(method, path);
+                    return {
+                        routeName: `${base}Route`,
+                        handlerName: `${base}RouteHandler`,
+                        path,
+                    };
+                });
+            });
+            return routeMappings;
+        };
+        const routeMappings = getRouteMaps(openAPI);
+        const appInit = 'export const api = app' +
+            routeMappings
+                .sort((a, b) => (a.routeName < b.routeName ? -1 : a.routeName > b.routeName ? 1 : 0))
+                .map(({ routeName, handlerName }) => `.openapi(${routeName},${handlerName})`)
+                .join('');
+        const code = `import { OpenAPIHono, type RouteHandler } from '@hono/zod-openapi'\n${hono}\nconst app = new OpenAPIHono()\n${routes.join('\n')}\n${appInit}\nexport type AddType = typeof api`;
+        const honoType = apiType(code);
+        if (honoType === undefined)
+            return { ok: false, error: 'not generated type' };
+        const mkdirResult = await mkdir(path.dirname(output));
+        if (!mkdirResult.ok)
+            return { ok: false, error: mkdirResult.error };
+        const type = `declare const routes:\n${honoType}\nexport default routes`;
+        const fmtResult = await fmt(type);
+        if (!fmtResult.ok)
+            return { ok: false, error: fmtResult.error };
+        const writeResult = await writeFile(output, fmtResult.value);
+        if (!writeResult.ok)
+            return { ok: false, error: writeResult.error };
+        return {
+            ok: true,
+            value: `Generated type code written to ${output}`,
+        };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+function apiType(code) {
+    const VIRTUAL_FILE_NAME = 'virtual.ts';
+    const compilerOptions = {
+        target: ts.ScriptTarget.ESNext,
+        module: ts.ModuleKind.NodeNext,
+        moduleResolution: ts.ModuleResolutionKind.NodeNext,
+        strict: true,
+    };
+    const sourceFile = ts.createSourceFile(VIRTUAL_FILE_NAME, code, compilerOptions.target ?? ts.ScriptTarget.ESNext);
+    const host = ts.createCompilerHost(compilerOptions);
+    const originalGetSourceFile = host.getSourceFile.bind(host);
+    host.getSourceFile = (fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile) => {
+        if (fileName === VIRTUAL_FILE_NAME)
+            return sourceFile;
+        return originalGetSourceFile(fileName, languageVersionOrOptions, onError, shouldCreateNewSourceFile);
+    };
+    const program = ts.createProgram([VIRTUAL_FILE_NAME], compilerOptions, host);
+    const checker = program.getTypeChecker();
+    const moduleSymbol = checker.getSymbolAtLocation(sourceFile);
+    if (!moduleSymbol)
+        return undefined;
+    const apiSymbol = checker.getExportsOfModule(moduleSymbol).find((s) => s.getName() === 'api');
+    if (!apiSymbol)
+        return undefined;
+    const type = checker.getTypeOfSymbolAtLocation(apiSymbol, sourceFile);
+    return checker.typeToString(type, undefined, ts.TypeFormatFlags.NoTruncation |
+        ts.TypeFormatFlags.UseFullyQualifiedType |
+        ts.TypeFormatFlags.WriteTypeArgumentsOfSignature);
+}

package/dist/generator/zod-openapi-hono/openapi/route/params/request-parameter.js

@@ -16,18 +16,16 @@ import { paramsObject } from './index.js';
  */
 export function requestParameter(parameters, body) {
     // Early return if no parameters or content
-    if (!(parameters || body?.content)) {
+    if (!(parameters || body?.content))
         return '';
-    }
     const requestBodyContentTypes = Object.keys(body?.content || {});
     const params = parameters
         ? (() => {
             const paramsObj = paramsObject(parameters);
             const requestParamsArr = requestParamsArray(paramsObj);
-            if (requestParamsArr.length) {
-                // params
+            // params
+            if (requestParamsArr.length)
                 return `request:{${requestParamsArr.join(',')}},`;
-            }
             return '';
         })()
         : '';
@@ -42,9 +40,8 @@ export function requestParameter(parameters, body) {
         const required = body.required ?? false;
         const [firstSchema] = uniqueSchemas.values();
         const requestBodyCode = requestBody(required, body.content, firstSchema);
-        if (params) {
+        if (params)
             return params.replace('request:{', `request:{${requestBodyCode}`);
-        }
         return `request:{${requestBodyCode}},`;
     }
     return params;

package/dist/generator/zod-openapi-hono/openapi/route/request/body/index.js

@@ -11,21 +11,12 @@ export function requestBody(required, content, schema) {
     const contentTypes = Object.keys(content);
     if (contentTypes.length === 0)
         return '';
-    // check duplication
     const isUniqueSchema = isUniqueContentSchema(contentTypes, content);
-    // all duplication same schema
-    if (isUniqueSchema) {
-        const contentParts = [];
-        for (const contentType of contentTypes) {
-            // z.date() → z.coerce.date()
-            if (schema.includes('z.date()')) {
-                contentParts.push(`'${contentType}':{schema:z.coerce.${schema.replace('z.', '')}}`);
-            }
-            else {
-                contentParts.push(`'${contentType}':{schema:${schema}}`);
-            }
-        }
-        return `body:{required:${required},content:{${contentParts.join(',')}}},`;
-    }
-    return '';
+    if (!isUniqueSchema)
+        return '';
+    // if z.date() → z.coerce.date()
+    const contentParts = contentTypes
+        .map((contentType) => `'${contentType}':{schema:${schema.includes('z.date()') ? `z.coerce.${schema.replace('z.', '')}` : schema}}`)
+        .join(',');
+    return `body:{required:${required},content:{${contentParts}}},`;
 }

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

@@ -12,53 +12,14 @@ import { zodToOpenAPI } from '../../../../zod-to-openapi/index.js';
  * - Deduplicates content types if all share the same schema.
  * - Escapes all descriptions safely for inline code.
  */
-// export function response(responses: Responses): string {
-//   // 1. get response codes (200, 404, etc.)
-//   const responseCodes = Object.keys(responses)
-//   // 2. processing for each response code
-//   const responseEntries = responseCodes.map((code) => {
-//     const response = responses[code]
-//     // 2.1 no content (description only response)
-//     if (!response.content)
-//       return `${code}:{description:'${escapeStringLiteral(response.description ?? '')}',},`
-//     // check duplication
-//     const contentTypes = Object.keys(response.content)
-//     const isUniqueSchema = isUniqueContentSchema(contentTypes, response.content)
-//     // all duplication same schema
-//     if (isUniqueSchema) {
-//       const contentParts: string[] = []
-//       for (const contentType of contentTypes) {
-//         const content = response.content[contentType]
-//         const z = zodToOpenAPI(content.schema)
-//         const examples = content.examples
-//         const exampleString =
-//           examples && Object.keys(examples).length > 0
-//             ? `,examples:{${Object.entries(examples)
-//                 .map(([key, example]) => {
-//                   const parts = []
-//                   if (example.summary) parts.push(`summary:${JSON.stringify(example.summary)}`)
-//                   if (example.value !== undefined)
-//                     parts.push(`value:${JSON.stringify(example.value)}`)
-//                   return `${JSON.stringify(key)}:{${parts.join(',')}}`
-//                 })
-//                 .join(',')}}`
-//             : ''
-//         contentParts.push(`'${contentType}':{schema:${z}${exampleString}}`)
-//       }
-//       return `${code}:{description:'${escapeStringLiteral(response.description ?? '')}',content:{${contentParts.join(',')}}},`
-//     }
-//   })
-//   // 3.combine all response definitions
-//   return responseEntries.join('')
-// }
 export function response(responses) {
     // 1. get response codes (200, 404, etc.)
-    const responseEntries = Object.keys(responses).map((code) => {
+    return Object.keys(responses)
+        .map((code) => {
         const res = responses[code];
         const content = res.content;
-        if (!content) {
+        if (!content)
             return `${code}:{description:'${escapeStringLiteral(res.description ?? '')}',},`;
-        }
         const contentTypes = Object.keys(content);
         const isUnique = isUniqueContentSchema(contentTypes, content);
         const sharedZ = isUnique ? zodToOpenAPI(content[contentTypes[0]].schema) : undefined;
@@ -68,19 +29,22 @@ export function response(responses) {
             const examples = media.examples;
             const exampleString = examples && Object.keys(examples).length > 0
                 ? `,examples:{${Object.entries(examples)
-                    .map(([k, v]) => {
-                    const parts = [];
-                    if (v.summary)
-                        parts.push(`summary:${JSON.stringify(v.summary)}`);
-                    if (v.value !== undefined)
-                        parts.push(`value:${JSON.stringify(v.value)}`);
-                    return `${JSON.stringify(k)}:{${parts.join(',')}}`;
+                    .map(([exampleKey, example]) => {
+                    const fields = [
+                        example.summary !== undefined
+                            ? `summary:${JSON.stringify(example.summary)}`
+                            : undefined,
+                        example.value !== undefined
+                            ? `value:${JSON.stringify(example.value)}`
+                            : undefined,
+                    ].filter((field) => field !== undefined);
+                    return `${JSON.stringify(exampleKey)}:{${fields.join(',')}}`;
                 })
                     .join(',')}}`
                 : '';
             return `'${ct}':{schema:${z}${exampleString}}`;
         });
         return `${code}:{description:'${escapeStringLiteral(res.description ?? '')}',content:{${contentParts.join(',')}}},`;
-    });
-    return responseEntries.join('');
+    })
+        .join('');
 }

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

@@ -1,27 +1,27 @@
 export function _enum(schema) {
-    /* hasType */
-    const hasType = (t) => schema.type === t || (Array.isArray(schema.type) && schema.type.some((x) => x === t));
+    /* ht */
+    const ht = (t) => schema.type === t || (Array.isArray(schema.type) && schema.type.some((v) => v === 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(',')}])`;
+    const tuple = (arr) => `z.tuple([${arr.map((v) => `z.literal(${lit(v)})`).join(',')}])`;
     /* guard */
     if (!schema.enum || schema.enum.length === 0)
         return 'z.any()';
     /* number / integer enum  */
-    if (hasType('number') || hasType('integer')) {
+    if (ht('number') || ht('integer')) {
         return schema.enum.length > 1
             ? `z.union([${schema.enum.map((v) => `z.literal(${v})`).join(',')}])`
             : `z.literal(${schema.enum[0]})`;
     }
     /* boolean enum */
-    if (hasType('boolean')) {
+    if (ht('boolean')) {
         return schema.enum.length > 1
             ? `z.union([${schema.enum.map((v) => `z.literal(${v})`).join(',')}])`
             : `z.literal(${schema.enum[0]})`;
     }
     /* array enum */
-    if (hasType('array')) {
+    if (ht('array')) {
         if (schema.enum.length === 1 && Array.isArray(schema.enum[0])) {
             return tuple(schema.enum[0]);
         }

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

@@ -6,86 +6,64 @@
  * @returns The Zod schema string
  */
 export function integer(schema) {
-    const isInt32 = schema.format === 'int32';
-    const isInt64 = schema.format === 'int64';
-    const isBigInt = schema.format === 'bigint';
-    const o = [
-        isInt32 ? 'z.int32()' : isInt64 ? 'z.int64()' : isBigInt ? 'z.bigint()' : 'z.int()',
-    ];
+    const base = schema.format === 'int32'
+        ? 'z.int32()'
+        : schema.format === 'int64'
+            ? 'z.int64()'
+            : schema.format === 'bigint'
+                ? 'z.bigint()'
+                : 'z.int()';
     const lit = (n) => {
-        if (isBigInt)
+        if (schema.format === 'bigint')
             return `BigInt(${n})`;
-        if (isInt64)
+        if (schema.format === 'int64')
             return `${n}n`;
         return `${n}`;
     };
-    // minimum
-    if (schema.minimum !== undefined || schema.exclusiveMinimum !== undefined) {
-        // > 0
-        // z.int().positive().safeParse(1) // { success: true }
-        // z.int().positive().safeParse(0) // { success: false }
-        if ((schema.minimum ?? schema.exclusiveMinimum) === 0 && schema.exclusiveMinimum === true) {
-            o.push('.positive()');
+    const minimum = (() => {
+        if (schema.minimum === undefined && schema.exclusiveMinimum === undefined) {
+            return undefined;
         }
-        // >= 0
-        // z.int().nonnegative().safeParse(0) // { success: true }
-        // z.int().nonnegative().safeParse(-1) // { success: false }
-        else if ((schema.minimum ?? schema.exclusiveMinimum) === 0 &&
-            schema.exclusiveMinimum === false) {
-            o.push('.nonnegative()');
+        const value = schema.minimum ?? schema.exclusiveMinimum;
+        if (value === 0 && schema.exclusiveMinimum === true) {
+            return '.positive()';
         }
-        // > value
-        // z.int().gt(100) // value > 100
-        // z.int().gt(100).safeParse(101) // { success: true }
-        // z.int().gt(100).safeParse(100) // { success: false }
-        else if ((schema.exclusiveMinimum === true || schema.minimum === undefined) &&
-            typeof (schema.minimum ?? schema.exclusiveMinimum) === 'number') {
-            o.push(`.gt(${lit((schema.minimum ?? schema.exclusiveMinimum))})`);
+        if (value === 0 && schema.exclusiveMinimum === false) {
+            return '.nonnegative()';
         }
-        // >= value
-        // z.int().min(100) // value >= 100
-        // z.int().min(100).safeParse(100) // { success: true }
-        // z.int().min(100).safeParse(99) // { success: false }
-        else if (typeof schema.minimum === 'number') {
-            o.push(`.min(${lit(schema.minimum)})`);
+        // > value → .gt(...)
+        if ((schema.exclusiveMinimum === true || schema.minimum === undefined) &&
+            typeof value === 'number') {
+            return `.gt(${lit(value)})`;
         }
-    }
-    // maximum
-    if (schema.maximum !== undefined || schema.exclusiveMaximum !== undefined) {
-        // < 0
-        // z.int().negative().safeParse(-1) // { success: true }
-        // z.int().negative().safeParse(0) // { success: false }
-        if ((schema.maximum ?? schema.exclusiveMaximum) === 0 && schema.exclusiveMaximum === true) {
-            o.push('.negative()');
+        // >= value → .min(...)
+        if (typeof schema.minimum === 'number') {
+            return `.min(${lit(schema.minimum)})`;
         }
-        // <= 0
-        // z.int().nonpositive().safeParse(0) // { success: true }
-        // z.int().nonpositive().safeParse(1) // { success: false }
-        else if ((schema.maximum ?? schema.exclusiveMaximum) === 0 &&
-            schema.exclusiveMaximum === false) {
-            o.push('.nonpositive()');
+        return undefined;
+    })();
+    const maximum = (() => {
+        if (schema.maximum === undefined && schema.exclusiveMaximum === undefined) {
+            return undefined;
         }
-        // < value
-        // z.int().lt(100) // value < 100
-        // z.int().lt(100).safeParse(99) -> { success: true }
-        // z.int().lt(100).safeParse(100) -> { success: false }
-        else if ((schema.exclusiveMaximum === true || schema.maximum === undefined) &&
-            typeof (schema.maximum ?? schema.exclusiveMaximum) === 'number') {
-            o.push(`.lt(${lit((schema.maximum ?? schema.exclusiveMaximum))})`);
+        const value = schema.maximum ?? schema.exclusiveMaximum;
+        if (value === 0 && schema.exclusiveMaximum === true) {
+            return '.negative()';
         }
-        // <= value
-        // z.int().max(100) // value <= 100
-        // z.int().max(100).safeParse(100) -> { success: true }
-        // z.int().max(100).safeParse(101) -> { success: false }
-        else if (typeof schema.maximum === 'number') {
-            o.push(`.max(${lit(schema.maximum)})`);
+        if (value === 0 && schema.exclusiveMaximum === false) {
+            return '.nonpositive()';
         }
-    }
-    // multipleOf
-    // z.int().multipleOf(2).safeParse(2) // { success: true }
-    // z.int().multipleOf(2).safeParse(1) // { success: false }
-    if (schema.multipleOf !== undefined && typeof schema.multipleOf === 'number') {
-        o.push(`.multipleOf(${lit(schema.multipleOf)})`);
-    }
-    return o.join('');
+        if ((schema.exclusiveMaximum === true || schema.maximum === undefined) &&
+            typeof value === 'number') {
+            return `.lt(${lit(value)})`;
+        }
+        if (typeof schema.maximum === 'number') {
+            return `.max(${lit(schema.maximum)})`;
+        }
+        return undefined;
+    })();
+    const multipleOf = schema.multipleOf !== undefined && typeof schema.multipleOf === 'number'
+        ? `.multipleOf(${lit(schema.multipleOf)})`
+        : undefined;
+    return [base, minimum, maximum, multipleOf].filter((v) => v !== undefined).join('');
 }

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

@@ -6,76 +6,47 @@
  * @returns The Zod schema string
  */
 export function number(schema) {
-    const o = [
-        schema.format === 'float' || schema.format === 'float32'
-            ? 'z.float32()'
-            : schema.format === 'float64'
-                ? 'z.float64()'
-                : 'z.number()',
-    ];
-    // minimum
-    if (schema.minimum !== undefined) {
-        // > 0
-        // z.number().positive().safeParse(1) // { success: true }
-        // z.number().positive().safeParse(0) // { success: false }
-        if (schema.minimum === 0 && schema.exclusiveMinimum === true) {
-            o.push('.positive()');
-        }
-        // >= 0
-        // z.number().nonnegative().safeParse(0) // { success: true }
-        // z.number().nonnegative().safeParse(-1) // { success: false }
-        else if (schema.minimum === 0 && schema.exclusiveMinimum === false) {
-            o.push('.nonnegative()');
-        }
-        // > value
-        // z.number().gt(100) // value > 100
-        else if (schema.exclusiveMinimum === true) {
-            o.push(`.gt(${schema.minimum})`);
-        }
-        // >= value
-        // z.number().min(100) // value >= 100
-        else {
-            o.push(`.min(${schema.minimum})`);
-        }
-    }
-    else if (typeof schema.exclusiveMinimum === 'number') {
-        // > value (no minimum)
-        o.push(`.gt(${schema.exclusiveMinimum})`);
-    }
-    // maximum
-    if (schema.maximum !== undefined) {
-        // < 0
-        // z.number().negative().safeParse(-1) // { success: true }
-        // z.number().negative().safeParse(0) // { success: false }
-        if (schema.maximum === 0 && schema.exclusiveMaximum === true) {
-            o.push('.negative()');
-        }
-        // <= 0
-        // z.number().nonpositive().safeParse(0) // { success: true }
-        // z.number().nonpositive().safeParse(1) // { success: false }
-        else if (schema.maximum === 0 && schema.exclusiveMaximum === false) {
-            o.push('.nonpositive()');
-        }
-        // < value
-        // z.number().lt(100) // value < 100
-        else if (schema.exclusiveMaximum === true) {
-            o.push(`.lt(${schema.maximum})`);
-        }
-        // <= value
-        // z.number().max(100) // value <= 100
-        else {
-            o.push(`.max(${schema.maximum})`);
-        }
-    }
-    else if (typeof schema.exclusiveMaximum === 'number') {
-        // < value (no maximum)
-        o.push(`.lt(${schema.exclusiveMaximum})`);
-    }
-    // multipleOf
-    // z.number().multipleOf(2).safeParse(2) // { success: true }
-    // z.number().multipleOf(2).safeParse(1) // { success: false }
-    if (schema.multipleOf !== undefined) {
-        o.push(`.multipleOf(${schema.multipleOf})`);
-    }
-    return o.join('');
+    const base = schema.format === 'float' || schema.format === 'float32'
+        ? 'z.float32()'
+        : schema.format === 'float64'
+            ? 'z.float64()'
+            : 'z.number()';
+    const minimum = (() => {
+        if (schema.minimum !== undefined) {
+            if (schema.minimum === 0 && schema.exclusiveMinimum === true) {
+                return '.positive()';
+            }
+            if (schema.minimum === 0 && schema.exclusiveMinimum === false) {
+                return '.nonnegative()';
+            }
+            if (schema.exclusiveMinimum === true) {
+                return `.gt(${schema.minimum})`;
+            }
+            return `.min(${schema.minimum})`;
+        }
+        if (typeof schema.exclusiveMinimum === 'number') {
+            return `.gt(${schema.exclusiveMinimum})`;
+        }
+        return undefined;
+    })();
+    const maximum = (() => {
+        if (schema.maximum !== undefined) {
+            if (schema.maximum === 0 && schema.exclusiveMaximum === true) {
+                return '.negative()';
+            }
+            if (schema.maximum === 0 && schema.exclusiveMaximum === false) {
+                return '.nonpositive()';
+            }
+            if (schema.exclusiveMaximum === true) {
+                return `.lt(${schema.maximum})`;
+            }
+            return `.max(${schema.maximum})`;
+        }
+        if (typeof schema.exclusiveMaximum === 'number') {
+            return `.lt(${schema.exclusiveMaximum})`;
+        }
+        return undefined;
+    })();
+    const multipleOf = schema.multipleOf !== undefined ? `.multipleOf(${schema.multipleOf})` : undefined;
+    return [base, minimum, maximum, multipleOf].filter((v) => v !== undefined).join('');
 }

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

@@ -7,7 +7,7 @@ import { zodToOpenAPI } from '../index.js';
  * @returns The Zod object schema string.
  */
 export function object(schema) {
-    // // allOf, oneOf, anyOf, not
+    // allOf, oneOf, anyOf, not
     if (schema.oneOf)
         return zodToOpenAPI(schema);
     if (schema.anyOf)

package/dist/generator/zod-to-openapi/z/string.d.ts

@@ -8,26 +8,6 @@ import type { Schema } from '../../../openapi/index.js';
  * - Otherwise, appends `.min(n)` and/or `.max(n)` individually
  * - Returns the concatenated Zod schema string
  *
- * ```mermaid
- * flowchart TD
- *   A["string(schema)"] --> B["format = schema.format && FORMAT_STRING[format]"]
- *   B --> C{"Format exists?"}
- *   C -- "Yes" --> D["o.push(z.${format})"]
- *   C -- "No"  --> E["o.push(z.string())"]
- *   D --> F{"Pattern exists?"}
- *   E --> F
- *   F -- "Yes" --> G["o.push(regex(schema.pattern))"]
- *   F -- "No"  --> I
- *   G --> I{"minLength and maxLength are equal?"}
- *   I -- "Yes" --> J["o.push(length(minLength))"]
- *   I -- "No"  --> K{"minLength or maxLength?"}
- *   K -- "min" --> L["o.push(min(minLength))"]
- *   K -- "max" --> M["o.push(max(maxLength))"]
- *   L --> N["return o.join('')"]
- *   M --> N
- *   J --> N
- * ```
- *
  * @example
  * ```ts
  * // With format, pattern, and minLength

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

@@ -36,26 +36,6 @@ const FORMAT_STRING = {
  * - Otherwise, appends `.min(n)` and/or `.max(n)` individually
  * - Returns the concatenated Zod schema string
  *
- * ```mermaid
- * flowchart TD
- *   A["string(schema)"] --> B["format = schema.format && FORMAT_STRING[format]"]
- *   B --> C{"Format exists?"}
- *   C -- "Yes" --> D["o.push(z.${format})"]
- *   C -- "No"  --> E["o.push(z.string())"]
- *   D --> F{"Pattern exists?"}
- *   E --> F
- *   F -- "Yes" --> G["o.push(regex(schema.pattern))"]
- *   F -- "No"  --> I
- *   G --> I{"minLength and maxLength are equal?"}
- *   I -- "Yes" --> J["o.push(length(minLength))"]
- *   I -- "No"  --> K{"minLength or maxLength?"}
- *   K -- "min" --> L["o.push(min(minLength))"]
- *   K -- "max" --> M["o.push(max(maxLength))"]
- *   L --> N["return o.join('')"]
- *   M --> N
- *   J --> N
- * ```
- *
  * @example
  * ```ts
  * // With format, pattern, and minLength
@@ -67,26 +47,20 @@ const FORMAT_STRING = {
  * @returns Concatenated Zod string schema
  */
 export function string(schema) {
-    const o = [];
     const format = schema.format && FORMAT_STRING[schema.format];
-    o.push(format ? `z.${format}` : 'z.string()');
-    // pattern
-    if (schema.pattern) {
-        o.push(regex(schema.pattern));
-    }
-    // length
-    if (schema.minLength !== undefined &&
+    const base = format ? `z.${format}` : 'z.string()';
+    const pattern = schema.pattern ? regex(schema.pattern) : undefined;
+    const isFixedLength = schema.minLength !== undefined &&
         schema.maxLength !== undefined &&
-        schema.minLength === schema.maxLength) {
-        o.push(`.length(${schema.minLength})`);
-    }
-    else {
-        if (schema.minLength !== undefined) {
-            o.push(`.min(${schema.minLength})`);
-        }
-        if (schema.maxLength !== undefined) {
-            o.push(`.max(${schema.maxLength})`);
-        }
-    }
-    return o.join('');
+        schema.minLength === schema.maxLength;
+    return [
+        base,
+        pattern,
+        // minLength === maxLength → .length(n)
+        isFixedLength ? `.length(${schema.minLength})` : undefined,
+        !isFixedLength && schema.minLength !== undefined ? `.min(${schema.minLength})` : undefined,
+        !isFixedLength && schema.maxLength !== undefined ? `.max(${schema.maxLength})` : undefined,
+    ]
+        .filter((v) => v !== undefined)
+        .join('');
 }

package/dist/helper/docs.js

@@ -11,5 +11,5 @@ export function docs(openapi) {
         servers: openapi.servers,
         externalDocs: openapi.externalDocs,
         tags: openapi.tags,
-    }).filter(([, value]) => value !== undefined));
+    }).filter(([, v]) => v !== undefined));
 }

package/dist/helper/properties-schema.js

@@ -51,10 +51,10 @@ export function propertiesSchema(properties, required) {
         return `${safeKey}:${zodToOpenAPI(schema)}${isRequired ? '' : '.optional()'}`;
     });
     // Check if all properties are optional
-    const allOptional = objectProperties.every((prop) => prop.includes('.optional()'));
+    const allOptional = objectProperties.every((v) => v.includes('.optional()'));
     // If all properties are optional and no required properties, return partial schema
     if (required.length === 0 && allOptional) {
-        const cleanProperties = objectProperties.map((prop) => prop.replace('.optional()', ''));
+        const cleanProperties = objectProperties.map((v) => v.replace('.optional()', ''));
         return `z.object({${cleanProperties}}).partial()`;
     }
     return `z.object({${objectProperties}})`;

package/dist/helper/wrap.js

@@ -30,22 +30,26 @@ export function wrap(zod, schema, paramName, paramIn) {
     const isNullable = schema.nullable === true ||
         (Array.isArray(schema.type) ? schema.type.includes('null') : schema.type === 'null');
     const z = isNullable ? `${s}.nullable()` : s;
-    const openapiProps = [];
-    if (paramIn && paramName) {
-        const required = paramIn === 'path' ? true : !!schema.required;
-        openapiProps.push(`param:{in:"${paramIn}",name:${JSON.stringify(paramName)},required:${required}}`);
-    }
-    /* 'example' if defined */
-    if ('example' in schema && schema.example !== undefined) {
-        openapiProps.push(`example:${JSON.stringify(schema.example)}`);
-    }
-    /* 'examples' if defined */
-    if ('examples' in schema && Array.isArray(schema.examples) && schema.examples.length > 0) {
-        openapiProps.push(`examples:${JSON.stringify(schema.examples)}`);
-    }
-    /* 'description' if defined */
-    if ('description' in schema && schema.description !== undefined) {
-        openapiProps.push(`description:${JSON.stringify(schema.description)}`);
-    }
+    const openapiProps = [
+        // param
+        paramIn && paramName
+            ? (() => {
+                const required = paramIn === 'path' ? true : !!schema.required;
+                return `param:{in:"${paramIn}",name:${JSON.stringify(paramName)},required:${required}}`;
+            })()
+            : undefined,
+        // example
+        'example' in schema && schema.example !== undefined
+            ? `example:${JSON.stringify(schema.example)}`
+            : undefined,
+        // examples
+        'examples' in schema && Array.isArray(schema.examples) && schema.examples.length > 0
+            ? `examples:${JSON.stringify(schema.examples)}`
+            : undefined,
+        // description
+        'description' in schema && schema.description !== undefined
+            ? `description:${JSON.stringify(schema.description)}`
+            : undefined,
+    ].filter((v) => v !== undefined);
     return openapiProps.length === 0 ? z : `${z}.openapi({${openapiProps.join(',')}})`;
 }

package/dist/openapi/index.d.ts

@@ -128,7 +128,7 @@ export type Schema = {
     name?: string;
     description?: string;
     type?: Type | [Type, ...Type[]];
-    format?: Format | FormatString | FormatNumber;
+    format?: Format;
     pattern?: string;
     minLength?: number;
     maxLength?: number;
@@ -143,7 +143,7 @@ export type Schema = {
     example?: unknown;
     examples?: unknown;
     properties?: Record<string, Schema>;
-    required?: string[];
+    required?: string[] | boolean;
     items?: Schema;
     enum?: (string | number | boolean | null | (string | number | boolean | null)[])[];
     nullable?: boolean;

package/dist/utils/index.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Parse the config object.
+ *
+ * @param config - The config object to parse.
+ */
 export declare function parseConfig(config: {
     readonly input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
     readonly 'zod-openapi'?: {
@@ -15,6 +20,9 @@ export declare function parseConfig(config: {
             readonly split?: boolean;
         };
     };
+    readonly type?: {
+        readonly output: `${string}.ts`;
+    };
     readonly rpc?: {
         readonly output: string | `${string}.ts`;
         readonly import: string;
@@ -39,6 +47,9 @@ export declare function parseConfig(config: {
                 readonly split?: boolean;
             };
         };
+        readonly type?: {
+            readonly output: `${string}.ts`;
+        };
         readonly rpc?: {
             readonly output: string | `${string}.ts`;
             readonly import: string;

package/dist/utils/index.js

@@ -1,5 +1,11 @@
+/**
+ * Parse the config object.
+ *
+ * @param config - The config object to parse.
+ */
 export function parseConfig(config) {
     const isYamlOrJsonOrTsp = (i) => typeof i === 'string' && (i.endsWith('.yaml') || i.endsWith('.json') || i.endsWith('.tsp'));
+    // ts
     const isTs = (o) => typeof o === 'string' && o.endsWith('.ts');
     const c = config;
     if (!isYamlOrJsonOrTsp(c.input)) {
@@ -118,6 +124,16 @@ export function parseConfig(config) {
             }
         }
     }
+    // type
+    const t = c.type;
+    if (t !== undefined) {
+        if (!isTs(t.output)) {
+            return {
+                ok: false,
+                error: `Invalid type output format: ${String(t.output)} (must be .ts file)`,
+            };
+        }
+    }
     // rpc
     const rpc = c.rpc;
     if (rpc !== undefined) {

package/dist/vite-plugin/index.js

@@ -44,7 +44,7 @@ const loadConfigHot = async (server) => {
         const def = isRecord(mod) ? Reflect.get(mod, 'default') : undefined;
         if (def === undefined)
             return { ok: false, error: 'Config must export default object' };
-        // as unknown as Conf
+        // as Conf
         const parsed = parseConfig(def);
         return parsed.ok ? { ok: true, value: parsed.value } : { ok: false, error: parsed.error };
     }

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.60",
+  "version": "0.9.61",
   "type": "module",
   "license": "MIT",
   "keywords": [
@@ -47,22 +47,22 @@
   },
   "dependencies": {
     "@apidevtools/swagger-parser": "^12.1.0",
-    "@typespec/compiler": "^1.5.0",
-    "@typespec/openapi3": "^1.5.0",
-    "prettier": "^3.6.2",
-    "tsx": "^4.20.6"
+    "@typespec/compiler": "^1.7.0",
+    "@typespec/openapi3": "^1.7.0",
+    "prettier": "^3.7.4",
+    "tsx": "^4.21.0"
   },
   "devDependencies": {
-    "@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",
+    "@hono/zod-openapi": "1.1.5",
+    "@types/node": "^25.0.0",
+    "@typespec/http": "^1.7.0",
+    "@typespec/rest": "^0.77.0",
+    "@typespec/versioning": "^0.77.0",
+    "@vitest/coverage-v8": "^4.0.15",
     "typescript": "^5.9.3",
-    "vite": "^7.1.12",
-    "vitest": "^4.0.3",
-    "zod": "^4.1.12"
+    "vite": "^7.2.7",
+    "vitest": "^4.0.15",
+    "zod": "^4.1.13"
   },
   "scripts": {
     "dev": "vite --host",