hono-takibi 0.9.22 → 0.9.24

package/dist/cli/index.d.ts

@@ -31,9 +31,9 @@
  * - `{ ok: false, error: string }` on validation or generation errors
  */
 export declare function honoTakibi(): Promise<{
-    ok: true;
-    value: string;
+    readonly ok: true;
+    readonly value: string;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 }>;

package/dist/cli/index.js

@@ -1,9 +1,11 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { config } from '../config/index.js';
-import core from '../core/core.js';
+import { core } from '../core/core.js';
+import { route } from '../core/route.js';
+import { schema } from '../core/schema.js';
 import { takibi } from '../core/takibi.js';
-import rpc from '../generator/rpc/index.js';
+import { rpc } from '../generator/rpc/index.js';
 // import { honoRpcWithSWR } from '../generator/swr/index.js'
 import { parseCli } from '../utils/index.js';
 const HELP_TEXT = `Usage: hono-takibi <input.{yaml,json,tsp}> -o <routes.ts> [options]
@@ -81,15 +83,29 @@ export async function honoTakibi() {
         return { ok: false, error: configResult.error };
     }
     const c = configResult.value;
-    const takibiResult = c['hono-takibi']
-        ? await takibi(c['hono-takibi']?.input, c['hono-takibi']?.output, c['hono-takibi']?.exportSchema ?? false, c['hono-takibi']?.exportType ?? false, false, // template
+    const takibiResult = c['zod-openapi']
+        ? await takibi(c.input, c['zod-openapi']?.output, c['zod-openapi']?.exportSchema ?? false, c['zod-openapi']?.exportType ?? false, false, // template
         false)
         : undefined;
     if (takibiResult && !takibiResult.ok) {
         return { ok: false, error: takibiResult.error };
     }
+    // schema
+    const schemaResult = c['zod-openapi']?.schema
+        ? await schema(c.input, c['zod-openapi'].schema.output, c['zod-openapi'].schema.exportType ?? false, c['zod-openapi']?.schema.split ?? false)
+        : undefined;
+    if (schemaResult && !schemaResult.ok) {
+        return { ok: false, error: schemaResult.error };
+    }
+    // route
+    const routeResult = c['zod-openapi']?.route
+        ? await route(c.input, c['zod-openapi'].route.output, c['zod-openapi'].route.import, c['zod-openapi'].route.split ?? false)
+        : undefined;
+    if (routeResult && !routeResult.ok) {
+        return { ok: false, error: routeResult.error };
+    }
     const rpcResult = c.rpc
-        ? await core(c.rpc.input, c.rpc.output, c.rpc.import, 'Generated RPC code written to', rpc)
+        ? await core(c.input, c.rpc.output, c.rpc.import, 'Generated RPC code written to', rpc)
         : undefined;
     if (rpcResult && !rpcResult.ok) {
         return { ok: false, error: rpcResult.error };

package/dist/config/index.d.ts

@@ -1,27 +1,31 @@
 type Config = {
-    'hono-takibi'?: {
-        input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
-        output: `${string}.ts`;
-        exportType?: boolean;
-        exportSchema?: boolean;
+    readonly input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
+    readonly 'zod-openapi'?: {
+        readonly output: `${string}.ts`;
+        readonly exportType?: boolean;
+        readonly exportSchema?: boolean;
+        readonly schema?: {
+            readonly output: string | `${string}.ts`;
+            readonly exportType?: boolean;
+            readonly split?: boolean;
+        };
+        readonly route?: {
+            readonly output: string | `${string}.ts`;
+            readonly import: string;
+            readonly split?: boolean;
+        };
     };
-    rpc?: {
-        input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
-        output: `${string}.ts`;
-        import: string;
-    };
-    swr?: {
-        input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
-        output: `${string}.ts`;
-        import: string;
+    readonly rpc?: {
+        readonly output: `${string}.ts`;
+        readonly import: string;
     };
 };
 export declare function config(): Promise<{
-    ok: true;
-    value: Config;
+    readonly ok: true;
+    readonly value: Config;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 }>;
-export default function defineConfig(config: Config): Config;
+export declare function defineConfig(c: Config): Config;
 export {};

package/dist/config/index.js

@@ -1,23 +1,150 @@
+import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { pathToFileURL } from 'node:url';
 import { register } from 'tsx/esm/api';
+const isYamlOrJsonOrTsp = (i) => typeof i === 'string' && (i.endsWith('.yaml') || i.endsWith('.json') || i.endsWith('.tsp'));
+const isTs = (o) => typeof o === 'string' && o.endsWith('.ts');
 export async function config() {
     const abs = resolve(process.cwd(), 'hono-takibi.config.ts');
-    // if (!existsSync(abs)) {
-    //   return { ok: false, error: `Config not found: ${abs}` }
-    // }
-    register();
+    if (!existsSync(abs))
+        return { ok: false, error: `Config not found: ${abs}` };
     try {
+        register();
         const mod = await import(pathToFileURL(abs).href);
         if (!('default' in mod)) {
             return { ok: false, error: 'Config must export default object' };
         }
+        if (mod.default) {
+            // input
+            if (!isYamlOrJsonOrTsp(mod.default.input)) {
+                return {
+                    ok: false,
+                    error: `Invalid input format for zod-openapi: ${String(mod.default.input)}`,
+                };
+            }
+            // zod-openapi
+            const zo = mod.default['zod-openapi'];
+            if (zo) {
+                // boolean flags
+                if (zo.exportSchema !== undefined && typeof zo.exportSchema !== 'boolean') {
+                    return {
+                        ok: false,
+                        error: `Invalid exportSchema format for zod-openapi: ${String(zo.exportSchema)}`,
+                    };
+                }
+                if (zo.exportType !== undefined && typeof zo.exportType !== 'boolean') {
+                    return {
+                        ok: false,
+                        error: `Invalid exportType format for zod-openapi: ${String(zo.exportType)}`,
+                    };
+                }
+                const hasSchema = zo.schema !== undefined;
+                const hasRoute = zo.route !== undefined;
+                if (hasSchema || hasRoute) {
+                    if (Object.hasOwn(zo, 'output')) {
+                        return {
+                            ok: false,
+                            error: "Invalid config: When using 'zod-openapi.schema' or 'zod-openapi.route', do NOT set 'zod-openapi.output'.",
+                        };
+                    }
+                }
+                else {
+                    if (!isTs(zo.output)) {
+                        return {
+                            ok: false,
+                            error: `Invalid output format for zod-openapi: ${String(zo.output)}`,
+                        };
+                    }
+                }
+                if (hasSchema) {
+                    const s = zo.schema;
+                    if (!s)
+                        return { ok: false, error: 'Invalid config: zod-openapi.schema is undefined' };
+                    if (s.split !== undefined && typeof s.split !== 'boolean') {
+                        return {
+                            ok: false,
+                            error: `Invalid schema split format for zod-openapi: ${String(s.split)}`,
+                        };
+                    }
+                    if (typeof s.output !== 'string') {
+                        return { ok: false, error: `Invalid schema output path: ${String(s.output)}` };
+                    }
+                    if (s.split === true) {
+                        if (isTs(s.output)) {
+                            return {
+                                ok: false,
+                                error: `Invalid schema output path for split mode (must be a directory, not .ts): ${s.output}`,
+                            };
+                        }
+                    }
+                    else {
+                        if (!isTs(s.output)) {
+                            return {
+                                ok: false,
+                                error: `Invalid schema output path for non-split mode (must be .ts file): ${s.output}`,
+                            };
+                        }
+                    }
+                    if (s.exportType !== undefined && typeof s.exportType !== 'boolean') {
+                        return {
+                            ok: false,
+                            error: `Invalid schema exportType format for zod-openapi: ${String(s.exportType)}`,
+                        };
+                    }
+                }
+                if (hasRoute) {
+                    const r = zo.route;
+                    if (!r)
+                        return { ok: false, error: 'Invalid config: zod-openapi.route is undefined' };
+                    if (typeof r.import !== 'string') {
+                        return {
+                            ok: false,
+                            error: `Invalid route import format for zod-openapi: ${String(r.import)}`,
+                        };
+                    }
+                    if (r.split !== undefined && typeof r.split !== 'boolean') {
+                        return {
+                            ok: false,
+                            error: `Invalid route split format for zod-openapi: ${String(r.split)}`,
+                        };
+                    }
+                    if (typeof r.output !== 'string') {
+                        return { ok: false, error: `Invalid route output path: ${String(r.output)}` };
+                    }
+                    if (r.split === true) {
+                        if (isTs(r.output)) {
+                            return {
+                                ok: false,
+                                error: `Invalid route output path for split mode (must be a directory, not .ts): ${r.output}`,
+                            };
+                        }
+                    }
+                    else {
+                        if (!isTs(r.output)) {
+                            return {
+                                ok: false,
+                                error: `Invalid route output path for non-split mode (must be .ts file): ${r.output}`,
+                            };
+                        }
+                    }
+                }
+            }
+            const rpc = mod.default.rpc;
+            if (rpc) {
+                if (!isTs(rpc.output)) {
+                    return { ok: false, error: `Invalid output format for rpc: ${String(rpc.output)}` };
+                }
+                if (typeof rpc.import !== 'string') {
+                    return { ok: false, error: `Invalid import format for rpc: ${String(rpc.import)}` };
+                }
+            }
+        }
         return { ok: true, value: mod.default };
     }
     catch (e) {
         return { ok: false, error: e instanceof Error ? e.message : String(e) };
     }
 }
-export default function defineConfig(config) {
-    return config;
+export function defineConfig(c) {
+    return c;
 }

package/dist/core/core.d.ts

@@ -1,8 +1,8 @@
 import { type OpenAPI } from '../openapi/index.js';
-export default function core(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: `${string}.ts`, importCode: string, value: string, fn: (openapi: OpenAPI, importCode: string) => string): Promise<{
-    ok: true;
-    value: string;
+export declare function core(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: `${string}.ts`, importCode: string, value: string, fn: (openapi: OpenAPI, importCode: string) => string): Promise<{
+    readonly ok: true;
+    readonly value: string;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 }>;

package/dist/core/core.js

@@ -2,21 +2,21 @@ import path from 'node:path';
 import { fmt } from '../format/index.js';
 import { mkdir, writeFile } from '../fsp/index.js';
 import { parseOpenAPI } from '../openapi/index.js';
-export default async function core(input, output, importCode, value, fn) {
+export async function core(input, output, importCode, value, fn) {
     const openAPIResult = await parseOpenAPI(input);
     if (!openAPIResult.ok) {
         return { ok: false, error: openAPIResult.error };
     }
     const openAPI = openAPIResult.value;
-    const honoRpcResult = await fmt(fn(openAPI, importCode));
-    if (!honoRpcResult.ok) {
-        return { ok: false, error: honoRpcResult.error };
+    const fnResult = await fmt(fn(openAPI, importCode));
+    if (!fnResult.ok) {
+        return { ok: false, error: fnResult.error };
     }
     const mkdirResult = await mkdir(path.dirname(output));
     if (!mkdirResult.ok) {
         return { ok: false, error: mkdirResult.error };
     }
-    const writeResult = await writeFile(output, honoRpcResult.value);
+    const writeResult = await writeFile(output, fnResult.value);
     if (!writeResult.ok) {
         return { ok: false, error: writeResult.error };
     }

package/dist/core/route.d.ts

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

package/dist/core/route.js

@@ -0,0 +1,96 @@
+import path from 'node:path';
+import { fmt } from '../format/index.js';
+import { mkdir, writeFile } from '../fsp/index.js';
+import { routeCode } from '../generator/zod-openapi-hono/openapi/route/index.js';
+import { parseOpenAPI } from '../openapi/index.js';
+const findSchemaTokens = (code) => Array.from(new Set(Array.from(code.matchAll(/\b([A-Za-z_$][A-Za-z0-9_$]*Schema)\b/g))
+    .map((m) => m[1] ?? '')
+    .filter(Boolean)));
+const extractRouteBlocks = (src) => {
+    const re = /export\s+const\s+([A-Za-z_$][A-Za-z0-9_$]*)Route\s*=/g;
+    const hits = [];
+    for (const m of src.matchAll(re)) {
+        const name = (m[1] ?? '').trim();
+        const start = m.index ?? 0;
+        if (name)
+            hits.push({ name, start });
+    }
+    return hits.map((h, i) => {
+        const start = h.start;
+        const end = i + 1 < hits.length ? (hits[i + 1]?.start ?? src.length) : src.length;
+        return { name: h.name, block: src.slice(start, end).trim() };
+    });
+};
+const lowerFirst = (s) => (s ? s.charAt(0).toLowerCase() + s.slice(1) : s);
+export async function route(input, output, importPath, split) {
+    const openAPIResult = await parseOpenAPI(input);
+    if (!openAPIResult.ok) {
+        return { ok: false, error: openAPIResult.error };
+    }
+    const openAPI = openAPIResult.value;
+    const routesSrc = routeCode(openAPI.paths);
+    if (!split) {
+        const includeZ = routesSrc.includes('z.');
+        const schemaTokens = findSchemaTokens(routesSrc);
+        const importHono = `import { createRoute${includeZ ? ', z' : ''} } from '@hono/zod-openapi'`;
+        const importSchemas = schemaTokens.length > 0 ? `import { ${schemaTokens.join(',')} } from '${importPath}'` : '';
+        const finalSrc = [importHono, importSchemas, '\n', routesSrc].filter(Boolean).join('\n');
+        const fmtCode = await fmt(finalSrc);
+        if (!fmtCode.ok)
+            return { ok: false, error: fmtCode.error };
+        const mk = await mkdir(path.dirname(output));
+        if (!mk.ok)
+            return { ok: false, error: mk.error };
+        const wr = await writeFile(output, fmtCode.value);
+        return wr.ok
+            ? { ok: true, value: `Generated route code written to ${output}` }
+            : { ok: false, error: wr.error };
+    }
+    const outDir = output.replace(/\.ts$/, '');
+    const blocks = extractRouteBlocks(routesSrc);
+    if (blocks.length === 0) {
+        const includeZ = routesSrc.includes('z.');
+        const schemaTokens = findSchemaTokens(routesSrc);
+        const importHono = `import { createRoute${includeZ ? ', z' : ''} } from '@hono/zod-openapi'`;
+        const importSchemas = schemaTokens.length > 0 ? `import { ${schemaTokens.join(',')} } from '${importPath}'` : '';
+        const finalSrc = [importHono, importSchemas, '\n', routesSrc].filter(Boolean).join('\n');
+        const fmtCode = await fmt(finalSrc);
+        if (!fmtCode.ok)
+            return { ok: false, error: fmtCode.error };
+        const mk = await mkdir(path.dirname(output));
+        if (!mk.ok)
+            return { ok: false, error: mk.error };
+        const wr = await writeFile(output, fmtCode.value);
+        return wr.ok
+            ? { ok: true, value: `Generated route code written to ${output}` }
+            : { ok: false, error: wr.error };
+    }
+    for (const { name, block } of blocks) {
+        const includeZ = block.includes('z.');
+        const schemaTokens = findSchemaTokens(block);
+        const importHono = `import { createRoute${includeZ ? ', z' : ''} } from '@hono/zod-openapi'`;
+        const importSchemas = schemaTokens.length > 0 ? `import { ${schemaTokens.join(',')} } from '${importPath}'` : '';
+        const fileSrc = [importHono, importSchemas, '\n', block, ''].filter(Boolean).join('\n');
+        const fmtCode = await fmt(fileSrc);
+        if (!fmtCode.ok)
+            return { ok: false, error: fmtCode.error };
+        const filePath = `${outDir}/${lowerFirst(name)}.ts`;
+        const mk = await mkdir(path.dirname(filePath));
+        if (!mk.ok)
+            return { ok: false, error: mk.error };
+        const wr = await writeFile(filePath, fmtCode.value);
+        if (!wr.ok)
+            return { ok: false, error: wr.error };
+    }
+    const indexBody = `${blocks.map(({ name }) => `export * from './${lowerFirst(name)}'`).join('\n')}\n`;
+    const indexFmt = await fmt(indexBody);
+    if (!indexFmt.ok)
+        return { ok: false, error: indexFmt.error };
+    const mkIndex = await mkdir(path.dirname(`${outDir}/index.ts`));
+    if (!mkIndex.ok)
+        return { ok: false, error: mkIndex.error };
+    const wrIndex = await writeFile(`${outDir}/index.ts`, indexFmt.value);
+    if (!wrIndex.ok)
+        return { ok: false, error: wrIndex.error };
+    return { ok: true, value: `Generated route code written to ${outDir}/*.ts (index.ts included)` };
+}

package/dist/core/schema.d.ts

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

package/dist/core/schema.js

@@ -0,0 +1,103 @@
+import path from 'node:path';
+import { fmt } from '../format/index.js';
+import { mkdir, writeFile } from '../fsp/index.js';
+import { zodToOpenAPI } from '../generator/zod-to-openapi/index.js';
+import { resolveSchemasDependencies } from '../helper/resolve-schemas-dependencies.js';
+import { zodToOpenAPISchema } from '../helper/zod-to-openapi-schema.js';
+import { parseOpenAPI } from '../openapi/index.js';
+const lowerFirst = (s) => (s ? (s[0]?.toLowerCase() ?? '') + s.slice(1) : s);
+const findSchemaRefs = (code, selfName) => {
+    const re = /\b([A-Za-z_$][A-Za-z0-9_$]*)Schema\b/g;
+    const out = new Set();
+    for (const m of code.matchAll(re)) {
+        const base = m[1] ?? '';
+        if (base !== selfName && base)
+            out.add(base);
+    }
+    return Array.from(out);
+};
+export async function schema(input, output, exportType, split) {
+    const openAPIResult = await parseOpenAPI(input);
+    if (!openAPIResult.ok) {
+        return { ok: false, error: openAPIResult.error };
+    }
+    const openAPI = openAPIResult.value;
+    const { schemas } = openAPI.components ? openAPI.components : {};
+    if (!schemas) {
+        return { ok: false, error: 'No schemas found' };
+    }
+    const orderedSchemas = resolveSchemasDependencies(schemas);
+    if (orderedSchemas.length === 0) {
+        return { ok: true, value: 'No schemas found' };
+    }
+    // split
+    if (split) {
+        const outDir = output.replace(/\.ts$/, '');
+        for (const schemaName of orderedSchemas) {
+            const schema = schemas[schemaName];
+            const z = zodToOpenAPI(schema);
+            const zs = zodToOpenAPISchema(schemaName, z, true, exportType);
+            const importZ = `import { z } from '@hono/zod-openapi'`;
+            const deps = findSchemaRefs(zs, schemaName).filter((d) => d in schemas);
+            const depImports = deps.length > 0
+                ? deps.map((d) => `import { ${d}Schema } from './${lowerFirst(d)}'`).join('\n')
+                : '';
+            const fileCode = [importZ, depImports, '\n', zs].filter(Boolean).join('\n');
+            const fmtCode = await fmt(fileCode);
+            if (!fmtCode.ok) {
+                return { ok: false, error: fmtCode.error };
+            }
+            const filePath = `${outDir}/${lowerFirst(schemaName)}.ts`;
+            const mkdirResult = await mkdir(path.dirname(filePath));
+            if (!mkdirResult.ok) {
+                return { ok: false, error: mkdirResult.error };
+            }
+            const writeResult = await writeFile(filePath, fmtCode.value);
+            if (!writeResult.ok) {
+                return { ok: false, error: writeResult.error };
+            }
+        }
+        // index.ts
+        const indexBody = `${orderedSchemas
+            .map((n) => `export * from './${lowerFirst(n)}'`)
+            .join('\n')}\n`;
+        const indexFmt = await fmt(indexBody);
+        if (!indexFmt.ok) {
+            return { ok: false, error: indexFmt.error };
+        }
+        const mkIndex = await mkdir(path.dirname(`${outDir}/index.ts`));
+        if (!mkIndex.ok) {
+            return { ok: false, error: mkIndex.error };
+        }
+        const wrIndex = await writeFile(`${outDir}/index.ts`, indexFmt.value);
+        if (!wrIndex.ok) {
+            return { ok: false, error: wrIndex.error };
+        }
+        return {
+            ok: true,
+            value: `Generated schema code written to ${outDir}/*.ts (index.ts included)`,
+        };
+    }
+    const schemaDefinitions = orderedSchemas
+        .map((schemaName) => {
+        const schema = schemas[schemaName];
+        const z = zodToOpenAPI(schema);
+        return zodToOpenAPISchema(schemaName, z, true, exportType);
+    })
+        .join('\n\n');
+    const importCode = `import { z } from '@hono/zod-openapi'`;
+    const schemaDefinitionsCode = `${importCode}\n\n${schemaDefinitions}`;
+    const fmtCode = await fmt(schemaDefinitionsCode);
+    if (!fmtCode.ok) {
+        return { ok: false, error: fmtCode.error };
+    }
+    const mkdirResult = await mkdir(path.dirname(output));
+    if (!mkdirResult.ok) {
+        return { ok: false, error: mkdirResult.error };
+    }
+    const writeResult = await writeFile(output, fmtCode.value);
+    if (!writeResult.ok) {
+        return { ok: false, error: writeResult.error };
+    }
+    return { ok: true, value: `Generated schema code written to ${output}` };
+}

package/dist/core/takibi.d.ts

@@ -46,9 +46,9 @@
  * @returns A `Result` containing a success message or an error string.
  */
 export declare function takibi(input: `${string}.yaml` | `${string}.json` | `${string}.tsp`, output: `${string}.ts`, exportSchema: boolean, exportType: boolean, template: boolean, test: boolean, basePath?: string): Promise<{
-    ok: true;
-    value: string;
+    readonly ok: true;
+    readonly value: string;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 }>;

