@temporary-name/server 0.0.1-alpha.0cb08cf84b740850e7d8dcd1d8b87f78af26071b

package/dist/shared/server.RQr7F4gX.mjs

@@ -0,0 +1,1292 @@
+import { isAsyncIteratorObject, toArray, isObject, stringifyJSON, findDeepMatches, clone, assertNever, fallbackContractConfig } from '@temporary-name/shared';
+import * as z from '@temporary-name/zod';
+import { custom, safeParseAsync } from '@temporary-name/zod';
+import { V as ValidationError, s as standardizeHTTPPath, u as unlazyResources, g as getDynamicParams } from './server.D7jtfDRy.mjs';
+import { mapEventIterator } from '@temporary-name/standard-server';
+import { JSONSchemaFormat, JSONSchemaContentEncoding } from '@temporary-name/server/openapi';
+import { registry, globalRegistry } from 'zod/v4/core';
+import { TypeName } from '@temporary-name/interop/json-schema-typed/draft-2020-12';
+
+const EVENT_ITERATOR_DETAILS_SYMBOL = Symbol("KRUSTY_EVENT_ITERATOR_DETAILS");
+function eventIterator(yields, returns) {
+  const schema = custom(
+    (iterator) => isAsyncIteratorObject(iterator)
+  ).transform((iterator) => {
+    const mapped = mapEventIterator(iterator, {
+      async value(value, done) {
+        const schema2 = done ? returns : yields;
+        if (!schema2) {
+          return value;
+        }
+        const result = await safeParseAsync(schema2, value);
+        if (result.success) {
+          return result.data;
+        } else {
+          throw new Error("Event iterator validation failed", {
+            cause: new ValidationError({
+              issues: result.error.issues,
+              data: value
+            })
+          });
+        }
+      },
+      error: async (error) => error
+    });
+    return mapped;
+  });
+  schema[EVENT_ITERATOR_DETAILS_SYMBOL] = {
+    yields,
+    returns
+  };
+  return schema;
+}
+function getEventIteratorSchemaDetails(schema) {
+  if (schema === void 0) {
+    return void 0;
+  }
+  return schema[EVENT_ITERATOR_DETAILS_SYMBOL];
+}
+
+var JsonSchemaXNativeType = /* @__PURE__ */ ((JsonSchemaXNativeType2) => {
+  JsonSchemaXNativeType2["BigInt"] = "bigint";
+  JsonSchemaXNativeType2["RegExp"] = "regexp";
+  JsonSchemaXNativeType2["Date"] = "date";
+  JsonSchemaXNativeType2["Url"] = "url";
+  JsonSchemaXNativeType2["Set"] = "set";
+  JsonSchemaXNativeType2["Map"] = "map";
+  return JsonSchemaXNativeType2;
+})(JsonSchemaXNativeType || {});
+
+const JSON_SCHEMA_REGISTRY = registry();
+const JSON_SCHEMA_INPUT_REGISTRY = registry();
+const JSON_SCHEMA_OUTPUT_REGISTRY = registry();
+
+class ZodToJsonSchemaConverter {
+  maxLazyDepth;
+  maxStructureDepth;
+  anyJsonSchema;
+  unsupportedJsonSchema;
+  undefinedJsonSchema;
+  constructor(options = {}) {
+    this.maxLazyDepth = options.maxLazyDepth ?? 2;
+    this.maxStructureDepth = options.maxStructureDepth ?? 10;
+    this.anyJsonSchema = options.anyJsonSchema ?? {};
+    this.unsupportedJsonSchema = options.unsupportedJsonSchema ?? { not: {} };
+    this.undefinedJsonSchema = options.undefinedJsonSchema ?? { not: {} };
+  }
+  convert = (schema, options) => {
+    return this.#convert(schema, options, 0, 0);
+  };
+  #convert(schema, options, lazyDepth, structureDepth, isHandledCustomJSONSchema = false) {
+    if (structureDepth > this.maxStructureDepth) {
+      return [false, this.anyJsonSchema];
+    }
+    if (!options.minStructureDepthForRef || options.minStructureDepthForRef <= structureDepth) {
+      const components = toArray(options.components);
+      for (const component of components) {
+        if (component.schema === schema && component.allowedStrategies.includes(options.strategy)) {
+          return [component.required, { $ref: component.ref }];
+        }
+      }
+    }
+    if (!isHandledCustomJSONSchema) {
+      const customJSONSchema = this.#getCustomJsonSchema(schema, options);
+      if (customJSONSchema) {
+        const [required, json] = this.#convert(schema, options, lazyDepth, structureDepth, true);
+        return [required, { ...json, ...customJSONSchema }];
+      }
+    }
+    switch (schema._zod.def.type) {
+      case "string": {
+        const string = schema;
+        const json = { type: "string" };
+        const { minimum, maximum, format, patterns, contentEncoding } = string._zod.bag;
+        if (typeof minimum === "number") {
+          json.minLength = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maxLength = maximum;
+        }
+        if (typeof contentEncoding === "string") {
+          json.contentEncoding = this.#handleContentEncoding(contentEncoding);
+        }
+        if (typeof format === "string" && format !== "regex" && json.contentEncoding === void 0) {
+          json.format = this.#handleStringFormat(format);
+        }
+        if (patterns instanceof Set && json.contentEncoding === void 0 && json.format === void 0) {
+          for (const pattern of patterns) {
+            if (json.pattern === void 0) {
+              json.pattern = pattern.source;
+            } else {
+              json.allOf ??= [];
+              json.allOf.push({ pattern: pattern.source });
+            }
+          }
+        }
+        if (format === "jwt" && json.contentEncoding === void 0 && json.format === void 0 && json.pattern === void 0) {
+          json.pattern = /^[\w-]+\.[\w-]+\.[\w-]+$/.source;
+        }
+        return [true, json];
+      }
+      case "number": {
+        const number = schema;
+        const json = { type: "number" };
+        const { minimum, maximum, format, multipleOf, exclusiveMaximum, exclusiveMinimum } = number._zod.bag;
+        if (typeof format === "string" && format?.includes("int")) {
+          json.type = "integer";
+        }
+        if (typeof minimum === "number") {
+          json.minimum = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maximum = maximum;
+        }
+        if (typeof exclusiveMinimum === "number") {
+          json.exclusiveMinimum = exclusiveMinimum;
+        }
+        if (typeof exclusiveMaximum === "number") {
+          json.exclusiveMaximum = exclusiveMaximum;
+        }
+        if (typeof multipleOf === "number") {
+          json.multipleOf = multipleOf;
+        }
+        return [true, json];
+      }
+      case "boolean": {
+        return [true, { type: "boolean" }];
+      }
+      case "bigint": {
+        return [
+          true,
+          {
+            type: "string",
+            pattern: "^-?[0-9]+$",
+            "x-native-type": JsonSchemaXNativeType.BigInt
+          }
+        ];
+      }
+      case "date": {
+        return [
+          true,
+          {
+            type: "string",
+            format: JSONSchemaFormat.DateTime,
+            "x-native-type": JsonSchemaXNativeType.Date
+          }
+        ];
+      }
+      case "null": {
+        return [true, { type: "null" }];
+      }
+      case "undefined":
+      case "void": {
+        return [false, this.undefinedJsonSchema];
+      }
+      case "any": {
+        return [false, this.anyJsonSchema];
+      }
+      case "unknown": {
+        return [false, this.anyJsonSchema];
+      }
+      case "never": {
+        return [true, this.unsupportedJsonSchema];
+      }
+      case "array": {
+        const array = schema;
+        const json = { type: "array" };
+        const { minimum, maximum } = array._zod.bag;
+        if (typeof minimum === "number") {
+          json.minItems = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maxItems = maximum;
+        }
+        json.items = this.#handleArrayItemJsonSchema(
+          this.#convert(array._zod.def.element, options, lazyDepth, structureDepth + 1),
+          options
+        );
+        return [true, json];
+      }
+      case "object": {
+        const object = schema;
+        const json = { type: "object" };
+        let required = true;
+        for (const [key, value] of Object.entries(object._zod.def.shape)) {
+          const [itemRequired, itemJson] = this.#convert(value, options, lazyDepth, structureDepth + 1);
+          json.properties ??= {};
+          json.properties[key] = itemJson;
+          if (itemRequired) {
+            json.required ??= [];
+            json.required.push(key);
+          }
+        }
+        const { catchall } = object._zod.def;
+        if (!catchall || catchall._zod.def.type === "never") {
+          json.additionalProperties = false;
+        } else if (catchall) {
+          const [_, addJson] = this.#convert(catchall, options, lazyDepth, structureDepth + 1);
+          json.additionalProperties = addJson;
+        }
+        if (options.strategy === "input" && structureDepth === 0 && (!json.properties || Object.keys(json.properties).length === 0)) {
+          required = false;
+        }
+        return [required, json];
+      }
+      case "union": {
+        const union = schema;
+        const anyOf = [];
+        let required = true;
+        for (const item of union._zod.def.options) {
+          const [itemRequired, itemJson] = this.#convert(item, options, lazyDepth, structureDepth);
+          if (!itemRequired) {
+            required = false;
+          }
+          if (options.strategy === "input") {
+            if (itemJson !== this.undefinedJsonSchema && itemJson !== this.unsupportedJsonSchema) {
+              anyOf.push(itemJson);
+            }
+          } else {
+            if (itemJson !== this.undefinedJsonSchema) {
+              anyOf.push(itemJson);
+            }
+          }
+        }
+        return [required, anyOf.length === 1 ? anyOf[0] : { anyOf }];
+      }
+      case "intersection": {
+        const intersection = schema;
+        const json = { allOf: [] };
+        let required = false;
+        for (const item of [intersection._zod.def.left, intersection._zod.def.right]) {
+          const [itemRequired, itemJson] = this.#convert(item, options, lazyDepth, structureDepth);
+          json.allOf.push(itemJson);
+          if (itemRequired) {
+            required = true;
+          }
+        }
+        return [required, json];
+      }
+      case "tuple": {
+        const tuple = schema;
+        const json = { type: "array", prefixItems: [] };
+        for (const item of tuple._zod.def.items) {
+          json.prefixItems.push(
+            this.#handleArrayItemJsonSchema(
+              this.#convert(item, options, lazyDepth, structureDepth + 1),
+              options
+            )
+          );
+        }
+        if (tuple._zod.def.rest) {
+          json.items = this.#handleArrayItemJsonSchema(
+            this.#convert(tuple._zod.def.rest, options, lazyDepth, structureDepth + 1),
+            options
+          );
+        }
+        const { minimum, maximum } = tuple._zod.bag;
+        if (typeof minimum === "number") {
+          json.minItems = minimum;
+        }
+        if (typeof maximum === "number") {
+          json.maxItems = maximum;
+        }
+        return [true, json];
+      }
+      case "record": {
+        const record = schema;
+        const json = { type: "object" };
+        json.propertyNames = this.#convert(
+          record._zod.def.keyType,
+          options,
+          lazyDepth,
+          structureDepth + 1
+        )[1];
+        json.additionalProperties = this.#convert(
+          record._zod.def.valueType,
+          options,
+          lazyDepth,
+          structureDepth + 1
+        )[1];
+        return [true, json];
+      }
+      case "map": {
+        const map = schema;
+        return [
+          true,
+          {
+            type: "array",
+            items: {
+              type: "array",
+              prefixItems: [
+                this.#handleArrayItemJsonSchema(
+                  this.#convert(map._zod.def.keyType, options, lazyDepth, structureDepth + 1),
+                  options
+                ),
+                this.#handleArrayItemJsonSchema(
+                  this.#convert(map._zod.def.valueType, options, lazyDepth, structureDepth + 1),
+                  options
+                )
+              ],
+              maxItems: 2,
+              minItems: 2
+            },
+            "x-native-type": JsonSchemaXNativeType.Map
+          }
+        ];
+      }
+      case "set": {
+        const set = schema;
+        return [
+          true,
+          {
+            type: "array",
+            uniqueItems: true,
+            items: this.#handleArrayItemJsonSchema(
+              this.#convert(set._zod.def.valueType, options, lazyDepth, structureDepth + 1),
+              options
+            ),
+            "x-native-type": JsonSchemaXNativeType.Set
+          }
+        ];
+      }
+      case "enum": {
+        const enum_ = schema;
+        return [true, { enum: Object.values(enum_._zod.def.entries) }];
+      }
+      case "literal": {
+        const literal = schema;
+        let required = true;
+        const values = /* @__PURE__ */ new Set();
+        for (const value of literal._zod.def.values) {
+          if (value === void 0) {
+            required = false;
+          } else {
+            values.add(typeof value === "bigint" ? value.toString() : value);
+          }
+        }
+        const json = values.size === 0 ? this.undefinedJsonSchema : values.size === 1 ? { const: values.values().next().value } : { enum: Array.from(values) };
+        return [required, json];
+      }
+      case "file": {
+        const file = schema;
+        const oneOf = [];
+        const { mime } = file._zod.bag;
+        if (mime === void 0 || Array.isArray(mime) && mime.every((m) => typeof m === "string")) {
+          for (const type of mime ?? ["*/*"]) {
+            oneOf.push({
+              type: "string",
+              contentMediaType: type
+            });
+          }
+        }
+        return [true, oneOf.length === 1 ? oneOf[0] : { anyOf: oneOf }];
+      }
+      case "transform": {
+        return [false, this.anyJsonSchema];
+      }
+      case "nullable": {
+        const nullable = schema;
+        const [required, json] = this.#convert(
+          nullable._zod.def.innerType,
+          options,
+          lazyDepth,
+          structureDepth
+        );
+        return [required, { anyOf: [json, { type: "null" }] }];
+      }
+      case "nonoptional": {
+        const nonoptional = schema;
+        const [, json] = this.#convert(nonoptional._zod.def.innerType, options, lazyDepth, structureDepth);
+        return [true, json];
+      }
+      case "success": {
+        return [true, { type: "boolean" }];
+      }
+      case "default":
+      case "prefault": {
+        const default_ = schema;
+        const [, json] = this.#convert(default_._zod.def.innerType, options, lazyDepth, structureDepth);
+        return [
+          false,
+          {
+            ...json,
+            default: default_._zod.def.defaultValue
+          }
+        ];
+      }
+      case "catch": {
+        const catch_ = schema;
+        return this.#convert(catch_._zod.def.innerType, options, lazyDepth, structureDepth);
+      }
+      case "nan": {
+        return [true, options.strategy === "input" ? this.unsupportedJsonSchema : { type: "null" }];
+      }
+      case "pipe": {
+        const pipe = schema;
+        return this.#convert(
+          options.strategy === "input" ? pipe._zod.def.in : pipe._zod.def.out,
+          options,
+          lazyDepth,
+          structureDepth
+        );
+      }
+      case "readonly": {
+        const readonly_ = schema;
+        const [required, json] = this.#convert(
+          readonly_._zod.def.innerType,
+          options,
+          lazyDepth,
+          structureDepth
+        );
+        return [required, { ...json, readOnly: true }];
+      }
+      case "template_literal": {
+        const templateLiteral = schema;
+        return [
+          true,
+          {
+            type: "string",
+            pattern: templateLiteral._zod.pattern.source
+          }
+        ];
+      }
+      case "optional": {
+        const optional = schema;
+        const [, json] = this.#convert(optional._zod.def.innerType, options, lazyDepth, structureDepth);
+        return [false, json];
+      }
+      case "lazy": {
+        const lazy = schema;
+        const currentLazyDepth = lazyDepth + 1;
+        if (currentLazyDepth > this.maxLazyDepth) {
+          return [false, this.anyJsonSchema];
+        }
+        return this.#convert(lazy._zod.def.getter(), options, currentLazyDepth, structureDepth);
+      }
+      default: {
+        schema._zod.def.type;
+        return [true, this.unsupportedJsonSchema];
+      }
+    }
+  }
+  #getCustomJsonSchema(schema, options) {
+    if (options.strategy === "input" && JSON_SCHEMA_INPUT_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_INPUT_REGISTRY.get(schema);
+    }
+    if (options.strategy === "output" && JSON_SCHEMA_OUTPUT_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_OUTPUT_REGISTRY.get(schema);
+    }
+    if (JSON_SCHEMA_REGISTRY.has(schema)) {
+      return JSON_SCHEMA_REGISTRY.get(schema);
+    }
+    const global = globalRegistry.get(schema);
+    if (global) {
+      return {
+        title: global.title,
+        description: global.description,
+        examples: Array.isArray(global.examples) ? global.examples : void 0
+      };
+    }
+  }
+  #handleArrayItemJsonSchema([required, schema], options) {
+    if (required || options.strategy === "input" || schema.default !== void 0) {
+      return schema;
+    }
+    if (schema === this.undefinedJsonSchema) {
+      return { type: "null" };
+    }
+    return {
+      anyOf: [
+        // schema can contain { type: 'null' } so we should use anyOf instead of oneOf
+        schema,
+        { type: "null" }
+      ]
+    };
+  }
+  #handleStringFormat(format) {
+    if (format === "guid") {
+      return JSONSchemaFormat.UUID;
+    }
+    if (format === "url") {
+      return JSONSchemaFormat.URI;
+    }
+    if (format === "datetime") {
+      return JSONSchemaFormat.DateTime;
+    }
+    return Object.values(JSONSchemaFormat).includes(format) ? format : void 0;
+  }
+  #handleContentEncoding(contentEncoding) {
+    return Object.values(JSONSchemaContentEncoding).includes(contentEncoding) ? contentEncoding : void 0;
+  }
+}
+
+const OPERATION_EXTENDER_SYMBOL = Symbol("KRUSTY_OPERATION_EXTENDER");
+function customOpenAPIOperation(o, extend) {
+  return new Proxy(o, {
+    get(target, prop, receiver) {
+      if (prop === OPERATION_EXTENDER_SYMBOL) {
+        return extend;
+      }
+      return Reflect.get(target, prop, receiver);
+    }
+  });
+}
+function getCustomOpenAPIOperation(o) {
+  return o[OPERATION_EXTENDER_SYMBOL];
+}
+function applyCustomOpenAPIOperation(operation, contract) {
+  const operationCustoms = [];
+  for (const middleware of contract["~def"].middlewares) {
+    const maybeExtender = getCustomOpenAPIOperation(middleware);
+    if (maybeExtender) {
+      operationCustoms.push(maybeExtender);
+    }
+  }
+  let currentOperation = operation;
+  for (const custom of operationCustoms) {
+    if (typeof custom === "function") {
+      currentOperation = custom(currentOperation, contract);
+    } else {
+      currentOperation = {
+        ...currentOperation,
+        ...custom
+      };
+    }
+  }
+  return currentOperation;
+}
+
+const LOGIC_KEYWORDS = [
+  "$dynamicRef",
+  "$ref",
+  "additionalItems",
+  "additionalProperties",
+  "allOf",
+  "anyOf",
+  "const",
+  "contains",
+  "contentEncoding",
+  "contentMediaType",
+  "contentSchema",
+  "dependencies",
+  "dependentRequired",
+  "dependentSchemas",
+  "else",
+  "enum",
+  "exclusiveMaximum",
+  "exclusiveMinimum",
+  "format",
+  "if",
+  "items",
+  "maxContains",
+  "maximum",
+  "maxItems",
+  "maxLength",
+  "maxProperties",
+  "minContains",
+  "minimum",
+  "minItems",
+  "minLength",
+  "minProperties",
+  "multipleOf",
+  "not",
+  "oneOf",
+  "pattern",
+  "patternProperties",
+  "prefixItems",
+  "properties",
+  "propertyNames",
+  "required",
+  "then",
+  "type",
+  "unevaluatedItems",
+  "unevaluatedProperties",
+  "uniqueItems"
+];
+
+function isFileSchema(schema) {
+  return isObject(schema) && schema.type === "string" && typeof schema.contentMediaType === "string";
+}
+function isObjectSchema(schema) {
+  return isObject(schema) && schema.type === "object";
+}
+function isAnySchema(schema) {
+  if (schema === true) {
+    return true;
+  }
+  if (Object.keys(schema).every((k) => !LOGIC_KEYWORDS.includes(k))) {
+    return true;
+  }
+  return false;
+}
+function separateObjectSchema(schema, separatedProperties) {
+  if (Object.keys(schema).some(
+    (k) => !["type", "properties", "required", "additionalProperties"].includes(k) && LOGIC_KEYWORDS.includes(k) && schema[k] !== void 0
+  )) {
+    return [{ type: "object" }, schema];
+  }
+  const matched = { ...schema };
+  const rest = { ...schema };
+  matched.properties = separatedProperties.reduce((acc, key) => {
+    const keySchema = schema.properties?.[key] ?? schema.additionalProperties;
+    if (keySchema !== void 0) {
+      acc[key] = keySchema;
+    }
+    return acc;
+  }, {});
+  matched.required = schema.required?.filter((key) => separatedProperties.includes(key));
+  matched.examples = schema.examples?.map((example) => {
+    if (!isObject(example)) {
+      return example;
+    }
+    return Object.entries(example).reduce(
+      (acc, [key, value]) => {
+        if (separatedProperties.includes(key)) {
+          acc[key] = value;
+        }
+        return acc;
+      },
+      {}
+    );
+  });
+  rest.properties = schema.properties && Object.entries(schema.properties).filter(([key]) => !separatedProperties.includes(key)).reduce(
+    (acc, [key, value]) => {
+      acc[key] = value;
+      return acc;
+    },
+    {}
+  );
+  rest.required = schema.required?.filter((key) => !separatedProperties.includes(key));
+  rest.examples = schema.examples?.map((example) => {
+    if (!isObject(example)) {
+      return example;
+    }
+    return Object.entries(example).reduce(
+      (acc, [key, value]) => {
+        if (!separatedProperties.includes(key)) {
+          acc[key] = value;
+        }
+        return acc;
+      },
+      {}
+    );
+  });
+  return [matched, rest];
+}
+function filterSchemaBranches(schema, check, matches = []) {
+  if (check(schema)) {
+    matches.push(schema);
+    return [matches, void 0];
+  }
+  if (isObject(schema)) {
+    for (const keyword of ["anyOf", "oneOf"]) {
+      if (schema[keyword] && Object.keys(schema).every((k) => k === keyword || !LOGIC_KEYWORDS.includes(k))) {
+        const rest = schema[keyword].map((s) => filterSchemaBranches(s, check, matches)[1]).filter((v) => !!v);
+        if (rest.length === 1 && typeof rest[0] === "object") {
+          return [matches, { ...schema, [keyword]: void 0, ...rest[0] }];
+        }
+        return [matches, { ...schema, [keyword]: rest }];
+      }
+    }
+  }
+  return [matches, schema];
+}
+function applySchemaOptionality(required, schema) {
+  if (required) {
+    return schema;
+  }
+  return {
+    anyOf: [schema, { not: {} }]
+  };
+}
+function expandUnionSchema(schema) {
+  if (typeof schema === "object") {
+    for (const keyword of ["anyOf", "oneOf"]) {
+      if (schema[keyword] && Object.keys(schema).every((k) => k === keyword || !LOGIC_KEYWORDS.includes(k))) {
+        return schema[keyword].flatMap((s) => expandUnionSchema(s));
+      }
+    }
+  }
+  return [schema];
+}
+function expandArrayableSchema(schema) {
+  const schemas = expandUnionSchema(schema);
+  if (schemas.length !== 2) {
+    return void 0;
+  }
+  const arraySchema = schemas.find(
+    (s) => typeof s === "object" && s.type === "array" && Object.keys(s).filter((k) => LOGIC_KEYWORDS.includes(k)).every((k) => k === "type" || k === "items")
+  );
+  if (arraySchema === void 0) {
+    return void 0;
+  }
+  const items1 = arraySchema.items;
+  const items2 = schemas.find((s) => s !== arraySchema);
+  if (stringifyJSON(items1) !== stringifyJSON(items2)) {
+    return void 0;
+  }
+  return [items2, arraySchema];
+}
+const PRIMITIVE_SCHEMA_TYPES = /* @__PURE__ */ new Set([
+  TypeName.String,
+  TypeName.Number,
+  TypeName.Integer,
+  TypeName.Boolean,
+  TypeName.Null
+]);
+function isPrimitiveSchema(schema) {
+  return expandUnionSchema(schema).every((s) => {
+    if (typeof s === "boolean") {
+      return false;
+    }
+    if (typeof s.type === "string" && PRIMITIVE_SCHEMA_TYPES.has(s.type)) {
+      return true;
+    }
+    if (s.const !== void 0) {
+      return true;
+    }
+    return false;
+  });
+}
+
+function toOpenAPIPath(path) {
+  return standardizeHTTPPath(path).replace(/\/\{\+([^}]+)\}/g, "/{$1}");
+}
+function toOpenAPIMethod(method) {
+  return method.toLocaleLowerCase();
+}
+function toOpenAPIContent(schema) {
+  const content = {};
+  const [matches, restSchema] = filterSchemaBranches(schema, isFileSchema);
+  for (const file of matches) {
+    content[file.contentMediaType] = {
+      schema: toOpenAPISchema(file)
+    };
+  }
+  if (restSchema !== void 0) {
+    content["application/json"] = {
+      schema: toOpenAPISchema(restSchema)
+    };
+    const isStillHasFileSchema = findDeepMatches((v) => isObject(v) && isFileSchema(v), restSchema).values.length > 0;
+    if (isStillHasFileSchema) {
+      content["multipart/form-data"] = {
+        schema: toOpenAPISchema(restSchema)
+      };
+    }
+  }
+  return content;
+}
+function toOpenAPIEventIteratorContent([yieldsRequired, yieldsSchema], [returnsRequired, returnsSchema]) {
+  return {
+    "text/event-stream": {
+      schema: toOpenAPISchema({
+        oneOf: [
+          {
+            type: "object",
+            properties: {
+              event: { const: "message" },
+              data: yieldsSchema,
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: yieldsRequired ? ["event", "data"] : ["event"]
+          },
+          {
+            type: "object",
+            properties: {
+              event: { const: "done" },
+              data: returnsSchema,
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: returnsRequired ? ["event", "data"] : ["event"]
+          },
+          {
+            type: "object",
+            properties: {
+              event: { const: "error" },
+              data: {},
+              id: { type: "string" },
+              retry: { type: "number" }
+            },
+            required: ["event"]
+          }
+        ]
+      })
+    }
+  };
+}
+function toOpenAPIParameters(schema, parameterIn) {
+  const parameters = [];
+  for (const key in schema.properties) {
+    const keySchema = schema.properties[key];
+    let isDeepObjectStyle = true;
+    if (parameterIn !== "query") {
+      isDeepObjectStyle = false;
+    } else if (isPrimitiveSchema(keySchema)) {
+      isDeepObjectStyle = false;
+    } else {
+      const [item] = expandArrayableSchema(keySchema) ?? [];
+      if (item !== void 0 && isPrimitiveSchema(item)) {
+        isDeepObjectStyle = false;
+      }
+    }
+    parameters.push({
+      name: key,
+      in: parameterIn,
+      required: schema.required?.includes(key),
+      schema: toOpenAPISchema(keySchema),
+      style: isDeepObjectStyle ? "deepObject" : void 0,
+      explode: isDeepObjectStyle ? true : void 0,
+      allowEmptyValue: parameterIn === "query" ? true : void 0,
+      allowReserved: parameterIn === "query" ? true : void 0
+    });
+  }
+  return parameters;
+}
+function checkParamsSchema(schema, params) {
+  const properties = Object.keys(schema.properties ?? {});
+  const required = schema.required ?? [];
+  if (properties.length !== params.length || properties.some((v) => !params.includes(v))) {
+    return false;
+  }
+  if (required.length !== params.length || required.some((v) => !params.includes(v))) {
+    return false;
+  }
+  return true;
+}
+function toOpenAPISchema(schema) {
+  if (schema === true) {
+    return {};
+  } else if (schema === false) {
+    return { not: {} };
+  }
+  if (schema.type === "object" && !schema.properties && schema.additionalProperties === false) {
+    return {
+      ...schema,
+      "x-stainless-empty-object": true
+    };
+  }
+  return schema;
+}
+const OPENAPI_JSON_SCHEMA_REF_PREFIX = "#/components/schemas/";
+function resolveOpenAPIJsonSchemaRef(doc, schema) {
+  if (typeof schema !== "object" || !schema.$ref?.startsWith(OPENAPI_JSON_SCHEMA_REF_PREFIX)) {
+    return schema;
+  }
+  const name = schema.$ref.slice(OPENAPI_JSON_SCHEMA_REF_PREFIX.length);
+  const resolved = doc.components?.schemas?.[name];
+  return resolved ?? schema;
+}
+
+class OpenAPIGeneratorError extends Error {
+}
+async function generateOpenApiSpec(resources, options = {}) {
+  const converter = typeof options.schemaConverter === "function" ? options.schemaConverter : new ZodToJsonSchemaConverter(options.schemaConverter ?? {}).convert;
+  const doc = {
+    ...clone(options.spec),
+    info: options.spec?.info ?? { title: "API Reference", version: "0.0.0" },
+    openapi: "3.1.1"
+  };
+  const contractsById = /* @__PURE__ */ new Map();
+  const apiResources = await unlazyResources(resources);
+  for (const apiResource of apiResources) {
+    for (const [methodName, contract] of Object.entries(apiResource.methods)) {
+      const operationId = `${apiResource.name}.${methodName}`;
+      if (contractsById.has(operationId)) {
+        throw new Error(`Multiple ApiResources have the same name: "${operationId}"`);
+      }
+      contractsById.set(operationId, contract);
+    }
+  }
+  const combinedErrorMap = {};
+  for (const contract of contractsById.values()) {
+    const { errorMap } = contract["~def"];
+    for (const key in errorMap) {
+      if (!errorMap[key]) {
+        continue;
+      }
+      if (key in combinedErrorMap && combinedErrorMap[key] !== errorMap[key]) {
+        throw new OpenAPIGeneratorError(
+          `Conflicting error map entries for key "${key}". Please ensure that all error maps have unique keys or identical values for shared keys.`
+        );
+      }
+      combinedErrorMap[key] = errorMap[key];
+    }
+  }
+  const { baseSchemaConvertOptions } = await resolveCommonSchemas(doc, options.commonSchemas, converter);
+  const errorRefMap = await generateErrorComponents(
+    combinedErrorMap,
+    doc,
+    baseSchemaConvertOptions,
+    converter
+  );
+  const namesByAuthConfig = getNamesByAuthConfig(contractsById.values());
+  if (namesByAuthConfig.size > 0) {
+    doc.components ??= {};
+    const schemes = doc.components.securitySchemes ??= {};
+    for (const [authConfig, name] of namesByAuthConfig) {
+      schemes[name] ??= authConfigToSecurityScheme(authConfig);
+    }
+  }
+  const errors = [];
+  for (const [operationId, contract] of contractsById) {
+    const def = contract["~def"];
+    const path = def.methodConfig.path;
+    try {
+      const method = toOpenAPIMethod(def.methodConfig.method);
+      const httpPath = toOpenAPIPath(path);
+      let operationObjectRef;
+      if (def.methodConfig.spec !== void 0 && typeof def.methodConfig.spec !== "function") {
+        operationObjectRef = def.methodConfig.spec;
+      } else {
+        operationObjectRef = {
+          operationId,
+          summary: def.methodConfig.summary,
+          description: def.methodConfig.description,
+          deprecated: def.methodConfig.deprecated,
+          tags: def.methodConfig.tags?.map((tag) => tag)
+        };
+        const security = def.authConfigs.map(
+          (authConfig) => authConfig.type === "none" ? {} : { [namesByAuthConfig.get(authConfig)]: [] }
+        );
+        if (security.length > 0) {
+          operationObjectRef.security = security;
+        }
+        await handleRequest(doc, operationObjectRef, def, baseSchemaConvertOptions, converter);
+        await handleSuccessResponse(doc, operationObjectRef, def, baseSchemaConvertOptions, converter);
+        handleErrorResponse(operationObjectRef, def, errorRefMap);
+      }
+      if (typeof def.methodConfig.spec === "function") {
+        operationObjectRef = def.methodConfig.spec(operationObjectRef);
+      }
+      doc.paths ??= {};
+      doc.paths[httpPath] ??= {};
+      doc.paths[httpPath][method] = applyCustomOpenAPIOperation(operationObjectRef, contract);
+    } catch (e) {
+      if (!(e instanceof OpenAPIGeneratorError)) {
+        throw e;
+      }
+      errors.push(
+        `[OpenAPIGenerator] Error occurred while generating OpenAPI for method at path: ${path}
+${e.message}`
+      );
+    }
+  }
+  if (errors.length) {
+    throw new OpenAPIGeneratorError(
+      `Some error occurred during OpenAPI generation:
+
+${errors.join("\n\n")}`
+    );
+  }
+  return doc;
+}
+async function resolveCommonSchemas(doc, commonSchemas, converter) {
+  const baseSchemaConvertOptions = {};
+  if (commonSchemas) {
+    baseSchemaConvertOptions.components = [];
+    for (const key in commonSchemas) {
+      const options = commonSchemas[key];
+      if (options.schema === void 0) {
+        continue;
+      }
+      const { schema, strategy = "input" } = options;
+      const [required, json] = await converter(schema, { strategy });
+      const allowedStrategies = [strategy];
+      if (strategy === "input") {
+        const [outputRequired, outputJson] = await converter(schema, { strategy: "output" });
+        if (outputRequired === required && stringifyJSON(outputJson) === stringifyJSON(json)) {
+          allowedStrategies.push("output");
+        }
+      } else if (strategy === "output") {
+        const [inputRequired, inputJson] = await converter(schema, { strategy: "input" });
+        if (inputRequired === required && stringifyJSON(inputJson) === stringifyJSON(json)) {
+          allowedStrategies.push("input");
+        }
+      }
+      baseSchemaConvertOptions.components.push({
+        schema,
+        required,
+        ref: `#/components/schemas/${key}`,
+        allowedStrategies
+      });
+    }
+    doc.components ??= {};
+    doc.components.schemas ??= {};
+    for (const key in commonSchemas) {
+      const options = commonSchemas[key];
+      if (options.schema === void 0) {
+        continue;
+      }
+      const { schema, strategy = "input" } = options;
+      const [, json] = await converter(schema, {
+        ...baseSchemaConvertOptions,
+        strategy,
+        minStructureDepthForRef: 1
+        // not allow use $ref for root schemas
+      });
+      doc.components.schemas[key] = toOpenAPISchema(json);
+    }
+  }
+  return { baseSchemaConvertOptions };
+}
+async function handleRequest(doc, ref, def, baseSchemaConvertOptions, converter) {
+  const method = def.methodConfig.method;
+  const dynamicParams = getDynamicParams(def.methodConfig.path)?.map((v) => v.name);
+  const [_pathRequired, pathSchema] = await converter(def.schemas.pathSchema, {
+    ...baseSchemaConvertOptions,
+    strategy: "input",
+    minStructureDepthForRef: 1
+  });
+  if (dynamicParams?.length) {
+    const error = new OpenAPIGeneratorError(
+      // TODO: fix this error
+      'When input structure is "compact", and path has dynamic params, input schema must be an object with all dynamic params as required.'
+    );
+    if (!isObjectSchema(pathSchema)) {
+      throw error;
+    }
+    if (!checkParamsSchema(pathSchema, dynamicParams)) {
+      throw error;
+    }
+    ref.parameters ??= [];
+    ref.parameters.push(...toOpenAPIParameters(pathSchema, "path"));
+  } else {
+    const error = new OpenAPIGeneratorError("Path placeholders do not match the path schema");
+    if (!isObjectSchema(pathSchema)) {
+      throw error;
+    }
+    if (!checkParamsSchema(pathSchema, [])) {
+      throw error;
+    }
+  }
+  const [_queryRequired, querySchema] = await converter(def.schemas.querySchema, {
+    ...baseSchemaConvertOptions,
+    strategy: "input",
+    minStructureDepthForRef: 0
+  });
+  if (!isAnySchema(querySchema)) {
+    const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, querySchema);
+    if (!isObjectSchema(resolvedSchema)) {
+      throw new OpenAPIGeneratorError("Query param schema must satisfy: object | any | unknown");
+    }
+    ref.parameters ??= [];
+    ref.parameters.push(...toOpenAPIParameters(resolvedSchema, "query"));
+  }
+  const [_headersRequired, headersSchema] = await converter(def.schemas.headersSchema, {
+    ...baseSchemaConvertOptions,
+    strategy: "input",
+    minStructureDepthForRef: 0
+  });
+  if (!isAnySchema(headersSchema)) {
+    const resolvedSchema = resolveOpenAPIJsonSchemaRef(doc, headersSchema);
+    if (!isObjectSchema(resolvedSchema)) {
+      throw new OpenAPIGeneratorError("Header schema must satisfy: object | any | unknown");
+    }
+    ref.parameters ??= [];
+    ref.parameters.push(...toOpenAPIParameters(resolvedSchema, "header"));
+  }
+  if (method !== "GET") {
+    const details = getEventIteratorSchemaDetails(def.schemas.bodySchema);
+    if (details) {
+      ref.requestBody = {
+        required: true,
+        content: toOpenAPIEventIteratorContent(
+          await converter(details.yields, { ...baseSchemaConvertOptions, strategy: "input" }),
+          await converter(details.returns, { ...baseSchemaConvertOptions, strategy: "input" })
+        )
+      };
+    } else {
+      const [bodyRequired, bodySchema] = await converter(def.schemas.bodySchema, {
+        ...baseSchemaConvertOptions,
+        strategy: "input",
+        minStructureDepthForRef: 0
+      });
+      if (isAnySchema(bodySchema)) {
+        return;
+      }
+      ref.requestBody = {
+        required: bodyRequired,
+        content: toOpenAPIContent(bodySchema)
+      };
+    }
+  }
+}
+async function handleSuccessResponse(doc, ref, def, baseSchemaConvertOptions, converter) {
+  const responseSchema = def.schemas.responseSchema;
+  const status = fallbackContractConfig("defaultSuccessStatus", def.methodConfig.successStatus);
+  const description = fallbackContractConfig(
+    "defaultSuccessDescription",
+    def.methodConfig?.successDescription
+  );
+  const eventIteratorSchemaDetails = getEventIteratorSchemaDetails(responseSchema);
+  if (eventIteratorSchemaDetails) {
+    ref.responses ??= {};
+    ref.responses[status] = {
+      description,
+      content: toOpenAPIEventIteratorContent(
+        await converter(eventIteratorSchemaDetails.yields, {
+          ...baseSchemaConvertOptions,
+          strategy: "output"
+        }),
+        await converter(eventIteratorSchemaDetails.returns, {
+          ...baseSchemaConvertOptions,
+          strategy: "output"
+        })
+      )
+    };
+    return;
+  }
+  const [required, json] = await converter(responseSchema, {
+    ...baseSchemaConvertOptions,
+    strategy: "output",
+    minStructureDepthForRef: 0
+  });
+  ref.responses ??= {};
+  ref.responses[status] = {
+    description
+  };
+  ref.responses[status].content = toOpenAPIContent(applySchemaOptionality(required, json));
+}
+function getNamesByAuthConfig(contracts) {
+  const namesByAuthConfig = /* @__PURE__ */ new Map();
+  const authConfigNames = /* @__PURE__ */ new Set();
+  for (const contract of contracts) {
+    for (const authConfig of contract["~def"].authConfigs) {
+      if (authConfig.type === "none" || namesByAuthConfig.has(authConfig)) {
+        continue;
+      }
+      const oasNameBase = authConfig.oasName ?? `${authConfig.type}Auth`;
+      let oasName = oasNameBase;
+      for (let i = 2; authConfigNames.has(oasName); i++) {
+        oasName = `${oasNameBase}${i}`;
+      }
+      namesByAuthConfig.set(authConfig, oasName);
+      authConfigNames.add(oasName);
+    }
+  }
+  return namesByAuthConfig;
+}
+function authConfigToSecurityScheme(authConfig) {
+  switch (authConfig.type) {
+    case "basic":
+      return {
+        type: "http",
+        scheme: "basic",
+        description: authConfig.oasDescription
+      };
+    case "bearer":
+      return {
+        type: "http",
+        scheme: "bearer",
+        description: authConfig.oasDescription,
+        bearerFormat: authConfig.oasBearerFormat
+      };
+    case "header":
+      return {
+        type: "apiKey",
+        in: "header",
+        name: authConfig.name,
+        description: authConfig.oasDescription
+      };
+    case "query":
+      return {
+        type: "apiKey",
+        in: "query",
+        name: authConfig.name,
+        description: authConfig.oasDescription
+      };
+    case "cookie":
+      return {
+        type: "apiKey",
+        in: "cookie",
+        name: authConfig.name,
+        description: authConfig.oasDescription
+      };
+    default:
+      assertNever(authConfig, `Unsupported auth config type: ${authConfig.type}`);
+  }
+}
+async function generateErrorComponents(combinedErrorMap, doc, baseSchemaConvertOptions, converter) {
+  const refMap = /* @__PURE__ */ new Map();
+  const schemas = {};
+  for (const mapKey in combinedErrorMap) {
+    const errorClass = combinedErrorMap[mapKey];
+    if (!errorClass) {
+      continue;
+    }
+    const extraZod = z.object(errorClass.extraSchema).strict();
+    const [, extraSchema] = await converter(extraZod, {
+      ...baseSchemaConvertOptions,
+      strategy: "output"
+    });
+    if (!isObjectSchema(extraSchema)) {
+      throw new OpenAPIGeneratorError(
+        `Error response extra schema must be an object, but got: ${stringifyJSON(extraSchema)}`
+      );
+    }
+    const schema = {
+      type: "object",
+      properties: {
+        type: { const: errorClass.type },
+        message: { type: "string", default: errorClass.defaultMessage },
+        ...extraSchema.properties
+      },
+      required: ["type", "message", ...extraSchema.required ?? []]
+    };
+    schemas[mapKey] = toOpenAPISchema(schema);
+    const ref = `#/components/schemas/${mapKey}`;
+    refMap.set(mapKey, ref);
+  }
+  if (refMap.size > 0) {
+    if (doc.components?.schemas?.Error) {
+      throw new OpenAPIGeneratorError(
+        '"Error" is a reserved name for models, please choose a different name.'
+      );
+    }
+    schemas.Error = {
+      oneOf: [...refMap.values()].map((ref) => ({ $ref: ref }))
+    };
+  }
+  if (Object.keys(schemas).length > 0) {
+    doc.components ??= {};
+    doc.components.schemas ??= {};
+    for (const key in doc.components.schemas) {
+      if (Object.prototype.hasOwnProperty.call(schemas, key)) {
+        throw new OpenAPIGeneratorError(
+          `Model name "${key}" conflicts with an error class of the same name. Please rename one of them.`
+        );
+      }
+    }
+    Object.assign(doc.components.schemas, schemas);
+  }
+  return refMap;
+}
+function handleErrorResponse(ref, def, errorRefMap) {
+  const errorMap = def.errorMap;
+  const errorResponsesByStatus = {};
+  for (const mapKey in errorMap) {
+    const errorClass = errorMap[mapKey];
+    const errorRef = errorRefMap.get(mapKey);
+    if (!errorClass || !errorRef) {
+      continue;
+    }
+    errorResponsesByStatus[errorClass.status] ??= { status: errorClass.status, refs: [] };
+    errorResponsesByStatus[errorClass.status].refs.push({ $ref: errorRef });
+  }
+  ref.responses ??= {};
+  for (const statusString in errorResponsesByStatus) {
+    const errorResponse = errorResponsesByStatus[statusString];
+    ref.responses[statusString] = {
+      description: statusString,
+      content: toOpenAPIContent(
+        errorResponse.refs.length === 1 ? errorResponse.refs[0] : {
+          oneOf: errorResponse.refs
+        }
+      )
+    };
+  }
+}
+
+export { JSON_SCHEMA_OUTPUT_REGISTRY as A, JsonSchemaXNativeType as J, LOGIC_KEYWORDS as L, ZodToJsonSchemaConverter as Z, applyCustomOpenAPIOperation as a, generateOpenApiSpec as b, customOpenAPIOperation as c, getNamesByAuthConfig as d, toOpenAPIMethod as e, toOpenAPIContent as f, getCustomOpenAPIOperation as g, toOpenAPIEventIteratorContent as h, toOpenAPIParameters as i, checkParamsSchema as j, toOpenAPISchema as k, isFileSchema as l, isObjectSchema as m, isAnySchema as n, filterSchemaBranches as o, applySchemaOptionality as p, expandUnionSchema as q, resolveOpenAPIJsonSchemaRef as r, separateObjectSchema as s, toOpenAPIPath as t, expandArrayableSchema as u, isPrimitiveSchema as v, eventIterator as w, getEventIteratorSchemaDetails as x, JSON_SCHEMA_REGISTRY as y, JSON_SCHEMA_INPUT_REGISTRY as z };