@contractkit/openapi-to-ck 0.7.1

package/dist/chunk-REM25FDE.js

@@ -0,0 +1,1779 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/normalize.ts
+function normalize(doc, warnings) {
+  const version = detectVersion(doc);
+  if (version === "2.0") {
+    return normalizeSwagger2(doc, warnings);
+  }
+  if (version === "3.0") {
+    return normalizeOas30(doc, warnings);
+  }
+  return doc;
+}
+__name(normalize, "normalize");
+function detectVersion(doc) {
+  if (typeof doc.swagger === "string" && doc.swagger.startsWith("2")) return "2.0";
+  if (typeof doc.openapi === "string") {
+    if (doc.openapi.startsWith("3.0")) return "3.0";
+  }
+  return "3.1";
+}
+__name(detectVersion, "detectVersion");
+function normalizeSwagger2(doc, warnings) {
+  const info = doc.info ?? {
+    title: "Untitled",
+    version: "0.0.0"
+  };
+  const basePath = doc.basePath ?? "";
+  const schemes = doc.schemes ?? [
+    "https"
+  ];
+  const host = doc.host ?? "localhost";
+  const globalConsumes = doc.consumes ?? [
+    "application/json"
+  ];
+  const globalProduces = doc.produces ?? [
+    "application/json"
+  ];
+  const result = {
+    openapi: "3.1.0",
+    info: {
+      title: info.title ?? "Untitled",
+      version: info.version ?? "0.0.0",
+      description: info.description
+    },
+    servers: [
+      {
+        url: `${schemes[0]}://${host}${basePath}`
+      }
+    ],
+    paths: {},
+    components: {
+      schemas: {},
+      securitySchemes: {}
+    },
+    tags: doc.tags ?? []
+  };
+  const definitions = doc.definitions ?? {};
+  for (const [name, schema] of Object.entries(definitions)) {
+    result.components.schemas[name] = normalizeNullable30(schema);
+  }
+  const secDefs = doc.securityDefinitions ?? {};
+  for (const [name, scheme] of Object.entries(secDefs)) {
+    result.components.securitySchemes[name] = convertSecurityScheme2(scheme);
+  }
+  const paths = doc.paths ?? {};
+  for (const [path, pathItem] of Object.entries(paths)) {
+    result.paths[path] = normalizePathItem2(pathItem, globalConsumes, globalProduces, warnings);
+  }
+  if (doc.security) {
+    result.security = doc.security;
+  }
+  return result;
+}
+__name(normalizeSwagger2, "normalizeSwagger2");
+function normalizePathItem2(pathItem, globalConsumes, globalProduces, warnings) {
+  const methods = [
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+    "head",
+    "options"
+  ];
+  const normalized = {};
+  const pathParams = pathItem.parameters ?? [];
+  for (const method of methods) {
+    const op = pathItem[method];
+    if (!op) continue;
+    const opConsumes = op.consumes ?? globalConsumes;
+    const opProduces = op.produces ?? globalProduces;
+    const params = [
+      ...pathParams,
+      ...op.parameters ?? []
+    ];
+    const nonBodyParams = [];
+    let requestBody;
+    for (const param of params) {
+      if (param.in === "body") {
+        const contentType = opConsumes[0] ?? "application/json";
+        requestBody = {
+          description: param.description,
+          required: param.required ?? true,
+          content: {
+            [contentType]: {
+              schema: normalizeNullable30(param.schema ?? {})
+            }
+          }
+        };
+      } else if (param.in === "formData") {
+        warnings.info(`#/paths/${encodePathSegment(method)}`, "formData parameters converted to multipart/form-data requestBody");
+        if (!requestBody) {
+          requestBody = {
+            content: {
+              "multipart/form-data": {
+                schema: {
+                  type: "object",
+                  properties: {},
+                  required: []
+                }
+              }
+            }
+          };
+        }
+        const formSchema = requestBody.content["multipart/form-data"].schema;
+        const props = formSchema.properties;
+        props[param.name] = normalizeNullable30(param);
+        if (param.required) {
+          formSchema.required.push(param.name);
+        }
+      } else {
+        const normalizedParam = {
+          ...param
+        };
+        if (param.type) {
+          normalizedParam.schema = normalizeNullable30({
+            type: param.type,
+            format: param.format,
+            enum: param.enum,
+            items: param.items,
+            default: param.default,
+            minimum: param.minimum,
+            maximum: param.maximum,
+            minLength: param.minLength,
+            maxLength: param.maxLength,
+            pattern: param.pattern
+          });
+          delete normalizedParam.type;
+          delete normalizedParam.format;
+          delete normalizedParam.enum;
+          delete normalizedParam.items;
+        }
+        nonBodyParams.push(normalizedParam);
+      }
+    }
+    const responses = {};
+    const opResponses = op.responses ?? {};
+    for (const [code, resp] of Object.entries(opResponses)) {
+      const contentType = opProduces[0] ?? "application/json";
+      const headers = convertResponseHeaders2(resp.headers);
+      const responseEntry = {
+        description: resp.description ?? ""
+      };
+      if (resp.schema) {
+        responseEntry.content = {
+          [contentType]: {
+            schema: normalizeNullable30(resp.schema)
+          }
+        };
+      }
+      if (headers) {
+        responseEntry.headers = headers;
+      }
+      responses[code] = responseEntry;
+    }
+    normalized[method] = {
+      operationId: op.operationId,
+      summary: op.summary,
+      description: op.description,
+      tags: op.tags,
+      parameters: nonBodyParams.length > 0 ? nonBodyParams : void 0,
+      requestBody,
+      responses,
+      security: op.security,
+      deprecated: op.deprecated
+    };
+  }
+  return normalized;
+}
+__name(normalizePathItem2, "normalizePathItem2");
+function convertResponseHeaders2(headers) {
+  if (!headers) return void 0;
+  const out = {};
+  for (const [name, header] of Object.entries(headers)) {
+    if (!header || typeof header !== "object") continue;
+    const { description, type, format, items, ...rest } = header;
+    const schema = {
+      ...rest
+    };
+    if (type !== void 0) schema.type = type;
+    if (format !== void 0) schema.format = format;
+    if (items !== void 0) schema.items = items;
+    const normalized = {};
+    if (description !== void 0) normalized.description = description;
+    if (Object.keys(schema).length > 0) normalized.schema = normalizeNullable30(schema);
+    out[name] = normalized;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+__name(convertResponseHeaders2, "convertResponseHeaders2");
+function convertSecurityScheme2(scheme) {
+  const type = scheme.type;
+  if (type === "basic") {
+    return {
+      type: "http",
+      scheme: "basic"
+    };
+  }
+  if (type === "apiKey") {
+    return {
+      type: "apiKey",
+      name: scheme.name,
+      in: scheme.in
+    };
+  }
+  if (type === "oauth2") {
+    const flow = scheme.flow;
+    const flows = {};
+    if (flow === "implicit") {
+      flows.implicit = {
+        authorizationUrl: scheme.authorizationUrl,
+        scopes: scheme.scopes ?? {}
+      };
+    } else if (flow === "password") {
+      flows.password = {
+        tokenUrl: scheme.tokenUrl,
+        scopes: scheme.scopes ?? {}
+      };
+    } else if (flow === "application") {
+      flows.clientCredentials = {
+        tokenUrl: scheme.tokenUrl,
+        scopes: scheme.scopes ?? {}
+      };
+    } else if (flow === "accessCode") {
+      flows.authorizationCode = {
+        authorizationUrl: scheme.authorizationUrl,
+        tokenUrl: scheme.tokenUrl,
+        scopes: scheme.scopes ?? {}
+      };
+    }
+    return {
+      type: "oauth2",
+      flows
+    };
+  }
+  return scheme;
+}
+__name(convertSecurityScheme2, "convertSecurityScheme2");
+function normalizeOas30(doc, _warnings) {
+  if (doc.components?.schemas) {
+    for (const [name, schema] of Object.entries(doc.components.schemas)) {
+      doc.components.schemas[name] = normalizeNullable30(schema);
+    }
+  }
+  if (doc.paths) {
+    for (const pathItem of Object.values(doc.paths)) {
+      normalizePathItemSchemas(pathItem);
+    }
+  }
+  doc.openapi = "3.1.0";
+  return doc;
+}
+__name(normalizeOas30, "normalizeOas30");
+function normalizePathItemSchemas(pathItem) {
+  const methods = [
+    "get",
+    "post",
+    "put",
+    "patch",
+    "delete",
+    "head",
+    "options"
+  ];
+  for (const method of methods) {
+    const op = pathItem[method];
+    if (!op) continue;
+    const params = op.parameters ?? [];
+    for (const param of params) {
+      if (param.schema) {
+        param.schema = normalizeNullable30(param.schema);
+      }
+    }
+    const reqBody = op.requestBody;
+    if (reqBody?.content) {
+      for (const mediaType of Object.values(reqBody.content)) {
+        if (mediaType.schema) {
+          mediaType.schema = normalizeNullable30(mediaType.schema);
+        }
+      }
+    }
+    const responses = op.responses ?? {};
+    for (const resp of Object.values(responses)) {
+      if (resp.content) {
+        for (const mediaType of Object.values(resp.content)) {
+          if (mediaType.schema) {
+            mediaType.schema = normalizeNullable30(mediaType.schema);
+          }
+        }
+      }
+    }
+  }
+}
+__name(normalizePathItemSchemas, "normalizePathItemSchemas");
+function normalizeNullable30(schema) {
+  if (!schema || typeof schema !== "object") return schema;
+  const result = {
+    ...schema
+  };
+  if (result.nullable === true && typeof result.type === "string") {
+    result.type = [
+      result.type,
+      "null"
+    ];
+    delete result.nullable;
+  }
+  if (result.properties && typeof result.properties === "object") {
+    const props = result.properties;
+    for (const [key, val] of Object.entries(props)) {
+      props[key] = normalizeNullable30(val);
+    }
+  }
+  if (result.items && typeof result.items === "object" && !Array.isArray(result.items)) {
+    result.items = normalizeNullable30(result.items);
+  }
+  if (result.additionalProperties && typeof result.additionalProperties === "object") {
+    result.additionalProperties = normalizeNullable30(result.additionalProperties);
+  }
+  for (const combiner of [
+    "allOf",
+    "oneOf",
+    "anyOf"
+  ]) {
+    if (Array.isArray(result[combiner])) {
+      result[combiner] = result[combiner].map(normalizeNullable30);
+    }
+  }
+  return result;
+}
+__name(normalizeNullable30, "normalizeNullable30");
+function encodePathSegment(s) {
+  return s.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+__name(encodePathSegment, "encodePathSegment");
+
+// src/circular-refs.ts
+function detectCircularRefs(schemas) {
+  const circular = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  function visit(name) {
+    if (visited.has(name)) return;
+    if (visiting.has(name)) {
+      circular.add(name);
+      return;
+    }
+    visiting.add(name);
+    const schema = schemas[name];
+    if (schema && typeof schema === "object") {
+      for (const ref of collectRefs(schema)) {
+        const refName = extractRefName(ref);
+        if (refName && schemas[refName]) {
+          visit(refName);
+        }
+      }
+    }
+    visiting.delete(name);
+    visited.add(name);
+  }
+  __name(visit, "visit");
+  for (const name of Object.keys(schemas)) {
+    visit(name);
+  }
+  return circular;
+}
+__name(detectCircularRefs, "detectCircularRefs");
+function collectRefs(obj) {
+  const refs = [];
+  function walk(val) {
+    if (!val || typeof val !== "object") return;
+    if (Array.isArray(val)) {
+      for (const item of val) walk(item);
+      return;
+    }
+    const record = val;
+    if (typeof record.$ref === "string") {
+      refs.push(record.$ref);
+    }
+    for (const v of Object.values(record)) {
+      walk(v);
+    }
+  }
+  __name(walk, "walk");
+  walk(obj);
+  return refs;
+}
+__name(collectRefs, "collectRefs");
+function extractRefName(ref) {
+  const match = ref.match(/^#\/(?:components\/schemas|definitions)\/(.+)$/);
+  return match?.[1];
+}
+__name(extractRefName, "extractRefName");
+
+// src/schema-to-ast.ts
+var LOC = {
+  file: "",
+  line: 0
+};
+var FORMAT_TO_SCALAR = {
+  email: "email",
+  uri: "url",
+  url: "url",
+  uuid: "uuid",
+  date: "date",
+  "date-time": "datetime",
+  time: "time",
+  binary: "binary",
+  int64: "bigint"
+};
+function schemasToModels(schemas, ctx) {
+  const models = [];
+  for (const [name, schema] of Object.entries(schemas)) {
+    const modelCtx = {
+      ...ctx,
+      path: `#/components/schemas/${name}`
+    };
+    const model = schemaToModel(name, schema, modelCtx);
+    if (model) models.push(model);
+  }
+  models.push(...ctx.extractedModels);
+  return models;
+}
+__name(schemasToModels, "schemasToModels");
+function schemaToModel(name, schema, ctx) {
+  warnUnsupported(schema, ctx);
+  const description = ctx.includeComments ? schema.description : void 0;
+  if (schema.allOf && schema.allOf.length === 2) {
+    const [first, second] = schema.allOf;
+    const refMember = first?.$ref ? first : second?.$ref ? second : null;
+    const objectMember = first?.$ref ? second : first;
+    if (refMember?.$ref && objectMember?.properties) {
+      const baseName = extractRefName(refMember.$ref);
+      if (baseName) {
+        const fields = schemaPropertiesToFields(objectMember, ctx);
+        return {
+          kind: "model",
+          name,
+          bases: [
+            baseName
+          ],
+          fields,
+          description,
+          loc: LOC
+        };
+      }
+    }
+  }
+  if (schema.properties || schema.type === "object" && !schema.additionalProperties) {
+    const fields = schemaPropertiesToFields(schema, ctx);
+    return {
+      kind: "model",
+      name,
+      fields,
+      description,
+      loc: LOC
+    };
+  }
+  const typeNode = schemaToTypeNode(schema, ctx);
+  return {
+    kind: "model",
+    name,
+    fields: [],
+    type: typeNode,
+    description,
+    loc: LOC
+  };
+}
+__name(schemaToModel, "schemaToModel");
+function schemaToTypeNode(schema, ctx) {
+  if (schema.$ref) {
+    const refName = extractRefName(schema.$ref);
+    if (refName) {
+      if (ctx.circularRefs.has(refName)) {
+        return {
+          kind: "lazy",
+          inner: {
+            kind: "ref",
+            name: refName
+          }
+        };
+      }
+      return {
+        kind: "ref",
+        name: refName
+      };
+    }
+    ctx.warnings.warn(ctx.path, `Unresolvable $ref: ${schema.$ref}`);
+    return {
+      kind: "scalar",
+      name: "unknown"
+    };
+  }
+  if (schema.const !== void 0) {
+    return {
+      kind: "literal",
+      value: schema.const
+    };
+  }
+  if (schema.enum) {
+    return {
+      kind: "enum",
+      values: schema.enum.map(String)
+    };
+  }
+  if (schema.oneOf && schema.oneOf.length > 0) {
+    if (schema.discriminator?.propertyName) {
+      return toDiscriminatedUnion(schema.oneOf, schema.discriminator.propertyName, ctx);
+    }
+    return toUnion(schema.oneOf, ctx);
+  }
+  if (schema.anyOf && schema.anyOf.length > 0) {
+    if (schema.discriminator?.propertyName) {
+      return toDiscriminatedUnion(schema.anyOf, schema.discriminator.propertyName, ctx);
+    }
+    return toUnion(schema.anyOf, ctx);
+  }
+  if (schema.allOf && schema.allOf.length > 0) {
+    if (schema.allOf.length === 1) {
+      return schemaToTypeNode(schema.allOf[0], ctx);
+    }
+    return {
+      kind: "intersection",
+      members: schema.allOf.map((s) => schemaToTypeNode(s, ctx))
+    };
+  }
+  const types = normalizeTypeField(schema);
+  if (types === null) {
+    if (schema.properties) {
+      return schemaToInlineObject(schema, ctx);
+    }
+    return {
+      kind: "scalar",
+      name: "unknown"
+    };
+  }
+  const { baseType, nullable } = types;
+  let typeNode;
+  switch (baseType) {
+    case "string":
+      typeNode = stringSchemaToType(schema);
+      break;
+    case "integer":
+      typeNode = integerSchemaToType(schema);
+      break;
+    case "number":
+      typeNode = numberSchemaToType(schema);
+      break;
+    case "boolean":
+      typeNode = {
+        kind: "scalar",
+        name: "boolean"
+      };
+      break;
+    case "null":
+      typeNode = {
+        kind: "scalar",
+        name: "null"
+      };
+      break;
+    case "array":
+      typeNode = arraySchemaToType(schema, ctx);
+      break;
+    case "object":
+      typeNode = objectSchemaToType(schema, ctx);
+      break;
+    default:
+      ctx.warnings.warn(ctx.path, `Unknown type: ${baseType}`);
+      typeNode = {
+        kind: "scalar",
+        name: "unknown"
+      };
+  }
+  if (nullable) {
+    return {
+      kind: "union",
+      members: [
+        typeNode,
+        {
+          kind: "scalar",
+          name: "null"
+        }
+      ]
+    };
+  }
+  return typeNode;
+}
+__name(schemaToTypeNode, "schemaToTypeNode");
+function stringSchemaToType(schema) {
+  if (schema.format) {
+    const scalarName = FORMAT_TO_SCALAR[schema.format];
+    if (scalarName) {
+      return {
+        kind: "scalar",
+        name: scalarName
+      };
+    }
+  }
+  const mods = {};
+  if (schema.minLength !== void 0 && schema.maxLength !== void 0 && schema.minLength === schema.maxLength) {
+    mods.len = schema.minLength;
+  } else {
+    if (schema.minLength !== void 0) mods.min = schema.minLength;
+    if (schema.maxLength !== void 0) mods.max = schema.maxLength;
+  }
+  if (schema.pattern) mods.regex = `/${schema.pattern}/`;
+  if (schema.format && !FORMAT_TO_SCALAR[schema.format]) mods.format = schema.format;
+  return {
+    kind: "scalar",
+    name: "string",
+    ...mods
+  };
+}
+__name(stringSchemaToType, "stringSchemaToType");
+function integerSchemaToType(schema) {
+  const name = schema.format === "int64" ? "bigint" : "int";
+  const mods = {};
+  if (schema.minimum !== void 0) mods.min = schema.minimum;
+  if (schema.maximum !== void 0) mods.max = schema.maximum;
+  return {
+    kind: "scalar",
+    name,
+    ...mods
+  };
+}
+__name(integerSchemaToType, "integerSchemaToType");
+function numberSchemaToType(schema) {
+  const mods = {};
+  if (schema.minimum !== void 0) mods.min = schema.minimum;
+  if (schema.maximum !== void 0) mods.max = schema.maximum;
+  return {
+    kind: "scalar",
+    name: "number",
+    ...mods
+  };
+}
+__name(numberSchemaToType, "numberSchemaToType");
+function arraySchemaToType(schema, ctx) {
+  if (schema.prefixItems && schema.prefixItems.length > 0) {
+    return {
+      kind: "tuple",
+      items: schema.prefixItems.map((s) => schemaToTypeNode(s, ctx))
+    };
+  }
+  const item = schema.items ? schemaToTypeNode(schema.items, ctx) : {
+    kind: "scalar",
+    name: "unknown"
+  };
+  const mods = {};
+  if (schema.minItems !== void 0) mods.min = schema.minItems;
+  if (schema.maxItems !== void 0) mods.max = schema.maxItems;
+  return {
+    kind: "array",
+    item,
+    ...mods
+  };
+}
+__name(arraySchemaToType, "arraySchemaToType");
+function objectSchemaToType(schema, ctx) {
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object" && !schema.properties) {
+    return {
+      kind: "record",
+      key: {
+        kind: "scalar",
+        name: "string"
+      },
+      value: schemaToTypeNode(schema.additionalProperties, ctx)
+    };
+  }
+  if (schema.properties) {
+    return schemaToInlineObject(schema, ctx);
+  }
+  return {
+    kind: "scalar",
+    name: "object"
+  };
+}
+__name(objectSchemaToType, "objectSchemaToType");
+function schemaToInlineObject(schema, ctx) {
+  const fields = schemaPropertiesToFields(schema, ctx);
+  return {
+    kind: "inlineObject",
+    fields
+  };
+}
+__name(schemaToInlineObject, "schemaToInlineObject");
+function schemaPropertiesToFields(schema, ctx) {
+  const properties = schema.properties ?? {};
+  const required = new Set(schema.required ?? []);
+  const fields = [];
+  for (const [name, propSchema] of Object.entries(properties)) {
+    const propCtx = {
+      ...ctx,
+      path: `${ctx.path}/properties/${name}`
+    };
+    const fieldType = schemaToTypeNode(propSchema, propCtx);
+    let nullable = false;
+    let effectiveType = fieldType;
+    if (fieldType.kind === "union") {
+      const nonNull = fieldType.members.filter((m) => !(m.kind === "scalar" && m.name === "null"));
+      if (nonNull.length < fieldType.members.length) {
+        nullable = true;
+        effectiveType = nonNull.length === 1 ? nonNull[0] : {
+          kind: "union",
+          members: nonNull
+        };
+      }
+    }
+    const visibility = propSchema.readOnly ? "readonly" : propSchema.writeOnly ? "writeonly" : "normal";
+    fields.push({
+      name,
+      optional: !required.has(name),
+      nullable,
+      visibility,
+      type: effectiveType,
+      default: propSchema.default,
+      deprecated: propSchema.deprecated,
+      description: ctx.includeComments ? propSchema.description : void 0,
+      loc: LOC
+    });
+  }
+  return fields;
+}
+__name(schemaPropertiesToFields, "schemaPropertiesToFields");
+function normalizeTypeField(schema) {
+  if (!schema.type) return null;
+  if (typeof schema.type === "string") {
+    return {
+      baseType: schema.type,
+      nullable: false
+    };
+  }
+  if (Array.isArray(schema.type)) {
+    const types = schema.type;
+    const nonNull = types.filter((t) => t !== "null");
+    const nullable = types.includes("null");
+    if (nonNull.length === 1) {
+      return {
+        baseType: nonNull[0],
+        nullable
+      };
+    }
+    if (nonNull.length === 0) {
+      return {
+        baseType: "null",
+        nullable: false
+      };
+    }
+    return {
+      baseType: nonNull[0],
+      nullable
+    };
+  }
+  return null;
+}
+__name(normalizeTypeField, "normalizeTypeField");
+function toUnion(schemas, ctx) {
+  const members = schemas.map((s) => schemaToTypeNode(s, ctx));
+  if (members.length === 1) return members[0];
+  return {
+    kind: "union",
+    members
+  };
+}
+__name(toUnion, "toUnion");
+function toDiscriminatedUnion(schemas, discriminator, ctx) {
+  const members = schemas.map((s) => schemaToTypeNode(s, ctx));
+  if (members.length === 1) return members[0];
+  return {
+    kind: "discriminatedUnion",
+    discriminator,
+    members
+  };
+}
+__name(toDiscriminatedUnion, "toDiscriminatedUnion");
+function warnUnsupported(schema, ctx) {
+  if (schema.xml) ctx.warnings.warn(ctx.path, "xml metadata is not supported, skipping");
+  if (schema.externalDocs) ctx.warnings.info(ctx.path, "externalDocs is not supported, skipping");
+  if (schema.not) ctx.warnings.warn(ctx.path, "not keyword is not supported, skipping");
+}
+__name(warnUnsupported, "warnUnsupported");
+function extractInlineModel(schema, suggestedName, ctx) {
+  if (schema.$ref) {
+    return {
+      typeNode: schemaToTypeNode(schema, ctx)
+    };
+  }
+  if (schema.properties || schema.type === "object" && schema.additionalProperties === void 0) {
+    const fields = schemaPropertiesToFields(schema, ctx);
+    const model = {
+      kind: "model",
+      name: suggestedName,
+      fields,
+      description: ctx.includeComments ? schema.description : void 0,
+      loc: LOC
+    };
+    return {
+      typeNode: {
+        kind: "ref",
+        name: suggestedName
+      },
+      model
+    };
+  }
+  return {
+    typeNode: schemaToTypeNode(schema, ctx)
+  };
+}
+__name(extractInlineModel, "extractInlineModel");
+function sanitizeName(name, warnings) {
+  const cleaned = name.replace(/[^a-zA-Z0-9_$]/g, " ").split(/\s+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  if (cleaned !== name) {
+    warnings.info(`#/components/schemas/${name}`, `Schema name sanitized: "${name}" \u2192 "${cleaned}"`);
+  }
+  return cleaned || "UnnamedSchema";
+}
+__name(sanitizeName, "sanitizeName");
+
+// src/paths-to-ast.ts
+var LOC2 = {
+  file: "",
+  line: 0
+};
+var HTTP_METHODS = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete"
+];
+function pathsToRoutes(doc, ctx) {
+  const routes = [];
+  const routeTags = /* @__PURE__ */ new Map();
+  const paths = doc.paths ?? {};
+  for (const [path, pathItem] of Object.entries(paths)) {
+    if (!pathItem) continue;
+    const result = pathItemToRoute(path, pathItem, ctx);
+    if (result) {
+      routes.push(result.route);
+      routeTags.set(result.route, result.tag);
+    }
+  }
+  return {
+    routes,
+    routeTags
+  };
+}
+__name(pathsToRoutes, "pathsToRoutes");
+function pathItemToRoute(path, pathItem, ctx) {
+  const operations = [];
+  let primaryTag = "default";
+  const pathParams = (pathItem.parameters ?? []).filter((p) => p.in === "path");
+  for (const method of HTTP_METHODS) {
+    const op = pathItem[method];
+    if (!op) continue;
+    const opNode = operationToNode(method, op, path, ctx);
+    operations.push(opNode);
+    if (op.tags && op.tags.length > 0 && primaryTag === "default") {
+      primaryTag = op.tags[0];
+    }
+  }
+  if (operations.length === 0) return null;
+  const params = buildPathParams(path, pathParams, pathItem, ctx);
+  const route = {
+    path,
+    operations,
+    loc: LOC2
+  };
+  if (params.length > 0) {
+    route.params = {
+      kind: "params",
+      nodes: params
+    };
+  }
+  if (pathItem.description && ctx.includeComments) {
+    route.description = pathItem.description;
+  }
+  return {
+    route,
+    tag: primaryTag
+  };
+}
+__name(pathItemToRoute, "pathItemToRoute");
+function operationToNode(method, op, path, ctx) {
+  const pathPrefix = `#/paths/${encodePathSegment2(path)}/${method}`;
+  const schemaCtx = makeSchemaCtx(ctx, pathPrefix);
+  const node = {
+    method,
+    responses: [],
+    loc: LOC2
+  };
+  if (op.operationId) {
+    node.sdk = op.operationId;
+  }
+  if (op.description && ctx.includeComments) {
+    node.description = op.description;
+  }
+  if (op.deprecated) {
+    node.modifiers = [
+      "deprecated"
+    ];
+  }
+  const queryParams = [];
+  const headerParams = [];
+  for (const param of op.parameters ?? []) {
+    if (param.in === "query") {
+      queryParams.push(parameterToNode(param, schemaCtx));
+    } else if (param.in === "header") {
+      headerParams.push(parameterToNode(param, schemaCtx));
+    }
+  }
+  if (queryParams.length > 0) {
+    node.query = {
+      kind: "params",
+      nodes: queryParams
+    };
+  }
+  if (headerParams.length > 0) {
+    node.headers = {
+      kind: "params",
+      nodes: headerParams
+    };
+  }
+  if (op.requestBody) {
+    node.request = requestBodyToNode(op.requestBody, op.operationId ?? `${method}${toPascalCase(path)}`, schemaCtx, ctx);
+  }
+  const responses = op.responses ?? {};
+  for (const [code, resp] of Object.entries(responses)) {
+    const statusCode = parseInt(code, 10);
+    if (isNaN(statusCode)) continue;
+    const respNode = responseToNode(statusCode, resp, op.operationId ?? `${method}${toPascalCase(path)}`, schemaCtx, ctx);
+    node.responses.push(respNode);
+  }
+  if (op.security !== void 0) {
+    node.security = convertSecurity(op.security);
+  }
+  return node;
+}
+__name(operationToNode, "operationToNode");
+function buildPathParams(path, pathLevelParams, pathItem, ctx) {
+  const schemaCtx = makeSchemaCtx(ctx, `#/paths/${encodePathSegment2(path)}`);
+  const paramMap = /* @__PURE__ */ new Map();
+  for (const p of pathLevelParams) {
+    paramMap.set(p.name, p);
+  }
+  for (const method of HTTP_METHODS) {
+    const op = pathItem[method];
+    if (!op?.parameters) continue;
+    for (const p of op.parameters) {
+      if (p.in === "path" && !paramMap.has(p.name)) {
+        paramMap.set(p.name, p);
+      }
+    }
+  }
+  const templateNames = [
+    ...path.matchAll(/\{([^}]+)\}/g)
+  ].map((m) => m[1]);
+  return templateNames.map((name) => {
+    const param = paramMap.get(name);
+    if (param) {
+      return parameterToNode(param, schemaCtx);
+    }
+    return {
+      name,
+      optional: false,
+      nullable: false,
+      type: {
+        kind: "scalar",
+        name: "string"
+      },
+      loc: LOC2
+    };
+  });
+}
+__name(buildPathParams, "buildPathParams");
+function parameterToNode(param, ctx) {
+  const type = param.schema ? schemaToTypeNode(param.schema, ctx) : {
+    kind: "scalar",
+    name: "string"
+  };
+  return {
+    name: param.name,
+    optional: param.in !== "path" && !param.required,
+    nullable: false,
+    type,
+    description: ctx.includeComments ? param.description : void 0,
+    loc: LOC2
+  };
+}
+__name(parameterToNode, "parameterToNode");
+function requestBodyToNode(reqBody, operationName, schemaCtx, ctx) {
+  const content = reqBody.content;
+  if (!content) return void 0;
+  const supported = /* @__PURE__ */ new Set([
+    "application/json",
+    "application/x-www-form-urlencoded",
+    "multipart/form-data"
+  ]);
+  const bodies = [];
+  for (const [contentType, mediaType] of Object.entries(content)) {
+    if (!supported.has(contentType) || !mediaType?.schema) continue;
+    const { typeNode, model } = extractInlineModel(mediaType.schema, `${toPascalCase(operationName)}Request`, schemaCtx);
+    if (model) {
+      ctx.extractedModels.push(model);
+    }
+    bodies.push({
+      contentType,
+      bodyType: typeNode
+    });
+  }
+  if (bodies.length === 0) return void 0;
+  return {
+    bodies
+  };
+}
+__name(requestBodyToNode, "requestBodyToNode");
+function responseToNode(statusCode, resp, operationName, schemaCtx, ctx) {
+  const headers = convertResponseHeaders(resp.headers, schemaCtx);
+  if (!resp.content) {
+    return headers ? {
+      statusCode,
+      headers
+    } : {
+      statusCode
+    };
+  }
+  const [contentType, mediaType] = Object.entries(resp.content)[0] ?? [];
+  if (!contentType || !mediaType?.schema) {
+    return headers ? {
+      statusCode,
+      headers
+    } : {
+      statusCode
+    };
+  }
+  const { typeNode, model } = extractInlineModel(mediaType.schema, `${toPascalCase(operationName)}Response${statusCode}`, schemaCtx);
+  if (model) {
+    ctx.extractedModels.push(model);
+  }
+  return {
+    statusCode,
+    contentType,
+    bodyType: typeNode,
+    ...headers ? {
+      headers
+    } : {}
+  };
+}
+__name(responseToNode, "responseToNode");
+function convertResponseHeaders(headers, schemaCtx) {
+  if (!headers) return void 0;
+  const out = [];
+  for (const [name, header] of Object.entries(headers)) {
+    if (!header) continue;
+    const type = header.schema ? schemaToTypeNode(header.schema, schemaCtx) : {
+      kind: "scalar",
+      name: "string"
+    };
+    out.push({
+      name,
+      optional: !header.required,
+      type,
+      description: schemaCtx.includeComments ? header.description : void 0
+    });
+  }
+  return out.length > 0 ? out : void 0;
+}
+__name(convertResponseHeaders, "convertResponseHeaders");
+function convertSecurity(security) {
+  if (security.length === 0) {
+    return "none";
+  }
+  const allScopes = [];
+  for (const requirement of security) {
+    for (const scopes of Object.values(requirement)) {
+      allScopes.push(...scopes);
+    }
+  }
+  if (allScopes.length > 0) {
+    return {
+      roles: allScopes,
+      loc: LOC2
+    };
+  }
+  return {
+    roles: [],
+    loc: LOC2
+  };
+}
+__name(convertSecurity, "convertSecurity");
+function makeSchemaCtx(ctx, path) {
+  return {
+    circularRefs: ctx.circularRefs,
+    warnings: ctx.warnings,
+    path,
+    includeComments: ctx.includeComments,
+    namedSchemas: ctx.namedSchemas,
+    extractedModels: ctx.extractedModels,
+    inlineCounter: 0
+  };
+}
+__name(makeSchemaCtx, "makeSchemaCtx");
+function toPascalCase(input) {
+  return input.replace(/[^a-zA-Z0-9]/g, " ").split(/\s+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+__name(toPascalCase, "toPascalCase");
+function encodePathSegment2(s) {
+  return s.replace(/~/g, "~0").replace(/\//g, "~1");
+}
+__name(encodePathSegment2, "encodePathSegment");
+
+// src/tag-splitter.ts
+function splitByTag(models, routes, routeTags) {
+  const routesByTag = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const tag = routeTags.get(route) ?? "default";
+    const group = routesByTag.get(tag) ?? [];
+    group.push(route);
+    routesByTag.set(tag, group);
+  }
+  const modelsByTag = /* @__PURE__ */ new Map();
+  for (const [tag, tagRoutes] of routesByTag) {
+    const refs = /* @__PURE__ */ new Set();
+    for (const route of tagRoutes) {
+      collectRouteRefs(route, refs);
+    }
+    modelsByTag.set(tag, refs);
+  }
+  const modelNameToModel = new Map(models.map((m) => [
+    m.name,
+    m
+  ]));
+  const modelAssignment = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    const tags = [];
+    for (const [tag, refs] of modelsByTag) {
+      if (refs.has(model.name)) {
+        tags.push(tag);
+      }
+    }
+    if (tags.length === 0) {
+      modelAssignment.set(model.name, "shared");
+    } else if (tags.length === 1) {
+      modelAssignment.set(model.name, tags[0]);
+    } else {
+      modelAssignment.set(model.name, "shared");
+    }
+  }
+  for (const model of models) {
+    if (modelAssignment.get(model.name) === "shared") {
+      const refs = /* @__PURE__ */ new Set();
+      collectModelRefs(model, refs);
+      for (const ref of refs) {
+        if (modelNameToModel.has(ref)) {
+          const currentTag = modelAssignment.get(ref);
+          if (currentTag && currentTag !== "shared") {
+            const otherTags = [
+              ...modelsByTag.entries()
+            ].filter(([t, r]) => t !== currentTag && r.has(ref)).map(([t]) => t);
+            if (otherTags.length > 0) {
+              modelAssignment.set(ref, "shared");
+            }
+          }
+        }
+      }
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  const allTags = /* @__PURE__ */ new Set([
+    ...routesByTag.keys(),
+    ...new Set(modelAssignment.values())
+  ]);
+  for (const tag of allTags) {
+    const tagModels = models.filter((m) => modelAssignment.get(m.name) === tag);
+    const tagRoutes = routesByTag.get(tag) ?? [];
+    if (tagModels.length === 0 && tagRoutes.length === 0) continue;
+    const filename = sanitizeFilename(tag);
+    result.set(`${filename}.ck`, {
+      kind: "ckRoot",
+      meta: tag !== "shared" ? {
+        area: tag
+      } : {},
+      services: {},
+      models: tagModels,
+      routes: tagRoutes,
+      file: `${filename}.ck`
+    });
+  }
+  return result;
+}
+__name(splitByTag, "splitByTag");
+function mergeIntoSingle(models, routes, filename = "api") {
+  return {
+    kind: "ckRoot",
+    meta: {},
+    services: {},
+    models,
+    routes,
+    file: `${filename}.ck`
+  };
+}
+__name(mergeIntoSingle, "mergeIntoSingle");
+function collectRouteRefs(route, refs) {
+  if (route.params) {
+    collectParamSourceRefs(route.params, refs);
+  }
+  for (const op of route.operations) {
+    if (op.query) collectParamSourceRefs(op.query, refs);
+    if (op.headers) collectParamSourceRefs(op.headers, refs);
+    if (op.request) {
+      for (const body of op.request.bodies) collectTypeRefs(body.bodyType, refs);
+    }
+    for (const resp of op.responses) {
+      if (resp.bodyType) collectTypeRefs(resp.bodyType, refs);
+    }
+  }
+}
+__name(collectRouteRefs, "collectRouteRefs");
+function collectParamSourceRefs(source, refs) {
+  if (typeof source === "string") {
+    refs.add(source);
+    return;
+  }
+  if (Array.isArray(source)) {
+    for (const param of source) {
+      if (param && typeof param === "object" && "type" in param) {
+        collectTypeRefs(param.type, refs);
+      }
+    }
+    return;
+  }
+  if (source && typeof source === "object" && "kind" in source) {
+    collectTypeRefs(source, refs);
+  }
+}
+__name(collectParamSourceRefs, "collectParamSourceRefs");
+function collectTypeRefs(type, refs) {
+  switch (type.kind) {
+    case "ref":
+      refs.add(type.name);
+      break;
+    case "array":
+      collectTypeRefs(type.item, refs);
+      break;
+    case "tuple":
+      for (const item of type.items) collectTypeRefs(item, refs);
+      break;
+    case "record":
+      collectTypeRefs(type.key, refs);
+      collectTypeRefs(type.value, refs);
+      break;
+    case "union":
+    case "discriminatedUnion":
+    case "intersection":
+      for (const member of type.members) collectTypeRefs(member, refs);
+      break;
+    case "inlineObject":
+      for (const field of type.fields) collectTypeRefs(field.type, refs);
+      break;
+    case "lazy":
+      collectTypeRefs(type.inner, refs);
+      break;
+  }
+}
+__name(collectTypeRefs, "collectTypeRefs");
+function collectModelRefs(model, refs) {
+  if (model.bases) for (const b of model.bases) refs.add(b);
+  if (model.type) collectTypeRefs(model.type, refs);
+  for (const field of model.fields) {
+    collectTypeRefs(field.type, refs);
+  }
+}
+__name(collectModelRefs, "collectModelRefs");
+function sanitizeFilename(tag) {
+  return tag.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "") || "default";
+}
+__name(sanitizeFilename, "sanitizeFilename");
+
+// src/ast-to-ck.ts
+var INDENT = "    ";
+function astToCk(root, options = {}) {
+  const { includeComments = true } = options;
+  const ctx = {
+    includeComments
+  };
+  const parts = [];
+  const optionsBlock = serializeOptions(root);
+  if (optionsBlock) parts.push(optionsBlock);
+  for (const model of root.models) {
+    parts.push(serializeModel(model, ctx));
+  }
+  for (const route of root.routes) {
+    parts.push(serializeRoute(route, ctx));
+  }
+  return parts.join("\n\n") + "\n";
+}
+__name(astToCk, "astToCk");
+function serializeOptions(root) {
+  const hasKeys = Object.keys(root.meta).length > 0;
+  const hasServices = root.services && Object.keys(root.services).length > 0;
+  const hasSecurity = root.security !== void 0;
+  if (!hasKeys && !hasServices && !hasSecurity) return null;
+  const lines = [
+    "options {"
+  ];
+  if (hasKeys) {
+    lines.push(`${INDENT}keys: {`);
+    for (const [key, value] of Object.entries(root.meta)) {
+      lines.push(`${INDENT}${INDENT}${key}: ${value}`);
+    }
+    lines.push(`${INDENT}}`);
+  }
+  if (hasServices) {
+    lines.push(`${INDENT}services: {`);
+    for (const [name, path] of Object.entries(root.services)) {
+      lines.push(`${INDENT}${INDENT}${name}: "${path}"`);
+    }
+    lines.push(`${INDENT}}`);
+  }
+  if (hasSecurity) {
+    lines.push(`${INDENT}security: {`);
+    if (root.security === "none") {
+      lines.push(`${INDENT}${INDENT}none`);
+    } else {
+      const sec = root.security;
+      if (sec.roles && sec.roles.length > 0) {
+        lines.push(`${INDENT}${INDENT}roles: [${sec.roles.join(", ")}]`);
+      }
+    }
+    lines.push(`${INDENT}}`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+__name(serializeOptions, "serializeOptions");
+function serializeModel(model, ctx) {
+  const parts = [];
+  const prefixes = [];
+  if (model.inputCase && model.inputCase !== "camel") {
+    prefixes.push(`format(input=${model.inputCase})`);
+  }
+  if (model.mode && model.mode !== "strict") {
+    prefixes.push(`mode(${model.mode})`);
+  }
+  if (model.deprecated) {
+    prefixes.push("deprecated");
+  }
+  const prefix = prefixes.length > 0 ? prefixes.join(" ") + " " : "";
+  const comment = ctx.includeComments && model.description ? ` # ${model.description}` : "";
+  if (model.type) {
+    parts.push(`contract ${prefix}${model.name}: ${serializeType(model.type)}${comment}`);
+    return parts.join("");
+  }
+  if (model.bases && model.bases.length > 0) {
+    parts.push(`contract ${prefix}${model.name}: ${model.bases.join(" & ")} & {${comment}`);
+  } else {
+    parts.push(`contract ${prefix}${model.name}: {${comment}`);
+  }
+  for (const field of model.fields) {
+    parts.push(serializeField(field, 1, ctx));
+  }
+  parts.push("}");
+  return parts.join("\n");
+}
+__name(serializeModel, "serializeModel");
+function serializeField(field, depth, ctx) {
+  const indent = INDENT.repeat(depth);
+  const optional = field.optional ? "?" : "";
+  const visibility = field.visibility !== "normal" ? `${field.visibility} ` : "";
+  const deprecated = field.deprecated ? "deprecated " : "";
+  let typeStr = serializeType(field.type);
+  if (field.nullable && !typeContainsNull(field.type)) {
+    typeStr = `${typeStr} | null`;
+  }
+  const defaultVal = field.default !== void 0 ? ` = ${serializeDefault(field.default)}` : "";
+  const comment = ctx.includeComments && field.description ? ` # ${field.description}` : "";
+  return `${indent}${field.name}${optional}: ${deprecated}${visibility}${typeStr}${defaultVal}${comment}`;
+}
+__name(serializeField, "serializeField");
+function typeContainsNull(type) {
+  if (type.kind === "scalar" && type.name === "null") return true;
+  if (type.kind === "union") return type.members.some(typeContainsNull);
+  return false;
+}
+__name(typeContainsNull, "typeContainsNull");
+function serializeDefault(value) {
+  if (typeof value === "string") {
+    if (/^[a-zA-Z_$][a-zA-Z0-9_$\-.]*$/.test(value)) return value;
+    return `"${value}"`;
+  }
+  return String(value);
+}
+__name(serializeDefault, "serializeDefault");
+function serializeType(type) {
+  switch (type.kind) {
+    case "scalar":
+      return serializeScalar(type);
+    case "array":
+      return serializeArray(type);
+    case "tuple":
+      return `tuple(${type.items.map(serializeType).join(", ")})`;
+    case "record":
+      return `record(${serializeType(type.key)}, ${serializeType(type.value)})`;
+    case "enum":
+      return `enum(${type.values.join(", ")})`;
+    case "literal":
+      return serializeLiteral(type);
+    case "union":
+      return type.members.map(serializeType).join(" | ");
+    case "discriminatedUnion":
+      return `discriminated(by=${type.discriminator}, ${type.members.map(serializeType).join(" | ")})`;
+    case "intersection":
+      return type.members.map(serializeType).join(" & ");
+    case "ref":
+      return type.name;
+    case "inlineObject":
+      return serializeInlineObject(type);
+    case "lazy":
+      return `lazy(${serializeType(type.inner)})`;
+  }
+}
+__name(serializeType, "serializeType");
+function serializeScalar(type) {
+  const args = [];
+  if (type.len !== void 0) args.push(`length=${type.len}`);
+  if (type.min !== void 0) args.push(typeof type.min === "string" ? `min="${type.min}"` : `min=${type.min}`);
+  if (type.max !== void 0) args.push(typeof type.max === "string" ? `max="${type.max}"` : `max=${type.max}`);
+  if (type.regex !== void 0) args.push(`regex=${type.regex}`);
+  if (type.format !== void 0) args.push(`format=${type.format}`);
+  if (args.length === 0) return type.name;
+  return `${type.name}(${args.join(", ")})`;
+}
+__name(serializeScalar, "serializeScalar");
+function serializeArray(type) {
+  const args = [
+    serializeType(type.item)
+  ];
+  if (type.min !== void 0) args.push(`min=${type.min}`);
+  if (type.max !== void 0) args.push(`max=${type.max}`);
+  return `array(${args.join(", ")})`;
+}
+__name(serializeArray, "serializeArray");
+function serializeLiteral(type) {
+  if (typeof type.value === "string") return `literal("${type.value}")`;
+  return `literal(${type.value})`;
+}
+__name(serializeLiteral, "serializeLiteral");
+function serializeInlineObject(type) {
+  const modePrefix = type.mode ? `mode(${type.mode}) ` : "";
+  if (type.fields.length === 0) return `${modePrefix}{}`;
+  const lines = [
+    `${modePrefix}{`
+  ];
+  for (const field of type.fields) {
+    lines.push(serializeField(field, 2, {
+      includeComments: true
+    }));
+  }
+  lines.push(`${INDENT}}`);
+  return lines.join("\n");
+}
+__name(serializeInlineObject, "serializeInlineObject");
+function serializeRoute(route, ctx) {
+  const lines = [];
+  const modStr = serializeModifiers(route.modifiers);
+  const comment = ctx.includeComments && route.description ? ` # ${route.description}` : "";
+  lines.push(`operation${modStr} ${route.path}: {${comment}`);
+  if (route.params) {
+    serializeParamSource(lines, "params", route.params, route.paramsMode, 1, ctx);
+  }
+  if (route.security !== void 0) {
+    serializeSecurityBlock(lines, route.security, 1, ctx);
+  }
+  for (const op of route.operations) {
+    serializeOperation(lines, op, 1, ctx);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+__name(serializeRoute, "serializeRoute");
+function serializeOperation(lines, op, depth, ctx) {
+  const indent = INDENT.repeat(depth);
+  const modStr = serializeModifiers(op.modifiers);
+  const comment = ctx.includeComments && op.description ? ` # ${op.description}` : "";
+  lines.push(`${indent}${op.method}${modStr}: {${comment}`);
+  const inner = INDENT.repeat(depth + 1);
+  if (op.service) {
+    lines.push(`${inner}service: ${op.service}`);
+  }
+  if (op.sdk) {
+    lines.push(`${inner}sdk: ${op.sdk}`);
+  }
+  if (op.signature) {
+    const sigComment = ctx.includeComments && op.signatureDescription ? ` # ${op.signatureDescription}` : "";
+    lines.push(`${inner}signature: ${op.signature}${sigComment}`);
+  }
+  if (op.security !== void 0) {
+    serializeSecurityBlock(lines, op.security, depth + 1, ctx);
+  }
+  if (op.query) {
+    serializeParamSource(lines, "query", op.query, op.queryMode, depth + 1, ctx);
+  }
+  if (op.headers) {
+    serializeParamSource(lines, "headers", op.headers, op.headersMode, depth + 1, ctx);
+  }
+  if (op.request) {
+    serializeRequest(lines, op.request, depth + 1);
+  }
+  if (op.responses.length > 0) {
+    serializeResponses(lines, op.responses, depth + 1);
+  }
+  lines.push(`${indent}}`);
+  return lines;
+}
+__name(serializeOperation, "serializeOperation");
+function serializeModifiers(modifiers) {
+  if (!modifiers || modifiers.length === 0) return "";
+  return `(${modifiers.join(", ")})`;
+}
+__name(serializeModifiers, "serializeModifiers");
+function serializeParamSource(lines, keyword, source, mode, depth, ctx) {
+  const indent = INDENT.repeat(depth);
+  if (source.kind === "ref") {
+    lines.push(`${indent}${keyword}: ${source.name}`);
+    return;
+  }
+  if (source.kind === "type") {
+    lines.push(`${indent}${keyword}: ${serializeType(source.node)}`);
+    return;
+  }
+  const modeStr = mode ? `mode(${mode}) ` : "";
+  lines.push(`${indent}${keyword}: ${modeStr}{`);
+  for (const param of source.nodes) {
+    const optional = param.optional ? "?" : "";
+    let typeStr = serializeType(param.type);
+    if (param.nullable && !typeContainsNull(param.type)) {
+      typeStr = `${typeStr} | null`;
+    }
+    const defaultVal = param.default !== void 0 ? ` = ${serializeDefault(param.default)}` : "";
+    const comment = ctx.includeComments && param.description ? ` # ${param.description}` : "";
+    lines.push(`${INDENT.repeat(depth + 1)}${param.name}${optional}: ${typeStr}${defaultVal}${comment}`);
+  }
+  lines.push(`${indent}}`);
+}
+__name(serializeParamSource, "serializeParamSource");
+function serializeRequest(lines, request, depth) {
+  const indent = INDENT.repeat(depth);
+  lines.push(`${indent}request: {`);
+  for (const body of request.bodies) {
+    lines.push(`${INDENT.repeat(depth + 1)}${body.contentType}: ${serializeType(body.bodyType)}`);
+  }
+  lines.push(`${indent}}`);
+}
+__name(serializeRequest, "serializeRequest");
+function serializeResponses(lines, responses, depth) {
+  const indent = INDENT.repeat(depth);
+  lines.push(`${indent}response: {`);
+  for (const resp of responses) {
+    const hasBody = resp.bodyType && resp.contentType;
+    const hasHeaders = resp.headers && resp.headers.length > 0;
+    if (hasBody || hasHeaders) {
+      lines.push(`${INDENT.repeat(depth + 1)}${resp.statusCode}: {`);
+      if (hasBody) {
+        lines.push(`${INDENT.repeat(depth + 2)}${resp.contentType}: ${serializeType(resp.bodyType)}`);
+      }
+      if (hasHeaders) {
+        lines.push(`${INDENT.repeat(depth + 2)}headers: {`);
+        for (const h of resp.headers) {
+          const opt = h.optional ? "?" : "";
+          const trail = h.description ? ` # ${h.description}` : "";
+          lines.push(`${INDENT.repeat(depth + 3)}${h.name}${opt}: ${serializeType(h.type)}${trail}`);
+        }
+        lines.push(`${INDENT.repeat(depth + 2)}}`);
+      }
+      lines.push(`${INDENT.repeat(depth + 1)}}`);
+    } else {
+      lines.push(`${INDENT.repeat(depth + 1)}${resp.statusCode}:`);
+    }
+  }
+  lines.push(`${indent}}`);
+}
+__name(serializeResponses, "serializeResponses");
+function serializeSecurityBlock(lines, security, depth, ctx) {
+  const indent = INDENT.repeat(depth);
+  if (security === "none") {
+    lines.push(`${indent}security: none`);
+    return;
+  }
+  const sec = security;
+  if (sec.roles && sec.roles.length > 0) {
+    const rolesComment = ctx.includeComments && sec.rolesDescription ? ` # ${sec.rolesDescription}` : "";
+    lines.push(`${indent}security: {`);
+    lines.push(`${INDENT.repeat(depth + 1)}roles: [${sec.roles.join(", ")}]${rolesComment}`);
+    lines.push(`${indent}}`);
+  } else {
+    lines.push(`${indent}security: {}`);
+  }
+}
+__name(serializeSecurityBlock, "serializeSecurityBlock");
+
+// src/convert.ts
+import { readFileSync } from "fs";
+import { parse as parseYaml } from "yaml";
+
+// src/warnings.ts
+var WarningCollector = class {
+  static {
+    __name(this, "WarningCollector");
+  }
+  warnings = [];
+  onWarning;
+  constructor(onWarning) {
+    this.onWarning = onWarning;
+  }
+  warn(path, message) {
+    this.add({
+      path,
+      message,
+      severity: "warn"
+    });
+  }
+  info(path, message) {
+    this.add({
+      path,
+      message,
+      severity: "info"
+    });
+  }
+  add(warning) {
+    this.warnings.push(warning);
+    this.onWarning?.(warning);
+  }
+};
+
+// src/convert.ts
+async function convertOpenApiToCk(options) {
+  const { split = "by-tag", includeComments = true } = options;
+  const warnings = new WarningCollector(options.onWarning);
+  const rawDoc = await parseInput(options.input);
+  const doc = normalize(rawDoc, warnings);
+  const schemas = sanitizeSchemaNames(doc, warnings);
+  const circularRefs = detectCircularRefs(schemas);
+  const extractedModels = [];
+  const schemaCtx = {
+    circularRefs,
+    warnings,
+    path: "#/components/schemas",
+    includeComments,
+    namedSchemas: schemas,
+    extractedModels,
+    inlineCounter: 0
+  };
+  const models = schemasToModels(schemas, schemaCtx);
+  const { routes, routeTags } = pathsToRoutes(doc, {
+    circularRefs,
+    warnings,
+    includeComments,
+    namedSchemas: schemas,
+    extractedModels,
+    globalSecurity: doc.security
+  });
+  const files = /* @__PURE__ */ new Map();
+  if (split === "by-tag") {
+    const ckRoots = splitByTag(models, routes, routeTags);
+    for (const [filename, root] of ckRoots) {
+      files.set(filename, astToCk(root, {
+        includeComments
+      }));
+    }
+  } else {
+    const root = mergeIntoSingle(models, routes);
+    files.set("api.ck", astToCk(root, {
+      includeComments
+    }));
+  }
+  return {
+    files,
+    warnings: warnings.warnings
+  };
+}
+__name(convertOpenApiToCk, "convertOpenApiToCk");
+async function parseInput(input) {
+  if (typeof input === "object") {
+    return input;
+  }
+  try {
+    const content = readFileSync(input, "utf-8");
+    return parseJsonOrYaml(content);
+  } catch {
+    return parseJsonOrYaml(input);
+  }
+}
+__name(parseInput, "parseInput");
+function parseJsonOrYaml(content) {
+  try {
+    return JSON.parse(content);
+  } catch {
+    return parseYaml(content);
+  }
+}
+__name(parseJsonOrYaml, "parseJsonOrYaml");
+function sanitizeSchemaNames(doc, warnings) {
+  const original = doc.components?.schemas ?? {};
+  const sanitized = {};
+  const nameMap = /* @__PURE__ */ new Map();
+  for (const name of Object.keys(original)) {
+    const clean = sanitizeName(name, warnings);
+    if (sanitized[clean]) {
+      warnings.warn(`#/components/schemas/${name}`, `Name collision after sanitization: "${name}" and another schema both map to "${clean}"`);
+      let i = 2;
+      while (sanitized[`${clean}${i}`]) i++;
+      nameMap.set(name, `${clean}${i}`);
+      sanitized[`${clean}${i}`] = original[name];
+    } else {
+      nameMap.set(name, clean);
+      sanitized[clean] = original[name];
+    }
+  }
+  if (nameMap.size > 0) {
+    updateRefs(doc, nameMap);
+  }
+  return sanitized;
+}
+__name(sanitizeSchemaNames, "sanitizeSchemaNames");
+function updateRefs(obj, nameMap) {
+  if (!obj || typeof obj !== "object") return;
+  if (Array.isArray(obj)) {
+    for (const item of obj) updateRefs(item, nameMap);
+    return;
+  }
+  const record = obj;
+  if (typeof record.$ref === "string") {
+    const match = record.$ref.match(/^#\/components\/schemas\/(.+)$/);
+    if (match?.[1] && nameMap.has(match[1])) {
+      record.$ref = `#/components/schemas/${nameMap.get(match[1])}`;
+    }
+  }
+  for (const value of Object.values(record)) {
+    updateRefs(value, nameMap);
+  }
+}
+__name(updateRefs, "updateRefs");
+
+export {
+  __name,
+  normalize,
+  detectCircularRefs,
+  extractRefName,
+  schemasToModels,
+  schemaToTypeNode,
+  sanitizeName,
+  pathsToRoutes,
+  splitByTag,
+  mergeIntoSingle,
+  astToCk,
+  serializeType,
+  convertOpenApiToCk
+};
+//# sourceMappingURL=chunk-REM25FDE.js.map