package/dist/core/takibi.js

@@ -2,9 +2,9 @@ import path from 'node:path';
 import { fmt } from '../format/index.js';
 import { mkdir, readdir, writeFile } from '../fsp/index.js';
 import { app } from '../generator/zod-openapi-hono/app/index.js';
-import zodOpenAPIHono from '../generator/zod-openapi-hono/openapi/index.js';
+import { zodOpenAPIHono } from '../generator/zod-openapi-hono/openapi/index.js';
 import { parseOpenAPI } from '../openapi/index.js';
-import { groupHandlersByFileName, methodPath } from '../utils/index.js';
+import { groupHandlersByFileName, isHttpMethod, methodPath } from '../utils/index.js';
 /**
  * Generates TypeScript code from an OpenAPI spec and optional templates.
  *
@@ -81,8 +81,7 @@ export async function takibi(input, output, exportSchema, exportType, template,
         if (!readdirResult.ok) {
             return { ok: false, error: readdirResult.error };
         }
-        const files = readdirResult.value;
-        const target = path.join(dir, files.includes('index.ts') ? 'main.ts' : 'index.ts');
+        const target = path.join(dir, readdirResult.value.includes('index.ts') ? 'main.ts' : 'index.ts');
         const writeResult = await writeFile(target, appResult.value);
         if (!writeResult.ok) {
             return { ok: false, error: writeResult.error };
@@ -109,13 +108,6 @@ export async function takibi(input, output, exportSchema, exportType, template,
 async function zodOpenapiHonoHandler(openapi, output, test) {
     const paths = openapi.paths;
     const handlers = [];
-    const isHttpMethod = (v) => {
-        for (const m of ['get', 'put', 'post', 'delete', 'patch', 'options', 'head', 'trace']) {
-            if (m === v)
-                return true;
-        }
-        return false;
-    };
     for (const [path, pathItem] of Object.entries(paths)) {
         for (const [method] of Object.entries(pathItem)) {
             if (!isHttpMethod(method))

package/dist/format/index.d.ts

@@ -5,11 +5,9 @@
  * @returns A `Result` containing the formatted code or an error message.
  */
 export declare function fmt(code: string): Promise<{
-    ok: true;
-    value: string;
-    error?: undefined;
+    readonly ok: true;
+    readonly value: string;
 } | {
-    ok: false;
-    error: string;
-    value?: undefined;
+    readonly ok: false;
+    readonly error: string;
 }>;

