@igniter-js/cli 0.4.93 → 0.4.96

package/dist/index.mjs

@@ -14,11 +14,11 @@ import { Command } from "commander";
 
 // src/commands/init/action.ts
 import * as p5 from "@clack/prompts";
-import * as path13 from "path";
+import * as path11 from "path";
 
 // src/commands/init/prompts.ts
 import * as p2 from "@clack/prompts";
-import * as path12 from "path";
+import * as path10 from "path";
 
 // src/core/package-manager.ts
 function getInstallCommand(pm) {
@@ -84,9 +84,6 @@ var StarterRegistry = class _StarterRegistry {
   }
 };
 
-// src/registry/starters/nextjs-starter.ts
-import path2 from "path";
-
 // src/core/registry/starters/base-starter.ts
 import * as path from "path";
 import * as fs from "fs/promises";
@@ -123,11 +120,11 @@ function registerHandlebarsHelpers() {
   handlebars.registerHelper("capitalizeSlug", function(slug) {
     return slug.replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
   });
-  handlebars.registerHelper("get", function(obj, path25) {
-    if (!path25 || typeof path25 !== "string") {
+  handlebars.registerHelper("get", function(obj, path23) {
+    if (!path23 || typeof path23 !== "string") {
       return void 0;
     }
-    const pathArray = path25.split(".");
+    const pathArray = path23.split(".");
     let current = obj;
     for (let i = 0; i < pathArray.length; i++) {
       if (current === null || current === void 0) {
@@ -181,39 +178,69 @@ function registerHandlebarsHelpers() {
 }
 
 // src/core/registry/starters/base-starter.ts
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta?.url);
+var __dirname = path.dirname(__filename);
+function resolveTemplatesDir() {
+  const candidates = [
+    // Bundled: dist/index.mjs -> dist/../templates/ (templates at package root)
+    path.resolve(__dirname, "..", "templates"),
+    // Bundled: dist/index.mjs -> dist/templates/ (if copied to dist)
+    path.resolve(__dirname, "templates"),
+    // Development: when running from source (src/core/registry/starters/)
+    path.resolve(__dirname, "..", "..", "..", "..", "templates"),
+    // Installed via npm: node_modules/@igniter-js/cli/templates
+    path.resolve(process.cwd(), "node_modules", "@igniter-js", "cli", "templates")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(
+    [
+      "Could not locate the CLI templates directory.",
+      "Looked in the following locations:",
+      ...candidates.map((candidate) => `- ${candidate}`)
+    ].join("\n")
+  );
+}
+function resolveTemplatePath(relativePath) {
+  return path.resolve(resolveTemplatesDir(), relativePath);
+}
 var BaseStarter = class {
   constructor() {
     this.templates = [
       {
-        template: path.resolve(process.cwd(), "templates/starters/igniter.router.hbs"),
+        template: resolveTemplatePath("starters/igniter.router.hbs"),
         outputPath: "src/igniter.router.ts"
       },
       {
-        template: path.resolve(process.cwd(), "templates/starters/igniter.client.hbs"),
+        template: resolveTemplatePath("starters/igniter.client.hbs"),
         outputPath: "src/igniter.client.ts"
       },
       {
-        template: path.resolve(process.cwd(), "templates/starters/igniter.context.hbs"),
+        template: resolveTemplatePath("starters/igniter.context.hbs"),
         outputPath: "src/igniter.context.ts"
       },
       {
-        template: path.resolve(process.cwd(), "templates/starters/igniter.hbs"),
+        template: resolveTemplatePath("starters/igniter.hbs"),
         outputPath: "src/igniter.ts"
       },
       {
-        template: path.resolve(process.cwd(), "templates/scaffold/example-feature/example.controller.hbs"),
+        template: resolveTemplatePath("scaffold/example-feature/example.controller.hbs"),
         outputPath: "src/features/example/controllers/example.controller.ts"
       },
       {
-        template: path.resolve(process.cwd(), "templates/scaffold/example-feature/example.procedure.hbs"),
+        template: resolveTemplatePath("scaffold/example-feature/example.procedure.hbs"),
         outputPath: "src/features/example/procedures/example.procedure.ts"
       },
       {
-        template: path.resolve(process.cwd(), "templates/scaffold/example-feature/example.interfaces.hbs"),
+        template: resolveTemplatePath("scaffold/example-feature/example.interfaces.hbs"),
         outputPath: "src/features/example/example.interfaces.ts"
       },
       {
-        template: path.resolve(process.cwd(), "templates/starters/open-api.hbs"),
+        template: resolveTemplatePath("starters/open-api.hbs"),
         outputPath: "src/docs/openapi.json"
       }
     ];
@@ -431,43 +458,43 @@ var NextJsStarter = class extends BaseStarter {
     this.repository = "starter-nextjs";
     this.templates = [
       {
-        template: path2.resolve(process.cwd(), "templates/starters/nextjs/route-handler.hbs"),
+        template: resolveTemplatePath("starters/nextjs/route-handler.hbs"),
         outputPath: "src/app/api/v1/[[...all]]/route.ts"
       },
       {
-        template: path2.resolve(process.cwd(), "templates/starters/igniter.router.hbs"),
+        template: resolveTemplatePath("starters/igniter.router.hbs"),
         outputPath: "src/igniter.router.ts"
       },
       {
-        template: path2.resolve(process.cwd(), "templates/starters/igniter.client.hbs"),
+        template: resolveTemplatePath("starters/igniter.client.hbs"),
         outputPath: "src/igniter.client.ts"
       },
       {
-        template: path2.resolve(process.cwd(), "templates/starters/igniter.context.hbs"),
+        template: resolveTemplatePath("starters/igniter.context.hbs"),
         outputPath: "src/igniter.context.ts"
       },
       {
-        template: path2.resolve(process.cwd(), "templates/starters/igniter.hbs"),
+        template: resolveTemplatePath("starters/igniter.hbs"),
         outputPath: "src/igniter.ts"
       },
       {
-        template: path2.resolve(process.cwd(), "templates/scaffold/example-feature/example.controller.hbs"),
+        template: resolveTemplatePath("scaffold/example-feature/example.controller.hbs"),
         outputPath: "src/features/example/controllers/example.controller.ts"
       },
       {
-        template: path2.resolve(process.cwd(), "templates/scaffold/example-feature/example.procedure.hbs"),
+        template: resolveTemplatePath("scaffold/example-feature/example.procedure.hbs"),
         outputPath: "src/features/example/procedures/example.procedure.ts"
       },
       {
-        template: path2.resolve(process.cwd(), "templates/scaffold/example-feature/example.interfaces.hbs"),
+        template: resolveTemplatePath("scaffold/example-feature/example.interfaces.hbs"),
         outputPath: "src/features/example/example.interfaces.ts"
       },
       {
-        template: path2.resolve(process.cwd(), "templates/starters/nextjs/tsconfig.hbs"),
+        template: resolveTemplatePath("starters/nextjs/tsconfig.hbs"),
         outputPath: "tsconfig.json"
       },
       {
-        template: path2.resolve(process.cwd(), "templates/starters/open-api.hbs"),
+        template: resolveTemplatePath("starters/open-api.hbs"),
         outputPath: "src/docs/openapi.json"
       }
     ];
@@ -574,7 +601,6 @@ var BunReactStarter = class extends BaseStarter {
 };
 
 // src/registry/starters/tanstack-start-starter.ts
-import path3 from "path";
 var TanStackStartStarter = class extends BaseStarter {
   constructor() {
     super(...arguments);
@@ -585,43 +611,43 @@ var TanStackStartStarter = class extends BaseStarter {
     this.repository = "starter-tanstack-start";
     this.templates = [
       {
-        template: path3.resolve(process.cwd(), "templates/starters/tanstack-start/route-handler.hbs"),
+        template: resolveTemplatePath("starters/tanstack-start/route-handler.hbs"),
         outputPath: "src/routes/api/v1/$.ts"
       },
       {
-        template: path3.resolve(process.cwd(), "templates/starters/igniter.router.hbs"),
+        template: resolveTemplatePath("starters/igniter.router.hbs"),
         outputPath: "src/igniter.router.ts"
       },
       {
-        template: path3.resolve(process.cwd(), "templates/starters/igniter.client.hbs"),
+        template: resolveTemplatePath("starters/igniter.client.hbs"),
         outputPath: "src/igniter.client.ts"
       },
       {
-        template: path3.resolve(process.cwd(), "templates/starters/igniter.context.hbs"),
+        template: resolveTemplatePath("starters/igniter.context.hbs"),
         outputPath: "src/igniter.context.ts"
       },
       {
-        template: path3.resolve(process.cwd(), "templates/starters/igniter.hbs"),
+        template: resolveTemplatePath("starters/igniter.hbs"),
         outputPath: "src/igniter.ts"
       },
       {
-        template: path3.resolve(process.cwd(), "templates/scaffold/example-feature/example.controller.hbs"),
+        template: resolveTemplatePath("scaffold/example-feature/example.controller.hbs"),
         outputPath: "src/features/example/controllers/example.controller.ts"
       },
       {
-        template: path3.resolve(process.cwd(), "templates/scaffold/example-feature/example.procedure.hbs"),
+        template: resolveTemplatePath("scaffold/example-feature/example.procedure.hbs"),
         outputPath: "src/features/example/procedures/example.procedure.ts"
       },
       {
-        template: path3.resolve(process.cwd(), "templates/scaffold/example-feature/example.interfaces.hbs"),
+        template: resolveTemplatePath("scaffold/example-feature/example.interfaces.hbs"),
         outputPath: "src/features/example/example.interfaces.ts"
       },
       {
-        template: path3.resolve(process.cwd(), "templates/starters/tanstack-start/tsconfig.hbs"),
+        template: resolveTemplatePath("starters/tanstack-start/tsconfig.hbs"),
         outputPath: "tsconfig.json"
       },
       {
-        template: path3.resolve(process.cwd(), "templates/starters/open-api.hbs"),
+        template: resolveTemplatePath("starters/open-api.hbs"),
         outputPath: "src/docs/openapi.json"
       }
     ];
@@ -670,7 +696,7 @@ var AddOnRegistry = class _AddOnRegistry {
 };
 
 // src/registry/add-ons/store.ts
-import path4 from "path";
+import path2 from "path";
 
 // src/core/registry/add-ons/base-addon.ts
 import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
@@ -1028,14 +1054,14 @@ var RedisStoreAddOn = class extends BaseAddOn {
     this.hint = "Recommended";
     this.templates = [
       {
-        template: path4.resolve(
+        template: path2.resolve(
           process.cwd(),
           "templates/add-ons/store/redis.ts.hbs"
         ),
         outputPath: "src/services/redis.ts"
       },
       {
-        template: path4.resolve(
+        template: path2.resolve(
           process.cwd(),
           "templates/add-ons/store/store.ts.hbs"
         ),
@@ -1096,7 +1122,7 @@ var RedisStoreAddOn = class extends BaseAddOn {
 };
 
 // src/registry/add-ons/jobs.ts
-import path5 from "path";
+import path3 from "path";
 var JobsAddOn = class extends BaseAddOn {
   constructor() {
     super(...arguments);
@@ -1106,21 +1132,21 @@ var JobsAddOn = class extends BaseAddOn {
     this.hint = "For background processing";
     this.templates = [
       {
-        template: path5.resolve(
+        template: path3.resolve(
           process.cwd(),
           "templates/add-ons/jobs/jobs.ts.hbs"
         ),
         outputPath: "src/services/jobs.ts"
       },
       {
-        template: path5.resolve(
+        template: path3.resolve(
           process.cwd(),
           "templates/add-ons/jobs/redis.ts.hbs"
         ),
         outputPath: "src/services/redis.ts"
       },
       {
-        template: path5.resolve(
+        template: path3.resolve(
           process.cwd(),
           "templates/add-ons/jobs/store.ts.hbs"
         ),
@@ -1196,7 +1222,7 @@ var JobsAddOn = class extends BaseAddOn {
 };
 
 // src/registry/add-ons/mcp.ts
-import path6 from "path";
+import path4 from "path";
 var McpServerAddOn = class extends BaseAddOn {
   constructor() {
     super(...arguments);
@@ -1206,7 +1232,7 @@ var McpServerAddOn = class extends BaseAddOn {
     this.hint = "For AI integration";
     this.templates = [
       {
-        template: path6.resolve(
+        template: path4.resolve(
           process.cwd(),
           "templates/add-ons/mcp/mcp.ts.hbs"
         ),
@@ -1215,11 +1241,11 @@ var McpServerAddOn = class extends BaseAddOn {
       {
         template: (data) => {
           const templates = {
-            nextjs: path6.resolve(
+            nextjs: path4.resolve(
               process.cwd(),
               "templates/add-ons/mcp/nextjs/route-handler.hbs"
             ),
-            "tanstack-start": path6.resolve(
+            "tanstack-start": path4.resolve(
               process.cwd(),
               "templates/add-ons/mcp/tanstack-start/route-handler.hbs"
             )
@@ -1299,7 +1325,7 @@ var McpServerAddOn = class extends BaseAddOn {
 };
 
 // src/registry/add-ons/logging.ts
-import path7 from "path";
+import path5 from "path";
 var LoggingAddOn = class extends BaseAddOn {
   constructor() {
     super(...arguments);
@@ -1309,7 +1335,7 @@ var LoggingAddOn = class extends BaseAddOn {
     this.hint = "For better observability";
     this.templates = [
       {
-        template: path7.resolve(
+        template: path5.resolve(
           process.cwd(),
           "templates/add-ons/logging/logger.ts.hbs"
         ),
@@ -1335,7 +1361,7 @@ var LoggingAddOn = class extends BaseAddOn {
 };
 
 // src/registry/add-ons/telemetry.ts
-import path8 from "path";
+import path6 from "path";
 var TelemetryAddOn = class extends BaseAddOn {
   constructor() {
     super(...arguments);
@@ -1346,7 +1372,7 @@ var TelemetryAddOn = class extends BaseAddOn {
     this.dockerServices = [];
     this.templates = [
       {
-        template: path8.resolve(
+        template: path6.resolve(
           process.cwd(),
           "templates/add-ons/telemetry/telemetry.ts.hbs"
         ),
@@ -1386,7 +1412,7 @@ var TelemetryAddOn = class extends BaseAddOn {
 };
 
 // src/registry/add-ons/bots.ts
-import path9 from "path";
+import path7 from "path";
 var BotsAddOn = class extends BaseAddOn {
   constructor() {
     super(...arguments);
@@ -1396,7 +1422,7 @@ var BotsAddOn = class extends BaseAddOn {
     this.hint = "For multi-platform chatbot support";
     this.templates = [
       {
-        template: path9.resolve(
+        template: path7.resolve(
           process.cwd(),
           "templates/add-ons/bots/sample-bot.hbs"
         ),
@@ -1405,11 +1431,11 @@ var BotsAddOn = class extends BaseAddOn {
       {
         template: (data) => {
           const templates = {
-            nextjs: path9.resolve(
+            nextjs: path7.resolve(
               process.cwd(),
               "templates/add-ons/bots/nextjs/route-handler.hbs"
             ),
-            "tanstack-start": path9.resolve(
+            "tanstack-start": path7.resolve(
               process.cwd(),
               "templates/add-ons/bots/tanstack-start/route-handler.hbs"
             )
@@ -1453,7 +1479,7 @@ var BotsAddOn = class extends BaseAddOn {
 };
 
 // src/registry/add-ons/database.ts
-import path10 from "path";
+import path8 from "path";
 var DatabaseAddOn = class extends BaseAddOn {
   constructor() {
     super(...arguments);
@@ -1491,21 +1517,21 @@ var DatabaseAddOn = class extends BaseAddOn {
             ],
             templates: [
               {
-                template: path10.resolve(
+                template: path8.resolve(
                   process.cwd(),
                   "templates/add-ons/database/prisma/lib.hbs"
                 ),
                 outputPath: "src/lib/database.ts"
               },
               {
-                template: path10.resolve(
+                template: path8.resolve(
                   process.cwd(),
                   "templates/add-ons/database/prisma/prisma.config.hbs"
                 ),
                 outputPath: "prisma.config.ts"
               },
               {
-                template: path10.resolve(
+                template: path8.resolve(
                   process.cwd(),
                   "templates/add-ons/database/prisma/schema.hbs"
                 ),
@@ -1519,7 +1545,7 @@ var DatabaseAddOn = class extends BaseAddOn {
             hint: "Lightweight, modern, SQL-like",
             templates: [
               {
-                template: path10.resolve(
+                template: path8.resolve(
                   process.cwd(),
                   "templates/add-ons/database/drizzle/lib.hbs"
                 ),
@@ -1838,9 +1864,9 @@ var addOnRegistry = AddOnRegistry.create().register(new RedisStoreAddOn()).regis
 
 // src/core/file-system.ts
 import * as fs2 from "fs/promises";
-async function isPathEmpty(path25) {
+async function isPathEmpty(path23) {
   try {
-    const files = await fs2.readdir(path25);
+    const files = await fs2.readdir(path23);
     return files.length === 0;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -1851,13 +1877,13 @@ async function isPathEmpty(path25) {
 }
 
 // src/core/framework.ts
-import path11 from "path";
+import path9 from "path";
 import fs3 from "fs";
 function detectFramework(projectDir) {
-  if (fs3.existsSync(path11.join(projectDir, "next.config.js")) || fs3.existsSync(path11.join(projectDir, "next.config.ts"))) {
+  if (fs3.existsSync(path9.join(projectDir, "next.config.js")) || fs3.existsSync(path9.join(projectDir, "next.config.ts"))) {
     return "nextjs";
   }
-  const packageJson = JSON.parse(fs3.readFileSync(path11.join(projectDir, "package.json"), "utf8"));
+  const packageJson = JSON.parse(fs3.readFileSync(path9.join(projectDir, "package.json"), "utf8"));
   if (packageJson.dependencies["@tanstack/react-start"]) {
     return "tanstack-start";
   } else {
@@ -1916,7 +1942,7 @@ async function runInitPrompts(options) {
       },
       projectName: async ({ results }) => {
         if (options.projectName) return options.projectName;
-        if (results.useCurrentDir) return path12.basename(process.cwd());
+        if (results.useCurrentDir) return path10.basename(process.cwd());
         const projectName = await p2.text({
           message: "What will your project be called?",
           validate: (value) => {
@@ -1931,7 +1957,7 @@ async function runInitPrompts(options) {
       },
       mode: async ({ results }) => {
         const projectName = results.projectName;
-        const targetDir = path12.resolve(projectName);
+        const targetDir = path10.resolve(projectName);
         const isEmpty = await isPathEmpty(targetDir);
         if (!isEmpty) {
           return await p2.select({
@@ -1946,7 +1972,7 @@ async function runInitPrompts(options) {
       },
       starter: async ({ results }) => {
         if (results.mode !== "new-project") {
-          const targetDir = path12.resolve(results.projectName);
+          const targetDir = path10.resolve(results.projectName);
           const framework = detectFramework(targetDir);
           if (framework === "nextjs") {
             return "nextjs";
@@ -2174,9 +2200,9 @@ var ProjectGenerator = class {
         `Checking and stopping currently running containers...`
       );
       const fs9 = await import("fs/promises");
-      const path25 = await import("path");
+      const path23 = await import("path");
       const yaml2 = await import("js-yaml");
-      const composeFilePath = path25.join(this.targetDir, "docker-compose.yml");
+      const composeFilePath = path23.join(this.targetDir, "docker-compose.yml");
       let ports = [];
       try {
         const composeContent = await fs9.readFile(composeFilePath, "utf8");
@@ -2260,7 +2286,7 @@ async function handleInitAction(projectName, options) {
       git: options.git,
       install: options.install
     });
-    const targetDir = path13.resolve(config.projectName);
+    const targetDir = path11.resolve(config.projectName);
     const generator = new ProjectGenerator(config, targetDir);
     await generator.generate();
     p5.log.success("Project initialized successfully!");
@@ -2293,7 +2319,7 @@ import { Command as Command8 } from "commander";
 import { Command as Command2 } from "commander";
 
 // src/commands/generate/feature/action.ts
-import * as path17 from "path";
+import * as path15 from "path";
 import * as p7 from "@clack/prompts";
 import { existsSync as existsSync4 } from "fs";
 import { writeFile as writeFile5 } from "fs/promises";
@@ -2301,11 +2327,11 @@ import { writeFile as writeFile5 } from "fs/promises";
 // src/core/template-engine.ts
 import { mkdirSync, existsSync as existsSync3 } from "fs";
 import { readFile as readFile3, writeFile as writeFile3 } from "fs/promises";
-import * as path14 from "path";
+import * as path12 from "path";
 import handlebars4 from "handlebars";
-import { fileURLToPath } from "url";
-var __filename = fileURLToPath(import.meta?.url);
-var __dirname = path14.dirname(__filename);
+import { fileURLToPath as fileURLToPath2 } from "url";
+var __filename2 = fileURLToPath2(import.meta?.url);
+var __dirname2 = path12.dirname(__filename2);
 var TemplateEngine = class {
   constructor() {
   }
@@ -2323,7 +2349,7 @@ var _DefaultTemplateEngine = class _DefaultTemplateEngine extends TemplateEngine
     this.templateRoot = this.resolveTemplateRoot();
   }
   resolvePath(...segments) {
-    return path14.join(this.templateRoot, ...segments);
+    return path12.join(this.templateRoot, ...segments);
   }
   async render(templatePath, context) {
     this.ensureHelpersRegistered();
@@ -2333,7 +2359,7 @@ var _DefaultTemplateEngine = class _DefaultTemplateEngine extends TemplateEngine
   }
   async renderToFile(templatePath, context, outputPath) {
     const rendered = await this.render(templatePath, context);
-    const outputDir = path14.dirname(outputPath);
+    const outputDir = path12.dirname(outputPath);
     if (!existsSync3(outputDir)) {
       mkdirSync(outputDir, { recursive: true });
     }
@@ -2363,24 +2389,24 @@ var _DefaultTemplateEngine = class _DefaultTemplateEngine extends TemplateEngine
   }
 };
 _DefaultTemplateEngine.TEMPLATE_CANDIDATES = [
-  path14.resolve(__dirname, "..", "..", "templates"),
-  path14.resolve(__dirname, "..", "..", "..", "templates"),
-  path14.resolve(__dirname, "..", "templates"),
-  path14.resolve(__dirname, "..", "..", "..", "templates"),
-  path14.resolve(
+  path12.resolve(__dirname2, "..", "..", "templates"),
+  path12.resolve(__dirname2, "..", "..", "..", "templates"),
+  path12.resolve(__dirname2, "..", "templates"),
+  path12.resolve(__dirname2, "..", "..", "..", "templates"),
+  path12.resolve(
     process.cwd(),
     "node_modules",
     "@igniter-js",
     "new-cli",
     "templates"
   ),
-  path14.resolve(process.cwd(), "templates")
+  path12.resolve(process.cwd(), "templates")
 ];
 var DefaultTemplateEngine = _DefaultTemplateEngine;
 
 // src/commands/generate/feature/feature.ts
 import { mkdir as mkdir2, readdir as readdir3, stat as stat2, writeFile as writeFile4 } from "fs/promises";
-import * as path15 from "path";
+import * as path13 from "path";
 var FeatureWorkspace = class {
   constructor() {
   }
@@ -2388,30 +2414,30 @@ var FeatureWorkspace = class {
    * Returns the absolute path to the feature root directory.
    */
   static root() {
-    return path15.join(process.cwd(), "src", "features");
+    return path13.join(process.cwd(), "src", "features");
   }
   /**
    * Returns the absolute path for a specific feature name.
    */
   static featureDir(featureName) {
-    return path15.join(this.root(), featureName);
+    return path13.join(this.root(), featureName);
   }
   /**
    * Ensures that the directory structure required for a feature exists.
    */
   static async ensureStructure(featureDir) {
     await mkdir2(featureDir, { recursive: true });
-    await mkdir2(path15.join(featureDir, "controllers"), { recursive: true });
-    await mkdir2(path15.join(featureDir, "procedures"), { recursive: true });
-    await mkdir2(path15.join(featureDir, "presentation"), { recursive: true });
-    await mkdir2(path15.join(featureDir, "presentation", "components"), { recursive: true });
-    await writeFile4(path15.join(featureDir, "presentation", "components", ".gitkeep"), "");
-    await mkdir2(path15.join(featureDir, "presentation", "hooks"), { recursive: true });
-    await writeFile4(path15.join(featureDir, "presentation", "hooks", ".gitkeep"), "");
-    await mkdir2(path15.join(featureDir, "presentation", "contexts"), { recursive: true });
-    await writeFile4(path15.join(featureDir, "presentation", "contexts", ".gitkeep"), "");
-    await mkdir2(path15.join(featureDir, "presentation", "utils"), { recursive: true });
-    await writeFile4(path15.join(featureDir, "presentation", "utils", ".gitkeep"), "");
+    await mkdir2(path13.join(featureDir, "controllers"), { recursive: true });
+    await mkdir2(path13.join(featureDir, "procedures"), { recursive: true });
+    await mkdir2(path13.join(featureDir, "presentation"), { recursive: true });
+    await mkdir2(path13.join(featureDir, "presentation", "components"), { recursive: true });
+    await writeFile4(path13.join(featureDir, "presentation", "components", ".gitkeep"), "");
+    await mkdir2(path13.join(featureDir, "presentation", "hooks"), { recursive: true });
+    await writeFile4(path13.join(featureDir, "presentation", "hooks", ".gitkeep"), "");
+    await mkdir2(path13.join(featureDir, "presentation", "contexts"), { recursive: true });
+    await writeFile4(path13.join(featureDir, "presentation", "contexts", ".gitkeep"), "");
+    await mkdir2(path13.join(featureDir, "presentation", "utils"), { recursive: true });
+    await writeFile4(path13.join(featureDir, "presentation", "utils", ".gitkeep"), "");
   }
   /**
    * Lists all available feature directories under `src/features`.
@@ -2570,7 +2596,7 @@ var SchemaProviderRegistryBuilder = class {
 // src/registry/schema-provider/prisma.ts
 import { getSchema } from "@mrleebo/prisma-ast";
 import * as fs4 from "fs/promises";
-import * as path16 from "path";
+import * as path14 from "path";
 
 // src/core/registry/schema-provider/base-schema-provider.ts
 var SchemaProvider = class {
@@ -2651,7 +2677,7 @@ var PrismaSchemaProvider = class extends SchemaProvider {
     super(...arguments);
     this.id = "prisma";
     this.name = "Prisma";
-    this.defaultSchemaPath = path16.join(process.cwd(), "prisma", "schema.prisma");
+    this.defaultSchemaPath = path14.join(process.cwd(), "prisma", "schema.prisma");
   }
   async validateSchemaPath(schemaPath) {
     try {
@@ -2706,7 +2732,7 @@ var PrismaSchemaProvider = class extends SchemaProvider {
         })),
         createOmitFields: modelFields.filter((field) => field.isId || field.isAutoGenerated || field.hasDefault).map((field) => field.name)
       },
-      path16.join(context.featureDir, `${context.featureName}.interfaces.ts`)
+      path14.join(context.featureDir, `${context.featureName}.interfaces.ts`)
     );
     await context.templateEngine.renderToFile(
       procedureTemplate,
@@ -2718,7 +2744,7 @@ var PrismaSchemaProvider = class extends SchemaProvider {
         featureName: context.featureName,
         idType: this.mapIdType(modelFields)
       },
-      path16.join(context.featureDir, "procedures", `${context.featureName}.procedure.ts`)
+      path14.join(context.featureDir, "procedures", `${context.featureName}.procedure.ts`)
     );
     await context.templateEngine.renderToFile(
       controllerTemplate,
@@ -2732,7 +2758,7 @@ var PrismaSchemaProvider = class extends SchemaProvider {
         featureName: context.featureName,
         procedureExport: target.procedureExport
       },
-      path16.join(context.featureDir, "controllers", `${context.featureName}.controller.ts`)
+      path14.join(context.featureDir, "controllers", `${context.featureName}.controller.ts`)
     );
   }
   extractFields(model) {
@@ -2762,13 +2788,13 @@ var PrismaSchemaProvider = class extends SchemaProvider {
   }
   async ensurePathsAreFree(featureDir, featureSlug) {
     const filesToCheck = [
-      path16.join(featureDir, "controllers", `${featureSlug}.controller.ts`),
-      path16.join(featureDir, "procedures", `${featureSlug}.procedure.ts`),
-      path16.join(featureDir, `${featureSlug}.interfaces.ts`)
+      path14.join(featureDir, "controllers", `${featureSlug}.controller.ts`),
+      path14.join(featureDir, "procedures", `${featureSlug}.procedure.ts`),
+      path14.join(featureDir, `${featureSlug}.interfaces.ts`)
     ];
     for (const file of filesToCheck) {
       if (await FeatureWorkspace.fileExists(file)) {
-        throw new Error(`File '${path16.relative(process.cwd(), file)}' already exists.`);
+        throw new Error(`File '${path14.relative(process.cwd(), file)}' already exists.`);
       }
     }
   }
@@ -2895,7 +2921,7 @@ async function handleGenerateFeatureAction(name, options) {
   const featureDir = FeatureWorkspace.featureDir(featureSlug);
   if (existsSync4(featureDir)) {
     p7.log.error(
-      `Feature '${featureSlug}' already exists at ${path17.relative(process.cwd(), featureDir)}.`
+      `Feature '${featureSlug}' already exists at ${path15.relative(process.cwd(), featureDir)}.`
     );
     p7.outro("Nothing to do.");
     process.exit(1);
@@ -3003,14 +3029,14 @@ async function generateEmptyFeature(featureSlug, featureDir, templateEngine) {
       controllerDisplayName,
       controllerRoute: featureSlug
     },
-    path17.join(featureDir, "controllers", `${featureSlug}.controller.ts`)
+    path15.join(featureDir, "controllers", `${featureSlug}.controller.ts`)
   );
   await templateEngine.renderToFile(
     interfacesTemplate,
     { featureName: Casing.toPascalCase(featureSlug) },
-    path17.join(featureDir, `${featureSlug}.interfaces.ts`)
+    path15.join(featureDir, `${featureSlug}.interfaces.ts`)
   );
-  await writeFile5(path17.join(featureDir, "procedures", ".gitkeep"), "");
+  await writeFile5(path15.join(featureDir, "procedures", ".gitkeep"), "");
 }
 
 // src/commands/generate/feature/index.ts
@@ -3063,13 +3089,13 @@ var OpenAPIGenerator = class _OpenAPIGenerator {
     for (const [controllerKey, controller] of Object.entries(router.controllers)) {
       for (const [actionKey, action] of Object.entries(controller.actions)) {
         const actionName = action.name || actionKey;
-        let path25 = `/${controller.path}/${action.path}`;
-        path25 = path25.replace(/\/{2,}/g, "/");
-        if (path25.length > 1 && path25.endsWith("/")) {
-          path25 = path25.slice(0, -1);
+        let path23 = `/${controller.path}/${action.path}`;
+        path23 = path23.replace(/\/{2,}/g, "/");
+        if (path23.length > 1 && path23.endsWith("/")) {
+          path23 = path23.slice(0, -1);
         }
-        if (!paths[path25]) {
-          paths[path25] = {};
+        if (!paths[path23]) {
+          paths[path23] = {};
         }
         const operation = {
           summary: action.description || actionName,
@@ -3131,7 +3157,7 @@ var OpenAPIGenerator = class _OpenAPIGenerator {
         if (action.isStream) {
           operation.description = (operation.description ? operation.description + "\n\n" : "") + "This endpoint supports Server-Sent Events (SSE) for real-time updates. It functions as a standard GET request initially, then maintains an open connection for streaming data.";
         }
-        paths[path25][action.method.toLowerCase()] = operation;
+        paths[path23][action.method.toLowerCase()] = operation;
       }
     }
     return paths;
@@ -3139,7 +3165,7 @@ var OpenAPIGenerator = class _OpenAPIGenerator {
 };
 
 // src/core/router-instrospector.ts
-import * as path18 from "path";
+import * as path16 from "path";
 import { build } from "esbuild";
 import zodToJsonSchema from "zod-to-json-schema";
 import { createRequire } from "module";
@@ -3165,7 +3191,7 @@ var RouterInstrospector = class _RouterInstrospector {
    * @throws RouterLoadError if loading or compiling fails.
    */
   async loadRouter(routerPath) {
-    const fullPath = path18.resolve(process.cwd(), routerPath);
+    const fullPath = path16.resolve(process.cwd(), routerPath);
     try {
       const result = await build({
         entryPoints: [fullPath],
@@ -3204,7 +3230,7 @@ var RouterInstrospector = class _RouterInstrospector {
         }
       };
       const factory = new Function("exports", "require", "module", "__filename", "__dirname", compiledCode);
-      factory(routerModule.exports, requireFunc, routerModule, fullPath, path18.dirname(fullPath));
+      factory(routerModule.exports, requireFunc, routerModule, fullPath, path16.dirname(fullPath));
       const moduleExports = routerModule.exports;
       const router = moduleExports.AppRouter || moduleExports.default || moduleExports;
       if (router && typeof router.controllers === "object") {
@@ -3275,14 +3301,14 @@ ${errorMessages}`;
 // src/commands/generate/docs/action.ts
 import * as p9 from "@clack/prompts";
 import * as fs5 from "fs";
-import * as path19 from "path";
+import * as path17 from "path";
 async function generateDocsWatchMode(routerPath, outputDir) {
   const startTime = Date.now();
-  const outputDirFull = path19.resolve(outputDir);
+  const outputDirFull = path17.resolve(outputDir);
   if (!fs5.existsSync(outputDirFull)) {
     fs5.mkdirSync(outputDirFull, { recursive: true });
   }
-  const outputPath = path19.join(outputDirFull, "openapi.json");
+  const outputPath = path17.join(outputDirFull, "openapi.json");
   if (!fs5.existsSync(outputPath)) {
     fs5.writeFileSync(outputPath, "{}", "utf8");
   }
@@ -3330,7 +3356,7 @@ import { Command as Command4 } from "commander";
 
 // src/commands/generate/schema/action.ts
 import * as fs6 from "fs";
-import * as path20 from "path";
+import * as path18 from "path";
 import * as p10 from "@clack/prompts";
 async function generateSchemaWatchMode(routerPath, outputPath) {
   const startTime = Date.now();
@@ -3343,7 +3369,7 @@ async function generateSchemaWatchMode(routerPath, outputPath) {
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     schemaString: JSON.stringify(schema, null, 2)
   });
-  const outputFullPath = path20.resolve(process.cwd(), outputPath);
+  const outputFullPath = path18.resolve(process.cwd(), outputPath);
   fs6.writeFileSync(outputFullPath, schemaContent, "utf8");
   return {
     durationMs: Date.now() - startTime,
@@ -3377,7 +3403,7 @@ var schemaCommand = new Command4().command("schema").description("Generate clien
 import { Command as Command5 } from "commander";
 
 // src/commands/generate/controller/action.ts
-import * as path21 from "path";
+import * as path19 from "path";
 import * as p11 from "@clack/prompts";
 
 // src/utils/try-catch.ts
@@ -3415,14 +3441,14 @@ async function handleGenerateControllerAction(name, options) {
   const featureSlug = Casing.toKebabCase(selectedFeature.data);
   const featureDir = FeatureWorkspace.featureDir(featureSlug);
   await FeatureWorkspace.ensureStructure(featureDir);
-  const controllerPath = path21.join(
+  const controllerPath = path19.join(
     featureDir,
     "controllers",
     `${controllerSlug}.controller.ts`
   );
   if (await FeatureWorkspace.fileExists(controllerPath)) {
     p11.log.error(
-      `Controller '${controllerSlug}' already exists at ${path21.relative(process.cwd(), controllerPath)}.`
+      `Controller '${controllerSlug}' already exists at ${path19.relative(process.cwd(), controllerPath)}.`
     );
     process.exit(1);
   }
@@ -3466,7 +3492,7 @@ var controllerCommand = new Command5().command("controller").description("Scaffo
 import { Command as Command6 } from "commander";
 
 // src/commands/generate/procedure/action.ts
-import * as path22 from "path";
+import * as path20 from "path";
 import * as p12 from "@clack/prompts";
 import { rm as rm2 } from "fs/promises";
 async function handleGenerateProcedureAction(name, options) {
@@ -3493,14 +3519,14 @@ async function handleGenerateProcedureAction(name, options) {
   const featureSlug = Casing.toKebabCase(selectedFeature.data);
   const featureDir = FeatureWorkspace.featureDir(featureSlug);
   await FeatureWorkspace.ensureStructure(featureDir);
-  const procedurePath = path22.join(
+  const procedurePath = path20.join(
     featureDir,
     "procedures",
     `${procedureSlug}.procedure.ts`
   );
   if (await FeatureWorkspace.fileExists(procedurePath)) {
     p12.log.error(
-      `Procedure '${procedureSlug}' already exists at ${path22.relative(process.cwd(), procedurePath)}.`
+      `Procedure '${procedureSlug}' already exists at ${path20.relative(process.cwd(), procedurePath)}.`
     );
     process.exit(1);
   }
@@ -3514,8 +3540,8 @@ async function handleGenerateProcedureAction(name, options) {
   spinner8.start(
     `Creating procedure '${procedureSlug}' inside feature '${featureSlug}'...`
   );
-  if (await FeatureWorkspace.fileExists(path22.join(featureDir, "procedures", ".gitkeep"))) {
-    await rm2(path22.join(featureDir, "procedures", ".gitkeep"));
+  if (await FeatureWorkspace.fileExists(path20.join(featureDir, "procedures", ".gitkeep"))) {
+    await rm2(path20.join(featureDir, "procedures", ".gitkeep"));
   }
   try {
     await templateEngine.renderToFile(
@@ -3548,11 +3574,11 @@ import { Command as Command7 } from "commander";
 
 // src/commands/generate/caller/action.ts
 import { promises as fs7 } from "fs";
-import path23 from "path";
+import path21 from "path";
 import * as p13 from "@clack/prompts";
 import yaml from "js-yaml";
 import SwaggerParser from "@apidevtools/swagger-parser";
-var SUPPORTED_METHODS = ["get", "post", "put", "patch", "delete"];
+var SUPPORTED_METHODS = ["get", "post", "put", "patch", "delete", "head"];
 async function handleGenerateCallerAction(options) {
   p13.intro("Generate Igniter Caller");
   try {
@@ -3562,32 +3588,34 @@ async function handleGenerateCallerAction(options) {
     spinner8.start("Loading OpenAPI spec...");
     const parsedDoc = await loadOpenApiDocument(source);
     const host = deriveHostname(source, parsedDoc) || "api";
-    const outputDir = path23.resolve(
+    const outputDir = path21.resolve(
       process.cwd(),
-      options.output ?? path23.join("src", "callers", host)
+      options.output ?? path21.join("src", "callers", host)
     );
     const prefix = Casing.toPascalCase(callerName);
     const converter = new SchemaConverter(prefix, parsedDoc.components);
-    const pathsCode = buildSchemasObject(parsedDoc, converter);
     const componentsCode = converter.renderComponentSchemas();
-    const schemaConstName = `${prefix}Schema`;
-    const schemaTypeName = `${prefix}SchemaType`;
+    const schemaConstName = `${Casing.toCamelCase(callerName)}CallerSchemas`;
+    const schemaTypeName = `${prefix}CallerSchemas`;
+    const { builderCode, typeAliases } = buildSchemaBuilder(
+      parsedDoc,
+      converter,
+      schemaConstName
+    );
     const schemaFileContents = [
       "/* eslint-disable */",
       "/* prettier-ignore */",
-      "",
       "/**",
       " * @generated by @igniter-js/cli",
       " * This file was automatically created from your OpenAPI spec.",
       " * Do not edit manually; regenerate via `igniter generate caller`.",
       " */",
-      "",
       'import { z } from "zod";',
+      'import { IgniterCallerSchema } from "@igniter-js/caller";',
       componentsCode,
-      `const schemas = ${pathsCode};`,
-      "",
-      `export const ${schemaConstName} = schemas;`,
+      builderCode,
       `export type ${schemaTypeName} = typeof ${schemaConstName};`,
+      typeAliases,
       ""
     ].filter(Boolean).join("\n");
     const baseUrl = inferBaseUrl(source, parsedDoc);
@@ -3607,15 +3635,13 @@ async function handleGenerateCallerAction(options) {
       ""
     ].filter(Boolean).join("\n");
     await fs7.mkdir(outputDir, { recursive: true });
-    await fs7.writeFile(path23.join(outputDir, "schema.ts"), schemaFileContents, "utf8");
-    await fs7.writeFile(path23.join(outputDir, "index.ts"), callerFileContents, "utf8");
+    await fs7.writeFile(path21.join(outputDir, "schema.ts"), schemaFileContents, "utf8");
+    await fs7.writeFile(path21.join(outputDir, "index.ts"), callerFileContents, "utf8");
     spinner8.stop("Caller generated successfully.");
     p13.log.success(
-      `Schemas and caller created at ${path23.relative(process.cwd(), outputDir)}`
-    );
-    p13.log.info(
-      `Exported caller: ${callerVar} (schemas: ${schemaConstName})`
+      `Schemas and caller created at ${path21.relative(process.cwd(), outputDir)}`
     );
+    p13.log.info(`Exported caller: ${callerVar} (schemas: ${schemaConstName})`);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     p13.log.error(message);
@@ -3684,13 +3710,12 @@ async function resolveSource(options) {
 async function loadOpenApiDocument(source) {
   const raw = await loadRawContent(source);
   const parsed = parseOpenApi(raw);
-  if (!parsed.openapi || !parsed.openapi.startsWith("3.")) {
+  const version = parsed.openapi ?? "";
+  if (typeof version !== "string" || !version.startsWith("3.")) {
     throw new Error("Only OpenAPI 3.x documents are supported.");
   }
-  const dereferenced = await SwaggerParser.dereference(
-    parsed
-  );
-  return dereferenced;
+  const bundled = await SwaggerParser.bundle(parsed);
+  return bundled;
 }
 async function loadRawContent(source) {
   if (source.type === "url") {
@@ -3702,7 +3727,7 @@ async function loadRawContent(source) {
     }
     return await response.text();
   }
-  const filePath = path23.resolve(process.cwd(), source.path);
+  const filePath = path21.resolve(process.cwd(), source.path);
   return await fs7.readFile(filePath, "utf8");
 }
 function parseOpenApi(content) {
@@ -3756,15 +3781,34 @@ var SchemaConverter = class {
   }
   renderComponentSchemas() {
     const entries = [];
-    const names = Object.keys(this.components?.schemas ?? {}).sort();
+    const names = this.listComponents();
     for (const name of names) {
       const identifier = this.componentIdentifier(name);
       const expression = this.convertWithCache(name);
-      entries.push(`const ${identifier} = ${expression};`);
+      const registryKey = this.registryKey(name);
+      entries.push(
+        [
+          "/**",
+          ` * Schema: ${registryKey}`,
+          ` * Source: openapi#/components/schemas/${name}`,
+          " */",
+          `const ${identifier} = ${expression};`,
+          ""
+        ].join("\n")
+      );
     }
     return entries.length ? `${entries.join("\n")}
 ` : "";
   }
+  listComponents() {
+    return Object.keys(this.components?.schemas ?? {}).sort();
+  }
+  registryKey(name) {
+    return Casing.toPascalCase(name);
+  }
+  componentName(name) {
+    return this.componentIdentifier(name);
+  }
   convert(schema) {
     if ("$ref" in schema) {
       const refName = this.refName(schema.$ref);
@@ -3772,13 +3816,15 @@ var SchemaConverter = class {
       this.convertWithCache(refName);
       return this.wrapLazyIfNeeded(refName, identifier);
     }
+    const schemaType = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+    const nullable = isNullable(schema);
     if (schema.oneOf?.length) {
       const parts = schema.oneOf.map((item) => this.convert(item));
-      return `z.union([${parts.join(", ")}])${schema.nullable ? ".nullable()" : ""}`;
+      return wrapNullable(`z.union([${parts.join(", ")}])`, nullable);
     }
     if (schema.anyOf?.length) {
       const parts = schema.anyOf.map((item) => this.convert(item));
-      return `z.union([${parts.join(", ")}])${schema.nullable ? ".nullable()" : ""}`;
+      return wrapNullable(`z.union([${parts.join(", ")}])`, nullable);
     }
     if (schema.allOf?.length) {
       const [first, ...rest] = schema.allOf;
@@ -3786,31 +3832,29 @@ var SchemaConverter = class {
       for (const part of rest) {
         expr = `z.intersection(${expr}, ${this.convert(part)})`;
       }
-      return schema.nullable ? `${expr}.nullable()` : expr;
+      return wrapNullable(expr, nullable);
     }
-    switch (schema.type) {
+    switch (schemaType) {
       case "string":
         if (schema.enum) {
           const values = schema.enum.map((v) => JSON.stringify(String(v)));
-          return `z.enum([${values.join(", ")}])${schema.nullable ? ".nullable()" : ""}`;
+          return wrapNullable(`z.enum([${values.join(", ")}])`, nullable);
         }
-        return `z.string()${schema.nullable ? ".nullable()" : ""}`;
+        return wrapNullable("z.string()", nullable);
       case "number":
       case "integer": {
         let expr = "z.number()";
-        if (schema.type === "integer") {
+        if (schemaType === "integer") {
           expr = `${expr}.int()`;
         }
-        if (schema.nullable) {
-          expr = `${expr}.nullable()`;
-        }
-        return expr;
+        return wrapNullable(expr, nullable);
       }
       case "boolean":
-        return `z.boolean()${schema.nullable ? ".nullable()" : ""}`;
+        return wrapNullable("z.boolean()", nullable);
       case "array": {
-        const items = schema.items ? this.convert(schema.items) : "z.unknown()";
-        return `z.array(${items})${schema.nullable ? ".nullable()" : ""}`;
+        const arraySchema = schema;
+        const items = arraySchema.items ? this.convert(arraySchema.items) : "z.unknown()";
+        return wrapNullable(`z.array(${items})`, nullable);
       }
       case "object": {
         const properties = schema.properties ?? {};
@@ -3824,10 +3868,7 @@ var SchemaConverter = class {
           const apValue = schema.additionalProperties === true ? "z.unknown()" : this.convert(schema.additionalProperties);
           base = `${base}.catchall(${apValue})`;
         }
-        if (schema.nullable) {
-          base = `${base}.nullable()`;
-        }
-        return base;
+        return wrapNullable(base, nullable);
       }
       default:
         return "z.unknown()";
@@ -3848,9 +3889,8 @@ var SchemaConverter = class {
     this.inProgress.add(name);
     const expression = this.convert(schema);
     this.inProgress.delete(name);
-    const finalized = expression.startsWith("z.lazy(") ? expression : expression;
-    this.generated.set(name, finalized);
-    return finalized;
+    this.generated.set(name, expression);
+    return expression;
   }
   componentIdentifier(name) {
     return `${this.prefix}${Casing.toPascalCase(name)}Schema`;
@@ -3869,71 +3909,271 @@ var SchemaConverter = class {
     return identifier;
   }
 };
-function buildSchemasObject(doc, converter) {
-  const pathEntries = [];
+function buildSchemaBuilder(doc, converter, schemaConstName) {
+  const usedNames = /* @__PURE__ */ new Map();
+  const operations = [];
+  const pathBlocks = [];
+  let needsVoid = false;
   const sortedPaths = Object.keys(doc.paths || {}).sort();
   for (const rawPath of sortedPaths) {
     const pathItem = doc.paths?.[rawPath];
     if (!pathItem) continue;
-    const methodEntries = [];
+    const methodBlocks = [];
     for (const method of SUPPORTED_METHODS) {
       const operation = pathItem[method];
       if (!operation) continue;
-      const responses = buildResponses(operation.responses, converter);
-      const requestBody = buildRequestBody(operation.requestBody, converter);
-      const segments = [];
-      if (requestBody) {
-        segments.push(`request: ${requestBody}`);
-      }
-      segments.push(`responses: ${responses}`);
-      const methodBlock = [
-        `${method.toUpperCase()}: {`,
-        indentLines(segments.join(",\n"), 2),
-        "}"
-      ].join("\n");
-      methodEntries.push(indentLines(methodBlock, 2));
+      const normalizedPath2 = normalizePath(rawPath);
+      const requestBody = buildRequestBody(
+        operation.requestBody,
+        converter,
+        doc
+      );
+      const responses = buildResponses(operation.responses, converter, doc);
+      const typeBaseName = ensureUniqueTypeName(
+        buildOperationTypeName(rawPath, method, operation.operationId),
+        usedNames
+      );
+      operations.push({
+        path: normalizedPath2,
+        method: method.toUpperCase(),
+        request: Boolean(requestBody),
+        responses: responses.entries,
+        typeName: typeBaseName
+      });
+      const docBlock = buildMethodDocBlock({
+        method: method.toUpperCase(),
+        path: normalizedPath2,
+        summary: operation.summary ?? operation.description,
+        tags: operation.tags,
+        operationId: operation.operationId,
+        requestLabel: requestBody?.label,
+        responses: responses.entries,
+        source: `openapi#/paths/${encodeJsonPointerPath(rawPath)}/${method}`
+      });
+      const methodCall = buildMethodCall(method, {
+        request: requestBody?.expression,
+        responses: responses.code,
+        doc: operation.summary ?? operation.description,
+        tags: operation.tags,
+        operationId: operation.operationId
+      });
+      methodBlocks.push(indent(`${docBlock}
+${methodCall}`, 3));
+      needsVoid = needsVoid || responses.usesVoid;
     }
-    if (!methodEntries.length) continue;
+    if (!methodBlocks.length) continue;
     const normalizedPath = normalizePath(rawPath);
-    const pathBlock = [
-      `${JSON.stringify(normalizedPath)}: {`,
-      methodEntries.join(",\n"),
-      "}"
-    ].join("\n");
-    pathEntries.push(indentLines(pathBlock, 1));
-  }
-  return `{
-${pathEntries.join(",\n")}
-}`;
+    const pathLines = [
+      `  .path(${JSON.stringify(normalizedPath)}, (path) =>`,
+      "    path",
+      methodBlocks.join("\n"),
+      "  )"
+    ];
+    pathBlocks.push(pathLines.join("\n"));
+  }
+  const builderLines = [];
+  builderLines.push(`export const ${schemaConstName} = IgniterCallerSchema.create()`);
+  const componentNames = converter.listComponents();
+  for (const name of componentNames) {
+    const registryKey = converter.registryKey(name);
+    const identifier = converter.componentName(name);
+    builderLines.push(`  .schema(${JSON.stringify(registryKey)}, ${identifier})`);
+  }
+  if (needsVoid) {
+    builderLines.push(`  .schema("Void", z.void(), { internal: true })`);
+  }
+  if (pathBlocks.length) {
+    builderLines.push(pathBlocks.join("\n"));
+  }
+  builderLines.push("  .build()");
+  return {
+    builderCode: `${builderLines.join("\n")}
+`,
+    typeAliases: buildTypeAliases(operations, schemaConstName)
+  };
 }
-function buildResponses(responses, converter) {
-  if (!responses || !Object.keys(responses).length) {
-    return "{ }";
+function buildMethodDocBlock(params) {
+  const lines = [];
+  lines.push("/**");
+  lines.push(` * ${params.method} ${params.path}`);
+  if (params.summary) {
+    lines.push(` * Summary: ${params.summary}`);
+  }
+  if (params.tags?.length) {
+    lines.push(` * Tags: ${params.tags.join(", ")}`);
+  }
+  if (params.operationId) {
+    lines.push(` * OperationId: ${params.operationId}`);
+  }
+  if (params.requestLabel) {
+    lines.push(` * Request: ${params.requestLabel}`);
+  }
+  if (params.responses.length) {
+    lines.push(" * Responses:");
+    for (const response of params.responses) {
+      lines.push(` *  - ${response.status}: ${response.label}`);
+    }
   }
+  lines.push(` * Source: ${params.source}`);
+  lines.push(" */");
+  return lines.join("\n");
+}
+function buildMethodCall(method, params) {
+  const lines = [];
+  lines.push(`.${method}({`);
+  if (params.request) {
+    lines.push(`  request: ${params.request},`);
+  }
+  lines.push("  responses: {");
+  lines.push(params.responses);
+  lines.push("  },");
+  if (params.doc) {
+    lines.push(`  doc: ${JSON.stringify(params.doc)},`);
+  }
+  if (params.tags?.length) {
+    lines.push(`  tags: ${JSON.stringify(params.tags)},`);
+  }
+  if (params.operationId) {
+    lines.push(`  operationId: ${JSON.stringify(params.operationId)},`);
+  }
+  lines.push("})");
+  return lines.join("\n");
+}
+function buildResponses(responses, converter, doc) {
+  const builder = new CodeBuilder();
   const entries = [];
+  let usesVoid = false;
+  if (!responses || !Object.keys(responses).length) {
+    const expression = `path.ref("Void").schema`;
+    builder.line(indent(`200: ${expression},`, 2));
+    entries.push({
+      status: "200",
+      statusLiteral: "200",
+      label: "Void"
+    });
+    return { code: builder.toString(), entries, usesVoid: true };
+  }
   const sorted = Object.keys(responses).sort();
   for (const status of sorted) {
     const responseOrRef = responses[status];
     if (!responseOrRef) continue;
-    const response = "$ref" in responseOrRef ? void 0 : responseOrRef;
-    const schema = resolveSchemaFromResponse(response);
-    const expression = schema ? converter.convert(schema) : "z.unknown()";
-    entries.push(`${status}: ${expression}`);
-  }
-  if (!entries.length) {
-    return "{ }";
+    const resolved = resolveResponse(responseOrRef, doc);
+    const schema = resolveSchemaFromResponse(resolved);
+    const resolvedSchema = resolveSchemaExpression(schema, converter);
+    builder.line(indent(`${formatStatusKey(status)}: ${resolvedSchema.expression},`, 2));
+    entries.push({
+      status: String(status),
+      statusLiteral: formatStatusType(status),
+      label: resolvedSchema.label
+    });
+    usesVoid = usesVoid || resolvedSchema.usesVoid;
   }
-  return `{
-${indentLines(entries.join(",\n"), 2)}
-  }`;
+  return { code: builder.toString(), entries, usesVoid };
 }
-function buildRequestBody(requestBody, converter) {
+function buildRequestBody(requestBody, converter, doc) {
   if (!requestBody) return null;
-  const resolved = "$ref" in requestBody ? null : requestBody;
+  const resolved = "$ref" in requestBody ? resolveRequestBody(requestBody, doc) : requestBody;
   if (!resolved?.content) return null;
   const schema = selectJsonSchema(resolved.content);
   if (!schema) return null;
-  return converter.convert(schema);
+  return resolveSchemaExpression(schema, converter);
+}
+function resolveSchemaExpression(schema, converter) {
+  if (!schema) {
+    return {
+      expression: `path.ref("Void").schema`,
+      label: "Void",
+      usesVoid: true
+    };
+  }
+  const refName = extractSchemaRef(schema);
+  if (refName) {
+    const registryKey = converter.registryKey(refName);
+    const base = `path.ref(${JSON.stringify(registryKey)}).schema`;
+    return {
+      expression: wrapNullable(base, isNullable(schema)),
+      label: registryKey,
+      usesVoid: false
+    };
+  }
+  const arrayRefName = extractArraySchemaRef(schema);
+  if (arrayRefName) {
+    const registryKey = converter.registryKey(arrayRefName);
+    const base = `path.ref(${JSON.stringify(registryKey)}).array()`;
+    return {
+      expression: wrapNullable(base, isNullable(schema)),
+      label: `${registryKey}[]`,
+      usesVoid: false
+    };
+  }
+  return {
+    expression: converter.convert(schema),
+    label: "InlineSchema",
+    usesVoid: false
+  };
+}
+function buildTypeAliases(operations, schemaConstName) {
+  if (!operations.length) return "";
+  const lines = [];
+  lines.push("// Derived types");
+  for (const operation of operations) {
+    const pathLiteral = JSON.stringify(operation.path);
+    const methodLiteral = JSON.stringify(operation.method);
+    if (operation.request) {
+      lines.push(
+        `export type ${operation.typeName}Request = ReturnType<typeof ${schemaConstName}.$Infer.Request<${pathLiteral}, ${methodLiteral}>>;`
+      );
+    }
+    lines.push(
+      `export type ${operation.typeName}Responses = ReturnType<typeof ${schemaConstName}.$Infer.Responses<${pathLiteral}, ${methodLiteral}>>;`
+    );
+    for (const response of operation.responses) {
+      const suffix = formatStatusSuffix(response.status);
+      lines.push(
+        `export type ${operation.typeName}Response${suffix} = ReturnType<typeof ${schemaConstName}.$Infer.Response<${pathLiteral}, ${methodLiteral}, ${response.statusLiteral}>>;`
+      );
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function buildOperationTypeName(rawPath, method, operationId) {
+  if (operationId) {
+    return Casing.toPascalCase(operationId);
+  }
+  const normalizedPath = normalizePath(rawPath);
+  const segments = normalizedPath.split("/").filter(Boolean).map((segment) => segment.startsWith(":") ? `by-${segment.slice(1)}` : segment);
+  return Casing.toPascalCase([...segments, method].join("-"));
+}
+function ensureUniqueTypeName(baseName, used) {
+  const count = used.get(baseName) ?? 0;
+  if (count === 0) {
+    used.set(baseName, 1);
+    return baseName;
+  }
+  const next = `${baseName}${count + 1}`;
+  used.set(baseName, count + 1);
+  return next;
+}
+function encodeJsonPointerPath(pathname) {
+  return pathname.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function extractSchemaRef(schema) {
+  if (!schema || typeof schema !== "object") return null;
+  if (!("$ref" in schema)) return null;
+  return extractComponentSchemaName(schema.$ref);
+}
+function extractArraySchemaRef(schema) {
+  if (!schema || typeof schema !== "object") return null;
+  if (schema.type !== "array") return null;
+  const items = schema.items;
+  if (!items || typeof items !== "object") return null;
+  if (!("$ref" in items)) return null;
+  return extractComponentSchemaName(items.$ref);
+}
+function extractComponentSchemaName(ref) {
+  const match = ref.match(/^#\/components\/schemas\/(.+)$/);
+  return match ? match[1] : null;
 }
 function selectJsonSchema(content) {
   if (content["application/json"]?.schema) {
@@ -3951,10 +4191,61 @@ function resolveSchemaFromResponse(response) {
 function normalizePath(pathname) {
   return pathname.replace(/{(.*?)}/g, ":$1");
 }
-function indentLines(value, depth) {
+function indent(value, depth) {
   const pad = "  ".repeat(depth);
   return value.split("\n").map((line) => line ? pad + line : line).join("\n");
 }
+function isNullable(schema) {
+  if (!schema || typeof schema !== "object") return false;
+  return Boolean(schema.nullable);
+}
+function wrapNullable(expr, nullable) {
+  return nullable ? `${expr}.nullable()` : expr;
+}
+function formatStatusKey(status) {
+  const trimmed = String(status).trim();
+  const numeric = Number(trimmed);
+  if (!Number.isNaN(numeric) && `${numeric}` === trimmed) {
+    return trimmed;
+  }
+  return JSON.stringify(trimmed);
+}
+function formatStatusType(status) {
+  return formatStatusKey(status);
+}
+function formatStatusSuffix(status) {
+  const safe = String(status).replace(/[^a-zA-Z0-9]+/g, "-");
+  const pascal = Casing.toPascalCase(safe);
+  return pascal || "Unknown";
+}
+function resolveResponse(response, doc) {
+  if ("$ref" in response) {
+    return getComponent(doc, response.$ref, "responses");
+  }
+  return response;
+}
+function resolveRequestBody(requestBody, doc) {
+  return getComponent(doc, requestBody.$ref, "requestBodies");
+}
+function getComponent(doc, ref, type) {
+  const match = ref.match(/^#\/components\/([^/]+)\/(.+)$/);
+  if (!match) return void 0;
+  const [, category, name] = match;
+  if (category !== type) return void 0;
+  const component = doc.components?.[type]?.[name];
+  return component;
+}
+var CodeBuilder = class {
+  constructor() {
+    this.lines = [];
+  }
+  line(text4) {
+    this.lines.push(text4);
+  }
+  toString() {
+    return this.lines.join("\n");
+  }
+};
 
 // src/commands/generate/caller/index.ts
 var callerCommand = new Command7().command("caller").description("Generate Igniter Caller schemas from an OpenAPI spec").option("--name <name>", "Name used to prefix generated schemas and caller export").option("--url <url>", "URL to the OpenAPI document").option("--path <path>", "Local path to the OpenAPI document").option(
@@ -3969,7 +4260,7 @@ var generateCommand = new Command8().command("generate").description("Scaffold n
 import { Command as Command9 } from "commander";
 
 // src/commands/dev/action.ts
-import * as path24 from "path";
+import * as path22 from "path";
 import * as fs8 from "fs";
 import { spawn as spawn2 } from "child_process";
 import chokidar from "chokidar";
@@ -4074,7 +4365,7 @@ async function regenerateSchemaAndDocs(routerPath, outputPath, docsOutputDir, ad
 }
 async function handleDevAction(options) {
   const packageManager = detectPackageManager();
-  const routerPath = path24.resolve(process.cwd(), options.router || "src/igniter.router.ts");
+  const routerPath = path22.resolve(process.cwd(), options.router || "src/igniter.router.ts");
   const outputPath = options.output || "src/igniter.schema.ts";
   const docsOutputDir = options.docsOutput || "./src/docs";
   const devCommand2 = options.cmd || getDefaultDevCommand(packageManager);
@@ -4125,7 +4416,7 @@ async function handleDevAction(options) {
     });
     process.exit(1);
   }
-  const featuresDir = path24.join(process.cwd(), "src", "features");
+  const featuresDir = path22.join(process.cwd(), "src", "features");
   const watchPaths = [
     routerPath,
     // Watch router file directly
@@ -4142,7 +4433,7 @@ async function handleDevAction(options) {
   }
   addIgniterLog({
     type: "info",
-    message: `Watching for changes in: ${watchPaths.map((p14) => path24.relative(process.cwd(), p14)).join(", ")}`,
+    message: `Watching for changes in: ${watchPaths.map((p14) => path22.relative(process.cwd(), p14)).join(", ")}`,
     timestamp: /* @__PURE__ */ new Date()
   });
   let regenerateTimeout = null;
@@ -4162,7 +4453,7 @@ async function handleDevAction(options) {
     ignoreInitial: true
   });
   watcher.on("change", (filePath) => {
-    const relativePath = path24.relative(process.cwd(), filePath);
+    const relativePath = path22.relative(process.cwd(), filePath);
     if (regenerateTimeout) {
       clearTimeout(regenerateTimeout);
     }