@artil-ai/server 0.1.0 → 0.1.1

package/bin/main.js

@@ -22322,7 +22322,7 @@ var channel = {
   create: ({ webhookUrl, secret, fetch: fetch2 }) => new TelegramChannel(createBotApi({ webhook: webhookUrl ? { url: webhookUrl, secret } : undefined, fetch: fetch2 }))
 };
 // package.json
-var version2 = "0.1.0";
+var version2 = "0.1.1";
 
 // src/app/cli.ts
 import { parseArgs } from "util";
@@ -24560,14 +24560,108 @@ var findTargetHandler = (handler) => {
   return handler["__COMPOSED_HANDLER"] ? findTargetHandler(handler[COMPOSED_HANDLER]) : handler;
 };
 
-// ../../node_modules/.bun/hono-openapi@1.3.3+498ad4f22b3f3380/node_modules/hono-openapi/dist/index.js
+// ../../node_modules/.bun/hono-openapi@1.5.0+498ad4f22b3f3380/node_modules/hono-openapi/dist/index.js
 init_dist2();
 
 // ../../node_modules/.bun/@standard-community+standard-openapi@0.2.11+eb0485ab6460c735/node_modules/@standard-community/standard-openapi/dist/index.js
 init_index_CKGGDjCx();
 
-// ../../node_modules/.bun/hono-openapi@1.3.3+498ad4f22b3f3380/node_modules/hono-openapi/dist/index.js
-var uniqueSymbol = Symbol("openapi");
+// ../../node_modules/.bun/hono-openapi@1.5.0+498ad4f22b3f3380/node_modules/hono-openapi/dist/index.js
+var COMPONENTS_PREFIX = "#/components/";
+var SCHEMA_REF = `${COMPONENTS_PREFIX}schemas/`;
+var decodeName = (name) => name.replaceAll("~1", "/").replaceAll("~0", "~");
+var encodeName = (name) => name.replaceAll("~", "~0").replaceAll("/", "~1");
+var renameRef = (ref, rename) => {
+  if (!ref.startsWith(SCHEMA_REF)) {
+    return ref;
+  }
+  const renamed = rename(decodeName(ref.slice(SCHEMA_REF.length)));
+  return renamed === undefined ? ref : `${SCHEMA_REF}${encodeName(renamed)}`;
+};
+var renameMappingTarget = (target, rename) => {
+  if (target.startsWith(SCHEMA_REF)) {
+    return renameRef(target, rename);
+  }
+  if (target.includes("/") || target.includes("#")) {
+    return target;
+  }
+  return rename(target) ?? target;
+};
+var isDiscriminator = (value) => value != null && typeof value === "object" && typeof value.propertyName === "string";
+var LITERAL_FIELDS = /* @__PURE__ */ new Set([
+  "example",
+  "default",
+  "enum",
+  "const",
+  "value"
+]);
+var REFERENCE_MAPS = /* @__PURE__ */ new Set([
+  "paths",
+  "webhooks",
+  "examples",
+  "schemas",
+  "parameters",
+  "responses",
+  "requestBodies",
+  "headers",
+  "content",
+  "encoding",
+  "links",
+  "callbacks",
+  "pathItems",
+  "properties",
+  "patternProperties",
+  "$defs",
+  "definitions",
+  "dependentSchemas",
+  "dependencies"
+]);
+var mapReferences = (value, reference, isMap = false) => {
+  if (Array.isArray(value)) {
+    return value.map((item) => mapReferences(item, reference));
+  }
+  if (value == null || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => {
+    if (isMap) {
+      return [key, mapReferences(item, reference)];
+    }
+    if (LITERAL_FIELDS.has(key) || key.startsWith("x-") || key === "examples" && Array.isArray(item)) {
+      return [key, item];
+    }
+    if (key === "$ref" && typeof item === "string") {
+      return [key, reference(item, false)];
+    }
+    if (key === "discriminator" && isDiscriminator(item) && item.mapping) {
+      return [
+        key,
+        {
+          ...item,
+          mapping: Object.fromEntries(Object.entries(item.mapping).map(([name, target]) => [
+            name,
+            reference(target, true)
+          ]))
+        }
+      ];
+    }
+    return [key, mapReferences(item, reference, REFERENCE_MAPS.has(key))];
+  }));
+};
+var renameSchemaRefs = (value, rename, isMap = false) => mapReferences(value, (target, mapping) => mapping ? renameMappingTarget(target, rename) : renameRef(target, rename), isMap);
+var componentRefs = (value) => {
+  const refs = [];
+  mapReferences(value, (target, mapping) => {
+    if (target.startsWith(COMPONENTS_PREFIX)) {
+      refs.push(target.slice(COMPONENTS_PREFIX.length));
+    } else if (mapping && !target.includes("/") && !target.includes("#")) {
+      refs.push(`schemas/${encodeName(target)}`);
+    }
+    return target;
+  });
+  return refs;
+};
+var uniqueSymbol = Symbol.for("hono-openapi");
 var VALIDATION_MARKER = "__HonoOpenAPIValidator__";
 var ALLOWED_METHODS = [
   "GET",
@@ -24611,6 +24705,40 @@ var generateOperationId = (route) => {
   }
   return operationId;
 };
