@rexeus/typeweaver 0.0.2 → 0.0.4

package/dist/{cli-C3cTfNLj.js → cli-Cz6q9I7F.js}

@@ -1,9 +1,12 @@
 import * as path from 'path';
 import path__default, { dirname } from 'path';
+import url, { fileURLToPath, pathToFileURL, URL as URL$1 } from 'url';
+import { Command } from 'commander';
 import fs, { realpathSync, statSync } from 'fs';
-import { HttpResponseDefinition, HttpOperationDefinition, HttpStatusCodeNameMap } from '@rexeus/typeweaver-core';
+import { PluginRegistry, PluginContextBuilder } from '@rexeus/typeweaver-gen';
+import TypesPlugin from '@rexeus/typeweaver-types';
+import { render } from 'ejs';
 import { createRequire, builtinModules } from 'module';
-import url, { fileURLToPath, pathToFileURL, URL as URL$1 } from 'url';
 import process3 from 'process';
 import os from 'os';
 import tty from 'tty';
@@ -11,202 +14,140 @@ import fs$1 from 'fs/promises';
 import assert2 from 'assert';
 import v8 from 'v8';
 import { format, inspect } from 'util';
-import { PluginRegistry, PluginContextBuilder } from '@rexeus/typeweaver-gen';
-import TypesPlugin from '@rexeus/typeweaver-types';
-import { Command } from 'commander';
+import { HttpMethod, HttpStatusCode, HttpResponseDefinition, HttpOperationDefinition, HttpStatusCodeNameMap } from '@rexeus/typeweaver-core';
+import { z } from 'zod/v4';
 
