@codewithagents/openapi-server 1.7.0 → 1.9.0

package/dist/cli.cjs

@@ -18475,44 +18475,46 @@ function validateInputPath(resolvedInput) {
     }
   }
 }
-async function loadConfigFile(opts) {
-  const resolvedConfigPath = opts.configPath ?? (0, import_node_path.join)(opts.cwd, opts.defaultFileName);
-  if (opts.configPath !== void 0) {
-    validateConfigPath(opts.configPath);
+async function loadJsConfig(resolvedConfigPath) {
+  let mod;
+  try {
+    mod = await import((0, import_node_url.pathToFileURL)(resolvedConfigPath).href);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Failed to load JS config file: ${resolvedConfigPath}
+${message}`);
+  }
+  const exported = mod["default"] ?? mod;
+  if (typeof exported !== "object" || exported === null) {
+    throw new Error("Config must be a JSON object");
   }
-  let raw;
+  return exported;
+}
+async function loadJsonConfig(resolvedConfigPath) {
+  let fileContents;
+  try {
+    fileContents = await (0, import_promises.readFile)(resolvedConfigPath, "utf-8");
+  } catch {
+    throw new Error(`Config file not found: ${resolvedConfigPath}`);
+  }
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(fileContents);
+  } catch {
+    throw new Error(`Config file is not valid JSON: ${resolvedConfigPath}`);
+  }
+  if (typeof parsed2 !== "object" || parsed2 === null) {
+    throw new Error("Config must be a JSON object");
+  }
+  return parsed2;
+}
+async function loadRawConfig(resolvedConfigPath) {
   if (isJsConfigPath(resolvedConfigPath)) {
-    let mod;
-    try {
-      mod = await import((0, import_node_url.pathToFileURL)(resolvedConfigPath).href);
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      throw new Error(`Failed to load JS config file: ${resolvedConfigPath}
-${message}`);
-    }
-    const exported = mod["default"] ?? mod;
-    if (typeof exported !== "object" || exported === null) {
-      throw new Error("Config must be a JSON object");
-    }
-    raw = exported;
-  } else {
-    let fileContents;
-    try {
-      fileContents = await (0, import_promises.readFile)(resolvedConfigPath, "utf-8");
-    } catch {
-      throw new Error(`Config file not found: ${resolvedConfigPath}`);
-    }
-    let parsed2;
-    try {
-      parsed2 = JSON.parse(fileContents);
-    } catch {
-      throw new Error(`Config file is not valid JSON: ${resolvedConfigPath}`);
-    }
-    if (typeof parsed2 !== "object" || parsed2 === null) {
-      throw new Error("Config must be a JSON object");
-    }
-    raw = parsed2;
+    return loadJsConfig(resolvedConfigPath);
   }
+  return loadJsonConfig(resolvedConfigPath);
+}
+function parseBaseConfig(raw, cwd) {
   if (typeof raw["input_openapi"] !== "string" || !raw["input_openapi"]) {
     throw new Error('Config missing required field: "input_openapi" (path to OpenAPI 3.1 spec)');
   }
@@ -18521,34 +18523,80 @@ ${message}`);
   }
   const input_openapi = raw["input_openapi"];
   const output = raw["output"];
-  validateInputPath((0, import_node_path.resolve)(opts.cwd, input_openapi));
-  validateOutputPath((0, import_node_path.resolve)(opts.cwd, output));
-  const base = { input_openapi, output };
-  return opts.parse(raw, base, opts.cwd);
+  validateInputPath((0, import_node_path.resolve)(cwd, input_openapi));
+  validateOutputPath((0, import_node_path.resolve)(cwd, output));
+  return { input_openapi, output };
 }
-
-// src/config.ts
-async function loadConfig(cwd, configPath) {
-  return loadConfigFile({
-    cwd,
-    configPath,
-    defaultFileName: "openapi-server.config.json",
-    parse: (raw) => {
-      const framework = raw["framework"];
-      if (framework !== void 0 && framework !== "hono" && framework !== "express" && framework !== "fastify" && framework !== "none") {
-        throw new Error('"framework" must be one of: "hono", "express", "fastify", or "none"');
-      }
-      if (raw["input_schema"] !== void 0 && (typeof raw["input_schema"] !== "string" || !raw["input_schema"])) {
-        throw new Error('"input_schema" must be a non-empty string path to your Zod schema file');
-      }
-      return {
-        input_openapi: raw["input_openapi"],
-        output: raw["output"],
-        framework,
-        input_schema: raw["input_schema"]
-      };
+async function prepareRaw(opts) {
+  const resolvedConfigPath = opts.configPath ?? (0, import_node_path.join)(opts.cwd, opts.defaultFileName);
+  if (opts.configPath !== void 0) {
+    validateConfigPath(opts.configPath);
+  }
+  return { raw: await loadRawConfig(resolvedConfigPath) };
+}
+function parseProjectEntry(entry, index, opts) {
+  if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+    throw new Error(`projects[${index}]: entry must be a config object`);
+  }
+  const projectRaw = entry;
+  let base;
+  try {
+    base = parseBaseConfig(projectRaw, opts.cwd);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`projects[${index}]: ${message}`);
+  }
+  try {
+    return opts.parse(projectRaw, base, opts.cwd);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`projects[${index}]: ${message}`);
+  }
+}
+async function loadConfigsFile(opts) {
+  const { raw } = await prepareRaw(opts);
+  if ("projects" in raw) {
+    return parseProjectsArray(raw, opts);
+  }
+  const base = parseBaseConfig(raw, opts.cwd);
+  return [opts.parse(raw, base, opts.cwd)];
+}
+function parseProjectsArray(raw, opts) {
+  const hasTopLevelInput = "input_openapi" in raw && raw["input_openapi"] !== void 0;
+  const hasTopLevelOutput = "output" in raw && raw["output"] !== void 0;
+  if (hasTopLevelInput || hasTopLevelOutput) {
+    throw new Error('Config cannot have both top-level "input_openapi"/"output" and a "projects" array. Use one form or the other.');
+  }
+  const projects = raw["projects"];
+  if (!Array.isArray(projects)) {
+    throw new Error('"projects" must be an array of config objects');
+  }
+  if (projects.length === 0) {
+    throw new Error('"projects" array must contain at least one config entry');
+  }
+  return projects.map((entry, index) => parseProjectEntry(entry, index, opts));
+}
+async function runProjects(configs, generateOne2) {
+  if (configs.length === 0) {
+    throw new Error("runProjects requires at least one config entry");
+  }
+  if (configs.length === 1) {
+    await generateOne2(configs[0]);
+    return;
+  }
+  for (let i = 0; i < configs.length; i++) {
+    const label = `${i + 1}/${configs.length}`;
+    console.log(`
+[${label}] generating ${configs[i].input_openapi}...`);
+    try {
+      await generateOne2(configs[i], label);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`[${label}] Project failed (${configs[i].input_openapi}): ${message}`);
     }
-  });
+  }
+  console.log(`
+All ${configs.length} projects generated successfully.`);
 }
 
 // ../openapi-zod-ts/dist/parser.js
@@ -18787,7 +18835,31 @@ function toTypeName(name) {
   return safe.length > 0 ? safe : "_";
 }
 