+var generatedOperationIds = /* @__PURE__ */ new WeakMap;
+var derivedOperationIds = /* @__PURE__ */ new WeakMap;
+var pathParameterNames = (path) => path.split("/").filter((segment) => segment.startsWith(":")).map((segment) => toOpenAPIPathSegment(segment).slice(1, -1));
+var expandOptionalParameters = (route) => {
+  const paths = checkOptionalParameter(route.path);
+  if (!paths) {
+    return [{ route, omitted: undefined }];
+  }
+  const names = pathParameterNames(route.path);
+  return paths.map((path) => {
+    const kept = pathParameterNames(path);
+    return {
+      route: { ...route, path },
+      omitted: names.filter((name) => !kept.includes(name))
+    };
+  });
+};
+var withOmittedParameters = (specs, omitted) => {
+  if (!omitted || !specs) {
+    return specs;
+  }
+  const expanded = {
+    ...specs,
+    ...omitted.length && typeof specs.operationId === "string" ? {
+      operationId: `${specs.operationId}Without${omitted.map(toPascalCase).join("And")}`
+    } : {}
+  };
+  if (omitted.length && typeof expanded.operationId === "string") {
+    derivedOperationIds.set(expanded, expanded.operationId);
+  }
+  setSpecComponents(expanded, getSpecComponents(specs));
+  expandedOperations.add(expanded);
+  return expanded;
+};
 var paramKey = (param) => ("$ref" in param) ? param.$ref : `${param.in} ${param.name}`;
 function mergeParameters(...params) {
   const merged = params.flatMap((x) => x ?? []).reduce((acc, param) => {
@@ -24619,6 +24747,11 @@ function mergeParameters(...params) {
   }, /* @__PURE__ */ new Map);
   return Array.from(merged.values());
 }
+var specComponents = /* @__PURE__ */ new WeakMap;
+var setSpecComponents = (spec, components) => specComponents.set(spec, components);
+var getSpecComponents = (spec) => spec != null && typeof spec === "object" && specComponents.get(spec) || [];
+var expandedOperations = /* @__PURE__ */ new WeakSet;
+var isExpandedOperation = (spec) => spec != null && typeof spec === "object" && expandedOperations.has(spec);
 var specsByPathContext = /* @__PURE__ */ new Map;
 function getPathContext(path, pathContext) {
   const context = [];
@@ -24632,13 +24765,14 @@ function getPathContext(path, pathContext) {
   }
   return context;
 }
-function mergeRequestBodies(previous, current) {
+function mergeRequestBodies(previous, current, fromValidator = false) {
   if (!previous || !current || "$ref" in previous || "$ref" in current) {
     return current;
   }
   return {
     ...previous,
     ...current,
+    ...fromValidator && previous.required !== undefined ? { required: previous.required } : {},
     content: {
       ...previous.content,
       ...current.content
@@ -24646,12 +24780,17 @@ function mergeRequestBodies(previous, current) {
   };
 }
 function mergeSpecs(route, ...specs) {
-  return specs.reduce((prev, spec) => {
+  const generatedOperationId = generateOperationId(route);
+  const operationIdSpec = specs.findLast((spec) => spec?.operationId != null && generatedOperationIds.get(spec) !== spec.operationId);
+  const merged = specs.reduce((prev, spec) => {
     if (!spec || !prev)
       return prev;
     for (const [key, value] of Object.entries(spec)) {
       if (value == null)
         continue;
+      if (key === "operationId" && generatedOperationIds.get(spec) === value) {
+        continue;
+      }
       if (key in prev && (typeof value === "object" || typeof value === "function" && key === "operationId")) {
         if (Array.isArray(value)) {
           const values = [...prev[key] ?? [], ...value];
@@ -24668,7 +24807,7 @@ function mergeSpecs(route, ...specs) {
           if (key === "parameters") {
             prev[key] = mergeParameters(prev[key], value);
           } else if (key === "requestBody") {
-            prev.requestBody = mergeRequestBodies(prev.requestBody, value);
+            prev.requestBody = mergeRequestBodies(prev.requestBody, value, spec[VALIDATION_MARKER] === true);
           } else {
             prev[key] = {
               ...prev[key],
@@ -24682,8 +24821,18 @@ function mergeSpecs(route, ...specs) {
     }
     return prev;
   }, {
-    operationId: generateOperationId(route)
+    operationId: generatedOperationId
   });
+  if (!operationIdSpec) {
+    generatedOperationIds.set(merged, generatedOperationId);
+  } else if (derivedOperationIds.get(operationIdSpec) === merged.operationId) {
+    derivedOperationIds.set(merged, merged.operationId);
+  }
+  setSpecComponents(merged, specs.flatMap(getSpecComponents));
+  if (specs.some(isExpandedOperation)) {
+    expandedOperations.add(merged);
+  }
+  return merged;
 }
 function registerSchemaPath({ route, specs, paths }, pathContext = specsByPathContext) {
   const path = toOpenAPIPath(route.path);
@@ -24707,6 +24856,42 @@ function registerSchemaPath({ route, specs, paths }, pathContext = specsByPathCo
     }
   }
 }
+var uniqueOperationIds = (paths) => {
+  const methods = ALLOWED_METHODS.map((method) => method.toLowerCase());
+  const operations = Object.values(paths).flatMap((item) => methods.flatMap((method) => {
+    const operation = item?.[method];
+    return typeof operation?.operationId === "string" ? [operation] : [];
+  }));
+  const isGenerated = (operation) => generatedOperationIds.get(operation) === operation.operationId || derivedOperationIds.get(operation) === operation.operationId;
+  const reserved = new Set(operations.map(({ operationId }) => operationId));
+  const explicit = operations.filter((operation) => !isGenerated(operation));
+  operations.filter(isGenerated).reduce((taken, operation) => {
+    const operationId = operation.operationId;
+    if (taken.has(operationId)) {
+      operation.operationId = withFreeSuffix(operationId, (id) => taken.has(id) || reserved.has(id));
+    }
+    return taken.add(operation.operationId);
+  }, new Set(explicit.map(({ operationId }) => operationId)));
+};
+var withFreeSuffix = (operationId, isUsed) => {
+  let suffix = 2;
+  while (isUsed(`${operationId}${suffix}`))
+    suffix++;
+  return `${operationId}${suffix}`;
+};
+var parameterComponent = (ref, ctx) => {
+  const prefix = "#/components/parameters/";
+  if (!ref.$ref.startsWith(prefix)) {
+    return;
+  }
+  const name = ref.$ref.slice(prefix.length);
+  const generated = ctx.components.parameters?.[name];
+  if (generated) {
+    return { generated: true, name, parameter: generated };
+  }
+  const documented = ctx.options.documentation?.components?.parameters?.[name];
+  return documented && { generated: false, name, parameter: documented };
+};
 function removeExcludedPaths(paths, ctx) {
   const { exclude, excludeStaticFile } = ctx.options;
   const newPaths = {};
@@ -24738,6 +24923,29 @@ function removeExcludedPaths(paths, ctx) {
         continue;
       const hasValidation = schema[VALIDATION_MARKER] === true;
       delete schema[VALIDATION_MARKER];
+      if (schema.parameters && isExpandedOperation(schema)) {
+        const names = key.split("/").filter((x) => x.startsWith("{")).map((x) => x.slice(1, -1));
+        schema.parameters = schema.parameters.flatMap((x) => {
+          const component = "$ref" in x ? parameterComponent(x, ctx) : undefined;
+          const parameter = component?.parameter ?? x;
+          if ("$ref" in parameter || parameter.in !== "path") {
+            return [x];
+          }
+          if (!names.includes(parameter.name)) {
+            return [];
+          }
+          if (!component) {
+            return [{ ...parameter, required: true }];
+          }
+          if (component.generated && !parameter.required) {
+            ctx.components.parameters = {
+              ...ctx.components.parameters,
+              [component.name]: { ...parameter, required: true }
+            };
+          }
+          return [x];
+        });
+      }
       if (key.includes("{")) {
         schema.parameters = schema.parameters ? [...schema.parameters] : [];
         const pathParameters = key.split("/").filter((x) => x.startsWith("{") && !schema.parameters.find((params) => params.in === "path" && params.name === x.slice(1, x.length - 1)));
@@ -24745,12 +24953,9 @@ function removeExcludedPaths(paths, ctx) {
           const paramName = param.slice(1, param.length - 1);
           const index = schema.parameters.findIndex((x) => {
             if ("$ref" in x) {
-              const pos = x.$ref.split("/").pop();
-              if (pos) {
-                const param2 = ctx.components.parameters?.[pos];
-                if (param2 && !("$ref" in param2)) {
-                  return param2.in === "path" && param2.name === paramName;
-                }
+              const param2 = parameterComponent(x, ctx)?.parameter;
+              if (param2 && !("$ref" in param2)) {
+                return param2.in === "path" && param2.name === paramName;
               }
               return false;
             }
@@ -24766,9 +24971,9 @@ function removeExcludedPaths(paths, ctx) {
           }
         }
       }
-      if (!schema.responses) {
+      if (!schema.responses || Object.keys(schema.responses).length === 0) {
         schema.responses = {
-          200: {}
+          200: { description: "Successful response" }
         };
       }
       if (hasValidation && ctx.options.defaultValidationErrorResponse !== false && !schema.responses["400"]) {
@@ -24792,6 +24997,23 @@ function removeExcludedPaths(paths, ctx) {
   }
   return newPaths;
 }
+var componentKey = (type, name) => `${type}/${encodeName(name)}`;
+var reachableRefs = (refs, components, reached) => refs.reduce((seen, ref) => {
+  if (seen.has(ref)) {
+    return seen;
+  }
+  const [type, ...name] = ref.split("/");
+  const component = components[type]?.[decodeName(name.join("/"))];
+  return reachableRefs(componentRefs(component), components, seen.add(ref));
+}, reached);
+function documentedComponents(components, paths, documentation) {
+  const contributed = new Set(Object.values(paths).flatMap((item) => item == null ? [] : Object.values(item)).flatMap(getSpecComponents).flatMap((operationComponents) => Object.entries(operationComponents).flatMap(([type, entries]) => Object.keys(entries ?? {}).map((name) => componentKey(type, name)))));
+  const kept = reachableRefs([...componentRefs(paths), ...componentRefs(documentation)], components, contributed);
+  return Object.fromEntries(Object.entries(components).flatMap(([type, entries]) => {
+    const remaining = Object.entries(entries ?? {}).filter(([name]) => kept.has(componentKey(type, name)));
+    return remaining.length > 0 ? [[type, Object.fromEntries(remaining)]] : [];
+  }));
+}
 var DEFAULT_OPTIONS = {
   documentation: {},
   excludeStaticFile: true,
@@ -24851,7 +25073,9 @@ async function generateSpecs(hono, options = DEFAULT_OPTIONS, c3) {
   if (resolvedDocumentation && documentation.components) {
     documentation.components.responses = resolvedDocumentation.responses;
   }
-  const components = mergeComponentsObjects(documentation.components, resolvedDocumentation?.components, ctx.components);
+  const documentedPaths = removeExcludedPaths(paths, ctx);
+  uniqueOperationIds({ ...documentedPaths, ...documentation.paths });
+  const { components, paths: outputPaths } = splitOutputComponents(mergeComponentsObjects(documentation.components, resolvedDocumentation?.components, documentedComponents(ctx.components, documentedPaths, withOutputRefs([documentation, resolvedDocumentation?.components], ctx))), documentedPaths);
   return {
     openapi: "3.1.0",
     ...documentation,
@@ -24863,7 +25087,7 @@ async function generateSpecs(hono, options = DEFAULT_OPTIONS, c3) {
       ...documentation.info
     },
     paths: {
-      ...removeExcludedPaths(paths, ctx),
+      ...outputPaths,
       ...documentation.paths
     },
     components
@@ -24872,14 +25096,15 @@ async function generateSpecs(hono, options = DEFAULT_OPTIONS, c3) {
 async function generatePaths(hono, ctx) {
   const paths = {};
   const pathContext = /* @__PURE__ */ new Map;
+  const defaulted = /* @__PURE__ */ new Set;
   for (const route of hono.routes) {
     const middlewareHandler = findTargetHandler(route.handler)[uniqueSymbol];
     if (!middlewareHandler) {
       if (ctx.options.includeEmptyPaths) {
-        registerSchemaPath({
-          route,
+        expandOptionalParameters(route).forEach((expanded) => registerSchemaPath({
+          route: expanded.route,
           paths
-        }, pathContext);
+        }, pathContext));
       }
       continue;
     }
@@ -24892,14 +25117,23 @@ async function generatePaths(hono, ctx) {
         continue;
       }
     }
-    const defaultOptionsForThisMethod = ctx.options.defaultOptions?.[routeMethod] && { ...ctx.options.defaultOptions[routeMethod] };
-    const { schema: routeSpecs, components = {} } = await getSpec(middlewareHandler, defaultOptionsForThisMethod, ctx.components.parameters);
-    ctx.components = mergeComponentsObjects(ctx.components, components);
-    registerSchemaPath({
-      route,
-      specs: routeSpecs,
+    const operation = `${routeMethod} ${route.path}`;
+    const defaultOptionsForThisMethod = !defaulted.has(operation) && ctx.options.defaultOptions?.[routeMethod] && {
+      ...ctx.options.defaultOptions[routeMethod]
+    };
+    defaulted.add(operation);
+    const {
+      schema: routeSpecs,
+      components = {},
+      unreferencedComponents
+    } = await getSpec(middlewareHandler, defaultOptionsForThisMethod, ctx.components.parameters);
+    ctx.components = mergeComponentsObjects(ctx.components, components, unreferencedComponents);
+    setSpecComponents(routeSpecs, [components]);
+    expandOptionalParameters(route).forEach((expanded) => registerSchemaPath({
+      route: expanded.route,
+      specs: withOmittedParameters(routeSpecs, expanded.omitted),
       paths
-    }, pathContext);
+    }, pathContext));
   }
   return paths;
 }
@@ -24915,6 +25149,15 @@ function getHiddenValue(options) {
   }
   return false;
 }
+var COMBINING_KEYWORDS = ["allOf", "anyOf", "oneOf", "not", "if"];
+var needsBody = (schema, components) => {
+  const resolved = "$ref" in schema ? components?.schemas?.[schema.$ref.split("/").at(-1) ?? ""] : schema;
+  if (!resolved || "$ref" in resolved) {
+    return true;
+  }
+  const types = [resolved.type].flat();
+  return !types.includes("object") || COMBINING_KEYWORDS.some((keyword) => (keyword in resolved)) || (resolved.required?.length ?? 0) > 0 || (resolved.minProperties ?? 0) > 0;
+};
 async function getSpec(middlewareHandler, defaultOptions, parameterComponents) {
   if ("spec" in middlewareHandler) {
     const tmp = {
@@ -24925,42 +25168,30 @@ async function getSpec(middlewareHandler, defaultOptions, parameterComponents) {
         ...middlewareHandler.spec.responses
       }
     };
-    let components = {};
-    if (tmp.responses) {
-      const resolved = await resolveResponseSchemas(tmp.responses);
-      tmp.responses = resolved.responses;
-      components = resolved.components;
-    }
-    if (tmp.requestBody && "content" in tmp.requestBody) {
-      const resolved = await resolveContentSchemas(tmp.requestBody.content);
-      tmp.requestBody = {
-        ...tmp.requestBody,
-        content: resolved.content
-      };
-      components = mergeComponentsObjects(components, resolved.components);
-    }
-    return { schema: tmp, components };
+    return {
+      ...await resolveSpecSchemas(tmp),
+      unreferencedComponents: undefined
+    };
   }
   const result = await middlewareHandler.toOpenAPISchema();
   liftSchemaDefs(result);
+  let unreferencedComponents;
   const docs = {
     ...defaultOptions,
     [VALIDATION_MARKER]: true
   };
   if (middlewareHandler.target === "form" || middlewareHandler.target === "json") {
-    const media = middlewareHandler.options?.media ?? (middlewareHandler.target === "json" ? "application/json" : "multipart/form-data");
+    const mediaTypes = middlewareHandler.options?.media ? [middlewareHandler.options.media] : middlewareHandler.target === "json" ? ["application/json"] : ["application/x-www-form-urlencoded", "multipart/form-data"];
+    const content = Object.fromEntries(mediaTypes.map((media) => [media, { schema: result.schema }]));
     if (!docs.requestBody || !("content" in docs.requestBody) || !docs.requestBody.content) {
       docs.requestBody = {
-        required: true,
-        content: {
-          [media]: {
-            schema: result.schema
-          }
-        }
+        ...needsBody(result.schema, result.components) ? { required: true } : {},
+        content
       };
     } else {
-      docs.requestBody.content[media] = {
-        schema: result.schema
+      docs.requestBody = {
+        ...docs.requestBody,
+        content: { ...docs.requestBody.content, ...content }
       };
     }
   } else {
@@ -24980,6 +25211,8 @@ async function getSpec(middlewareHandler, defaultOptions, parameterComponents) {
           delete result.components.schemas[pos];
         } else {
           parameters = generatedParameters;
+          unreferencedComponents = { schemas: { [pos]: schema } };
+          delete result.components.schemas[pos];
         }
       }
     } else {
@@ -24987,7 +25220,27 @@ async function getSpec(middlewareHandler, defaultOptions, parameterComponents) {
     }
     docs.parameters = parameters;
   }
-  return { schema: docs, components: result.components };
+  const resolved = await resolveSpecSchemas(docs);
+  return {
+    schema: resolved.schema,
+    components: mergeComponentsObjects(result.components, resolved.components),
+    unreferencedComponents
+  };
+}
+async function resolveSpecSchemas(spec) {
+  const schema = { ...spec };
+  let components = {};
+  if (schema.responses) {
+    const resolved = await resolveResponseSchemas(schema.responses);
+    schema.responses = resolved.responses;
+    components = resolved.components;
+  }
+  if (schema.requestBody && "content" in schema.requestBody) {
+    const resolved = await resolveContentSchemas(schema.requestBody.content);
+    schema.requestBody = { ...schema.requestBody, content: resolved.content };
+    components = mergeComponentsObjects(components, resolved.components);
+  }
+  return { schema, components };
 }
 function generateParameters(target, schema, schemas4) {
   const parameters = [];
@@ -25004,59 +25257,134 @@ function generateParameters(target, schema, schemas4) {
       def.description = def.schema.description;
       def.schema = { ...def.schema, description: undefined };
     }
+    if (def.schema && "deprecated" in def.schema && def.schema.deprecated) {
+      def.deprecated = true;
+      def.schema = { ...def.schema, deprecated: undefined };
+    }
+    const referenced = def.schema && "$ref" in def.schema ? referencedSchema(def.schema.$ref, schemas4) : undefined;
+    if (referenced?.description && !def.description) {
+      def.description = referenced.description;
+    }
+    if (referenced?.deprecated) {
+      def.deprecated = true;
+    }
     parameters.push(def);
   }
   return parameters;
 }
-function collectParameterProperties(schema, schemas4) {
+var referencedSchema = ($ref, schemas4) => {
+  const prefix = "#/components/schemas/";
+  if (!$ref.startsWith(prefix)) {
+    return;
+  }
+  const name = $ref.slice(prefix.length).replaceAll("~1", "/").replaceAll("~0", "~");
+  return schemas4?.[name];
+};
+var intersect = (entries) => {
   const properties = /* @__PURE__ */ new Map;
-  const resolvingRefs = /* @__PURE__ */ new Set;
-  const collect = (current) => {
-    for (const [key, value] of Object.entries(current.properties ?? {})) {
-      const existing = properties.get(key);
-      properties.set(key, {
-        schema: existing ? { allOf: [existing.schema, value] } : value,
-        required: Boolean(current.required?.includes(key)) || existing?.required
-      });
-    }
-    for (const member of current.allOf ?? []) {
-      if ("$ref" in member) {
-        const prefix = "#/components/schemas/";
-        if (!member.$ref.startsWith(prefix))
-          continue;
-        const name = member.$ref.slice(prefix.length).replaceAll("~1", "/").replaceAll("~0", "~");
-        const referencedSchema = schemas4?.[name];
-        if (referencedSchema && !resolvingRefs.has(name)) {
-          resolvingRefs.add(name);
-          collect(referencedSchema);
-          resolvingRefs.delete(name);
-        }
-      } else {
-        collect(member);
+  for (const [key, property] of entries) {
+    const existing = properties.get(key);
+    properties.set(key, existing ? {
+      required: existing.required || property.required,
+      schema: { allOf: [existing.schema, property.schema] }
+    } : property);
+  }
+  return properties;
+};
+var unite = (variants) => {
+  const keys = new Set(variants.flatMap((variant) => [...variant.keys()]));
+  return new Map([...keys].map((key) => {
+    const found = variants.map((variant) => variant.get(key));
+    const [first, ...others] = new Map(found.filter((property) => property !== undefined).map(({ schema }) => [JSON.stringify(schema), schema])).values();
+    return [
+      key,
+      {
+        required: found.every((property) => property?.required),
+        schema: others.length ? { anyOf: [first, ...others] } : first
       }
+    ];
+  }));
+};
+var collectParameterProperties = (schema, schemas4) => {
+  const collectMember = (member, resolving) => {
+    if (!("$ref" in member))
+      return collect(member, resolving);
+    const prefix = "#/components/schemas/";
+    if (!member.$ref.startsWith(prefix))
+      return /* @__PURE__ */ new Map;
+    const name = member.$ref.slice(prefix.length).replaceAll("~1", "/").replaceAll("~0", "~");
+    const referencedSchema2 = schemas4?.[name];
+    if (!referencedSchema2 || resolving.has(name))
+      return /* @__PURE__ */ new Map;
+    return collect(referencedSchema2, new Set(resolving).add(name));
+  };
+  const collect = (current, resolving) => intersect([
+    ...Object.entries(current.properties ?? {}).map(([key, value]) => [
+      key,
+      { required: Boolean(current.required?.includes(key)), schema: value }
+    ]),
+    ...(current.allOf ?? []).flatMap((member) => [
+      ...collectMember(member, resolving)
+    ]),
+    ...[current.anyOf, current.oneOf].filter((variants) => variants?.length).flatMap((variants = []) => [
+      ...unite(variants.map((variant) => collectMember(variant, resolving)))
+    ])
+  ]);
+  return collect(schema, /* @__PURE__ */ new Set);
+};
+var resolveHeaders = async (headers, direction) => {
+  const resolved = await Promise.all(Object.entries(headers).map(async ([name, header]) => {
+    if ("$ref" in header || typeof header.schema !== "object" || header.schema === null || !("toOpenAPISchema" in header.schema)) {
+      return { components: undefined, entry: [name, header] };
     }
+    const result = await header.schema.toOpenAPISchema(undefined, direction);
+    liftSchemaDefs(result);
+    return {
+      components: result.components,
+      entry: [name, { ...header, schema: result.schema }]
+    };
+  }));
+  return {
+    components: mergeComponentsObjects({}, ...resolved.map(({ components }) => components)),
+    headers: Object.fromEntries(resolved.map(({ entry }) => entry))
   };
-  collect(schema);
-  return properties;
-}
-async function resolveContentSchemas(content) {
+};
+var resolveEncoding = async (encoding, direction) => {
+  const resolved = await Promise.all(Object.entries(encoding).map(async ([property, entry]) => {
+    if (!entry.headers) {
+      return { components: undefined, entry: [property, entry] };
+    }
+    const { components, headers } = await resolveHeaders(entry.headers, direction);
+    return { components, entry: [property, { ...entry, headers }] };
+  }));
+  return {
+    components: mergeComponentsObjects({}, ...resolved.map(({ components }) => components)),
+    encoding: Object.fromEntries(resolved.map(({ entry }) => entry))
+  };
+};
+async function resolveContentSchemas(content, direction) {
   let components = {};
   const resolvedContent = {};
   for (const [contentKey, raw] of Object.entries(content)) {
     if (!raw)
       continue;
-    if (raw.schema && "toOpenAPISchema" in raw.schema) {
-      const result = await raw.schema.toOpenAPISchema();
+    const encoding = raw.encoding ? await resolveEncoding(raw.encoding, direction) : undefined;
+    const media = encoding ? { ...raw, encoding: encoding.encoding } : raw;
+    if (encoding) {
+      components = mergeComponentsObjects(components, encoding.components);
+    }
+    if (media.schema != null && typeof media.schema === "object" && "toOpenAPISchema" in media.schema) {
+      const result = await media.schema.toOpenAPISchema(undefined, direction);
       liftSchemaDefs(result);
       resolvedContent[contentKey] = {
-        ...raw,
+        ...media,
         schema: result.schema
       };
       if (result.components) {
         components = mergeComponentsObjects(components, result.components);
       }
     } else {
-      resolvedContent[contentKey] = raw;
+      resolvedContent[contentKey] = media;
     }
   }
   return { content: resolvedContent, components };
@@ -25065,18 +25393,20 @@ async function resolveResponseSchemas(responses) {
   let components = {};
   const resolvedResponses = {};
   for (const [key, response] of Object.entries(responses)) {
-    if (!response || !("content" in response) || !response.content) {
+    if (!response || "$ref" in response || !response.content && !response.headers) {
       resolvedResponses[key] = response;
       continue;
     }
-    const resolved = await resolveContentSchemas(response.content);
+    const content = response.content ? await resolveContentSchemas(response.content, "output") : undefined;
+    const headers = response.headers ? await resolveHeaders(response.headers, "output") : undefined;
     resolvedResponses[key] = {
       ...response,
-      content: resolved.content
+      ...content && { content: content.content },
+      ...headers && { headers: headers.headers }
     };
-    components = mergeComponentsObjects(components, resolved.components);
+    components = mergeComponentsObjects(components, content?.components, headers?.components);
   }
-  return { responses: resolvedResponses, components };
+  return markAsOutput(resolvedResponses, components);
 }
 function liftSchemaDefs(result) {
   const defs = result.schema.$defs;
@@ -25108,6 +25438,96 @@ function mergeComponentsObjects(...components) {
     return prev;
   }, components[0] ?? {});
 }
+var OUTPUT_MARK = "\x00output";
+var isOutput = (name) => name.endsWith(OUTPUT_MARK);
+var inputName = (output3) => output3.slice(0, -OUTPUT_MARK.length);
+var markAsOutput = (responses, components) => {
+  const schemas4 = components.schemas ?? {};
+  const mark = (name) => Object.hasOwn(schemas4, name) ? `${name}${OUTPUT_MARK}` : undefined;
+  return {
+    responses: renameSchemaRefs(responses, mark, true),
+    components: {
+      ...components,
+      ...components.schemas && {
+        schemas: Object.fromEntries(Object.entries(schemas4).map(([name, schema]) => [
+          `${name}${OUTPUT_MARK}`,
+          renameSchemaRefs(schema, mark)
+        ]))
+      }
+    }
+  };
+};
+var withOutputRefs = (documentation, ctx) => [
+  documentation,
+  componentRefs(documentation).filter((ref) => ref.startsWith("schemas/")).map((ref) => decodeName(ref.slice("schemas/".length))).filter((name) => !Object.hasOwn(ctx.components.schemas ?? {}, name) && Object.hasOwn(ctx.components.schemas ?? {}, `${name}${OUTPUT_MARK}`)).map((name) => ({
+    $ref: `${SCHEMA_REF}${encodeName(`${name}${OUTPUT_MARK}`)}`
+  }))
+];
+var canonical = (value) => JSON.stringify(value, (_key, item) => item && typeof item === "object" && !Array.isArray(item) ? Object.fromEntries(Object.entries(item).toSorted(([a2], [b2]) => a2.localeCompare(b2))) : item);
+var freeName = (name, used) => {
+  let candidate = name;
+  for (let suffix = 2;used.has(candidate); suffix++) {
+    candidate = `${name}${suffix}`;
+  }
+  return candidate;
+};
+var assignOutputNames = (outputs, taken) => {
+  const used = new Set(taken);
+  const names = /* @__PURE__ */ new Map;
+  for (const output3 of outputs) {
+    const name = freeName(`${inputName(output3)}Output`, used);
+    used.add(name);
+    names.set(output3, name);
+  }
+  return names;
+};
+var splitOutputComponents = (components, paths) => {
+  const { schemas: schemas4 = {}, ...otherComponents } = components;
+  const outputs = Object.keys(schemas4).filter(isOutput);
+  if (outputs.length === 0) {
+    return { components, paths };
+  }
+  const asInput = (name) => isOutput(name) ? inputName(name) : undefined;
+  const shared = new Set(outputs.filter((output3) => Object.hasOwn(schemas4, inputName(output3))));
+  const outputRefs = new Map([...shared].map((output3) => [
+    output3,
+    componentRefs(schemas4[output3]).filter((ref) => ref.startsWith("schemas/")).map((ref) => decodeName(ref.slice("schemas/".length)))
+  ]));
+  const refersTo = (output3, split2) => outputRefs.get(output3)?.some((name) => split2.has(name));
+  const split = new Set([...shared].filter((output3) => canonical(renameSchemaRefs(schemas4[output3], asInput)) !== canonical(schemas4[inputName(output3)])));
+  let previousSize;
+  do {
+    previousSize = split.size;
+    for (const output3 of shared) {
+      if (!split.has(output3) && refersTo(output3, split)) {
+        split.add(output3);
+      }
+    }
+  } while (split.size !== previousSize);
+  const taken = [
+    ...Object.keys(schemas4).filter((name) => !isOutput(name)),
+    ...outputs.filter((output3) => !shared.has(output3)).map(inputName)
+  ];
+  const outputNames = assignOutputNames([...split].toSorted(), taken);
+  const rename = (name) => isOutput(name) ? outputNames.get(name) ?? inputName(name) : undefined;
+  return {
+    components: {
+      ...renameSchemaRefs(otherComponents, rename),
+      schemas: Object.fromEntries(Object.entries(schemas4).flatMap(([name, schema]) => {
+        const renamed = renameSchemaRefs(schema, rename);
+        if (!isOutput(name)) {
+          return [[name, renamed]];
+        }
+        const output3 = outputNames.get(name);
+        if (output3) {
+          return [[output3, renamed]];
+        }
+        return Object.hasOwn(schemas4, inputName(name)) ? [] : [[inputName(name), renamed]];
+      }))
+    },
+    paths: renameSchemaRefs(paths, rename, true)
+  };
+};
 var arktypeMorphFallback = (ctx) => ctx.base;
 var zodV4DateOverride = (ctx) => {
   if (ctx.zodSchema._zod.def.type === "date") {
@@ -25121,14 +25541,34 @@ function resolver(schema, userDefinedOptions) {
     vendor,
     validate: schema["~standard"].validate,
     toJSONSchema: (customOptions) => toJsonSchema(schema, { ...userDefinedOptions, ...customOptions }),
-    toOpenAPISchema: (customOptions) => toOpenAPISchema(schema, {
-      ...userDefinedOptions,
-      ...customOptions,
-      ...vendor === "arktype" ? injectArktypeFallback(userDefinedOptions, customOptions) : undefined,
-      ...vendor === "zod" ? injectZodV4DateOverride(schema, userDefinedOptions, customOptions) : undefined
-    })
+    toOpenAPISchema: (customOptions, direction) => {
+      const context = {
+        ...userDefinedOptions,
+        ...customOptions,
+        ...vendor === "arktype" ? injectArktypeFallback(userDefinedOptions, customOptions) : undefined,
+        ...vendor === "zod" ? injectZodV4DateOverride(schema, userDefinedOptions, customOptions) : undefined
+      };
+      const directionOptions = direction === "output" ? outputOptions(schema) : undefined;
+      return toOpenAPISchema(schema, directionOptions ? {
+        ...context,
+        options: {
+          ...directionOptions,
+          ...context.options
+        }
+      } : context);
+    }
   };
 }
+var outputOptions = (schema) => {
+  switch (schema["~standard"].vendor) {
+    case "zod":
+      return "_zod" in schema ? { io: "output" } : { schemaType: "output" };
+    case "valibot":
+      return { typeMode: "output" };
+    default:
+      return;
+  }
+};
 function injectArktypeFallback(userDefined, custom3) {
   const userNested = userDefined?.options;
   const customNested = custom3?.options;
@@ -28538,12 +28978,12 @@ function createSetOperator(type, isAll) {
 var getSQLiteSetOperators = () => ({
   union: union3,
   unionAll,
-  intersect,
+  intersect: intersect2,
   except
 });
 var union3 = createSetOperator("union", false);
 var unionAll = createSetOperator("union", true);
-var intersect = createSetOperator("intersect", false);
+var intersect2 = createSetOperator("intersect", false);
 var except = createSetOperator("except", false);
 
 // ../../node_modules/.bun/drizzle-orm@0.45.4+6458dd716b2a29fa/node_modules/drizzle-orm/sqlite-core/query-builders/query-builder.js
@@ -32336,8 +32776,12 @@ function setHeaders(ctx, headersToSet) {
 }
 
 // src/platform/http/openapi.ts
+var openObjects = { options: { io: "input" } };
 function jsonResponse(description, schema) {
-  return { description, content: { "application/json": { schema: resolver(schema) } } };
+  return {
+    description,
+    content: { "application/json": { schema: resolver(schema, openObjects) } }
+  };
 }
 var methods = ["GET", "POST", "PUT", "PATCH", "DELETE"];
 var failure2 = {
@@ -52158,5 +52602,5 @@ try {
   process.exitCode = 1;
 }
 
-//# debugId=2F8C02334FD34D1264756E2164756E21
+//# debugId=F29E635AF65D464664756E2164756E21
 //# sourceMappingURL=main.js.map