package/dist/fsp/index.d.ts

@@ -5,11 +5,11 @@
  * @returns A `Result` that is `ok` on success, otherwise an error message.
  */
 export declare function mkdir(dir: string): Promise<{
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 } | {
-    ok: true;
-    value: undefined;
+    readonly ok: true;
+    readonly value: undefined;
 }>;
 /**
  * Reads the contents of a directory.
@@ -18,11 +18,11 @@ export declare function mkdir(dir: string): Promise<{
  * @returns A `Result` with the file list on success, otherwise an error message.
  */
 export declare function readdir(dir: string): Promise<{
-    ok: false;
+    readonly ok: false;
     error: string;
 } | {
-    ok: true;
-    value: string[];
+    readonly ok: true;
+    readonly value: string[];
 }>;
 /**
  * Writes UTF-8 text to a file, creating it if necessary.
@@ -32,9 +32,9 @@ export declare function readdir(dir: string): Promise<{
  * @returns A `Result` that is `ok` on success, otherwise an error message.
  */
 export declare function writeFile(path: string, data: string): Promise<{
-    ok: true;
-    value: undefined;
+    readonly ok: true;
+    readonly value: undefined;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 }>;

package/dist/generator/rpc/index.d.ts

@@ -1,2 +1,2 @@
 import type { OpenAPI } from '../../openapi/index.js';