-// src/plugins/service.ts
+// src/config.ts
+function parseServerConfig(raw, base) {
+  const framework = raw["framework"];
+  if (framework !== void 0 && framework !== "hono" && framework !== "express" && framework !== "fastify" && framework !== "none") {
+    throw new Error('"framework" must be one of: "hono", "express", "fastify", or "none"');
+  }
+  if (raw["input_schema"] !== void 0 && (typeof raw["input_schema"] !== "string" || !raw["input_schema"])) {
+    throw new Error('"input_schema" must be a non-empty string path to your Zod schema file');
+  }
+  return {
+    ...base,
+    framework,
+    input_schema: raw["input_schema"]
+  };
+}
+async function loadConfigs2(cwd, configPath) {
+  return loadConfigsFile({
+    cwd,
+    configPath,
+    defaultFileName: "openapi-server.config.json",
+    parse: parseServerConfig
+  });
+}
+
+// src/plugins/shared.ts
 var SUPPORTED_METHODS = ["get", "post", "put", "patch", "delete"];
 function isRef3(obj) {
   return typeof obj === "object" && obj !== null && "$ref" in obj;
@@ -18799,7 +18871,7 @@ function refToName(ref) {
 function extractPathParamsFromPath(path) {
   const matches = path.match(/\{([^}]+)\}/g);
   if (matches === null) return [];
-  return matches.map((m) => sanitizeOperationId2(m.slice(1, -1)));
+  return matches.map((m) => m.slice(1, -1));
 }
 function resolveParam(p, spec) {
   if (!isRef3(p)) return p;
@@ -18866,6 +18938,13 @@ function normalizeParamName(name) {
   const camel = parts.map((part, i) => i === 0 ? part : part[0].toUpperCase() + part.slice(1)).join("");
   return /^[^a-zA-Z_$]/.test(camel) ? `_${camel}` : camel;
 }
+function schemaToTsType(schema) {
+  if (schema === void 0 || isRef3(schema)) return "string";
+  const s = schema;
+  if (s.type === "number" || s.type === "integer") return "number";
+  if (s.type === "boolean") return "boolean";
+  return "string";
+}
 function getQueryParams(operation, spec) {
   const parameters = operation.parameters;
   if (parameters === void 0) return [];
@@ -18874,39 +18953,131 @@ function getQueryParams(operation, spec) {
     const resolved = resolveParam(p, spec);
     if (resolved === void 0 || resolved.in !== "query") continue;
     const schema = resolved.schema;
-    let tsType = "string";
+    const resolvedStyle = resolved.style;
+    const resolvedExplode = resolved.explode;
+    const param = {
+      name: normalizeParamName(resolved.name),
+      rawName: resolved.name,
+      tsType: schemaToTsType(schema),
+      required: resolved.required === true
+    };
+    if (resolvedStyle === "deepObject" && schema !== void 0 && !isRef3(schema)) {
+      const s = schema;
+      if (s.type === "object" && s.properties !== void 0) {
+        param.isDeepObject = true;
+        param.deepObjectProperties = Object.entries(s.properties).map(([key, propSchema]) => ({
+          key,
+          tsType: schemaToTsType(propSchema)
+        }));
+      }
+    }
+    if (!param.isDeepObject && schema !== void 0 && !isRef3(schema) && schema.type === "array" && resolvedExplode === false) {
+      if (resolvedStyle === "spaceDelimited") {
+        param.delimiterStyle = "ssv";
+      } else if (resolvedStyle === "pipeDelimited") {
+        param.delimiterStyle = "psv";
+      } else {
+        param.delimiterStyle = "csv";
+      }
+    }
     if (schema !== void 0 && !isRef3(schema)) {
       const s = schema;
-      if (s.type === "number" || s.type === "integer") tsType = "number";
-      else if (s.type === "boolean") tsType = "boolean";
+      if (Array.isArray(s.enum)) param.enum = s.enum;
+      if (typeof s.minimum === "number") param.minimum = s.minimum;
+      if (typeof s.maximum === "number") param.maximum = s.maximum;
+      if (typeof s.exclusiveMinimum === "number") param.exclusiveMinimum = s.exclusiveMinimum;
+      if (typeof s.exclusiveMaximum === "number") param.exclusiveMaximum = s.exclusiveMaximum;
+      if (typeof s.minLength === "number") param.minLength = s.minLength;
+      if (typeof s.maxLength === "number") param.maxLength = s.maxLength;
+      if (typeof s.pattern === "string") param.pattern = s.pattern;
     }
-    result.push({
-      name: normalizeParamName(resolved.name),
-      tsType,
-      required: resolved.required === true
-    });
+    result.push(param);
   }
   return result;
 }
 function getBodyInfo(operation) {
   const requestBody = operation.requestBody;
   if (requestBody === void 0) return void 0;
-  if (isRef3(requestBody)) return { typeName: void 0 };
+  if (isRef3(requestBody)) {
+    return { typeName: void 0, contentType: "application/json", isSynthesized: false };
+  }
   const rb = requestBody;
   const content = rb.content;
-  if (content === void 0) return { typeName: void 0 };
+  if (content === void 0) {
+    return { typeName: void 0, contentType: "application/json", isSynthesized: false };
+  }
   const jsonContent = content["application/json"];
-  if (jsonContent === void 0 || jsonContent.schema === void 0) return { typeName: void 0 };
-  const schema = jsonContent.schema;
-  if (isRef3(schema)) {
-    return { typeName: refToName(schema.$ref) };
+  if (jsonContent !== void 0 && jsonContent.schema !== void 0) {
+    const schema = jsonContent.schema;
+    if (isRef3(schema)) {
+      return {
+        typeName: refToName(schema.$ref),
+        contentType: "application/json",
+        isSynthesized: false
+      };
+    }
+    const operationId = operation.operationId;
+    if (operationId !== void 0 && operationId.length > 0) {
+      return { typeName: toTypeName(operationId), contentType: "application/json", isSynthesized: true };
+    }
+    return { typeName: void 0, contentType: "application/json", isSynthesized: false };
+  }
+  const formContent = content["application/x-www-form-urlencoded"];
+  if (formContent !== void 0) {
+    const schema = formContent.schema;
+    if (schema !== void 0 && isRef3(schema)) {
+      return {
+        typeName: refToName(schema.$ref),
+        contentType: "application/x-www-form-urlencoded",
+        isSynthesized: false
+      };
+    }
+    const operationId = operation.operationId;
+    if (operationId !== void 0 && operationId.length > 0) {
+      return {
+        typeName: toTypeName(operationId),
+        contentType: "application/x-www-form-urlencoded",
+        isSynthesized: true
+      };
+    }
+    return { typeName: void 0, contentType: "application/x-www-form-urlencoded", isSynthesized: false };
   }
-  return { typeName: void 0 };
+  const multipartContent = content["multipart/form-data"];
+  if (multipartContent !== void 0) {
+    const schema = multipartContent.schema;
+    if (schema !== void 0 && isRef3(schema)) {
+      return {
+        typeName: refToName(schema.$ref),
+        contentType: "multipart/form-data",
+        isSynthesized: false
+      };
+    }
+    const operationId = operation.operationId;
+    if (operationId !== void 0 && operationId.length > 0) {
+      return {
+        typeName: toTypeName(operationId),
+        contentType: "multipart/form-data",
+        isSynthesized: true
+      };
+    }
+    return { typeName: void 0, contentType: "multipart/form-data", isSynthesized: false };
+  }
+  return { typeName: void 0, contentType: "application/json", isSynthesized: false };
+}
+
+// src/plugins/service.ts
+function collectContentfulTwoxxCodes(responses) {
+  return Object.keys(responses).filter((k) => /^2\d\d$/.test(k) && k !== "204").sort();
 }
 function getReturnInfo(operation) {
   const responses = operation.responses;
   if (responses === void 0) return { typeName: void 0, isArray: false, isVoid: true };
-  for (const code of ["200", "201"]) {
+  const contentfulCodes = collectContentfulTwoxxCodes(responses);
+  const isMultiStatus = contentfulCodes.length > 1;
+  const twoxxCodes = ["200", "201", ...Object.keys(responses).filter(
+    (k) => /^2\d\d$/.test(k) && k !== "200" && k !== "201" && k !== "204"
+  )];
+  for (const code of twoxxCodes) {
     const response = responses[code];
     if (response === void 0) continue;
     if (isRef3(response)) continue;
@@ -18914,28 +19085,37 @@ function getReturnInfo(operation) {
     const content = resp.content;
     if (content === void 0) continue;
     const jsonContent = content["application/json"];
-    if (jsonContent === void 0 || jsonContent.schema === void 0) continue;
-    const schema = jsonContent.schema;
-    if (isRef3(schema)) {
-      return {
-        typeName: refToName(schema.$ref),
-        isArray: false,
-        isVoid: false
-      };
-    }
-    const s = schema;
-    if (s.type === "array") {
-      const items = s.items;
-      if (items !== void 0 && isRef3(items)) {
+    if (jsonContent !== void 0 && jsonContent.schema !== void 0) {
+      const schema = jsonContent.schema;
+      if (isRef3(schema)) {
         return {
-          typeName: refToName(items.$ref),
-          isArray: true,
-          isVoid: false
+          typeName: refToName(schema.$ref),
+          isArray: false,
+          isVoid: false,
+          isMultiStatus
         };
       }
-      return { typeName: void 0, isArray: true, isVoid: false };
+      const s = schema;
+      if (s.type === "array") {
+        const items = s.items;
+        if (items !== void 0 && isRef3(items)) {
+          return {
+            typeName: refToName(items.$ref),
+            isArray: true,
+            isVoid: false,
+            isMultiStatus
+          };
+        }
+        return { typeName: void 0, isArray: true, isVoid: false, isMultiStatus };
+      }
+      return { typeName: void 0, isArray: false, isVoid: false, isMultiStatus };
+    }
+    if (content["text/plain"] !== void 0) {
+      return { typeName: void 0, isArray: false, isVoid: false, primitiveType: "string" };
+    }
+    if (content["application/octet-stream"] !== void 0) {
+      return { typeName: void 0, isArray: false, isVoid: false, primitiveType: "Uint8Array" };
     }
-    return { typeName: void 0, isArray: false, isVoid: false };
   }
   if (responses["204"] !== void 0) {
     return { typeName: void 0, isArray: false, isVoid: true };
@@ -18944,6 +19124,16 @@ function getReturnInfo(operation) {
 }
 function buildReturnType(info) {
   if (info.isVoid) return "Promise<void>";
+  if (info.primitiveType !== void 0) return `Promise<${info.primitiveType}>`;
+  if (info.isMultiStatus === true) {
+    let bodyType;
+    if (info.typeName !== void 0) {
+      bodyType = info.isArray ? `${info.typeName}[]` : info.typeName;
+    } else {
+      bodyType = info.isArray ? "unknown[]" : "unknown";
+    }
+    return `Promise<{ status: number; body: ${bodyType} }>`;
+  }
   if (info.typeName !== void 0) {
     return info.isArray ? `Promise<${info.typeName}[]>` : `Promise<${info.typeName}>`;
   }
@@ -18978,10 +19168,10 @@ function collectOperations(spec) {
 function buildMethodSignature(op) {
   const args = [];
   for (const p of op.pathParams) {
-    args.push(`${p}: string`);
+    args.push(`${sanitizeOperationId2(p)}: string`);
   }
   if (op.bodyInfo !== void 0) {
-    const typeName = op.bodyInfo.typeName ?? "unknown";
+    const typeName = op.bodyInfo.typeName !== void 0 && !op.bodyInfo.isSynthesized ? op.bodyInfo.typeName : "unknown";
     args.push(`body: ${typeName}`);
   }
   if (op.queryParams.length > 0) {
@@ -18999,7 +19189,7 @@ function generateService(spec) {
   const operations = collectOperations(spec);
   const importTypes = /* @__PURE__ */ new Set();
   for (const op of operations) {
-    if (op.bodyInfo?.typeName !== void 0) {
+    if (op.bodyInfo?.typeName !== void 0 && !op.bodyInfo.isSynthesized) {
       importTypes.add(op.bodyInfo.typeName);
     }
     if (op.returnInfo.typeName !== void 0) {
@@ -19028,110 +19218,9 @@ function generateService(spec) {
 }
 
 // src/plugins/router.ts
-var SUPPORTED_METHODS2 = ["get", "post", "put", "patch", "delete"];
-function isRef4(obj) {
-  return typeof obj === "object" && obj !== null && "$ref" in obj;
-}
-function refToName2(ref) {
-  const parts = ref.split("/");
-  return toTypeName(parts[parts.length - 1]);
-}
-function extractPathParamsFromPath2(path) {
-  const matches = path.match(/\{([^}]+)\}/g);
-  if (matches === null) return [];
-  return matches.map((m) => m.slice(1, -1));
-}
 function toHonoPath(openapiPath) {
   return openapiPath.replace(/\{([^}]+)\}/g, ":$1");
 }
-function resolveParam2(p, spec) {
-  if (!isRef4(p)) return p;
-  const refStr = p.$ref;
-  const name = refToName2(refStr);
-  const components = spec.components;
-  if (components?.parameters === void 0) return void 0;
-  const resolved = components.parameters[name];
-  if (resolved === void 0 || isRef4(resolved)) return void 0;
-  return resolved;
-}
-function deriveServiceName2(spec) {
-  const title = spec.info?.title ?? "";
-  const pascal = title.replace(/[^a-zA-Z0-9 ]/g, "").split(/\s+/).filter((s) => s.length > 0).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
-  if (pascal.length === 0) return "ApiService";
-  const safePascal = /^[0-9]/.test(pascal) ? `_${pascal}` : pascal;
-  if (safePascal.endsWith("Service")) return safePascal;
-  return `${safePascal}Service`;
-}
-function sanitizeOperationId3(id) {
-  const parts = id.replace(/'/g, "").split(/[^a-zA-Z0-9]+/).filter(Boolean);
-  if (parts.length === 0) return "unknown";
-  const [first = "", ...rest] = parts;
-  const camel = first.charAt(0).toLowerCase() + first.slice(1) + rest.map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
-  return /^[0-9]/.test(camel) ? `_${camel}` : camel;
-}
-function deriveMethodName2(operationId, method, path) {
-  if (operationId !== void 0 && operationId.length > 0) {
-    return sanitizeOperationId3(operationId);
-  }
-  return deriveOperationName3(method, path);
-}
-function deriveOperationName3(method, path) {
-  const prefixMap = {
-    get: "get",
-    post: "create",
-    put: "update",
-    patch: "patch",
-    delete: "delete"
-  };
-  const prefix = prefixMap[method] ?? method;
-  const segments = path.replace(/^\/api\/v\d+\//, "").replace(/^\//, "");
-  const parts = segments.split("/").map((seg) => {
-    const paramMatches = seg.match(/\{([^}]+)\}/g);
-    if (paramMatches !== null && !(seg.startsWith("{") && seg.endsWith("}"))) {
-      return paramMatches.map((m) => {
-        const name = sanitizeOperationId3(m.slice(1, -1));
-        return "By" + name.charAt(0).toUpperCase() + name.slice(1);
-      }).join("");
-    }
-    if (seg.startsWith("{") && seg.endsWith("}")) {
-      const name = seg.slice(1, -1);
-      const sanitized = sanitizeOperationId3(name);
-      return "By" + sanitized.charAt(0).toUpperCase() + sanitized.slice(1);
-    }
-    return toTypeName(seg);
-  });
-  return prefix + parts.join("");
-}
-function normalizeParamName2(name) {
-  const stripped = name.replace(/\[\]$/, "").replace(/'/g, "");
-  const parts = stripped.split(/[^a-zA-Z0-9]+/).filter(Boolean);
-  if (parts.length === 0) return "_";
-  const camel = parts.map((part, i) => i === 0 ? part : part[0].toUpperCase() + part.slice(1)).join("");
-  return /^[^a-zA-Z_$]/.test(camel) ? `_${camel}` : camel;
-}
-function schemaToTsType(schema) {
-  if (schema === void 0 || isRef4(schema)) return "string";
-  const s = schema;
-  if (s.type === "number" || s.type === "integer") return "number";
-  if (s.type === "boolean") return "boolean";
-  return "string";
-}
-function getQueryParams2(operation, spec) {
-  const parameters = operation.parameters;
-  if (parameters === void 0) return [];
-  const result = [];
-  for (const p of parameters) {
-    const resolved = resolveParam2(p, spec);
-    if (resolved === void 0 || resolved.in !== "query") continue;
-    const schema = resolved.schema;
-    result.push({
-      name: normalizeParamName2(resolved.name),
-      tsType: schemaToTsType(schema),
-      required: resolved.required === true
-    });
-  }
-  return result;
-}
 function formatToZodModifier(format) {
   switch (format) {
     case "uuid":
@@ -19148,8 +19237,23 @@ function formatToZodModifier(format) {
   }
 }
 function pathParamZodExpr(schema) {
-  if (schema === void 0 || isRef4(schema)) return void 0;
+  if (schema === void 0 || isRef3(schema)) return void 0;
   const s = schema;
+  if (s.type === "integer" || s.type === "number") {
+    const hasMin = typeof s.minimum === "number";
+    const hasMax = typeof s.maximum === "number";
+    const hasExcMin = typeof s.exclusiveMinimum === "number";
+    const hasExcMax = typeof s.exclusiveMaximum === "number";
+    if (hasMin || hasMax || hasExcMin || hasExcMax) {
+      let expr = "z.coerce.number()";
+      if (hasMin) expr += `.min(${s.minimum})`;
+      if (hasMax) expr += `.max(${s.maximum})`;
+      if (hasExcMin) expr += `.gt(${s.exclusiveMinimum})`;
+      if (hasExcMax) expr += `.lt(${s.exclusiveMaximum})`;
+      return expr;
+    }
+    return void 0;
+  }
   if (s.type !== "string") return void 0;
   const format = s.format;
   if (format === void 0) return void 0;
@@ -19157,30 +19261,71 @@ function pathParamZodExpr(schema) {
   if (modifier === "") return void 0;
   return `z.string()${modifier}`;
 }
-function paramZodExpr(tsType, required, schema) {
+function queryParamDelimitedZodBase(_param) {
+  return "z.array(z.string())";
+}
+function queryParamDeepObjectZodBase(param) {
+  const propFields = (param.deepObjectProperties ?? []).map((p) => {
+    const coerced = p.tsType === "number" ? "z.coerce.number()" : "z.string()";
+    return `${p.key}: ${coerced}.optional()`;
+  });
+  return `z.object({ ${propFields.join(", ")} })`;
+}
+function queryParamNumberZodBase(param) {
+  let base = "z.number()";
+  if (param.minimum !== void 0) base += `.min(${param.minimum})`;
+  if (param.maximum !== void 0) base += `.max(${param.maximum})`;
+  if (param.exclusiveMinimum !== void 0) base += `.gt(${param.exclusiveMinimum})`;
+  if (param.exclusiveMaximum !== void 0) base += `.lt(${param.exclusiveMaximum})`;
+  return base;
+}
+function queryParamStringZodBase(param) {
+  let base;
+  if (param.enum !== void 0 && param.enum.length > 0) {
+    const members = param.enum.map((v) => JSON.stringify(v)).join(", ");
+    base = `z.enum([${members}])`;
+  } else {
+    base = "z.string()";
+  }
+  if (param.minLength !== void 0) base += `.min(${param.minLength})`;
+  if (param.maxLength !== void 0) base += `.max(${param.maxLength})`;
+  if (param.pattern !== void 0) base += `.regex(/${param.pattern}/)`;
+  return base;
+}
+function queryParamZodExpr(param) {
   let base;
-  if (tsType === "number") {
-    base = "z.number()";
-  } else if (tsType === "boolean") {
+  if (param.delimiterStyle !== void 0) {
+    base = queryParamDelimitedZodBase(param);
+  } else if (param.isDeepObject === true && param.deepObjectProperties !== void 0) {
+    base = queryParamDeepObjectZodBase(param);
+  } else if (param.tsType === "number") {
+    base = queryParamNumberZodBase(param);
+  } else if (param.tsType === "boolean") {
     base = "z.boolean()";
   } else {
-    if (schema !== void 0 && !isRef4(schema)) {
-      const s = schema;
-      const format = s.format;
-      const modifier = format !== void 0 ? formatToZodModifier(format) : "";
-      base = `z.string()${modifier}`;
-    } else {
-      base = "z.string()";
-    }
+    base = queryParamStringZodBase(param);
   }
-  return required ? base : `${base}.optional()`;
+  return param.required ? base : `${base}.optional()`;
+}
+function headerParamZodExpr(param) {
+  let base;
+  if (param.enum !== void 0 && param.enum.length > 0) {
+    const members = param.enum.map((v) => JSON.stringify(v)).join(", ");
+    base = `z.enum([${members}])`;
+  } else {
+    base = "z.string()";
+  }
+  if (param.minLength !== void 0) base += `.min(${param.minLength})`;
+  if (param.maxLength !== void 0) base += `.max(${param.maxLength})`;
+  if (param.pattern !== void 0) base += `.regex(/${param.pattern}/)`;
+  return param.required ? base : `${base}.optional()`;
 }
 function getPathParamValidations(operation, spec, rawPathParamNames) {
   const parameters = operation.parameters;
   if (parameters === void 0) return [];
   const zodByName = /* @__PURE__ */ new Map();
   for (const p of parameters) {
-    const resolved = resolveParam2(p, spec);
+    const resolved = resolveParam(p, spec);
     if (resolved === void 0 || resolved.in !== "path") continue;
     const schema = resolved.schema;
     const zodExpr = pathParamZodExpr(schema);
@@ -19198,23 +19343,53 @@ function getHeaderParams(operation, spec) {
   if (parameters === void 0) return [];
   const result = [];
   for (const p of parameters) {
-    const resolved = resolveParam2(p, spec);
+    const resolved = resolveParam(p, spec);
     if (resolved === void 0 || resolved.in !== "header") continue;
-    result.push({
+    const param = {
       rawName: resolved.name,
       required: resolved.required === true
-    });
+    };
+    const schema = resolved.schema;
+    if (schema !== void 0 && !isRef3(schema)) {
+      const s = schema;
+      if (Array.isArray(s.enum)) param.enum = s.enum;
+      if (typeof s.minLength === "number") param.minLength = s.minLength;
+      if (typeof s.maxLength === "number") param.maxLength = s.maxLength;
+      if (typeof s.pattern === "string") param.pattern = s.pattern;
+    }
+    result.push(param);
   }
   return result;
 }
+function queryParamHasConstraints(q) {
+  const constraintFields = [
+    q.enum,
+    q.minimum,
+    q.maximum,
+    q.exclusiveMinimum,
+    q.exclusiveMaximum,
+    q.minLength,
+    q.maxLength,
+    q.pattern,
+    q.delimiterStyle
+  ];
+  return constraintFields.some((f) => f !== void 0) || q.isDeepObject === true;
+}
 function queryParamsNeedValidation(queryParams) {
-  return queryParams.some((q) => q.required || q.tsType !== "string");
+  return queryParams.some(
+    (q) => q.required || q.tsType !== "string" || queryParamHasConstraints(q)
+  );
+}
+function delimiterChar(style) {
+  if (style === "ssv") return " ";
+  if (style === "psv") return "|";
+  return ",";
 }
 function emitQueryValidation(lines, queryParams, indent) {
   const inner = `${indent}  `;
   const fieldIndent = `${indent}    `;
   const fields = queryParams.map((q) => {
-    const expr = paramZodExpr(q.tsType, q.required);
+    const expr = queryParamZodExpr(q);
     return `${fieldIndent}${q.name}: ${expr}`;
   }).join(",\n");
   lines.push(`${inner}// Validate query parameters: returns 422 with Zod issues on failure`);
@@ -19253,7 +19428,7 @@ function emitHeaderValidation(lines, headerParams, indent, framework) {
   const fieldIndent = `${indent}    `;
   const schemaFields = headerParams.map((h) => {
     const key = JSON.stringify(h.rawName);
-    const expr = h.required ? "z.string()" : "z.string().optional()";
+    const expr = headerParamZodExpr(h);
     return `${fieldIndent}${key}: ${expr}`;
   }).join(",\n");
   const rawFields = headerParams.map((h) => {
@@ -19275,54 +19450,84 @@ function emitHeaderValidation(lines, headerParams, indent, framework) {
   lines.push(rawFields);
   lines.push(`${inner}})`);
 }
-function getBodyInfo2(operation) {
-  const requestBody = operation.requestBody;
-  if (requestBody === void 0) return void 0;
-  if (isRef4(requestBody)) return { typeName: void 0 };
-  const rb = requestBody;
-  const content = rb.content;
-  if (content === void 0) return { typeName: void 0 };
-  const jsonContent = content["application/json"];
-  if (jsonContent === void 0 || jsonContent.schema === void 0) return { typeName: void 0 };
-  const schema = jsonContent.schema;
-  if (isRef4(schema)) {
-    return { typeName: refToName2(schema.$ref) };
-  }
-  return { typeName: void 0 };
-}
 function response200IsVoid(resp) {
-  if (isRef4(resp)) return false;
+  if (isRef3(resp)) return false;
   const r = resp;
   const content = r.content;
   return content === void 0 || Object.keys(content).length === 0;
 }
+function detectResponseContentType(resp) {
+  if (isRef3(resp)) return "application/json";
+  const r = resp;
+  const content = r.content;
+  if (content === void 0) return "application/json";
+  if ("text/plain" in content) return "text/plain";
+  if ("application/octet-stream" in content) return "application/octet-stream";
+  return "application/json";
+}
 function getResponseStatus(operation, httpMethod) {
   const responses = operation.responses;
   if (responses === void 0) {
-    return httpMethod === "delete" ? { status: 204, isVoid: true } : { status: 200, isVoid: false };
+    return httpMethod === "delete" ? { status: 204, isVoid: true, responseContentType: "application/json" } : { status: 200, isVoid: false, responseContentType: "application/json" };
+  }
+  const contentfulTwoxxKeys = Object.keys(responses).filter((k) => /^2\d\d$/.test(k) && k !== "204").sort();
+  if (contentfulTwoxxKeys.length > 1) {
+    return {
+      status: 200,
+      isVoid: false,
+      responseContentType: "application/json",
+      isMultiStatus: true
+    };
+  }
+  if (responses["201"] !== void 0) {
+    return {
+      status: 201,
+      isVoid: false,
+      responseContentType: detectResponseContentType(responses["201"])
+    };
+  }
+  if (responses["204"] !== void 0) {
+    return { status: 204, isVoid: true, responseContentType: "application/json" };
   }
-  if (responses["201"] !== void 0) return { status: 201, isVoid: false };
-  if (responses["204"] !== void 0) return { status: 204, isVoid: true };
   if (responses["200"] !== void 0) {
-    if (response200IsVoid(responses["200"])) return { status: 204, isVoid: true };
-    return { status: 200, isVoid: false };
+    if (response200IsVoid(responses["200"])) {
+      return { status: 204, isVoid: true, responseContentType: "application/json" };
+    }
+    return {
+      status: 200,
+      isVoid: false,
+      responseContentType: detectResponseContentType(responses["200"])
+    };
   }
-  return httpMethod === "delete" ? { status: 204, isVoid: true } : { status: 200, isVoid: false };
+  const twoxxKeys = Object.keys(responses).filter(
+    (k) => /^2\d\d$/.test(k) && k !== "200" && k !== "201" && k !== "204"
+  );
+  if (twoxxKeys.length === 1) {
+    const code = parseInt(twoxxKeys[0], 10);
+    const resp = responses[twoxxKeys[0]];
+    const isVoid = isRef3(resp) ? false : (() => {
+      const r = resp;
+      const content = r.content;
+      return content === void 0 || Object.keys(content).length === 0;
+    })();
+    return { status: code, isVoid, responseContentType: detectResponseContentType(resp) };
+  }
+  return httpMethod === "delete" ? { status: 204, isVoid: true, responseContentType: "application/json" } : { status: 200, isVoid: false, responseContentType: "application/json" };
 }
 function collectOperations2(spec) {
   const paths = spec.paths;
   if (paths === void 0) return [];
   const operations = [];
   for (const [path, pathItem] of Object.entries(paths)) {
-    for (const method of SUPPORTED_METHODS2) {
+    for (const method of SUPPORTED_METHODS) {
       const operation = pathItem[method];
       if (operation === void 0) continue;
-      const methodName = deriveMethodName2(operation.operationId, method, path);
-      const pathParams = extractPathParamsFromPath2(path);
+      const methodName = deriveMethodName(operation.operationId, method, path);
+      const pathParams = extractPathParamsFromPath(path);
       const pathParamValidations = getPathParamValidations(operation, spec, pathParams);
-      const queryParams = getQueryParams2(operation, spec);
+      const queryParams = getQueryParams(operation, spec);
       const headerParams = getHeaderParams(operation, spec);
-      const bodyInfo = getBodyInfo2(operation);
+      const bodyInfo = getBodyInfo(operation);
       const responseStatus = getResponseStatus(operation, method);
       operations.push({
         methodName,
@@ -19343,7 +19548,9 @@ function collectOperations2(spec) {
 function collectSortedBodyTypes(operations) {
   const bodyTypes = /* @__PURE__ */ new Set();
   for (const op of operations) {
-    if (op.bodyInfo?.typeName !== void 0) bodyTypes.add(op.bodyInfo.typeName);
+    if (op.bodyInfo?.typeName !== void 0 && !op.bodyInfo.isSynthesized) {
+      bodyTypes.add(op.bodyInfo.typeName);
+    }
   }
   return Array.from(bodyTypes).sort();
 }
@@ -19375,7 +19582,27 @@ function buildRouteHandler(op, indent, schemaNames) {
     lines.push(`${indent}  }`);
   }
   if (op.queryParams.length > 0) {
+    const deepObjectParams = op.queryParams.filter((q) => q.isDeepObject === true);
+    if (deepObjectParams.length > 0) {
+      lines.push(`${indent}  const _dq = c.req.queries()`);
+      for (const q of deepObjectParams) {
+        const prefixLen = q.rawName.length + 1;
+        const bracketPrefix = q.rawName + "[";
+        lines.push(`${indent}  const ${q.name} = Object.fromEntries(`);
+        lines.push(
+          `${indent}    Object.entries(_dq).filter(([k]) => k.startsWith('${bracketPrefix}') && k.endsWith(']')).map(([k, vs]) => [k.slice(${prefixLen}, -1), vs[0]])`
+        );
+        lines.push(`${indent}  )`);
+      }
+    }
     const fields = op.queryParams.map((q) => {
+      if (q.isDeepObject === true) {
+        return `    ${q.name}`;
+      }
+      if (q.delimiterStyle !== void 0) {
+        const delim = JSON.stringify(delimiterChar(q.delimiterStyle));
+        return `    ${q.name}: c.req.query('${q.rawName}') !== undefined ? c.req.query('${q.rawName}')!.split(${delim}) : undefined`;
+      }
       if (q.tsType === "number") {
         return `    ${q.name}: c.req.query('${q.name}') !== undefined ? Number(c.req.query('${q.name}')) : undefined`;
       }
@@ -19403,8 +19630,32 @@ function buildRouteHandler(op, indent, schemaNames) {
   }
   let bodyVarName = "body";
   if (op.bodyInfo !== void 0) {
-    const typeAnnotation = op.bodyInfo.typeName !== void 0 ? `<${op.bodyInfo.typeName}>` : "";
-    lines.push(`${indent}  const body = await c.req.json${typeAnnotation}()`);
+    const typeDecl = op.bodyInfo.typeName !== void 0 && !op.bodyInfo.isSynthesized ? op.bodyInfo.typeName : "unknown";
+    if (op.bodyInfo.contentType === "application/x-www-form-urlencoded") {
+      lines.push(`${indent}  const _ct = c.req.header('content-type') ?? ''`);
+      lines.push(
+        `${indent}  if (!_ct.toLowerCase().startsWith('application/x-www-form-urlencoded')) {`
+      );
+      lines.push(`${indent}    return c.json({ error: 'Unsupported Media Type' }, 415)`);
+      lines.push(`${indent}  }`);
+      lines.push(`${indent}  const body: unknown = await c.req.parseBody()`);
+    } else if (op.bodyInfo.contentType === "multipart/form-data") {
+      lines.push(
+        `${indent}  // multipart/form-data: parseBody({ all: true }) collects repeated keys into arrays.`
+      );
+      lines.push(`${indent}  const body: unknown = await c.req.parseBody({ all: true })`);
+    } else {
+      lines.push(`${indent}  const _ct = c.req.header('content-type') ?? ''`);
+      lines.push(`${indent}  if (!_ct.toLowerCase().startsWith('application/json')) {`);
+      lines.push(`${indent}    return c.json({ error: 'Unsupported Media Type' }, 415)`);
+      lines.push(`${indent}  }`);
+      lines.push(`${indent}  let body: ${typeDecl}`);
+      lines.push(`${indent}  try {`);
+      lines.push(`${indent}    body = JSON.parse(await c.req.text()) as ${typeDecl}`);
+      lines.push(`${indent}  } catch {`);
+      lines.push(`${indent}    return c.json({ error: 'Invalid JSON body' }, 400)`);
+      lines.push(`${indent}  }`);
+    }
     const schemaName = op.bodyInfo.typeName !== void 0 ? `${op.bodyInfo.typeName}Schema` : void 0;
     if (schemaName !== void 0 && schemaNames !== void 0 && schemaNames.has(schemaName)) {
       lines.push(`${indent}  // Validate request body: returns 422 with Zod issues on failure`);
@@ -19429,14 +19680,44 @@ function buildRouteHandler(op, indent, schemaNames) {
     serviceArgs.push("params");
   }
   const serviceCall = `service.${op.methodName}(${serviceArgs.join(", ")})`;
+  lines.push(`${indent}  try {`);
   if (op.responseStatus.isVoid) {
-    lines.push(`${indent}  await ${serviceCall}`);
-    lines.push(`${indent}  return new Response(null, { status: ${op.responseStatus.status} })`);
-  } else if (op.responseStatus.status === 201) {
-    lines.push(`${indent}  return c.json(await ${serviceCall}, 201)`);
+    lines.push(`${indent}    await ${serviceCall}`);
+    lines.push(`${indent}    return new Response(null, { status: ${op.responseStatus.status} })`);
+  } else if (op.responseStatus.isMultiStatus === true) {
+    lines.push(`${indent}    const _envelope = await ${serviceCall}`);
+    lines.push(`${indent}    return c.json(_envelope.body, _envelope.status as any)`);
+  } else if (op.responseStatus.responseContentType === "text/plain") {
+    if (op.responseStatus.status === 200) {
+      lines.push(`${indent}    return c.text(await ${serviceCall})`);
+    } else {
+      lines.push(`${indent}    return c.text(await ${serviceCall}, ${op.responseStatus.status})`);
+    }
+  } else if (op.responseStatus.responseContentType === "application/octet-stream") {
+    if (op.responseStatus.status === 200) {
+      lines.push(`${indent}    const _result = await ${serviceCall}`);
+      lines.push(
+        `${indent}    return new Response(_result, { headers: { 'content-type': 'application/octet-stream' } })`
+      );
+    } else {
+      lines.push(`${indent}    const _result = await ${serviceCall}`);
+      lines.push(
+        `${indent}    return new Response(_result, { status: ${op.responseStatus.status}, headers: { 'content-type': 'application/octet-stream' } })`
+      );
+    }
+  } else if (op.responseStatus.status === 200) {
+    lines.push(`${indent}    return c.json(await ${serviceCall})`);
   } else {
-    lines.push(`${indent}  return c.json(await ${serviceCall})`);
+    lines.push(`${indent}    return c.json(await ${serviceCall}, ${op.responseStatus.status})`);
   }
+  lines.push(`${indent}  } catch (err) {`);
+  lines.push(`${indent}    if (err instanceof HttpError) {`);
+  lines.push(
+    `${indent}      return new Response(JSON.stringify({ error: err.message }), { status: err.status, headers: { 'content-type': 'application/json' } })`
+  );
+  lines.push(`${indent}    }`);
+  lines.push(`${indent}    throw err`);
+  lines.push(`${indent}  }`);
   lines.push(`${indent}})`);
   return lines.join("\n");
 }
@@ -19455,6 +19736,13 @@ function buildExpressRouteHandler(op, indent, schemaNames) {
   }
   if (op.queryParams.length > 0) {
     const fields = op.queryParams.map((q) => {
+      if (q.isDeepObject === true) {
+        return `    ${q.name}: (req.query['${q.rawName}'] ?? {}) as Record<string, string | undefined>`;
+      }
+      if (q.delimiterStyle !== void 0) {
+        const delim = JSON.stringify(delimiterChar(q.delimiterStyle));
+        return `    ${q.name}: typeof req.query['${q.rawName}'] === 'string' ? (req.query['${q.rawName}'] as string).split(${delim}) : undefined`;
+      }
       if (q.tsType === "number") {
         return `    ${q.name}: Number(req.query['${q.name}'] as string)`;
       }
@@ -19485,21 +19773,28 @@ function buildExpressRouteHandler(op, indent, schemaNames) {
   }
   let bodyVarName = "body";
   if (op.bodyInfo !== void 0) {
-    const schemaName = op.bodyInfo.typeName !== void 0 ? `${op.bodyInfo.typeName}Schema` : void 0;
-    const useZod = schemaName !== void 0 && schemaNames !== void 0 && schemaNames.has(schemaName);
-    if (useZod) {
-      lines.push(`${indent}  // Validate request body: returns 422 with Zod issues on failure`);
-      lines.push(`${indent}  const parseResult = ${schemaName}.safeParse(req.body)`);
-      lines.push(`${indent}  if (!parseResult.success) {`);
+    if (op.bodyInfo.contentType === "multipart/form-data") {
       lines.push(
-        `${indent}    return void res.status(422).json({ error: 'Invalid request body', issues: parseResult.error.issues })`
+        `${indent}  // multipart/form-data: assumes multer middleware has populated req.files + req.body.`
       );
-      lines.push(`${indent}  }`);
-      lines.push(`${indent}  const validatedBody = parseResult.data`);
-      bodyVarName = "validatedBody";
+      lines.push(`${indent}  const body = { ...req.body, ...(req as any).files } as unknown`);
     } else {
-      const typeAnnotation = op.bodyInfo.typeName !== void 0 ? ` as ${op.bodyInfo.typeName}` : "";
-      lines.push(`${indent}  const body = req.body${typeAnnotation}`);
+      const schemaName = op.bodyInfo.typeName !== void 0 ? `${op.bodyInfo.typeName}Schema` : void 0;
+      const useZod = schemaName !== void 0 && schemaNames !== void 0 && schemaNames.has(schemaName);
+      if (useZod) {
+        lines.push(`${indent}  // Validate request body: returns 422 with Zod issues on failure`);
+        lines.push(`${indent}  const parseResult = ${schemaName}.safeParse(req.body)`);
+        lines.push(`${indent}  if (!parseResult.success) {`);
+        lines.push(
+          `${indent}    return void res.status(422).json({ error: 'Invalid request body', issues: parseResult.error.issues })`
+        );
+        lines.push(`${indent}  }`);
+        lines.push(`${indent}  const validatedBody = parseResult.data`);
+        bodyVarName = "validatedBody";
+      } else {
+        const typeAnnotation = op.bodyInfo.typeName !== void 0 && !op.bodyInfo.isSynthesized ? ` as ${op.bodyInfo.typeName}` : "";
+        lines.push(`${indent}  const body = req.body${typeAnnotation}`);
+      }
     }
   }
   const serviceArgs = [];
@@ -19513,14 +19808,42 @@ function buildExpressRouteHandler(op, indent, schemaNames) {
     serviceArgs.push("params");
   }
   const serviceCall = `service.${op.methodName}(${serviceArgs.join(", ")})`;
+  lines.push(`${indent}  try {`);
   if (op.responseStatus.isVoid) {
-    lines.push(`${indent}  await ${serviceCall}`);
-    lines.push(`${indent}  res.status(${op.responseStatus.status}).end()`);
-  } else if (op.responseStatus.status === 201) {
-    lines.push(`${indent}  res.status(201).json(await ${serviceCall})`);
+    lines.push(`${indent}    await ${serviceCall}`);
+    lines.push(`${indent}    res.status(${op.responseStatus.status}).end()`);
+  } else if (op.responseStatus.isMultiStatus === true) {
+    lines.push(`${indent}    const _envelope = await ${serviceCall}`);
+    lines.push(`${indent}    res.status(_envelope.status).json(_envelope.body)`);
+  } else if (op.responseStatus.responseContentType === "text/plain") {
+    if (op.responseStatus.status === 200) {
+      lines.push(`${indent}    res.type('text/plain').send(await ${serviceCall})`);
+    } else {
+      lines.push(
+        `${indent}    res.status(${op.responseStatus.status}).type('text/plain').send(await ${serviceCall})`
+      );
+    }
+  } else if (op.responseStatus.responseContentType === "application/octet-stream") {
+    if (op.responseStatus.status === 200) {
+      lines.push(
+        `${indent}    res.setHeader('Content-Type', 'application/octet-stream').send(Buffer.from(await ${serviceCall}))`
+      );
+    } else {
+      lines.push(
+        `${indent}    res.status(${op.responseStatus.status}).setHeader('Content-Type', 'application/octet-stream').send(Buffer.from(await ${serviceCall}))`
+      );
+    }
+  } else if (op.responseStatus.status === 200) {
+    lines.push(`${indent}    res.json(await ${serviceCall})`);
   } else {
-    lines.push(`${indent}  res.json(await ${serviceCall})`);
-  }
+    lines.push(`${indent}    res.status(${op.responseStatus.status}).json(await ${serviceCall})`);
+  }
+  lines.push(`${indent}  } catch (err) {`);
+  lines.push(`${indent}    if (err instanceof HttpError) {`);
+  lines.push(`${indent}      return void res.status(err.status).json({ error: err.message })`);
+  lines.push(`${indent}    }`);
+  lines.push(`${indent}    throw err`);
+  lines.push(`${indent}  }`);
   lines.push(`${indent}})`);
   return lines.join("\n");
 }
@@ -19528,14 +19851,23 @@ function buildFastifyRouteHandler(op, indent, schemaNames) {
   const lines = [];
   const genericParts = [];
   if (op.queryParams.length > 0) {
-    const queryFields = op.queryParams.map((q) => {
-      if (q.tsType === "number") return `${q.name}?: number`;
-      if (q.tsType === "boolean") return `${q.name}?: boolean`;
-      return `${q.name}?: string`;
-    }).join("; ");
-    genericParts.push(`Querystring: { ${queryFields} }`);
-  }
-  if (op.bodyInfo !== void 0 && op.bodyInfo.typeName !== void 0) {
+    const hasDeepOrDelimited = op.queryParams.some(
+      (q) => q.isDeepObject === true || q.delimiterStyle !== void 0
+    );
+    let querystringType;
+    if (hasDeepOrDelimited) {
+      querystringType = "Record<string, string | string[] | undefined>";
+    } else {
+      const queryFields = op.queryParams.map((q) => {
+        if (q.tsType === "number") return `${q.name}?: number`;
+        if (q.tsType === "boolean") return `${q.name}?: boolean`;
+        return `${q.name}?: string`;
+      }).join("; ");
+      querystringType = `{ ${queryFields} }`;
+    }
+    genericParts.push(`Querystring: ${querystringType}`);
+  }
+  if (op.bodyInfo !== void 0 && op.bodyInfo.typeName !== void 0 && !op.bodyInfo.isSynthesized) {
     genericParts.push(`Body: ${op.bodyInfo.typeName}`);
   } else if (op.bodyInfo !== void 0) {
     genericParts.push("Body: unknown");
@@ -19558,7 +19890,36 @@ function buildFastifyRouteHandler(op, indent, schemaNames) {
     lines.push(`${indent}  }`);
   }
   if (op.queryParams.length > 0) {
-    const fields = op.queryParams.map((q) => `    ${q.name}: req.query.${q.name}`).join(",\n");
+    const deepObjectParams = op.queryParams.filter((q) => q.isDeepObject === true);
+    const hasDeepOrDelimited = op.queryParams.some(
+      (q) => q.isDeepObject === true || q.delimiterStyle !== void 0
+    );
+    if (hasDeepOrDelimited) {
+      lines.push(
+        `${indent}  const _dq = req.query as unknown as Record<string, string | undefined>`
+      );
+    }
+    if (deepObjectParams.length > 0) {
+      for (const q of deepObjectParams) {
+        const prefixLen = q.rawName.length + 1;
+        const bracketPrefix = q.rawName + "[";
+        lines.push(`${indent}  const ${q.name} = Object.fromEntries(`);
+        lines.push(
+          `${indent}    Object.entries(_dq).filter(([k]) => k.startsWith('${bracketPrefix}') && k.endsWith(']')).map(([k, v]) => [k.slice(${prefixLen}, -1), v])`
+        );
+        lines.push(`${indent}  )`);
+      }
+    }
+    const fields = op.queryParams.map((q) => {
+      if (q.isDeepObject === true) {
+        return `    ${q.name}`;
+      }
+      if (q.delimiterStyle !== void 0) {
+        const delim = JSON.stringify(delimiterChar(q.delimiterStyle));
+        return `    ${q.name}: typeof _dq['${q.rawName}'] === 'string' ? _dq['${q.rawName}']!.split(${delim}) : undefined`;
+      }
+      return hasDeepOrDelimited ? `    ${q.name}: _dq['${q.rawName}']` : `    ${q.name}: req.query.${q.name}`;
+    }).join(",\n");
     lines.push(`${indent}  const params = {`);
     lines.push(fields);
     lines.push(`${indent}  }`);
@@ -19583,17 +19944,23 @@ function buildFastifyRouteHandler(op, indent, schemaNames) {
   }
   let bodyVarName = "req.body";
   if (op.bodyInfo !== void 0) {
-    const schemaName = op.bodyInfo.typeName !== void 0 ? `${op.bodyInfo.typeName}Schema` : void 0;
-    const useZod = schemaName !== void 0 && schemaNames !== void 0 && schemaNames.has(schemaName);
-    if (useZod) {
-      lines.push(`${indent}  // Validate request body: returns 422 with Zod issues on failure`);
-      lines.push(`${indent}  const parseResult = ${schemaName}.safeParse(req.body)`);
-      lines.push(`${indent}  if (!parseResult.success) {`);
+    if (op.bodyInfo.contentType === "multipart/form-data") {
       lines.push(
-        `${indent}    return reply.status(422).send({ error: 'Invalid request body', issues: parseResult.error.issues })`
+        `${indent}  // multipart/form-data: assumes @fastify/multipart plugin has populated req.body.`
       );
-      lines.push(`${indent}  }`);
-      bodyVarName = "parseResult.data";
+    } else {
+      const schemaName = op.bodyInfo.typeName !== void 0 ? `${op.bodyInfo.typeName}Schema` : void 0;
+      const useZod = schemaName !== void 0 && schemaNames !== void 0 && schemaNames.has(schemaName);
+      if (useZod) {
+        lines.push(`${indent}  // Validate request body: returns 422 with Zod issues on failure`);
+        lines.push(`${indent}  const parseResult = ${schemaName}.safeParse(req.body)`);
+        lines.push(`${indent}  if (!parseResult.success) {`);
+        lines.push(
+          `${indent}    return reply.status(422).send({ error: 'Invalid request body', issues: parseResult.error.issues })`
+        );
+        lines.push(`${indent}  }`);
+        bodyVarName = "parseResult.data";
+      }
     }
   }
   const serviceArgs = [];
@@ -19607,18 +19974,50 @@ function buildFastifyRouteHandler(op, indent, schemaNames) {
     serviceArgs.push("params");
   }
   const serviceCall = `service.${op.methodName}(${serviceArgs.join(", ")})`;
+  lines.push(`${indent}  try {`);
   if (op.responseStatus.isVoid) {
-    lines.push(`${indent}  await ${serviceCall}`);
-    lines.push(`${indent}  reply.status(${op.responseStatus.status}).send()`);
-  } else if (op.responseStatus.status === 201) {
-    lines.push(`${indent}  reply.status(201)`);
-    lines.push(`${indent}  return ${serviceCall}`);
+    lines.push(`${indent}    await ${serviceCall}`);
+    lines.push(`${indent}    reply.status(${op.responseStatus.status}).send()`);
+  } else if (op.responseStatus.isMultiStatus === true) {
+    lines.push(`${indent}    const _envelope = await ${serviceCall}`);
+    lines.push(`${indent}    return reply.status(_envelope.status).send(_envelope.body)`);
+  } else if (op.responseStatus.responseContentType === "text/plain") {
+    if (op.responseStatus.status === 200) {
+      lines.push(`${indent}    return reply.type('text/plain').send(await ${serviceCall})`);
+    } else {
+      lines.push(`${indent}    return reply.status(${op.responseStatus.status}).type('text/plain').send(await ${serviceCall})`);
+    }
+  } else if (op.responseStatus.responseContentType === "application/octet-stream") {
+    if (op.responseStatus.status === 200) {
+      lines.push(`${indent}    return reply.type('application/octet-stream').send(Buffer.from(await ${serviceCall}))`);
+    } else {
+      lines.push(`${indent}    return reply.status(${op.responseStatus.status}).type('application/octet-stream').send(Buffer.from(await ${serviceCall}))`);
+    }
+  } else if (op.responseStatus.status === 200) {
+    lines.push(`${indent}    return ${serviceCall}`);
   } else {
-    lines.push(`${indent}  return ${serviceCall}`);
-  }
+    lines.push(`${indent}    reply.status(${op.responseStatus.status})`);
+    lines.push(`${indent}    return ${serviceCall}`);
+  }
+  lines.push(`${indent}  } catch (err) {`);
+  lines.push(`${indent}    if (err instanceof HttpError) {`);
+  lines.push(`${indent}      return reply.status(err.status).send({ error: err.message })`);
+  lines.push(`${indent}    }`);
+  lines.push(`${indent}    throw err`);
+  lines.push(`${indent}  }`);
   lines.push(`${indent}})`);
   return lines.join("\n");
 }
+function httpErrorClassLines() {
+  return [
+    "export class HttpError extends Error {",
+    "  constructor(public readonly status: number, message: string) {",
+    "    super(message)",
+    "    this.name = 'HttpError'",
+    "  }",
+    "}"
+  ];
+}
 function operationsNeedZodForParams(operations) {
   for (const op of operations) {
     if (op.pathParamValidations.length > 0) return true;
@@ -19628,7 +20027,7 @@ function operationsNeedZodForParams(operations) {
   return false;
 }
 function generateExpressRouter(spec, options) {
-  const serviceName = deriveServiceName2(spec);
+  const serviceName = deriveServiceName(spec);
   const operations = collectOperations2(spec);
   const { sortedBodyTypes, usedSchemaNames, needsZod } = collectGeneratorSetup(operations, options);
   const lines = [];
@@ -19651,6 +20050,8 @@ function generateExpressRouter(spec, options) {
     lines.push(`import { ${sortedUsedSchemas.join(", ")} } from '${options.schemaImportPath}'`);
   }
   lines.push("");
+  for (const l of httpErrorClassLines()) lines.push(l);
+  lines.push("");
   lines.push(`export function createRouter(service: ${serviceName}): Router {`);
   lines.push("  const router = Router()");
   lines.push("");
@@ -19667,7 +20068,7 @@ function generateExpressRouter(spec, options) {
   };
 }
 function generateFastifyRouter(spec, options) {
-  const serviceName = deriveServiceName2(spec);
+  const serviceName = deriveServiceName(spec);
   const operations = collectOperations2(spec);
   const { sortedBodyTypes, usedSchemaNames, needsZod } = collectGeneratorSetup(operations, options);
   const lines = [];
@@ -19686,6 +20087,8 @@ function generateFastifyRouter(spec, options) {
     lines.push(`import { ${sortedUsedSchemas.join(", ")} } from '${options.schemaImportPath}'`);
   }
   lines.push("");
+  for (const l of httpErrorClassLines()) lines.push(l);
+  lines.push("");
   lines.push(`export function createRouter(app: FastifyInstance, service: ${serviceName}): void {`);
   for (const op of operations) {
     lines.push("");
@@ -19699,7 +20102,7 @@ function generateFastifyRouter(spec, options) {
   };
 }
 function generateRouter(spec, options) {
-  const serviceName = deriveServiceName2(spec);
+  const serviceName = deriveServiceName(spec);
   const operations = collectOperations2(spec);
   const { sortedBodyTypes, usedSchemaNames, needsZod } = collectGeneratorSetup(operations, options);
   const lines = [];
@@ -19718,6 +20121,8 @@ function generateRouter(spec, options) {
     lines.push(`import { ${sortedUsedSchemas.join(", ")} } from '${options.schemaImportPath}'`);
   }
   lines.push("");
+  for (const l of httpErrorClassLines()) lines.push(l);
+  lines.push("");
   lines.push(`export function createRouter(service: ${serviceName}): Hono {`);
   lines.push("  const app = new Hono()");
   lines.push("");
@@ -19740,63 +20145,63 @@ async function formatTs(content, filePath) {
   const config = await resolveConfig(filePath);
   return format(content, { ...config, parser: "typescript" });
 }
-async function generate2(cwd, configPath) {
-  console.log("Loading config...");
-  const config = await loadConfig(cwd, configPath);
+function buildRouterFile(spec, framework, options) {
+  if (framework === "hono") return generateRouter(spec, options);
+  if (framework === "express") return generateExpressRouter(spec, options);
+  return generateFastifyRouter(spec, options);
+}
+async function generateOne(cwd, config, label) {
   const inputPath = (0, import_node_path2.resolve)(cwd, config.input_openapi);
   const outputDir = (0, import_node_path2.resolve)(cwd, config.output);
   const framework = config.framework ?? "none";
-  console.log(`Parsing spec: ${inputPath}`);
+  const prefix = label !== void 0 ? `[${label}] ` : "";
+  console.log(`${prefix}Parsing spec: ${inputPath}`);
   const spec = await parseSpec(inputPath);
-  const generatedFiles = [];
-  generatedFiles.push(generateService(spec));
-  if (framework === "hono") {
-    generatedFiles.push(generateRouter(spec));
-  } else if (framework === "express") {
-    generatedFiles.push(generateExpressRouter(spec));
-  } else if (framework === "fastify") {
-    generatedFiles.push(generateFastifyRouter(spec));
-  }
-  console.log(`Writing output to: ${outputDir}`);
+  const generatedFiles = [generateService(spec)];
+  if (framework !== "none") {
+    generatedFiles.push(buildRouterFile(spec, framework));
+  }
+  console.log(`${prefix}Writing output to: ${outputDir}`);
   await (0, import_promises2.mkdir)(outputDir, { recursive: true });
   for (const file of generatedFiles) {
     const filePath = (0, import_node_path2.join)(outputDir, file.filename);
     await (0, import_promises2.writeFile)(filePath, await formatTs(file.content, filePath), "utf-8");
-    console.log(`  \u2713 ${file.filename}`);
+    console.log(`${prefix}  \u2713 ${file.filename}`);
   }
-  if ((framework === "hono" || framework === "express" || framework === "fastify") && config.input_schema !== void 0) {
-    const schemaPath = (0, import_node_path2.resolve)(cwd, config.input_schema);
-    let schemaContent;
-    try {
-      schemaContent = await (0, import_promises2.readFile)(schemaPath, "utf-8");
-    } catch {
-      console.log(`  \u2139 input_schema not found at ${schemaPath}, skipping Zod validation`);
-      console.log(`Done! Generated ${generatedFiles.length} file(s).`);
-      return;
-    }
-    const exportedSchemas = /* @__PURE__ */ new Set();
-    for (const match of schemaContent.matchAll(/^export\s+const\s+(\w+Schema)\b/gm)) {
-      exportedSchemas.add(match[1]);
-    }
-    if (exportedSchemas.size > 0) {
-      const relPath = (0, import_node_path2.relative)(outputDir, schemaPath).replace(/\\/g, "/");
-      const schemaImportPath = relPath.startsWith(".") ? relPath : `./${relPath}`;
-      const schemaImportPathJs = schemaImportPath.replace(/\.ts$/, ".js");
-      const routerOptions = { schemaNames: exportedSchemas, schemaImportPath: schemaImportPathJs };
-      let routerFile;
-      if (framework === "hono") {
-        routerFile = generateRouter(spec, routerOptions);
-      } else if (framework === "express") {
-        routerFile = generateExpressRouter(spec, routerOptions);
-      } else {
-        routerFile = generateFastifyRouter(spec, routerOptions);
-      }
-      const routerPath = (0, import_node_path2.join)(outputDir, routerFile.filename);
-      await (0, import_promises2.writeFile)(routerPath, await formatTs(routerFile.content, routerPath), "utf-8");
-      console.log(`  \u2713 router.ts (with Zod validation for ${exportedSchemas.size} schema(s))`);
-    }
+  if (framework !== "none" && config.input_schema !== void 0) {
+    await generateSchemaEnhancedRouter(cwd, config, spec, framework, outputDir, prefix);
   }
-  console.log(`Done! Generated ${generatedFiles.length} file(s).`);
+  console.log(`${prefix}Done! Generated ${generatedFiles.length} file(s).`);
+}
+async function generateSchemaEnhancedRouter(cwd, config, spec, framework, outputDir, prefix) {
+  const schemaPath = (0, import_node_path2.resolve)(cwd, config.input_schema);
+  let schemaContent;
+  try {
+    schemaContent = await (0, import_promises2.readFile)(schemaPath, "utf-8");
+  } catch {
+    console.log(`${prefix}  input_schema not found at ${schemaPath}, skipping Zod validation`);
+    return;
+  }
+  const exportedSchemas = /* @__PURE__ */ new Set();
+  for (const match of schemaContent.matchAll(/^export\s+const\s+(\w+Schema)\b/gm)) {
+    exportedSchemas.add(match[1]);
+  }
+  if (exportedSchemas.size === 0) return;
+  const relPath = (0, import_node_path2.relative)(outputDir, schemaPath).replace(/\\/g, "/");
+  const schemaImportPath = relPath.startsWith(".") ? relPath : `./${relPath}`;
+  const schemaImportPathJs = schemaImportPath.replace(/\.ts$/, ".js");
+  const routerFile = buildRouterFile(spec, framework, {
+    schemaNames: exportedSchemas,
+    schemaImportPath: schemaImportPathJs
+  });
+  const routerPath = (0, import_node_path2.join)(outputDir, routerFile.filename);
+  await (0, import_promises2.writeFile)(routerPath, await formatTs(routerFile.content, routerPath), "utf-8");
+  console.log(`${prefix}  \u2713 router.ts (with Zod validation for ${exportedSchemas.size} schema(s))`);
+}
+async function generate2(cwd, configPath) {
+  console.log("Loading config...");
+  const configs = await loadConfigs2(cwd, configPath);
+  await runProjects(configs, (config, label) => generateOne(cwd, config, label));
 }
 
 // ../openapi-zod-ts/dist/cli-core.js