-class InvalidSharedDirError extends Error {
-  constructor(explanation) {
-    super("Invalid shared dir");
-    this.explanation = explanation;
+var version = "0.0.4";
+var packageJson = {
+	version: version};
+
+class IndexFileGenerator {
+  constructor(templateDir) {
+    this.templateDir = templateDir;
+  }
+  generate(context) {
+    const templateFilePath = path__default.join(this.templateDir, "Index.ejs");
+    const template = fs.readFileSync(templateFilePath, "utf8");
+    const indexPaths = /* @__PURE__ */ new Set();
+    for (const generatedFile of context.getGeneratedFiles()) {
+      indexPaths.add(`./${generatedFile.replace(/\.ts$/, "")}`);
+    }
+    const content = render(template, {
+      indexPaths: Array.from(indexPaths).sort()
+    });
+    fs.writeFileSync(path__default.join(context.outputDir, "index.ts"), content);
   }
 }
 
-class InvalidSharedResponseDefinitionError extends Error {
-  constructor(fileName, dir, file, explanation) {
-    super("Invalid shared response definition");
-    this.fileName = fileName;
-    this.dir = dir;
-    this.file = file;
-    this.explanation = explanation;
+class PluginLoadingFailure extends Error {
+  constructor(pluginName, attempts) {
+    super(`Failed to load plugin '${pluginName}'`);
+    this.pluginName = pluginName;
+    this.attempts = attempts;
+    Object.setPrototypeOf(this, PluginLoadingFailure.prototype);
   }
 }
 
-class ResourceReader {
-  constructor(config) {
-    this.config = config;
+class PluginLoader {
+  constructor(registry, requiredPlugins, strategies = ["npm", "local"]) {
+    this.registry = registry;
+    this.requiredPlugins = requiredPlugins;
+    this.strategies = strategies;
   }
-  async getResources() {
-    const contents = fs.readdirSync(this.config.sourceDir, {
-      withFileTypes: true
-    });
-    const result = {
-      entityResources: {},
-      sharedResponseResources: []
-    };
-    const sharedDefinitions = contents.find(
-      (content) => content.name === "shared"
-    );
-    if (sharedDefinitions) {
-      if (!sharedDefinitions.isDirectory()) {
-        throw new InvalidSharedDirError("'shared' is a file, not a directory");
-      }
-      result.sharedResponseResources = await this.getSharedResponseResources();
-      console.info(
-        `Found '${result.sharedResponseResources.length}' shared responses`
-      );
-    } else {
-      console.info("No 'shared' directory found");
+  /**
+   * Load all plugins from configuration
+   */
+  async loadPlugins(config) {
+    for (const requiredPlugin of this.requiredPlugins) {
+      this.registry.register(requiredPlugin);
     }
-    for (const content of contents) {
-      if (!content.isDirectory()) {
-        console.info(`Skipping '${content.name}' as it is not a directory`);
-        continue;
-      }
-      if (content.name === "shared") {
-        continue;
-      }
-      const entityName = content.name;
-      const entitySourceDir = path__default.join(this.config.sourceDir, entityName);
-      const operationResources = await this.getEntityOperationResources(
-        entitySourceDir,
-        entityName
-      );
-      result.entityResources[entityName] = operationResources;
-      console.info(
-        `Found '${operationResources.length}' operation definitions for entity '${entityName}'`
-      );
+    if (!config?.plugins) {
+      return;
     }
-    return result;
-  }
-  async getSharedResponseResources() {
-    const sharedContents = fs.readdirSync(this.config.sharedSourceDir, {
-      withFileTypes: true
-    });
-    const sharedResponseResources = [];
-    for (const content of sharedContents) {
-      if (!content.isFile()) {
-        console.info(`Skipping '${content.name}' as it is not a file`);
-        continue;
-      }
-      const sourceFileName = content.name;
-      const sourceFile = path__default.join(this.config.sharedSourceDir, sourceFileName);
-      const definition = await import(sourceFile);
-      if (!definition.default) {
-        console.info(
-          `Skipping '${sourceFile}' as it does not have a default export`
-        );
-        continue;
-      }
-      if (!(definition.default instanceof HttpResponseDefinition)) {
-        console.info(
-          `Skipping '${sourceFile}' as it is not an instance of HttpResponseDefinition`
-        );
-        continue;
+    const successful = [];
+    for (const plugin of config.plugins) {
+      let result;
+      if (typeof plugin === "string") {
+        result = await this.loadPlugin(plugin);
+      } else {
+        result = await this.loadPlugin(plugin[0]);
       }
-      if (!definition.default.isShared) {
-        throw new InvalidSharedResponseDefinitionError(
-          sourceFileName,
-          this.config.sharedSourceDir,
-          sourceFile,
-          "'isShared' property is not set to 'true'"
+      if (result.success === false) {
+        throw new PluginLoadingFailure(
+          result.error.pluginName,
+          result.error.attempts
         );
       }
-      const outputDir = this.config.sharedOutputDir;
-      const outputFileName = `${definition.default.name}Response.ts`;
-      const outputFile = path__default.join(outputDir, outputFileName);
-      sharedResponseResources.push({
-        ...definition.default,
-        isShared: true,
-        sourceDir: this.config.sharedSourceDir,
-        sourceFile,
-        sourceFileName,
-        outputFile,
-        outputFileName,
-        outputDir
-      });
+      successful.push(result.value);
+      this.registry.register(result.value.plugin);
     }
-    return sharedResponseResources;
+    this.reportSuccessfulLoads(successful);
   }
-  async getEntityOperationResources(sourceDir, entityName) {
-    const contents = fs.readdirSync(sourceDir, {
-      withFileTypes: true
-    });
-    const definitions = [];
-    for (const content of contents) {
-      if (!content.isFile()) {
-        console.info(`Skipping '${content.name}' as it is not a file`);
-        continue;
-      }
-      const sourceFileName = content.name;
-      const sourceFile = path__default.join(sourceDir, sourceFileName);
-      const definition = await import(sourceFile);
-      if (!definition.default) {
-        console.info(
-          `Skipping '${sourceFile}' as it does not have a default export`
-        );
-        continue;
+  /**
+   * Load a plugin from a string identifier
+   */
+  async loadPlugin(pluginName) {
+    const possiblePaths = this.generatePluginPaths(pluginName);
+    const attempts = [];
+    for (const possiblePath of possiblePaths) {
+      try {
+        const pluginPackage = await import(possiblePath);
+        if (pluginPackage.default) {
+          return {
+            success: true,
+            value: {
+              plugin: new pluginPackage.default(),
+              source: possiblePath
+            }
+          };
+        }
+        attempts.push({
+          path: possiblePath,
+          error: "No default export found"
+        });
+      } catch (error) {
+        attempts.push({
+          path: possiblePath,
+          error: error instanceof Error ? error.message : String(error)
+        });
       }
-      if (!(definition.default instanceof HttpOperationDefinition)) {
-        console.info(
-          `Skipping '${sourceFile}' as it is not an instance of HttpOperationDefinition`
-        );
-        continue;
+    }
+    return {
+      success: false,
+      error: {
+        pluginName,
+        attempts
       }
-      const { operationId } = definition.default;
-      const outputDir = path__default.join(this.config.outputDir, entityName);
-      const outputRequestFileName = `${operationId}Request.ts`;
-      const outputRequestFile = path__default.join(outputDir, outputRequestFileName);
-      const outputResponseFileName = `${operationId}Response.ts`;
-      const outputResponseFile = path__default.join(outputDir, outputResponseFileName);
-      const outputRequestValidationFileName = `${operationId}RequestValidator.ts`;
-      const outputRequestValidationFile = path__default.join(
-        outputDir,
-        outputRequestValidationFileName
-      );
-      const outputResponseValidationFileName = `${operationId}ResponseValidator.ts`;
-      const outputResponseValidationFile = path__default.join(
-        outputDir,
-        outputResponseValidationFileName
-      );
-      const outputClientFileName = `${operationId}Client.ts`;
-      const outputClientFile = path__default.join(outputDir, outputClientFileName);
-      const operationResource = {
-        sourceDir,
-        sourceFile,
-        sourceFileName,
-        definition: {
-          ...definition.default,
-          responses: []
-        },
-        outputDir,
-        entityName,
-        outputRequestFile,
-        outputResponseFile,
-        outputResponseValidationFile,
-        outputRequestValidationFile,
-        outputRequestFileName,
-        outputRequestValidationFileName,
-        outputResponseFileName,
-        outputResponseValidationFileName,
-        outputClientFile,
-        outputClientFileName
-      };
-      if (!definition.default.responses) {
-        throw new Error(
-          `Operation '${operationId}' does not have any responses`
-        );
+    };
+  }
+  /**
+   * Generate possible plugin paths based on configured strategies
+   */
+  generatePluginPaths(pluginName) {
+    const paths = [];
+    for (const strategy of this.strategies) {
+      switch (strategy) {
+        case "npm":
+          paths.push(`@rexeus/typeweaver-${pluginName}`);
+          paths.push(`@rexeus/${pluginName}`);
+          break;
+        case "local":
+          paths.push(pluginName);
+          break;
       }
-      for (const response of definition.default.responses) {
-        const extendedResponse = {
-          ...response,
-          statusCodeName: HttpStatusCodeNameMap[response.statusCode]
-        };
-        operationResource.definition.responses.push(extendedResponse);
+    }
+    return paths;
+  }
+  /**
+   * Report successful plugin loads
+   */
+  reportSuccessfulLoads(successful) {
+    if (successful.length > 0) {
+      console.info(`Successfully loaded ${successful.length} plugin(s):`);
+      for (const result of successful) {
+        console.info(`  - ${result.plugin.name} (from ${result.source})`);
       }
-      definitions.push(operationResource);
     }
-    return definitions;
   }
 }
 
@@ -219,7 +160,7 @@ var public_exports$1 = {};
 __export$1(public_exports$1, {
   builders: () => builders,
   printer: () => printer,
-  utils: () => utils$1
+  utils: () => utils
 });
 var DOC_TYPE_STRING$1 = "string";
 var DOC_TYPE_ARRAY$1 = "array";
@@ -1326,7 +1267,7 @@ var builders = {
   concat: (parts) => parts
 };
 var printer = { printDocToString: printDocToString$1 };
-var utils$1 = {
+var utils = {
   willBreak,
   traverseDoc: traverse_doc_default$1,
   findInDoc,
@@ -1343,7 +1284,7 @@ var doc = /*#__PURE__*/Object.freeze({
   builders: builders,
   default: public_default,
   printer: printer,
-  utils: utils$1
+  utils: utils
 });
 
 const require = createRequire(import.meta.url);
@@ -22452,11 +22393,11 @@ var { parsers, printers } = createParsersAndPrinters([
     printers: ["estree", "estree-json"]
   },
   {
-    importPlugin: () => import('./flow--vV0j3Y-.js'),
+    importPlugin: () => import('./flow-q2wMXrDa.js'),
     parsers: ["flow"]
   },
   {
-    importPlugin: () => import('./glimmer-B-ODUU1A.js'),
+    importPlugin: () => import('./glimmer-wgjvri6H.js'),
     parsers: ["glimmer"],
     printers: ["glimmer"]
   },
@@ -22471,7 +22412,7 @@ var { parsers, printers } = createParsersAndPrinters([
     printers: ["html"]
   },
   {
-    importPlugin: () => import('./markdown-BsYj_q7V.js'),
+    importPlugin: () => import('./markdown-Nz6Lc3gB.js'),
     parsers: ["markdown", "mdx", "remark"],
     printers: ["mdast"]
   },
@@ -22480,16 +22421,16 @@ var { parsers, printers } = createParsersAndPrinters([
     parsers: ["meriyah"]
   },
   {
-    importPlugin: () => import('./postcss-DdgOJBTx.js'),
+    importPlugin: () => import('./postcss-yEOijaXJ.js'),
     parsers: ["css", "less", "scss"],
     printers: ["postcss"]
   },
   {
-    importPlugin: () => import('./typescript-C4gnKzhB.js'),
+    importPlugin: () => import('./typescript-Cv79a1Qz.js'),
     parsers: ["typescript"]
   },
   {
-    importPlugin: () => import('./yaml-B0tq6Ttj.js'),
+    importPlugin: () => import('./yaml-DT3qlFoE.js'),
     parsers: ["yaml"],
     printers: ["yaml"]
   }
@@ -22809,7 +22750,6 @@ var debugApis = {
   printDocToString: withPlugins(printDocToString2),
   mockable: mockable_default
 };
-var src_default = index_exports;
 
 class Prettier {
   constructor(outputDir) {
@@ -22824,7 +22764,7 @@ class Prettier {
       if (content.isFile()) {
         const filePath = path__default.join(targetDir, content.name);
         const unformatted = fs.readFileSync(filePath, "utf8");
-        const formatted = await src_default.format(unformatted, {
+        const formatted = await format2(unformatted, {
           parser: "typescript"
         });
         fs.writeFileSync(filePath, formatted);
@@ -22835,845 +22775,823 @@ class Prettier {
   }
 }
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+class DuplicateOperationIdError extends Error {
+  constructor(operationId, firstFile, duplicateFile) {
+    super(
+      `Duplicate operation ID '${operationId}' found.
+  First defined in: \`${firstFile}\`
+  Duplicate found in: \`${duplicateFile}\``
+    );
+    this.operationId = operationId;
+    this.firstFile = firstFile;
+    this.duplicateFile = duplicateFile;
+  }
 }
 
-var ejs$1 = {};
+class DuplicateResponseNameError extends Error {
+  constructor(responseName, firstFile, duplicateFile) {
+    super(
+      `Duplicate response name '${responseName}' found.
+  First defined in: \`${firstFile}\`
+  Duplicate found in: \`${duplicateFile}\``
+    );
+    this.responseName = responseName;
+    this.firstFile = firstFile;
+    this.duplicateFile = duplicateFile;
+  }
+}
 
-var utils = {};
-
-var hasRequiredUtils;
+class DuplicateRouteError extends Error {
+  constructor(path, method, firstOperationId, firstFile, duplicateOperationId, duplicateFile) {
+    super(
+      `Duplicate route '${method} ${path}' found.
+  First defined by operation '${firstOperationId}' in: \`${firstFile}\`
+  Duplicate defined by operation '${duplicateOperationId}' in: \`${duplicateFile}\``
+    );
+    this.path = path;
+    this.method = method;
+    this.firstOperationId = firstOperationId;
+    this.firstFile = firstFile;
+    this.duplicateOperationId = duplicateOperationId;
+    this.duplicateFile = duplicateFile;
+  }
+}
 
-function requireUtils () {
-	if (hasRequiredUtils) return utils;
-	hasRequiredUtils = 1;
-	(function (exports) {
-		var regExpChars = /[|\\{}()[\]^$+*?.]/g;
-		var hasOwnProperty = Object.prototype.hasOwnProperty;
-		var hasOwn = function(obj, key) {
-		  return hasOwnProperty.apply(obj, [key]);
-		};
-		exports.escapeRegExpChars = function(string) {
-		  if (!string) {
-		    return "";
-		  }
-		  return String(string).replace(regExpChars, "\\$&");
-		};
-		var _ENCODE_HTML_RULES = {
-		  "&": "&",
-		  "<": "&lt;",
-		  ">": "&gt;",
-		  '"': "&#34;",
-		  "'": "&#39;"
-		};
-		var _MATCH_HTML = /[&<>'"]/g;
-		function encode_char(c) {
-		  return _ENCODE_HTML_RULES[c] || c;
-		}
-		var escapeFuncStr = `var _ENCODE_HTML_RULES = {
-      "&": "&amp;"
-    , "<": "&lt;"
-    , ">": "&gt;"
-    , '"': "&#34;"
-    , "'": "&#39;"
-    }
-  , _MATCH_HTML = /[&<>'"]/g;
-function encode_char(c) {
-  return _ENCODE_HTML_RULES[c] || c;
-};
-`;
-		exports.escapeXML = function(markup) {
-		  return markup == void 0 ? "" : String(markup).replace(_MATCH_HTML, encode_char);
-		};
-		function escapeXMLToString() {
-		  return Function.prototype.toString.call(this) + ";\n" + escapeFuncStr;
-		}
-		try {
-		  if (typeof Object.defineProperty === "function") {
-		    Object.defineProperty(exports.escapeXML, "toString", { value: escapeXMLToString });
-		  } else {
-		    exports.escapeXML.toString = escapeXMLToString;
-		  }
-		} catch (err) {
-		  console.warn("Unable to set escapeXML.toString (is the Function prototype frozen?)");
-		}
-		exports.shallowCopy = function(to, from) {
-		  from = from || {};
-		  if (to !== null && to !== void 0) {
-		    for (var p in from) {
-		      if (!hasOwn(from, p)) {
-		        continue;
-		      }
-		      if (p === "__proto__" || p === "constructor") {
-		        continue;
-		      }
-		      to[p] = from[p];
-		    }
-		  }
-		  return to;
-		};
-		exports.shallowCopyFromList = function(to, from, list) {
-		  list = list || [];
-		  from = from || {};
-		  if (to !== null && to !== void 0) {
-		    for (var i = 0; i < list.length; i++) {
-		      var p = list[i];
-		      if (typeof from[p] != "undefined") {
-		        if (!hasOwn(from, p)) {
-		          continue;
-		        }
-		        if (p === "__proto__" || p === "constructor") {
-		          continue;
-		        }
-		        to[p] = from[p];
-		      }
-		    }
-		  }
-		  return to;
-		};
-		exports.cache = {
-		  _data: {},
-		  set: function(key, val) {
-		    this._data[key] = val;
-		  },
-		  get: function(key) {
-		    return this._data[key];
-		  },
-		  remove: function(key) {
-		    delete this._data[key];
-		  },
-		  reset: function() {
-		    this._data = {};
-		  }
-		};
-		exports.hyphenToCamel = function(str) {
-		  return str.replace(/-[a-z]/g, function(match) {
-		    return match[1].toUpperCase();
-		  });
-		};
-		exports.createNullProtoObjWherePossible = function() {
-		  if (typeof Object.create == "function") {
-		    return function() {
-		      return /* @__PURE__ */ Object.create(null);
-		    };
-		  }
-		  if (!({ __proto__: null } instanceof Object)) {
-		    return function() {
-		      return { __proto__: null };
-		    };
-		  }
-		  return function() {
-		    return {};
-		  };
-		}();
-		exports.hasOwnOnlyObject = function(obj) {
-		  var o = exports.createNullProtoObjWherePossible();
-		  for (var p in obj) {
-		    if (hasOwn(obj, p)) {
-		      o[p] = obj[p];
-		    }
-		  }
-		  return o;
-		}; 
-	} (utils));
-	return utils;
+class DefinitionRegistry {
+  operationIds = /* @__PURE__ */ new Map();
+  responseNames = /* @__PURE__ */ new Map();
+  routes = /* @__PURE__ */ new Map();
+  registerOperation(operation, sourceFile) {
+    const existingFile = this.operationIds.get(operation.operationId);
+    if (existingFile) {
+      throw new DuplicateOperationIdError(
+        operation.operationId,
+        existingFile,
+        sourceFile
+      );
+    }
+    this.operationIds.set(operation.operationId, sourceFile);
+    const normalizedPath = this.normalizePath(operation.path);
+    const routeKey = `${operation.method} ${normalizedPath}`;
+    const existingRoute = this.routes.get(routeKey);
+    if (existingRoute) {
+      throw new DuplicateRouteError(
+        operation.path,
+        operation.method,
+        existingRoute.operationId,
+        existingRoute.file,
+        operation.operationId,
+        sourceFile
+      );
+    }
+    this.routes.set(routeKey, {
+      operationId: operation.operationId,
+      file: sourceFile
+    });
+  }
+  registerResponse(response, sourceFile) {
+    const existingFile = this.responseNames.get(response.name);
+    if (existingFile) {
+      throw new DuplicateResponseNameError(
+        response.name,
+        existingFile,
+        sourceFile
+      );
+    }
+    this.responseNames.set(response.name, sourceFile);
+  }
+  hasOperationId(operationId) {
+    return this.operationIds.has(operationId);
+  }
+  hasResponseName(name) {
+    return this.responseNames.has(name);
+  }
+  hasRoute(method, path) {
+    const normalizedPath = this.normalizePath(path);
+    const routeKey = `${method} ${normalizedPath}`;
+    return this.routes.has(routeKey);
+  }
+  getOperationFile(operationId) {
+    return this.operationIds.get(operationId);
+  }
+  getResponseFile(name) {
+    return this.responseNames.get(name);
+  }
+  getRouteInfo(method, path) {
+    const normalizedPath = this.normalizePath(path);
+    const routeKey = `${method} ${normalizedPath}`;
+    return this.routes.get(routeKey);
+  }
+  normalizePath(path) {
+    let paramIndex = 1;
+    return path.replace(/:([a-zA-Z0-9_]+)/g, () => {
+      return `:param${paramIndex++}`;
+    });
+  }
 }
 
-var version$1 = "3.1.10";
-var require$$3 = {
-	version: version$1};
+class EmptyResponseArrayError extends Error {
+  constructor(operationId, file) {
+    super(
+      `Operation '${operationId}' has no responses defined at \`${file}\`
+  Operations must have at least one response definition`
+    );
+    this.operationId = operationId;
+    this.file = file;
+  }
+}
 
-var hasRequiredEjs;
+class InvalidHttpMethodError extends Error {
+  constructor(operationId, method, file) {
+    const validMethods = Object.values(HttpMethod).join(", ");
+    super(
+      `Invalid HTTP method '${method}' in operation '${operationId}' at \`${file}\`
+  Valid methods: ${validMethods}`
+    );
+    this.operationId = operationId;
+    this.method = method;
+    this.file = file;
+  }
+}
 
-function requireEjs () {
-	if (hasRequiredEjs) return ejs$1;
-	hasRequiredEjs = 1;
-	(function (exports) {
-		/**
-		 * @file Embedded JavaScript templating engine. {@link http://ejs.co}
-		 * @author Matthew Eernisse <mde@fleegix.org>
-		 * @author Tiancheng "Timothy" Gu <timothygu99@gmail.com>
-		 * @project EJS
-		 * @license {@link http://www.apache.org/licenses/LICENSE-2.0 Apache License, Version 2.0}
-		 */
-		var fs$1 = fs;
-		var path = path__default;
-		var utils = requireUtils();
-		var scopeOptionWarned = false;
-		var _VERSION_STRING = require$$3.version;
-		var _DEFAULT_OPEN_DELIMITER = "<";
-		var _DEFAULT_CLOSE_DELIMITER = ">";
-		var _DEFAULT_DELIMITER = "%";
-		var _DEFAULT_LOCALS_NAME = "locals";
-		var _NAME = "ejs";
-		var _REGEX_STRING = "(<%%|%%>|<%=|<%-|<%_|<%#|<%|%>|-%>|_%>)";
-		var _OPTS_PASSABLE_WITH_DATA = [
-		  "delimiter",
-		  "scope",
-		  "context",
-		  "debug",
-		  "compileDebug",
-		  "client",
-		  "_with",
-		  "rmWhitespace",
-		  "strict",
-		  "filename",
-		  "async"
-		];
-		var _OPTS_PASSABLE_WITH_DATA_EXPRESS = _OPTS_PASSABLE_WITH_DATA.concat("cache");
-		var _BOM = /^\uFEFF/;
-		var _JS_IDENTIFIER = /^[a-zA-Z_$][0-9a-zA-Z_$]*$/;
-		exports.cache = utils.cache;
-		exports.fileLoader = fs$1.readFileSync;
-		exports.localsName = _DEFAULT_LOCALS_NAME;
-		exports.promiseImpl = new Function("return this;")().Promise;
-		exports.resolveInclude = function(name, filename, isDir) {
-		  var dirname = path.dirname;
-		  var extname = path.extname;
-		  var resolve = path.resolve;
-		  var includePath = resolve(isDir ? filename : dirname(filename), name);
-		  var ext = extname(name);
-		  if (!ext) {
-		    includePath += ".ejs";
-		  }
-		  return includePath;
-		};
-		function resolvePaths(name, paths) {
-		  var filePath;
-		  if (paths.some(function(v) {
-		    filePath = exports.resolveInclude(name, v, true);
-		    return fs$1.existsSync(filePath);
-		  })) {
-		    return filePath;
-		  }
-		}
-		function getIncludePath(path2, options) {
-		  var includePath;
-		  var filePath;
-		  var views = options.views;
-		  var match = /^[A-Za-z]+:\\|^\//.exec(path2);
-		  if (match && match.length) {
-		    path2 = path2.replace(/^\/*/, "");
-		    if (Array.isArray(options.root)) {
-		      includePath = resolvePaths(path2, options.root);
-		    } else {
-		      includePath = exports.resolveInclude(path2, options.root || "/", true);
-		    }
-		  } else {
-		    if (options.filename) {
-		      filePath = exports.resolveInclude(path2, options.filename);
-		      if (fs$1.existsSync(filePath)) {
-		        includePath = filePath;
-		      }
-		    }
-		    if (!includePath && Array.isArray(views)) {
-		      includePath = resolvePaths(path2, views);
-		    }
-		    if (!includePath && typeof options.includer !== "function") {
-		      throw new Error('Could not find the include file "' + options.escapeFunction(path2) + '"');
-		    }
-		  }
-		  return includePath;
-		}
-		function handleCache(options, template) {
-		  var func;
-		  var filename = options.filename;
-		  var hasTemplate = arguments.length > 1;
-		  if (options.cache) {
-		    if (!filename) {
-		      throw new Error("cache option requires a filename");
-		    }
-		    func = exports.cache.get(filename);
-		    if (func) {
-		      return func;
-		    }
-		    if (!hasTemplate) {
-		      template = fileLoader(filename).toString().replace(_BOM, "");
-		    }
-		  } else if (!hasTemplate) {
-		    if (!filename) {
-		      throw new Error("Internal EJS error: no file name or template provided");
-		    }
-		    template = fileLoader(filename).toString().replace(_BOM, "");
-		  }
-		  func = exports.compile(template, options);
-		  if (options.cache) {
-		    exports.cache.set(filename, func);
-		  }
-		  return func;
-		}
-		function tryHandleCache(options, data, cb) {
-		  var result;
-		  if (!cb) {
-		    if (typeof exports.promiseImpl == "function") {
-		      return new exports.promiseImpl(function(resolve, reject) {
-		        try {
-		          result = handleCache(options)(data);
-		          resolve(result);
-		        } catch (err) {
-		          reject(err);
-		        }
-		      });
-		    } else {
-		      throw new Error("Please provide a callback function");
-		    }
-		  } else {
-		    try {
-		      result = handleCache(options)(data);
-		    } catch (err) {
-		      return cb(err);
-		    }
-		    cb(null, result);
-		  }
-		}
-		function fileLoader(filePath) {
-		  return exports.fileLoader(filePath);
-		}
-		function includeFile(path2, options) {
-		  var opts = utils.shallowCopy(utils.createNullProtoObjWherePossible(), options);
-		  opts.filename = getIncludePath(path2, opts);
-		  if (typeof options.includer === "function") {
-		    var includerResult = options.includer(path2, opts.filename);
-		    if (includerResult) {
-		      if (includerResult.filename) {
-		        opts.filename = includerResult.filename;
-		      }
-		      if (includerResult.template) {
-		        return handleCache(opts, includerResult.template);
-		      }
-		    }
-		  }
-		  return handleCache(opts);
-		}
-		function rethrow(err, str, flnm, lineno, esc) {
-		  var lines = str.split("\n");
-		  var start = Math.max(lineno - 3, 0);
-		  var end = Math.min(lines.length, lineno + 3);
-		  var filename = esc(flnm);
-		  var context = lines.slice(start, end).map(function(line, i) {
-		    var curr = i + start + 1;
-		    return (curr == lineno ? " >> " : "    ") + curr + "| " + line;
-		  }).join("\n");
-		  err.path = filename;
-		  err.message = (filename || "ejs") + ":" + lineno + "\n" + context + "\n\n" + err.message;
-		  throw err;
-		}
-		function stripSemi(str) {
-		  return str.replace(/;(\s*$)/, "$1");
-		}
-		exports.compile = function compile(template, opts) {
-		  var templ;
-		  if (opts && opts.scope) {
-		    if (!scopeOptionWarned) {
-		      console.warn("`scope` option is deprecated and will be removed in EJS 3");
-		      scopeOptionWarned = true;
-		    }
-		    if (!opts.context) {
-		      opts.context = opts.scope;
-		    }
-		    delete opts.scope;
-		  }
-		  templ = new Template(template, opts);
-		  return templ.compile();
-		};
-		exports.render = function(template, d, o) {
-		  var data = d || utils.createNullProtoObjWherePossible();
-		  var opts = o || utils.createNullProtoObjWherePossible();
-		  if (arguments.length == 2) {
-		    utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA);
-		  }
-		  return handleCache(opts, template)(data);
-		};
-		exports.renderFile = function() {
-		  var args = Array.prototype.slice.call(arguments);
-		  var filename = args.shift();
-		  var cb;
-		  var opts = { filename };
-		  var data;
-		  var viewOpts;
-		  if (typeof arguments[arguments.length - 1] == "function") {
-		    cb = args.pop();
-		  }
-		  if (args.length) {
-		    data = args.shift();
-		    if (args.length) {
-		      utils.shallowCopy(opts, args.pop());
-		    } else {
-		      if (data.settings) {
-		        if (data.settings.views) {
-		          opts.views = data.settings.views;
-		        }
-		        if (data.settings["view cache"]) {
-		          opts.cache = true;
-		        }
-		        viewOpts = data.settings["view options"];
-		        if (viewOpts) {
-		          utils.shallowCopy(opts, viewOpts);
-		        }
-		      }
-		      utils.shallowCopyFromList(opts, data, _OPTS_PASSABLE_WITH_DATA_EXPRESS);
-		    }
-		    opts.filename = filename;
-		  } else {
-		    data = utils.createNullProtoObjWherePossible();
-		  }
-		  return tryHandleCache(opts, data, cb);
-		};
-		exports.Template = Template;
-		exports.clearCache = function() {
-		  exports.cache.reset();
-		};
-		function Template(text, optsParam) {
-		  var opts = utils.hasOwnOnlyObject(optsParam);
-		  var options = utils.createNullProtoObjWherePossible();
-		  this.templateText = text;
-		  this.mode = null;
-		  this.truncate = false;
-		  this.currentLine = 1;
-		  this.source = "";
-		  options.client = opts.client || false;
-		  options.escapeFunction = opts.escape || opts.escapeFunction || utils.escapeXML;
-		  options.compileDebug = opts.compileDebug !== false;
-		  options.debug = !!opts.debug;
-		  options.filename = opts.filename;
-		  options.openDelimiter = opts.openDelimiter || exports.openDelimiter || _DEFAULT_OPEN_DELIMITER;
-		  options.closeDelimiter = opts.closeDelimiter || exports.closeDelimiter || _DEFAULT_CLOSE_DELIMITER;
-		  options.delimiter = opts.delimiter || exports.delimiter || _DEFAULT_DELIMITER;
-		  options.strict = opts.strict || false;
-		  options.context = opts.context;
-		  options.cache = opts.cache || false;
-		  options.rmWhitespace = opts.rmWhitespace;
-		  options.root = opts.root;
-		  options.includer = opts.includer;
-		  options.outputFunctionName = opts.outputFunctionName;
-		  options.localsName = opts.localsName || exports.localsName || _DEFAULT_LOCALS_NAME;
-		  options.views = opts.views;
-		  options.async = opts.async;
-		  options.destructuredLocals = opts.destructuredLocals;
-		  options.legacyInclude = typeof opts.legacyInclude != "undefined" ? !!opts.legacyInclude : true;
-		  if (options.strict) {
-		    options._with = false;
-		  } else {
-		    options._with = typeof opts._with != "undefined" ? opts._with : true;
-		  }
-		  this.opts = options;
-		  this.regex = this.createRegex();
-		}
-		Template.modes = {
-		  EVAL: "eval",
-		  ESCAPED: "escaped",
-		  RAW: "raw",
-		  COMMENT: "comment",
-		  LITERAL: "literal"
-		};
-		Template.prototype = {
-		  createRegex: function() {
-		    var str = _REGEX_STRING;
-		    var delim = utils.escapeRegExpChars(this.opts.delimiter);
-		    var open = utils.escapeRegExpChars(this.opts.openDelimiter);
-		    var close = utils.escapeRegExpChars(this.opts.closeDelimiter);
-		    str = str.replace(/%/g, delim).replace(/</g, open).replace(/>/g, close);
-		    return new RegExp(str);
-		  },
-		  compile: function() {
-		    var src;
-		    var fn;
-		    var opts = this.opts;
-		    var prepended = "";
-		    var appended = "";
-		    var escapeFn = opts.escapeFunction;
-		    var ctor;
-		    var sanitizedFilename = opts.filename ? JSON.stringify(opts.filename) : "undefined";
-		    if (!this.source) {
-		      this.generateSource();
-		      prepended += '  var __output = "";\n  function __append(s) { if (s !== undefined && s !== null) __output += s }\n';
-		      if (opts.outputFunctionName) {
-		        if (!_JS_IDENTIFIER.test(opts.outputFunctionName)) {
-		          throw new Error("outputFunctionName is not a valid JS identifier.");
-		        }
-		        prepended += "  var " + opts.outputFunctionName + " = __append;\n";
-		      }
-		      if (opts.localsName && !_JS_IDENTIFIER.test(opts.localsName)) {
-		        throw new Error("localsName is not a valid JS identifier.");
-		      }
-		      if (opts.destructuredLocals && opts.destructuredLocals.length) {
-		        var destructuring = "  var __locals = (" + opts.localsName + " || {}),\n";
-		        for (var i = 0; i < opts.destructuredLocals.length; i++) {
-		          var name = opts.destructuredLocals[i];
-		          if (!_JS_IDENTIFIER.test(name)) {
-		            throw new Error("destructuredLocals[" + i + "] is not a valid JS identifier.");
-		          }
-		          if (i > 0) {
-		            destructuring += ",\n  ";
-		          }
-		          destructuring += name + " = __locals." + name;
-		        }
-		        prepended += destructuring + ";\n";
-		      }
-		      if (opts._with !== false) {
-		        prepended += "  with (" + opts.localsName + " || {}) {\n";
-		        appended += "  }\n";
-		      }
-		      appended += "  return __output;\n";
-		      this.source = prepended + this.source + appended;
-		    }
-		    if (opts.compileDebug) {
-		      src = "var __line = 1\n  , __lines = " + JSON.stringify(this.templateText) + "\n  , __filename = " + sanitizedFilename + ";\ntry {\n" + this.source + "} catch (e) {\n  rethrow(e, __lines, __filename, __line, escapeFn);\n}\n";
-		    } else {
-		      src = this.source;
-		    }
-		    if (opts.client) {
-		      src = "escapeFn = escapeFn || " + escapeFn.toString() + ";\n" + src;
-		      if (opts.compileDebug) {
-		        src = "rethrow = rethrow || " + rethrow.toString() + ";\n" + src;
-		      }
-		    }
-		    if (opts.strict) {
-		      src = '"use strict";\n' + src;
-		    }
-		    if (opts.debug) {
-		      console.log(src);
-		    }
-		    if (opts.compileDebug && opts.filename) {
-		      src = src + "\n//# sourceURL=" + sanitizedFilename + "\n";
-		    }
-		    try {
-		      if (opts.async) {
-		        try {
-		          ctor = new Function("return (async function(){}).constructor;")();
-		        } catch (e) {
-		          if (e instanceof SyntaxError) {
-		            throw new Error("This environment does not support async/await");
-		          } else {
-		            throw e;
-		          }
-		        }
-		      } else {
-		        ctor = Function;
-		      }
-		      fn = new ctor(opts.localsName + ", escapeFn, include, rethrow", src);
-		    } catch (e) {
-		      if (e instanceof SyntaxError) {
-		        if (opts.filename) {
-		          e.message += " in " + opts.filename;
-		        }
-		        e.message += " while compiling ejs\n\n";
-		        e.message += "If the above error is not helpful, you may want to try EJS-Lint:\n";
-		        e.message += "https://github.com/RyanZim/EJS-Lint";
-		        if (!opts.async) {
-		          e.message += "\n";
-		          e.message += "Or, if you meant to create an async function, pass `async: true` as an option.";
-		        }
-		      }
-		      throw e;
-		    }
-		    var returnedFn = opts.client ? fn : function anonymous(data) {
-		      var include = function(path2, includeData) {
-		        var d = utils.shallowCopy(utils.createNullProtoObjWherePossible(), data);
-		        if (includeData) {
-		          d = utils.shallowCopy(d, includeData);
-		        }
-		        return includeFile(path2, opts)(d);
-		      };
-		      return fn.apply(
-		        opts.context,
-		        [data || utils.createNullProtoObjWherePossible(), escapeFn, include, rethrow]
-		      );
-		    };
-		    if (opts.filename && typeof Object.defineProperty === "function") {
-		      var filename = opts.filename;
-		      var basename = path.basename(filename, path.extname(filename));
-		      try {
-		        Object.defineProperty(returnedFn, "name", {
-		          value: basename,
-		          writable: false,
-		          enumerable: false,
-		          configurable: true
-		        });
-		      } catch (e) {
-		      }
-		    }
-		    return returnedFn;
-		  },
-		  generateSource: function() {
-		    var opts = this.opts;
-		    if (opts.rmWhitespace) {
-		      this.templateText = this.templateText.replace(/[\r\n]+/g, "\n").replace(/^\s+|\s+$/gm, "");
-		    }
-		    this.templateText = this.templateText.replace(/[ \t]*<%_/gm, "<%_").replace(/_%>[ \t]*/gm, "_%>");
-		    var self = this;
-		    var matches = this.parseTemplateText();
-		    var d = this.opts.delimiter;
-		    var o = this.opts.openDelimiter;
-		    var c = this.opts.closeDelimiter;
-		    if (matches && matches.length) {
-		      matches.forEach(function(line, index) {
-		        var closing;
-		        if (line.indexOf(o + d) === 0 && line.indexOf(o + d + d) !== 0) {
-		          closing = matches[index + 2];
-		          if (!(closing == d + c || closing == "-" + d + c || closing == "_" + d + c)) {
-		            throw new Error('Could not find matching close tag for "' + line + '".');
-		          }
-		        }
-		        self.scanLine(line);
-		      });
-		    }
-		  },
-		  parseTemplateText: function() {
-		    var str = this.templateText;
-		    var pat = this.regex;
-		    var result = pat.exec(str);
-		    var arr = [];
-		    var firstPos;
-		    while (result) {
-		      firstPos = result.index;
-		      if (firstPos !== 0) {
-		        arr.push(str.substring(0, firstPos));
-		        str = str.slice(firstPos);
-		      }
-		      arr.push(result[0]);
-		      str = str.slice(result[0].length);
-		      result = pat.exec(str);
-		    }
-		    if (str) {
-		      arr.push(str);
-		    }
-		    return arr;
-		  },
-		  _addOutput: function(line) {
-		    if (this.truncate) {
-		      line = line.replace(/^(?:\r\n|\r|\n)/, "");
-		      this.truncate = false;
-		    }
-		    if (!line) {
-		      return line;
-		    }
-		    line = line.replace(/\\/g, "\\\\");
-		    line = line.replace(/\n/g, "\\n");
-		    line = line.replace(/\r/g, "\\r");
-		    line = line.replace(/"/g, '\\"');
-		    this.source += '    ; __append("' + line + '")\n';
-		  },
-		  scanLine: function(line) {
-		    var self = this;
-		    var d = this.opts.delimiter;
-		    var o = this.opts.openDelimiter;
-		    var c = this.opts.closeDelimiter;
-		    var newLineCount = 0;
-		    newLineCount = line.split("\n").length - 1;
-		    switch (line) {
-		      case o + d:
-		      case o + d + "_":
-		        this.mode = Template.modes.EVAL;
-		        break;
-		      case o + d + "=":
-		        this.mode = Template.modes.ESCAPED;
-		        break;
-		      case o + d + "-":
-		        this.mode = Template.modes.RAW;
-		        break;
-		      case o + d + "#":
-		        this.mode = Template.modes.COMMENT;
-		        break;
-		      case o + d + d:
-		        this.mode = Template.modes.LITERAL;
-		        this.source += '    ; __append("' + line.replace(o + d + d, o + d) + '")\n';
-		        break;
-		      case d + d + c:
-		        this.mode = Template.modes.LITERAL;
-		        this.source += '    ; __append("' + line.replace(d + d + c, d + c) + '")\n';
-		        break;
-		      case d + c:
-		      case "-" + d + c:
-		      case "_" + d + c:
-		        if (this.mode == Template.modes.LITERAL) {
-		          this._addOutput(line);
-		        }
-		        this.mode = null;
-		        this.truncate = line.indexOf("-") === 0 || line.indexOf("_") === 0;
-		        break;
-		      default:
-		        if (this.mode) {
-		          switch (this.mode) {
-		            case Template.modes.EVAL:
-		            case Template.modes.ESCAPED:
-		            case Template.modes.RAW:
-		              if (line.lastIndexOf("//") > line.lastIndexOf("\n")) {
-		                line += "\n";
-		              }
-		          }
-		          switch (this.mode) {
-		            // Just executing code
-		            case Template.modes.EVAL:
-		              this.source += "    ; " + line + "\n";
-		              break;
-		            // Exec, esc, and output
-		            case Template.modes.ESCAPED:
-		              this.source += "    ; __append(escapeFn(" + stripSemi(line) + "))\n";
-		              break;
-		            // Exec and output
-		            case Template.modes.RAW:
-		              this.source += "    ; __append(" + stripSemi(line) + ")\n";
-		              break;
-		            case Template.modes.COMMENT:
-		              break;
-		            // Literal <%% mode, append as raw output
-		            case Template.modes.LITERAL:
-		              this._addOutput(line);
-		              break;
-		          }
-		        } else {
-		          this._addOutput(line);
-		        }
-		    }
-		    if (self.opts.compileDebug && newLineCount) {
-		      this.currentLine += newLineCount;
-		      this.source += "    ; __line = " + this.currentLine + "\n";
-		    }
-		  }
-		};
-		exports.escapeXML = utils.escapeXML;
-		exports.__express = exports.renderFile;
-		exports.VERSION = _VERSION_STRING;
-		exports.name = _NAME;
-		if (typeof window != "undefined") {
-		  window.ejs = exports;
-		} 
-	} (ejs$1));
-	return ejs$1;
+class InvalidPathParameterError extends Error {
+  constructor(operationId, path, issue, file) {
+    super(
+      `Invalid path parameters in operation '${operationId}' at \`${file}\`
+  Path: ${path}
+  Issue: ${issue}`
+    );
+    this.operationId = operationId;
+    this.path = path;
+    this.issue = issue;
+    this.file = file;
+  }
 }
 
-var ejsExports = requireEjs();
-var ejs = /*@__PURE__*/getDefaultExportFromCjs(ejsExports);
+class InvalidSchemaError extends Error {
+  constructor(schemaType, definitionName, context, file) {
+    const schemaRequirement = schemaType === "body" ? "Must be a Zod schema" : "Must be a Zod object schema";
+    super(
+      `Invalid ${schemaType} schema in ${context} '${definitionName}' at \`${file}\`. ${schemaRequirement}.`
+    );
+    this.schemaType = schemaType;
+    this.definitionName = definitionName;
+    this.context = context;
+    this.file = file;
+  }
+}
 
-class IndexFileGenerator {
-  constructor(templateDir) {
-    this.templateDir = templateDir;
+class InvalidSchemaShapeError extends Error {
+  constructor(schemaType, definitionName, context, propertyName, invalidType, file) {
+    const allowedTypes = schemaType === "param" ? "string-based types (ZodString, ZodLiteral<string>, ZodEnum) or ZodOptional of these types" : "string-based types (ZodString, ZodLiteral<string>, ZodEnum), ZodOptional, or ZodArray of these types";
+    super(
+      `Invalid ${schemaType} schema shape in ${context} '${definitionName}' at \`${file}\`
+  Property '${propertyName}' has invalid type: ${invalidType}
+  Allowed types: ${allowedTypes}`
+    );
+    this.schemaType = schemaType;
+    this.definitionName = definitionName;
+    this.context = context;
+    this.propertyName = propertyName;
+    this.invalidType = invalidType;
+    this.file = file;
   }
-  generate(context) {
-    const templateFilePath = path__default.join(this.templateDir, "Index.ejs");
-    const template = fs.readFileSync(templateFilePath, "utf8");
-    const indexPaths = /* @__PURE__ */ new Set();
-    for (const generatedFile of context.getGeneratedFiles()) {
-      indexPaths.add(`./${generatedFile.replace(/\.ts$/, "")}`);
-    }
-    const content = ejs.render(template, {
-      indexPaths: Array.from(indexPaths).sort()
-    });
-    fs.writeFileSync(path__default.join(context.outputDir, "index.ts"), content);
+}
+
+class InvalidStatusCodeError extends Error {
+  constructor(statusCode, responseName, file) {
+    const validStatusCodes = Object.values(HttpStatusCode).join(", ");
+    super(
+      `Invalid status code '${statusCode}' in response '${responseName}' at \`${file}\`
+  Valid status codes: ${validStatusCodes}`
+    );
+    this.statusCode = statusCode;
+    this.responseName = responseName;
+    this.file = file;
   }
 }
 
-class PluginLoadingFailure extends Error {
-  constructor(pluginName, attempts) {
-    super(`Failed to load plugin '${pluginName}'`);
-    this.pluginName = pluginName;
-    this.attempts = attempts;
-    Object.setPrototypeOf(this, PluginLoadingFailure.prototype);
+class MissingRequiredFieldError extends Error {
+  constructor(entityType, entityName, missingField, file) {
+    super(
+      `Missing required field '${missingField}' in ${entityType} '${entityName}' at \`${file}\``
+    );
+    this.entityType = entityType;
+    this.entityName = entityName;
+    this.missingField = missingField;
+    this.file = file;
   }
 }
 
-class PluginLoader {
-  constructor(registry, requiredPlugins, strategies = ["npm", "local"]) {
-    this.registry = registry;
-    this.requiredPlugins = requiredPlugins;
-    this.strategies = strategies;
+class DefinitionValidator {
+  registry;
+  constructor(registry) {
+    this.registry = registry ?? new DefinitionRegistry();
+  }
+  validateOperation(operation, sourceFile) {
+    this.registry.registerOperation(operation, sourceFile);
+    this.validateOperationRequiredFields(operation, sourceFile);
+    this.validateHttpMethod(operation, sourceFile);
+    if (operation.request) {
+      this.validateRequestSchemas(operation, sourceFile);
+    }
+    this.validateOperationResponses(operation, sourceFile);
+    this.validatePathParameters(operation, sourceFile);
+  }
+  validateResponse(response, sourceFile) {
+    this.registry.registerResponse(response, sourceFile);
+    this.validateResponseRequiredFields(response, sourceFile);
+    this.validateStatusCode(response, sourceFile);
+    this.validateResponseSchemas(response, sourceFile);
+  }
+  validateOperationRequiredFields(operation, sourceFile) {
+    if (!operation.operationId) {
+      throw new MissingRequiredFieldError(
+        "operation",
+        "unknown",
+        "operationId",
+        sourceFile
+      );
+    }
+    if (!operation.path) {
+      throw new MissingRequiredFieldError(
+        "operation",
+        operation.operationId,
+        "path",
+        sourceFile
+      );
+    }
+    if (!operation.method) {
+      throw new MissingRequiredFieldError(
+        "operation",
+        operation.operationId,
+        "method",
+        sourceFile
+      );
+    }
+    if (!operation.summary) {
+      throw new MissingRequiredFieldError(
+        "operation",
+        operation.operationId,
+        "summary",
+        sourceFile
+      );
+    }
   }
-  /**
-   * Load all plugins from configuration
-   */
-  async loadPlugins(config) {
-    for (const requiredPlugin of this.requiredPlugins) {
-      this.registry.register(requiredPlugin);
+  validateHttpMethod(operation, sourceFile) {
+    const validMethods = Object.values(HttpMethod);
+    if (!validMethods.includes(operation.method)) {
+      throw new InvalidHttpMethodError(
+        operation.operationId,
+        operation.method,
+        sourceFile
+      );
     }
-    if (!config?.plugins) {
-      return;
+  }
+  validateRequestSchemas(operation, sourceFile) {
+    const request = operation.request;
+    if (request.header) {
+      this.validateSchema(
+        request.header,
+        "header",
+        operation.operationId,
+        "request",
+        sourceFile
+      );
     }
-    const successful = [];
-    for (const plugin of config.plugins) {
-      let result;
-      if (typeof plugin === "string") {
-        result = await this.loadPlugin(plugin);
-      } else {
-        result = await this.loadPlugin(plugin[0]);
+    if (request.query) {
+      this.validateSchema(
+        request.query,
+        "query",
+        operation.operationId,
+        "request",
+        sourceFile
+      );
+    }
+    if (request.body) {
+      this.validateSchema(
+        request.body,
+        "body",
+        operation.operationId,
+        "request",
+        sourceFile
+      );
+    }
+    if (request.param) {
+      this.validateSchema(
+        request.param,
+        "param",
+        operation.operationId,
+        "request",
+        sourceFile
+      );
+    }
+  }
+  validateOperationResponses(operation, sourceFile) {
+    if (!operation.responses || operation.responses.length === 0) {
+      throw new EmptyResponseArrayError(operation.operationId, sourceFile);
+    }
+    for (const response of operation.responses) {
+      if (response instanceof HttpResponseDefinition) {
+        continue;
       }
-      if (result.success === false) {
-        throw new PluginLoadingFailure(
-          result.error.pluginName,
-          result.error.attempts
+      this.validateResponse(response, sourceFile);
+    }
+  }
+  validateResponseRequiredFields(response, sourceFile) {
+    if (!response.name) {
+      throw new MissingRequiredFieldError(
+        "response",
+        "unknown",
+        "name",
+        sourceFile
+      );
+    }
+    if (response.statusCode === void 0 || response.statusCode === null) {
+      throw new MissingRequiredFieldError(
+        "response",
+        response.name,
+        "statusCode",
+        sourceFile
+      );
+    }
+    if (!response.description) {
+      throw new MissingRequiredFieldError(
+        "response",
+        response.name,
+        "description",
+        sourceFile
+      );
+    }
+  }
+  validateStatusCode(response, sourceFile) {
+    const validStatusCodes = Object.values(HttpStatusCode);
+    if (!validStatusCodes.includes(response.statusCode)) {
+      throw new InvalidStatusCodeError(
+        response.statusCode,
+        response.name,
+        sourceFile
+      );
+    }
+  }
+  validateResponseSchemas(response, sourceFile) {
+    if (response.header) {
+      this.validateSchema(
+        response.header,
+        "header",
+        response.name,
+        "response",
+        sourceFile
+      );
+    }
+    if (response.body) {
+      this.validateSchema(
+        response.body,
+        "body",
+        response.name,
+        "response",
+        sourceFile
+      );
+    }
+  }
+  validateSchema(schema, schemaType, definitionName, context, sourceFile) {
+    if (schemaType === "body") {
+      if (!(schema instanceof z.ZodType)) {
+        throw new InvalidSchemaError(
+          schemaType,
+          definitionName,
+          context,
+          sourceFile
         );
       }
-      successful.push(result.value);
-      this.registry.register(result.value.plugin);
+      return;
+    }
+    if (!(schema instanceof z.ZodObject)) {
+      throw new InvalidSchemaError(
+        schemaType,
+        definitionName,
+        context,
+        sourceFile
+      );
+    }
+    if (schemaType === "param") {
+      this.validateParamShape(schema, definitionName, sourceFile);
+    } else {
+      this.validateHeaderOrQueryShape(
+        schema,
+        schemaType,
+        definitionName,
+        context,
+        sourceFile
+      );
     }
-    this.reportSuccessfulLoads(successful);
   }
-  /**
-   * Load a plugin from a string identifier
-   */
-  async loadPlugin(pluginName) {
-    const possiblePaths = this.generatePluginPaths(pluginName);
-    const attempts = [];
-    for (const possiblePath of possiblePaths) {
-      try {
-        const pluginPackage = await import(possiblePath);
-        if (pluginPackage.default) {
-          return {
-            success: true,
-            value: {
-              plugin: new pluginPackage.default(),
-              source: possiblePath
-            }
-          };
+  validatePathParameters(operation, sourceFile) {
+    const pathParamMatches = operation.path.matchAll(/:([a-zA-Z0-9_]+)/g);
+    const pathParamsSet = /* @__PURE__ */ new Set();
+    for (const match of pathParamMatches) {
+      const paramName = match[1];
+      if (pathParamsSet.has(paramName)) {
+        throw new InvalidPathParameterError(
+          operation.operationId,
+          operation.path,
+          `Duplicate parameter name '${paramName}' in path`,
+          sourceFile
+        );
+      }
+      pathParamsSet.add(paramName);
+    }
+    const paramSchema = operation.request?.param;
+    if (pathParamsSet.size > 0 && !paramSchema) {
+      throw new InvalidPathParameterError(
+        operation.operationId,
+        operation.path,
+        `Path contains parameters [${Array.from(pathParamsSet).join(", ")}] but request.param is not defined`,
+        sourceFile
+      );
+    }
+    if (paramSchema && paramSchema instanceof z.ZodObject) {
+      const paramShape = paramSchema.shape;
+      const paramKeys = new Set(Object.keys(paramShape));
+      for (const pathParam of pathParamsSet) {
+        if (!paramKeys.has(pathParam)) {
+          throw new InvalidPathParameterError(
+            operation.operationId,
+            operation.path,
+            `Path parameter ':${pathParam}' is not defined in request.param`,
+            sourceFile
+          );
+        }
+      }
+      for (const paramKey of paramKeys) {
+        if (!pathParamsSet.has(paramKey)) {
+          throw new InvalidPathParameterError(
+            operation.operationId,
+            operation.path,
+            `Parameter '${paramKey}' is defined in request.param but not used in the path`,
+            sourceFile
+          );
         }
-        attempts.push({
-          path: possiblePath,
-          error: "No default export found"
-        });
-      } catch (error) {
-        attempts.push({
-          path: possiblePath,
-          error: error instanceof Error ? error.message : String(error)
-        });
       }
     }
-    return {
-      success: false,
-      error: {
-        pluginName,
-        attempts
+  }
+  validateHeaderOrQueryShape(schema, schemaType, definitionName, context, sourceFile) {
+    const shape = schema.shape;
+    for (const [propName, propSchema] of Object.entries(shape)) {
+      if (!this.isValidHeaderOrQueryValue(propSchema)) {
+        const typeName = this.getZodTypeName(propSchema);
+        throw new InvalidSchemaShapeError(
+          schemaType,
+          definitionName,
+          context,
+          propName,
+          typeName,
+          sourceFile
+        );
+      }
+    }
+  }
+  validateParamShape(schema, operationId, sourceFile) {
+    const shape = schema.shape;
+    for (const [propName, propSchema] of Object.entries(shape)) {
+      if (!this.isValidParamValue(propSchema)) {
+        const typeName = this.getZodTypeName(propSchema);
+        throw new InvalidSchemaShapeError(
+          "param",
+          operationId,
+          "request",
+          propName,
+          typeName,
+          sourceFile
+        );
       }
+    }
+  }
+  isValidHeaderOrQueryValue(schema) {
+    if (this.isStringBasedType(schema)) {
+      return true;
+    }
+    if (schema instanceof z.ZodOptional) {
+      return this.isValidHeaderOrQueryValue(schema.unwrap());
+    }
+    if (schema instanceof z.ZodArray) {
+      return this.isStringBasedType(schema.element);
+    }
+    return false;
+  }
+  isValidParamValue(schema) {
+    if (this.isStringBasedType(schema)) {
+      return true;
+    }
+    if (schema instanceof z.ZodOptional) {
+      return this.isStringBasedType(schema.unwrap());
+    }
+    return false;
+  }
+  isStringBasedType(schema) {
+    if (schema instanceof z.ZodString) {
+      return true;
+    }
+    if (schema instanceof z.ZodLiteral && typeof schema.value === "string") {
+      return true;
+    }
+    if (schema instanceof z.ZodEnum) {
+      return true;
+    }
+    const typeName = schema.constructor.name;
+    const stringFormatTypes = [
+      "ZodULID",
+      "ZodUUID",
+      "ZodUUIDv4",
+      "ZodUUIDv7",
+      "ZodUUIDv8",
+      "ZodEmail",
+      "ZodURL",
+      "ZodCUID",
+      "ZodCUID2",
+      "ZodNanoID",
+      "ZodBase64",
+      "ZodBase64URL",
+      "ZodEmoji",
+      "ZodIPv4",
+      "ZodIPv6",
+      "ZodCIDRv4",
+      "ZodCIDRv6",
+      "ZodE164",
+      "ZodJWT",
+      "ZodASCII",
+      "ZodUTF8",
+      "ZodLowercase",
+      "ZodGUID",
+      "ZodISODate",
+      "ZodISOTime",
+      "ZodISODateTime",
+      "ZodISODuration"
+    ];
+    if (stringFormatTypes.includes(typeName)) {
+      return true;
+    }
+    if (schema._def && schema._def.typeName && schema._def.typeName.includes("String")) {
+      return true;
+    }
+    return false;
+  }
+  getZodTypeName(schema) {
+    const typeName = schema.constructor.name;
+    if (schema instanceof z.ZodOptional) {
+      return `ZodOptional<${this.getZodTypeName(schema.unwrap())}>`;
+    }
+    if (schema instanceof z.ZodArray) {
+      return `ZodArray<${this.getZodTypeName(schema.element)}>`;
+    }
+    if (schema instanceof z.ZodLiteral) {
+      return `ZodLiteral<${typeof schema.value}>`;
+    }
+    return typeName;
+  }
+  getRegistry() {
+    return this.registry;
+  }
+}
+
+class InvalidSharedDirError extends Error {
+  constructor(explanation) {
+    super("Invalid shared dir");
+    this.explanation = explanation;
+  }
+}
+
+class ResourceReader {
+  constructor(config) {
+    this.config = config;
+  }
+  async getResources() {
+    const contents = fs.readdirSync(this.config.sourceDir, {
+      withFileTypes: true
+    });
+    const result = {
+      entityResources: {},
+      sharedResponseResources: []
     };
+    const validator = new DefinitionValidator();
+    if (fs.existsSync(this.config.sharedSourceDir)) {
+      const sharedStats = fs.statSync(this.config.sharedSourceDir);
+      if (!sharedStats.isDirectory()) {
+        throw new InvalidSharedDirError(
+          `'${this.config.sharedSourceDir}' is a file, not a directory`
+        );
+      }
+      result.sharedResponseResources = await this.getSharedResponseResources(validator);
+      console.info(
+        `Found '${result.sharedResponseResources.length}' shared responses in '${this.config.sharedSourceDir}'`
+      );
+    } else {
+      console.info(
+        `No shared directory found at '${this.config.sharedSourceDir}'`
+      );
+    }
+    const normalizedSharedPath = path__default.resolve(this.config.sharedSourceDir);
+    for (const content of contents) {
+      if (!content.isDirectory()) {
+        console.info(`Skipping '${content.name}' as it is not a directory`);
+        continue;
+      }
+      const entityName = content.name;
+      const entitySourceDir = path__default.resolve(this.config.sourceDir, entityName);
+      if (entitySourceDir === normalizedSharedPath || normalizedSharedPath.startsWith(entitySourceDir + path__default.sep)) {
+        console.info(
+          `Skipping '${content.name}' as it is or contains the shared directory`
+        );
+        continue;
+      }
+      const responseResources = await this.getEntityResponseResources(
+        entitySourceDir,
+        entityName,
+        validator
+      );
+      const operationResources = await this.getEntityOperationResources(
+        entitySourceDir,
+        entityName,
+        validator,
+        [...result.sharedResponseResources, ...responseResources]
+      );
+      result.entityResources[entityName] = {
+        operations: operationResources,
+        responses: responseResources
+      };
+      console.info(
+        `Found '${operationResources.length}' operation definitions for entity '${entityName}'`
+      );
+      if (responseResources.length > 0) {
+        console.info(
+          `Found '${responseResources.length}' response definitions for entity '${entityName}'`
+        );
+      }
+    }
+    return result;
   }
-  /**
-   * Generate possible plugin paths based on configured strategies
-   */
-  generatePluginPaths(pluginName) {
-    const paths = [];
-    for (const strategy of this.strategies) {
-      switch (strategy) {
-        case "npm":
-          paths.push(`@rexeus/typeweaver-${pluginName}`);
-          paths.push(`@rexeus/${pluginName}`);
-          break;
-        case "local":
-          paths.push(pluginName);
-          break;
+  scanDirectoryRecursively(dir) {
+    const files = [];
+    const contents = fs.readdirSync(dir, { withFileTypes: true });
+    for (const content of contents) {
+      const fullPath = path__default.join(dir, content.name);
+      if (content.isDirectory()) {
+        files.push(...this.scanDirectoryRecursively(fullPath));
+      } else if (content.isFile() && content.name.endsWith(".ts")) {
+        files.push(fullPath);
       }
     }
-    return paths;
+    return files;
   }
-  /**
-   * Report successful plugin loads
-   */
-  reportSuccessfulLoads(successful) {
-    if (successful.length > 0) {
-      console.info(`Successfully loaded ${successful.length} plugin(s):`);
-      for (const result of successful) {
-        console.info(`  - ${result.plugin.name} (from ${result.source})`);
+  async getSharedResponseResources(validator) {
+    const files = this.scanDirectoryRecursively(this.config.sharedSourceDir);
+    const sharedResponseResources = [];
+    for (const sourceFile of files) {
+      const sourceFileName = path__default.basename(sourceFile);
+      const definition = await import(sourceFile);
+      if (!definition.default) {
+        console.info(
+          `Skipping '${sourceFile}' as it does not have a default export`
+        );
+        continue;
+      }
+      if (!(definition.default instanceof HttpResponseDefinition)) {
+        console.info(
+          `Skipping '${sourceFile}' as it is not an instance of HttpResponseDefinition`
+        );
+        continue;
+      }
+      validator.validateResponse(definition.default, sourceFile);
+      const outputDir = this.config.sharedOutputDir;
+      const outputFileName = `${definition.default.name}Response.ts`;
+      const outputFile = path__default.join(outputDir, outputFileName);
+      sharedResponseResources.push({
+        ...definition.default,
+        sourceDir: this.config.sharedSourceDir,
+        sourceFile,
+        sourceFileName,
+        outputFile,
+        outputFileName,
+        outputDir
+      });
+    }
+    return sharedResponseResources;
+  }
+  async getEntityOperationResources(sourceDir, entityName, validator, referencedResponses) {
+    const files = this.scanDirectoryRecursively(sourceDir);
+    const definitions = [];
+    for (const sourceFile of files) {
+      const sourceFileName = path__default.basename(sourceFile);
+      const definition = await import(sourceFile);
+      if (!definition.default) {
+        console.info(
+          `Skipping '${sourceFile}' as it does not have a default export`
+        );
+        continue;
       }
+      if (!(definition.default instanceof HttpOperationDefinition)) {
+        console.info(
+          `Skipping '${sourceFile}' as it is not an instance of HttpOperationDefinition`
+        );
+        continue;
+      }
+      validator.validateOperation(definition.default, sourceFile);
+      const { operationId } = definition.default;
+      const outputDir = path__default.join(this.config.outputDir, entityName);
+      const outputRequestFileName = `${operationId}Request.ts`;
+      const outputRequestFile = path__default.join(outputDir, outputRequestFileName);
+      const outputResponseFileName = `${operationId}Response.ts`;
+      const outputResponseFile = path__default.join(outputDir, outputResponseFileName);
+      const outputRequestValidationFileName = `${operationId}RequestValidator.ts`;
+      const outputRequestValidationFile = path__default.join(
+        outputDir,
+        outputRequestValidationFileName
+      );
+      const outputResponseValidationFileName = `${operationId}ResponseValidator.ts`;
+      const outputResponseValidationFile = path__default.join(
+        outputDir,
+        outputResponseValidationFileName
+      );
+      const outputClientFileName = `${operationId}Client.ts`;
+      const outputClientFile = path__default.join(outputDir, outputClientFileName);
+      const operationResource = {
+        sourceDir,
+        sourceFile,
+        sourceFileName,
+        definition: {
+          ...definition.default,
+          responses: []
+        },
+        outputDir,
+        entityName,
+        outputRequestFile,
+        outputResponseFile,
+        outputResponseValidationFile,
+        outputRequestValidationFile,
+        outputRequestFileName,
+        outputRequestValidationFileName,
+        outputResponseFileName,
+        outputResponseValidationFileName,
+        outputClientFile,
+        outputClientFileName
+      };
+      if (!definition.default.responses) {
+        throw new Error(
+          `Operation '${operationId}' does not have any responses`
+        );
+      }
+      for (const response of definition.default.responses) {
+        if (referencedResponses.some((ref) => ref.name === response.name)) {
+          const referencedResponse = {
+            ...response,
+            statusCodeName: HttpStatusCodeNameMap[response.statusCode],
+            isReference: true
+          };
+          operationResource.definition.responses.push(referencedResponse);
+        } else {
+          const extendedResponse = {
+            ...response,
+            statusCodeName: HttpStatusCodeNameMap[response.statusCode],
+            isReference: false
+          };
+          operationResource.definition.responses.push(extendedResponse);
+        }
+      }
+      definitions.push(operationResource);
     }
+    return definitions;
+  }
+  async getEntityResponseResources(sourceDir, entityName, validator) {
+    const files = this.scanDirectoryRecursively(sourceDir);
+    const responseResources = [];
+    for (const sourceFile of files) {
+      const sourceFileName = path__default.basename(sourceFile);
+      const definition = await import(sourceFile);
+      if (!definition.default) {
+        continue;
+      }
+      if (!(definition.default instanceof HttpResponseDefinition)) {
+        continue;
+      }
+      validator.validateResponse(definition.default, sourceFile);
+      const outputFileName = `${definition.default.name}Response.ts`;
+      const outputFile = path__default.join(
+        this.config.outputDir,
+        entityName,
+        outputFileName
+      );
+      responseResources.push({
+        ...definition.default,
+        sourceDir,
+        sourceFile,
+        sourceFileName,
+        outputFile,
+        outputFileName,
+        outputDir: path__default.join(this.config.outputDir, entityName),
+        entityName
+      });
+    }
+    return responseResources;
   }
 }
 
@@ -23687,6 +23605,8 @@ class Generator {
   indexFileGenerator;
   resourceReader = null;
   prettier = null;
+  inputDir = "";
+  sharedInputDir = "";
   outputDir = "";
   sourceDir = "";
   sharedSourceDir = "";
@@ -23702,13 +23622,22 @@ class Generator {
    */
   async generate(definitionDir, outputDir, config) {
     console.info("Starting generation...");
-    this.initializeDirectories(definitionDir, outputDir);
+    this.initializeDirectories(definitionDir, outputDir, config?.shared);
     if (config?.clean ?? true) {
       console.info("Cleaning output directory...");
       fs.rmSync(this.outputDir, { recursive: true, force: true });
     }
     fs.mkdirSync(this.outputDir, { recursive: true });
     fs.mkdirSync(this.sharedOutputDir, { recursive: true });
+    console.info(
+      `Copying definitions from '${this.inputDir}' to '${this.sourceDir}'...`
+    );
+    fs.cpSync(this.inputDir, this.sourceDir, {
+      recursive: true,
+      filter: (src) => {
+        return src.endsWith(".ts") || src.endsWith(".js") || src.endsWith(".json") || src.endsWith(".mjs") || src.endsWith(".cjs") || fs.statSync(src).isDirectory();
+      }
+    });
     await this.pluginLoader.loadPlugins(config);
     this.resourceReader = new ResourceReader({
       sourceDir: this.sourceDir,
@@ -23766,22 +23695,24 @@ class Generator {
       `Generated files: ${this.contextBuilder.getGeneratedFiles().length}`
     );
   }
-  initializeDirectories(definitionDir, outputDir) {
-    this.sourceDir = definitionDir;
+  initializeDirectories(definitionDir, outputDir, sharedDir) {
+    this.inputDir = definitionDir;
+    this.sharedInputDir = sharedDir ?? path__default.join(definitionDir, "shared");
     this.outputDir = outputDir;
-    this.sharedSourceDir = path__default.join(definitionDir, "shared");
     this.sharedOutputDir = path__default.join(outputDir, "shared");
+    this.sourceDir = path__default.join(this.outputDir, "definition");
+    const inputToSharedDirRelative = path__default.relative(
+      this.inputDir,
+      this.sharedInputDir
+    );
+    this.sharedSourceDir = path__default.join(this.sourceDir, inputToSharedDirRelative);
   }
 }
 
-var version = "0.0.2";
-var packageJson = {
-	version: version};
-
 const program = new Command();
 const execDir = process.cwd();
 program.name("@rexeus/typeweaver").description("Type-safe API framework with code generation for TypeScript").version(packageJson.version);
-program.command("generate").description("Generate types, validators, and clients from API definitions").option("-i, --input <inputDir>", "path to definition directory").option("-o, --output <outputDir>", "output directory for generated files").option("-c, --config <configFile>", "path to configuration file").option("-p, --plugins <plugins>", "comma-separated list of plugins to use").option("--prettier", "format generated code with Prettier (default: true)").option("--no-prettier", "disable Prettier formatting").option("--clean", "clean output directory before generation (default: true)").option("--no-clean", "disable cleaning output directory").action(async (options) => {
+program.command("generate").description("Generate types, validators, and clients from API definitions").option("-i, --input <inputDir>", "path to definition directory").option("-o, --output <outputDir>", "output directory for generated files").option("-s, --shared <path>", "path to shared definitions directory").option("-c, --config <configFile>", "path to configuration file").option("-p, --plugins <plugins>", "comma-separated list of plugins to use").option("--prettier", "format generated code with Prettier (default: true)").option("--no-prettier", "disable Prettier formatting").option("--clean", "clean output directory before generation (default: true)").option("--no-clean", "disable cleaning output directory").action(async (options) => {
   let config = {};
   if (options.config) {
     const configPath = path__default.isAbsolute(options.config) ? options.config : path__default.join(execDir, options.config);
@@ -23798,6 +23729,7 @@ program.command("generate").description("Generate types, validators, and clients
   }
   const inputDir = options.input ?? config.input;
   const outputDir = options.output ?? config.output;
+  const sharedDir = options.shared ?? config.shared;
   if (!inputDir) {
     throw new Error(
       "No input directory provided. Use --input or specify in config file."
@@ -23810,9 +23742,11 @@ program.command("generate").description("Generate types, validators, and clients
   }
   const resolvedInputDir = path__default.isAbsolute(inputDir) ? inputDir : path__default.join(execDir, inputDir);
   const resolvedOutputDir = path__default.isAbsolute(outputDir) ? outputDir : path__default.join(execDir, outputDir);
+  const resolvedSharedDir = sharedDir ? path__default.isAbsolute(sharedDir) ? sharedDir : path__default.join(execDir, sharedDir) : void 0;
   const finalConfig = {
     input: resolvedInputDir,
     output: resolvedOutputDir,
+    shared: resolvedSharedDir,
     prettier: options.prettier ?? config.prettier ?? true,
     clean: options.clean ?? config.clean ?? true
   };
@@ -23824,7 +23758,7 @@ program.command("generate").description("Generate types, validators, and clients
   const generator = new Generator();
   return generator.generate(resolvedInputDir, resolvedOutputDir, finalConfig);
 });
-program.command("init").description("Initialize a new TypeWeaver project (coming soon)").action(() => {
+program.command("init").description("Initialize a new typeweaver project (coming soon)").action(() => {
   console.log("The init command is coming soon!");
 });
 program.parse(process.argv);