-export default function rpc(openapi: OpenAPI, importCode: string): string;
+export declare function rpc(openapi: OpenAPI, importPath: string): string;

package/dist/generator/rpc/index.js

@@ -1,8 +1,6 @@
 import { methodPath } from '../../utils/index.js';
 /* ─────────────────────────────── Guards ─────────────────────────────── */
-/** Narrow to generic object records */
 const isRecord = (v) => typeof v === 'object' && v !== null;
-/** Narrow to OpenAPI paths object (shallow structural check) */
 const isOpenAPIPaths = (v) => {
     if (!isRecord(v))
         return false;
@@ -11,20 +9,11 @@ const isOpenAPIPaths = (v) => {
             return false;
     return true;
 };
-/** Treat any object as Schema (we rely on downstream field checks) */
 const isSchema = (v) => isRecord(v);
 /* ─────────────────────────────── Formatters ─────────────────────────────── */
-/** JS identifier check */
 const isValidIdent = (s) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(s);
-/** Escape single quotes and backslashes for single-quoted strings */
 const esc = (s) => s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-/**
- * Convert an OpenAPI path to a client access chain.
- * examples:
- *  '/'                 -> ".index"
- *  '/hono-x'           -> "['hono-x']"
- *  '/posts/hono/{id}'  -> ".posts.hono[':id']"
- */
+/** '/'->'.index' | '/hono-x'->"['hono-x']" | '/posts/hono/{id}'->".posts.hono[':id']" */
 const formatPath = (path) => {
     const segs = (path === '/' ? ['index'] : path.replace(/^\/+/, '').split('/')).filter(Boolean);
     return segs
@@ -35,7 +24,6 @@ const formatPath = (path) => {
             : `['${esc(seg)}']`)
         .join('');
 };
-/** 'type' to normalized list for uniform checks */
 const isJSONTypeName = (s) => typeof s === 'string' &&
     (s === 'object' ||
         s === 'array' ||
@@ -51,7 +39,6 @@ const toTypeArray = (t) => {
         return t.filter(isJSONTypeName);
     return [];
 };
-/** Build literal union from enum values (kept compact) */
 const literalFromEnum = (vals) => {
     const toLit = (v) => typeof v === 'string'
         ? `'${v.replace(/'/g, "\\'")}'`
@@ -62,7 +49,6 @@ const literalFromEnum = (vals) => {
                 : 'unknown';
     return vals.map(toLit).join('|');
 };
-/** Create a $ref resolver for #/components/schemas/... */
 const createResolveRef = (schemas) => (ref) => {
     if (!ref)
         return undefined;
@@ -72,60 +58,52 @@ const createResolveRef = (schemas) => (ref) => {
     const target = schemas[m[1]];
     return isSchema(target) ? target : undefined;
 };
-/** Create a Schema->TypeScript type printer (single instance, recursive-safe) */
+/** TS type printer (handles $ref / enums / combinators / additionalProperties / nullable) */
 const createTsTypeFromSchema = (resolveRef) => {
     const tt = (schema, seen = new Set()) => {
         if (!schema)
             return 'unknown';
-        // $ref resolution
         if (schema.$ref) {
             const tgt = resolveRef(schema.$ref);
             return tt(tgt, seen);
         }
-        // recursion guard
         if (seen.has(schema))
             return 'unknown';
-        const nextSeen = new Set(seen);
-        nextSeen.add(schema);
-        // combinators
+        const next = new Set(seen);
+        next.add(schema);
         if (Array.isArray(schema.oneOf) && schema.oneOf.length)
-            return schema.oneOf.map((s) => tt(s, nextSeen)).join('|') || 'unknown';
+            return schema.oneOf.map((s) => tt(s, next)).join('|') || 'unknown';
         if (Array.isArray(schema.anyOf) && schema.anyOf.length)
-            return schema.anyOf.map((s) => tt(s, nextSeen)).join('|') || 'unknown';
+            return schema.anyOf.map((s) => tt(s, next)).join('|') || 'unknown';
         if (Array.isArray(schema.allOf) && schema.allOf.length)
-            return schema.allOf.map((s) => tt(s, nextSeen)).join('&') || 'unknown';
-        // enum
+            return schema.allOf.map((s) => tt(s, next)).join('&') || 'unknown';
         if (Array.isArray(schema.enum) && schema.enum.length) {
             const base = literalFromEnum(schema.enum);
             return schema.nullable ? `${base}|null` : base;
         }
         const types = toTypeArray(schema.type);
-        // array
+        // array (parentheses when inner contains union/intersection)
         if (types.includes('array')) {
-            const inner = tt(isSchema(schema.items) ? schema.items : undefined, nextSeen);
-            const core = `${inner}[]`;
+            const item = isSchema(schema.items) ? schema.items : undefined;
+            const inner = tt(item, next);
+            const needParens = /[|&]/.test(inner) && !/^\(.*\)$/.test(inner);
+            const core = `${needParens ? `(${inner})` : inner}[]`;
             return schema.nullable ? `${core}|null` : core;
         }
-        // object
         if (types.includes('object')) {
             const req = new Set(Array.isArray(schema.required) ? schema.required : []);
             const props = schema.properties ?? {};
             const fields = Object.entries(props).map(([k, v]) => {
                 const opt = req.has(k) ? '' : '?';
                 const child = isSchema(v) ? v : undefined;
-                return `${k}${opt}:${tt(child, nextSeen)}`;
+                return `${k}${opt}:${tt(child, next)}`;
             });
             const ap = schema.additionalProperties;
-            const addl = ap === true
-                ? '[key:string]:unknown'
-                : isSchema(ap)
-                    ? `[key:string]:${tt(ap, nextSeen)}`
-                    : '';
+            const addl = ap === true ? '[key:string]:unknown' : isSchema(ap) ? `[key:string]:${tt(ap, next)}` : '';
             const members = [...fields, addl].filter(Boolean).join(',');
             const core = `{${members}}`;
             return schema.nullable ? `${core}|null` : core;
         }
-        // primitives
         if (types.length === 0)
             return schema.nullable ? 'unknown|null' : 'unknown';
         const prim = types
@@ -144,13 +122,11 @@ const isParameterObject = (v) => {
     const pos = v.in;
     return pos === 'path' || pos === 'query' || pos === 'header' || pos === 'cookie';
 };
-/** Extract components/parameters name from a ref-like value */
 const refParamName = (refLike) => {
     const ref = typeof refLike === 'string' ? refLike : isRefObject(refLike) ? refLike.$ref : undefined;
     const m = ref?.match(/^#\/components\/parameters\/(.+)$/);
     return m ? m[1] : undefined;
 };
-/** Build a resolver that returns normalized ParameterLike (resolving $ref) */
 const createResolveParameter = (componentsParameters) => (p) => {
     if (isParameterObject(p))
         return p;
@@ -158,7 +134,6 @@ const createResolveParameter = (componentsParameters) => (p) => {
     const cand = name ? componentsParameters[name] : undefined;
     return isParameterObject(cand) ? cand : undefined;
 };
-/** Convert raw parameters array into ParameterLike[] */
 const createToParameterLikes = (resolveParam) => (arr) => Array.isArray(arr)
     ? arr.reduce((acc, x) => {
         const r = resolveParam(x);
@@ -178,7 +153,7 @@ const HTTP_METHODS = [
     'patch',
     'trace',
 ];
-/** Extract the first suitable schema from requestBody.content by priority order */
+const hasSchemaProp = (v) => isRecord(v) && 'schema' in v;
 const pickBodySchema = (op) => {
     const rb = op.requestBody;
     if (!isRecord(rb))
@@ -196,14 +171,12 @@ const pickBodySchema = (op) => {
     ];
     for (const k of order) {
         const media = isRecord(content[k]) ? content[k] : undefined;
-        if (isRecord(media) && 'schema' in media && isSchema(media.schema)) {
+        if (hasSchemaProp(media) && isSchema(media.schema))
             return media.schema;
-        }
     }
     return undefined;
 };
 /* ─────────────────────────────── Args builders ─────────────────────────────── */
-/** Build TS type for params arg (compact formatting) */
 const createBuildParamsType = (tsTypeFromSchema) => (pathParams, queryParams) => {
     const parts = [];
     if (pathParams.length) {
@@ -216,28 +189,14 @@ const createBuildParamsType = (tsTypeFromSchema) => (pathParams, queryParams) =>
     }
     return parts.length ? `{${parts.join(',')}}` : '';
 };
-/** Build function argument signature */
 const buildArgSignature = (paramsType, bodyType) => paramsType && bodyType
-    ? `params:${paramsType}, body:${bodyType}`
+    ? `params:${paramsType},body:${bodyType}`
     : paramsType
         ? `params:${paramsType}`
         : bodyType
             ? `body:${bodyType}`
             : '';
-/** Build one query key:value piece with integer-to-string rules */
-const buildQueryPiece = (p) => {
-    const types = toTypeArray(p.schema?.type);
-    const isArr = types.includes('array');
-    const itemsInt = isArr && isSchema(p.schema?.items) && toTypeArray(p.schema?.items?.type).includes('integer');
-    const isInt = types.includes('integer');
-    const rhs = itemsInt
-        ? `(params.query.${p.name}??[]).map((v:unknown)=>String(v))`
-        : isInt
-            ? `String(params.query.${p.name})`
-            : `params.query.${p.name}`;
-    return `${p.name}:${rhs}`;
-};
-/** Build client call argument object (compact formatting) */
+/** pass query as-is (keep numbers/arrays) */
 const buildClientArgs = (pathParams, queryParams, hasBody) => {
     const pieces = [];
     if (pathParams.length) {
@@ -245,7 +204,7 @@ const buildClientArgs = (pathParams, queryParams, hasBody) => {
         pieces.push(`param:{${inner}}`);
     }
     if (queryParams.length) {
-        const inner = queryParams.map(buildQueryPiece).join(',');
+        const inner = queryParams.map((p) => `${p.name}:params.query.${p.name}`).join(',');
         pieces.push(`query:{${inner}}`);
     }
     if (hasBody)
@@ -276,36 +235,25 @@ const generateOperationCode = (path, method, item, deps) => {
         : `${deps.client}${clientAccess}.$${method}()`;
     const summary = typeof op.summary === 'string' ? op.summary : '';
     const description = typeof op.description === 'string' ? op.description : '';
-    return ('/**\n' +
-        (summary ? ` * ${summary}\n *\n` : '') +
-        (description ? ` * ${description}\n *\n` : '') +
-        ` * ${method.toUpperCase()} ${path}\n` +
-        ' */\n' +
-        `export async function ${funcName}(${argSig}) {\n` +
-        `  return await ${call}\n` +
-        '}');
+    const summaryBlock = summary ? ` * ${summary}\n *\n` : '';
+    const descriptionBlock = description ? ` * ${description}\n *\n` : '';
+    return `/**\n${summaryBlock}${descriptionBlock} * ${method.toUpperCase()} ${path}\n */\nexport async function ${funcName}(${argSig}){return await ${call}}`;
 };
 /* ─────────────────────────────── Entry ─────────────────────────────── */
-export default function rpc(openapi, importCode) {
+export function rpc(openapi, importPath) {
     const client = 'client';
     const out = [];
-    // import header (kept as-is, then a blank line if present)
-    const header = (() => {
-        const s = (importCode ?? '').trim();
-        return s.length ? `${s}\n\n` : '';
-    })();
-    // paths guard
+    const s = `import { client } from '${importPath}'`;
+    const header = s.length ? `${s}\n\n` : '';
     const pathsMaybe = openapi.paths;
     if (!isOpenAPIPaths(pathsMaybe))
         return header;
-    // schema & parameter resolvers
     const schemas = openapi.components?.schemas ?? {};
     const resolveRef = createResolveRef(schemas);
     const tsTypeFromSchema = createTsTypeFromSchema(resolveRef);
     const componentsParameters = openapi.components?.parameters ?? {};
     const resolveParameter = createResolveParameter(componentsParameters);
     const toParameterLikes = createToParameterLikes(resolveParameter);
-    // iterate path items & operations
     for (const path in pathsMaybe) {
         const rawItem = pathsMaybe[path];
         if (!isRecord(rawItem))
@@ -331,6 +279,5 @@ export default function rpc(openapi, importCode) {
                 out.push(code);
         }
     }
-    // final string (compact; Prettier will handle formatting as configured)
-    return header + out.join('\n\n') + (out.length ? '\n' : '');
+    return `${header}${out.join('\n\n')}${out.length ? '\n' : ''}`;
 }

package/dist/generator/zod-openapi-hono/openapi/index.d.ts

@@ -7,4 +7,4 @@ import type { OpenAPI } from '../../../openapi/index.js';
  * @param exportType - Whether to export inferred TypeScript types
  * @returns The generated TypeScript code string
  */
-export default function zodOpenAPIHono(openapi: OpenAPI, exportSchema: boolean, exportType: boolean): string;
+export declare function zodOpenAPIHono(openapi: OpenAPI, exportSchema: boolean, exportType: boolean): string;

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

@@ -8,7 +8,7 @@ import { routeCode } from './route/index.js';
  * @param exportType - Whether to export inferred TypeScript types
  * @returns The generated TypeScript code string
  */
-export default function zodOpenAPIHono(openapi, exportSchema, exportType) {
+export function zodOpenAPIHono(openapi, exportSchema, exportType) {
     const components = openapi.components
         ? componentsCode(openapi.components, exportSchema, exportType)
         : '';

package/dist/generator/zod-openapi-hono/openapi/route/params/params-object.d.ts

@@ -12,6 +12,6 @@ import type { Parameters } from '../../../../../openapi/index.js';
  * - Uses `zodToOpenAPI` for schema conversion and `zodToOpenAPISchema` for output generation.
  * - Supports conditional `export` statements for both schemas and types.
  */
-export declare function paramsObject(parameters: Parameters[]): {
+export declare function paramsObject(parameters: readonly Parameters[]): {
     [section: string]: Record<string, string>;
 };

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

@@ -11,4 +11,4 @@ import type { Parameters, RequestBody } from '../../../../../openapi/index.js';
  * - Deduplicates schemas if multiple content types share the same body schema.
  * - Uses `params` instead of `path` for Hono compatibility.
  */
-export declare function requestParameter(parameters: Parameters[] | undefined, body: RequestBody | undefined): string;
+export declare function requestParameter(parameters: readonly Parameters[] | undefined, body: RequestBody | undefined): string;

package/dist/helper/get-route-maps.d.ts

@@ -5,7 +5,7 @@ import type { OpenAPI } from '../openapi/index.js';
  * @param openapi - The OpenAPI specification object.
  * @returns An array of route mappings, each with route name, handler name, and path.
  */
-export declare function getRouteMaps(openapi: OpenAPI): {
+export declare function getRouteMaps(openapi: OpenAPI): readonly {
     routeName: string;
     handlerName: string;
     path: string;

package/dist/helper/get-route-maps.js

@@ -1,4 +1,4 @@
-import { methodPath } from '../utils/index.js';
+import { isHttpMethod, methodPath } from '../utils/index.js';
 /**
  * Extracts route mappings from an OpenAPI specification.
  *
@@ -6,13 +6,6 @@ import { methodPath } from '../utils/index.js';
  * @returns An array of route mappings, each with route name, handler name, and path.
  */
 export function getRouteMaps(openapi) {
-    const isHttpMethod = (v) => {
-        for (const m of ['get', 'put', 'post', 'delete', 'patch', 'options', 'head', 'trace']) {
-            if (m === v)
-                return true;
-        }
-        return false;
-    };
     const paths = openapi.paths;
     const routeMappings = Object.entries(paths).flatMap(([path, pathItem]) => {
         return Object.entries(pathItem).flatMap(([method]) => {

package/dist/helper/properties-schema.d.ts

@@ -43,4 +43,4 @@ import type { Schema } from '../openapi/index.js';
  * )
  * // → 'z.object({user:userSchema.optional(),tags:z.array(tagSchema).optional()}).partial()'
  */
-export declare function propertiesSchema(properties: Record<string, Schema>, required: string[]): string;
+export declare function propertiesSchema(properties: Record<string, Schema>, required: readonly string[]): string;

package/dist/openapi/index.d.ts

@@ -23,11 +23,11 @@ import SwaggerParser from '@apidevtools/swagger-parser';
  * in downstream code.
  */
 export declare function parseOpenAPI(input: string): Promise<{
-    ok: true;
-    value: OpenAPI;
+    readonly ok: true;
+    readonly value: OpenAPI;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 }>;
 /**
  * Base OpenAPI type derived from SwaggerParser

package/dist/typespec/index.d.ts

@@ -25,9 +25,9 @@ import type { SupportedOpenAPIDocuments } from '@typespec/openapi3';
  * @returns `{ ok:true, value }` with an OpenAPI document, or `{ ok:false, error }` on failure.
  */
 export declare function typeSpecToOpenAPI(input: string): Promise<{
-    ok: true;
-    value: SupportedOpenAPIDocuments;
+    readonly ok: true;
+    readonly value: SupportedOpenAPIDocuments;
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 }>;

package/dist/utils/index.d.ts

@@ -20,19 +20,19 @@
  * @returns `{ ok:true, value }` on success; `{ ok:false, error }` on invalid usage.
  */
 export declare function parseCli(args: readonly string[]): {
-    ok: true;
-    value: {
-        input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
-        output: `${string}.ts`;
-        exportType: boolean;
-        exportSchema: boolean;
-        template: boolean;
-        test: boolean;
-        basePath?: string;
+    readonly ok: true;
+    readonly value: {
+        readonly input: `${string}.yaml` | `${string}.json` | `${string}.tsp`;
+        readonly output: `${string}.ts`;
+        readonly exportType: boolean;
+        readonly exportSchema: boolean;
+        readonly template: boolean;
+        readonly test: boolean;
+        readonly basePath?: string;
     };
 } | {
-    ok: false;
-    error: string;
+    readonly ok: false;
+    readonly error: string;
 };
 /**
  * Normalize a JSON Schema `type` value into an array of type strings.
@@ -77,8 +77,8 @@ export declare function normalizeTypes(t?: 'string' | 'number' | 'integer' | 'da
  * @returns Array of import statements.
  */
 export declare function importRoutes(importsMap: {
-    [importPath: `${string}.ts`]: string[];
-}): string[];
+    [importPath: `${string}.ts`]: readonly string[];
+}): readonly string[];
 /**
  * Generates registration code for OpenAPI `securitySchemes`.
  *
@@ -130,12 +130,12 @@ export declare function registerComponent(securitySchemes: {
  * @param output - The output TypeScript file name (e.g., 'user.ts'). Used to determine the import path.
  * @returns A record where each key is an import path (e.g., 'user.ts') and the value is an array of route names imported from that path.
  */
-export declare function importMap(routeMappings: {
-    routeName: string;
-    handlerName: string;
-    path: string;
-}[], output: `${string}.ts`): {
-    [importPath: `${string}.ts`]: string[];
+export declare function importMap(routeMappings: Readonly<{
+    readonly routeName: string;
+    readonly handlerName: string;
+    readonly path: string;
+}[]>, output: `${string}.ts`): {
+    [importPath: `${string}.ts`]: readonly string[];
 };
 /**
  * Generates import statements for handler functions.
@@ -159,8 +159,8 @@ export declare function importMap(routeMappings: {
  * @returns An array of import statement strings.
  */
 export declare function importHandlers(handlerImportsMap: {
-    [fileName: string]: string[];
-}, output: `${string}.ts`): string[];
+    [fileName: string]: readonly string[];
+}, output: `${string}.ts`): readonly string[];
 /**
  * Groups route handlers by file name.
  *
@@ -180,15 +180,15 @@ export declare function importHandlers(handlerImportsMap: {
  * @returns A deduplicated array of grouped handler definitions per file.
  */
 export declare function groupHandlersByFileName(handlers: {
-    fileName: `${string}.ts`;
-    testFileName: `${string}.ts`;
-    routeHandlerContents: string[];
-    routeNames: string[];
+    readonly fileName: `${string}.ts`;
+    readonly testFileName: `${string}.ts`;
+    readonly routeHandlerContents: readonly string[];
+    readonly routeNames: readonly string[];
 }[]): {
-    fileName: `${string}.ts`;
-    testFileName: `${string}.ts`;
-    routeHandlerContents: string[];
-    routeNames: string[];
+    readonly fileName: `${string}.ts`;
+    readonly testFileName: `${string}.ts`;
+    readonly routeHandlerContents: readonly string[];
+    readonly routeNames: readonly string[];
 }[];
 /**
  * Generates a map of handler file names to handler names.
@@ -210,12 +210,12 @@ export declare function groupHandlersByFileName(handlers: {
  * @param handlerMaps - Array of route mappings including route name, handler name, and path.
  * @returns A map where keys are handler file names and values are arrays of handler names.
  */
-export declare function getHandlerImports(handlerMaps: {
-    routeName: string;
-    handlerName: string;
-    path: string;
-}[]): {
-    [fileName: `${string}.ts`]: string[];
+export declare function getHandlerImports(handlerMaps: Readonly<{
+    readonly routeName: string;
+    readonly handlerName: string;
+    readonly path: string;
+}[]>): {
+    [fileName: `${string}.ts`]: readonly string[];
 };
 /**
  * Checks if a value is a non-null object (e.g., a potential `$ref` object).
@@ -238,9 +238,16 @@ export declare function getHandlerImports(handlerMaps: {
  * ```
  */
 export declare function isRefObject(value: unknown): value is {
-    $ref?: string;
-    [key: string]: unknown;
+    readonly $ref?: string;
+    readonly [key: string]: unknown;
 };
+/**
+ * Checks if a string is a valid HTTP method.
+ *
+ * @param method - The HTTP method to check.
+ * @returns `true` if the method is a valid HTTP method; otherwise `false`.
+ */
+export declare function isHttpMethod(method: string): method is 'get' | 'put' | 'post' | 'delete' | 'patch' | 'options' | 'head' | 'trace';
 /**
  * Checks if all given content types share the same schema definition.
  *
@@ -266,10 +273,10 @@ export declare function isRefObject(value: unknown): value is {
  * }) // true
  * ```
  */
-export declare function isUniqueContentSchema(contentTypes: string[], content: {
+export declare function isUniqueContentSchema(contentTypes: readonly string[], content: {
     [key: string]: {
         schema: {
-            $ref?: `#/components/schemas/${string}`;
+            readonly $ref?: `#/components/schemas/${string}`;
         };
     };
 }): boolean;
@@ -340,16 +347,16 @@ export declare function methodPath(method: string, path: string): string;
  * // => export const getUserRoute = createRoute({method:"get",path:"/user",request:{query:...},responses:{...}})
  */
 export declare function createRoute(args: {
-    routeName: string;
-    tags?: string;
-    method: string;
-    path: string;
-    operationId?: string;
-    summary?: string;
-    description?: string;
-    security?: string;
-    requestParams: string;
-    responses: string;
+    readonly routeName: string;
+    readonly tags?: string;
+    readonly method: string;
+    readonly path: string;
+    readonly operationId?: string;
+    readonly summary?: string;
+    readonly description?: string;
+    readonly security?: string;
+    readonly requestParams: string;
+    readonly responses: string;
 }): string;
 /**
  * Generates an array of Zod validator strings from OpenAPI parameter objects.
@@ -371,7 +378,7 @@ export declare function createRoute(args: {
  */
 export declare function requestParamsArray(parameters: {
     [section: string]: Record<string, string>;
-}): string[];
+}): readonly string[];
 /**
  * Escapes a string for safe use in TypeScript string literals.
  *

package/dist/utils/index.js

@@ -302,6 +302,22 @@ export function getHandlerImports(handlerMaps) {
 export function isRefObject(value) {
     return typeof value === 'object' && value !== null;
 }
+/**
+ * Checks if a string is a valid HTTP method.
+ *
+ * @param method - The HTTP method to check.
+ * @returns `true` if the method is a valid HTTP method; otherwise `false`.
+ */
+export function isHttpMethod(method) {
+    return (method === 'get' ||
+        method === 'put' ||
+        method === 'post' ||
+        method === 'delete' ||
+        method === 'patch' ||
+        method === 'options' ||
+        method === 'head' ||
+        method === 'trace');
+}
 /**
  * Checks if all given content types share the same schema definition.
  *

package/dist/vite-plugin/index.js

@@ -1,7 +1,7 @@
 import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { fmt } from '../format/index.js';
-import zodOpenAPIHono from '../generator/zod-openapi-hono/openapi/index.js';
+import { zodOpenAPIHono } from '../generator/zod-openapi-hono/openapi/index.js';
 import { parseOpenAPI } from '../openapi/index.js';
 /**
  * Vite plugin to generate Hono routes from an OpenAPI or TypeSpec file.

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.22",
+  "version": "0.9.24",
   "type": "module",
   "license": "MIT",
   "keywords": [