@workos/oagen 0.0.1

package/dist/scripts/smoke/baseline.js

@@ -0,0 +1,1751 @@
+// scripts/smoke/baseline.ts
+import { writeFileSync } from "fs";
+
+// src/errors.ts
+var OagenError = class extends Error {
+  hint;
+  constructor(message, hint) {
+    const fullMessage = hint ? `${message}
+Hint: ${hint}` : message;
+    super(fullMessage);
+    this.name = "OagenError";
+    this.hint = hint;
+  }
+};
+var SpecParseError = class extends OagenError {
+  constructor(message, hint) {
+    super(message, hint);
+    this.name = "SpecParseError";
+  }
+};
+
+// src/parser/refs.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+import { makeDocumentFromString, bundleDocument, createConfig, BaseResolver } from "@redocly/openapi-core";
+async function loadAndBundleSpec(specPath) {
+  const absolutePath = resolve(specPath);
+  const content = await readFile(absolutePath, "utf-8");
+  const document = makeDocumentFromString(content, pathToFileURL(absolutePath).href);
+  const config = await createConfig({});
+  const resolver = new BaseResolver();
+  const result = await bundleDocument({
+    document,
+    config: config.styleguide,
+    externalRefResolver: resolver,
+    dereference: false
+  });
+  if (result.problems.some((p) => p.severity === "error")) {
+    const errors = result.problems.filter((p) => p.severity === "error").map((p) => p.message).join("\n");
+    throw new SpecParseError(
+      `Failed to parse spec: ${errors}`,
+      `Check the OpenAPI spec at "${absolutePath}" for syntax errors. Run a linter such as \`npx @redocly/cli lint ${specPath}\` to identify issues.`
+    );
+  }
+  return {
+    parsed: result.bundle.parsed,
+    specPath: absolutePath
+  };
+}
+
+// src/ir/types.ts
+function assertNever(x) {
+  const kind = x.kind;
+  const err = new Error(
+    `Unexpected TypeRef kind: ${kind}
+Hint: If you added a new TypeRef variant, handle it in every switch/case that calls assertNever.`
+  );
+  err.name = "InternalError";
+  throw err;
+}
+function walkTypeRef(ref, visitor) {
+  switch (ref.kind) {
+    case "model":
+      visitor.model?.(ref);
+      break;
+    case "enum":
+      visitor.enum?.(ref);
+      break;
+    case "array":
+      walkTypeRef(ref.items, visitor);
+      break;
+    case "nullable":
+      walkTypeRef(ref.inner, visitor);
+      break;
+    case "union":
+      for (const v of ref.variants) walkTypeRef(v, visitor);
+      break;
+    case "map":
+      if (ref.keyType) walkTypeRef(ref.keyType, visitor);
+      walkTypeRef(ref.valueType, visitor);
+      break;
+    case "literal":
+      visitor.literal?.(ref);
+      break;
+    case "primitive":
+      visitor.primitive?.(ref);
+      break;
+    default:
+      assertNever(ref);
+  }
+}
+
+// src/utils/naming.ts
+function splitWords(s) {
+  if (!s) return [];
+  return s.replace(/[^a-zA-Z0-9_\-\s.]/g, "_").replace(/([a-z])([A-Z])/g, "$1\0$2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1\0$2").replace(/([a-zA-Z])(\d)/g, "$1\0$2").replace(/(\d)([a-zA-Z])/g, "$1\0$2").split(/[\0_\-\s.]+/).filter((w) => w.length > 0);
+}
+var ACRONYM_SET = /* @__PURE__ */ new Set(["SSO", "FGA", "SAML", "SCIM", "JWT", "HMAC"]);
+function toPascalCase(s, acronyms) {
+  const merged = acronyms ? /* @__PURE__ */ new Set([...ACRONYM_SET, ...acronyms]) : ACRONYM_SET;
+  return splitWords(s).map((w) => {
+    const upper = w.toUpperCase();
+    if (merged.has(upper)) return upper;
+    if (upper === "OAUTH") return "OAuth";
+    return w.charAt(0).toUpperCase() + w.slice(1).toLowerCase();
+  }).join("");
+}
+function toCamelCase(s, acronyms) {
+  const merged = acronyms ? /* @__PURE__ */ new Set([...ACRONYM_SET, ...acronyms]) : ACRONYM_SET;
+  const words = splitWords(s);
+  if (words.length === 0) return "";
+  return words.map((w, i) => {
+    if (i === 0) return w.toLowerCase();
+    const upper = w.toUpperCase();
+    if (merged.has(upper)) return upper;
+    if (upper === "OAUTH") return "OAuth";
+    return w.charAt(0).toUpperCase() + w.slice(1).toLowerCase();
+  }).join("");
+}
+function toSnakeCase(s) {
+  return splitWords(s).map((w) => w.toLowerCase()).join("_");
+}
+function toUpperSnakeCase(s) {
+  return splitWords(s).map((w) => w.toUpperCase()).join("_");
+}
+var BACKEND_SUFFIXES = ["Dto", "DTO", "Controller"];
+function stripBackendSuffixes(name) {
+  for (const suffix of BACKEND_SUFFIXES) {
+    if (name.endsWith(suffix) && name.length > suffix.length) {
+      return name.slice(0, -suffix.length);
+    }
+  }
+  return name;
+}
+function stripBackendPrefixes(name) {
+  return name.replace(/Userland/g, "").replace(/Controller/g, "");
+}
+function stripListItemMarkers(name) {
+  return name.replace(/ListItem/g, "").replace(/ByExternalId/g, "").replace(/ByResourceId/g, "").replace(/ForResource/g, "");
+}
+var SINGULAR_SAFE_LIST = /* @__PURE__ */ new Set([
+  "Status",
+  "Address",
+  "Access",
+  "Process",
+  "Progress",
+  "Success",
+  "Radius",
+  "Canvas",
+  "Alias",
+  "Basis",
+  "Bus"
+]);
+function singularize(word) {
+  if (SINGULAR_SAFE_LIST.has(word)) return word;
+  if (word.endsWith("ies") && word.length > 4) {
+    return word.slice(0, -3) + "y";
+  }
+  if (word.endsWith("ses") && word.length > 4) {
+    return word.slice(0, -2);
+  }
+  if (word.endsWith("s") && !word.endsWith("ss") && word.length > 4) {
+    return word.slice(0, -1);
+  }
+  return word;
+}
+function cleanSchemaName(name) {
+  let result = stripBackendPrefixes(stripBackendSuffixes(name));
+  result = stripListItemMarkers(result);
+  const match = result.match(/^([A-Z][a-z]*)/);
+  if (match) {
+    const leadWord = match[1];
+    const singular = singularize(leadWord);
+    if (singular !== leadWord) {
+      result = singular + result.slice(leadWord.length);
+    }
+  }
+  return result;
+}
+
+// src/parser/inline-models.ts
+function qualifyInlineModelName(baseName, parentName) {
+  if (!parentName) return baseName;
+  const cleanParent = stripListItemMarkers(parentName);
+  if (baseName.startsWith(cleanParent)) return baseName;
+  const trailingMatch = baseName.match(/^(.*?)([A-Z][a-z]*)$/);
+  if (trailingMatch) {
+    const [, prefix, trailingWord] = trailingMatch;
+    const singular = singularize(trailingWord);
+    return `${cleanParent}${prefix}${singular}`;
+  }
+  return `${cleanParent}${baseName}`;
+}
+function extractInlineModelsFromSchemas(schemas) {
+  if (!schemas) return [];
+  const inlineModels = [];
+  for (const [schemaName, schema] of Object.entries(schemas)) {
+    const parentName = cleanSchemaName(toPascalCase(schemaName));
+    extractInlineModelsFromProperties(schema, inlineModels, parentName);
+  }
+  return inlineModels;
+}
+function extractInlineModelsFromProperties(schema, results, parentName) {
+  const properties = schema.properties ?? {};
+  const allOfSchemas = schema.allOf ?? [];
+  for (const sub of allOfSchemas) {
+    if (sub.properties) {
+      extractInlineModelsFromProperties(sub, results, parentName);
+    }
+  }
+  for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+    if (!fieldSchema) continue;
+    if (fieldSchema.properties && (fieldSchema.type === "object" || !fieldSchema.type)) {
+      const baseName = toPascalCase(fieldName);
+      const modelName = qualifyInlineModelName(baseName, parentName);
+      results.push(buildInlineModel(modelName, fieldSchema));
+      extractInlineModelsFromProperties(fieldSchema, results, modelName);
+    }
+    if (fieldSchema.type === "array" && fieldSchema.items) {
+      const items = fieldSchema.items;
+      if (items.properties && (items.type === "object" || !items.type)) {
+        const baseName = toPascalCase(fieldName);
+        const modelName = qualifyInlineModelName(baseName, parentName);
+        results.push(buildInlineModel(modelName, items));
+        extractInlineModelsFromProperties(items, results, modelName);
+      }
+    }
+    if (fieldSchema.oneOf) {
+      const objectVariant = fieldSchema.oneOf.find((v) => v.properties && (v.type === "object" || !v.type));
+      if (objectVariant) {
+        const baseName = toPascalCase(fieldName);
+        const modelName = qualifyInlineModelName(baseName, parentName);
+        const existingNames = new Set(results.map((r) => r.name));
+        if (!existingNames.has(modelName)) {
+          results.push(buildInlineModel(modelName, objectVariant));
+          extractInlineModelsFromProperties(objectVariant, results, modelName);
+        }
+      }
+    }
+  }
+}
+function buildInlineModel(name, schema) {
+  const requiredSet = new Set(schema.required ?? []);
+  const fields = [];
+  for (const [fieldName, fieldSchema] of Object.entries(schema.properties ?? {})) {
+    if (!fieldSchema) continue;
+    fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, requiredSet));
+  }
+  return { name, description: schema.description, fields };
+}
+
+// src/parser/schemas.ts
+function extractSchemas(schemas) {
+  const models = [];
+  const enums = [];
+  if (!schemas) return { models, enums };
+  for (const [name, schema] of Object.entries(schemas)) {
+    const pascalName = cleanSchemaName(toPascalCase(name));
+    if (schema.enum) {
+      enums.push(extractEnum(pascalName, schema));
+    } else {
+      models.push(extractModel(pascalName, schema, schemas));
+    }
+  }
+  const modelNames = new Set(models.map((m) => m.name));
+  const inlineQueue = [...models];
+  while (inlineQueue.length > 0) {
+    const model = inlineQueue.pop();
+    for (const field of model.fields) {
+      collectNestedInlineModels(field.type, field.name, model.name, schemas ?? {}, models, modelNames, inlineQueue);
+    }
+  }
+  for (const model of models) {
+    collectInlineEnums(model.fields, enums);
+  }
+  return { models, enums };
+}
+function collectInlineEnumFromRef(ref, enums, seen) {
+  walkTypeRef(ref, {
+    enum: (r) => {
+      if (r.values && !seen.has(r.name)) {
+        seen.add(r.name);
+        enums.push({
+          name: r.name,
+          values: r.values.map((v) => ({
+            name: toUpperSnakeCase(String(v)),
+            value: v,
+            description: void 0
+          }))
+        });
+      }
+    }
+  });
+}
+function collectInlineEnums(fields, enums) {
+  const seen = new Set(enums.map((e) => e.name));
+  for (const field of fields) {
+    collectInlineEnumFromRef(field.type, enums, seen);
+  }
+}
+function collectNestedInlineModels(ref, fieldName, parentModelName, schemas, models, modelNames, queue) {
+  walkTypeRef(ref, {
+    model: (modelRef) => {
+      if (modelNames.has(modelRef.name)) return;
+      const isComponent = Object.keys(schemas).some((k) => cleanSchemaName(toPascalCase(k)) === modelRef.name);
+      if (isComponent) return;
+      const parentSchema = findSchemaByName(parentModelName, schemas);
+      if (!parentSchema) return;
+      const fieldSchema = findNestedFieldSchema(fieldName, parentSchema, schemas);
+      if (!fieldSchema) return;
+      const extracted = extractNestedSchema(modelRef.name, fieldSchema);
+      for (const m of extracted) {
+        if (!modelNames.has(m.name)) {
+          models.push(m);
+          modelNames.add(m.name);
+          queue.push(m);
+        }
+      }
+    }
+  });
+}
+function findSchemaByName(pascalName, schemas) {
+  for (const [k, v] of Object.entries(schemas)) {
+    if (cleanSchemaName(toPascalCase(k)) === pascalName) return v;
+  }
+  return null;
+}
+function findNestedFieldSchema(fieldName, parentSchema, schemas) {
+  if (parentSchema.properties?.[fieldName]) {
+    return parentSchema.properties[fieldName];
+  }
+  if (parentSchema.allOf) {
+    for (const sub of parentSchema.allOf) {
+      let resolved = sub;
+      if (sub.$ref) {
+        const segments = sub.$ref.split("/");
+        const refName = segments[segments.length - 1];
+        if (refName && schemas[refName]) resolved = schemas[refName];
+      }
+      if (resolved.properties?.[fieldName]) {
+        return resolved.properties[fieldName];
+      }
+    }
+  }
+  return null;
+}
+function extractNestedSchema(name, schema) {
+  if (schema.oneOf) {
+    const models = [];
+    for (const variant of schema.oneOf) {
+      if (variant.$ref) continue;
+      if (variant.properties && (variant.type === "object" || !variant.type)) {
+        const requiredSet = new Set(variant.required ?? []);
+        const fields = [];
+        for (const [fn, fs] of Object.entries(variant.properties)) {
+          if (!fs) continue;
+          fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
+        }
+        const variantName = models.length === 0 ? name : `${name}${models.length + 1}`;
+        models.push({ name: variantName, description: variant.description, fields });
+      }
+    }
+    return models;
+  }
+  if (schema.properties && (schema.type === "object" || !schema.type)) {
+    const requiredSet = new Set(schema.required ?? []);
+    const fields = [];
+    for (const [fn, fs] of Object.entries(schema.properties)) {
+      if (!fs) continue;
+      fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
+    }
+    return [{ name, description: schema.description, fields }];
+  }
+  if (schema.type === "array" && schema.items?.properties) {
+    const requiredSet = new Set(schema.items.required ?? []);
+    const fields = [];
+    for (const [fn, fs] of Object.entries(schema.items.properties)) {
+      if (!fs) continue;
+      fields.push(buildFieldFromSchema(fn, fs, name, requiredSet));
+    }
+    return [{ name, description: schema.items.description, fields }];
+  }
+  return [];
+}
+function buildFieldFromSchema(fieldName, fieldSchema, contextName, requiredSet) {
+  return {
+    name: fieldName,
+    type: schemaToTypeRef(fieldSchema, fieldName, contextName),
+    required: requiredSet.has(fieldName),
+    description: fieldSchema.description,
+    readOnly: fieldSchema.readOnly || void 0,
+    writeOnly: fieldSchema.writeOnly || void 0,
+    deprecated: fieldSchema.deprecated || void 0,
+    default: fieldSchema.default
+  };
+}
+function extractEnum(name, schema) {
+  const values = (schema.enum ?? []).map((v) => ({
+    name: toUpperSnakeCase(String(v)),
+    value: typeof v === "number" ? v : String(v),
+    description: void 0
+  }));
+  return { name, values };
+}
+function extractModel(name, schema, schemas) {
+  if (schema.allOf) {
+    return extractAllOfModel(name, schema, schemas);
+  }
+  const requiredSet = new Set(schema.required ?? []);
+  const fields = [];
+  for (const [fieldName, fieldSchema] of Object.entries(schema.properties ?? {})) {
+    if (!fieldSchema) continue;
+    fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, requiredSet));
+  }
+  if (schema.additionalProperties && typeof schema.additionalProperties === "object" && schema.properties) {
+    const apKeys = Object.keys(schema.additionalProperties);
+    if (apKeys.length > 0) {
+      const valueType = schemaToTypeRef(schema.additionalProperties, "additionalProperties", name);
+      fields.push({
+        name: "additionalProperties",
+        type: { kind: "map", valueType },
+        required: false,
+        description: "Additional properties not captured by named fields"
+      });
+    }
+  }
+  return { name, description: schema.description, fields };
+}
+function extractAllOfModel(name, schema, schemas) {
+  const fields = [];
+  const requiredSet = /* @__PURE__ */ new Set();
+  for (const subSchema of schema.allOf ?? []) {
+    let resolved = subSchema;
+    if (subSchema.$ref && schemas) {
+      const segments = subSchema.$ref.split("/");
+      const refName = segments[segments.length - 1];
+      if (refName && schemas[refName]) {
+        resolved = schemas[refName];
+      }
+    }
+    if (resolved.allOf) {
+      const nested = extractAllOfModel(name, resolved, schemas);
+      for (const f of nested.fields) {
+        fields.push({ ...f, required: false });
+        if (f.required) requiredSet.add(f.name);
+      }
+    } else {
+      if (resolved.required) {
+        for (const r of resolved.required) requiredSet.add(r);
+      }
+      if (resolved.properties) {
+        const emptyRequired = /* @__PURE__ */ new Set();
+        for (const [fieldName, fieldSchema] of Object.entries(resolved.properties)) {
+          if (!fieldSchema) continue;
+          fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, emptyRequired));
+        }
+      }
+    }
+  }
+  if (schema.required) {
+    for (const r of schema.required) requiredSet.add(r);
+  }
+  for (const f of fields) {
+    f.required = requiredSet.has(f.name);
+  }
+  return { name, description: schema.description, fields };
+}
+function schemaToTypeRef(schema, contextName, parentModelName) {
+  if (schema.$ref) {
+    const segments = schema.$ref.split("/");
+    const rawName = segments[segments.length - 1];
+    return { kind: "model", name: cleanSchemaName(toPascalCase(rawName)) };
+  }
+  if (Array.isArray(schema.type)) {
+    const nonNullTypes = schema.type.filter((t) => t !== "null");
+    if (nonNullTypes.length === 0) {
+      return { kind: "nullable", inner: { kind: "primitive", type: "unknown" } };
+    }
+    if (schema.type.includes("null") && nonNullTypes.length === 1) {
+      return {
+        kind: "nullable",
+        inner: schemaToTypeRef({ ...schema, type: nonNullTypes[0], nullable: false }, contextName)
+      };
+    }
+    if (nonNullTypes.length > 1) {
+      const variants = nonNullTypes.map((t) => schemaToTypeRef({ ...schema, type: t }, contextName));
+      const ref = { kind: "union", variants };
+      if (schema.type.includes("null")) {
+        return { kind: "nullable", inner: ref };
+      }
+      return ref;
+    }
+  }
+  if (schema.nullable && schema.type) {
+    return {
+      kind: "nullable",
+      inner: schemaToTypeRef({ ...schema, nullable: false }, contextName)
+    };
+  }
+  if (schema.allOf) {
+    const refItem = schema.allOf.find((s) => s.$ref);
+    if (refItem) {
+      const hasAugmentation = schema.allOf.some((s) => !s.$ref && (s.properties || s.type === "object"));
+      if (hasAugmentation) {
+        const baseName = toPascalCase(contextName ?? "UnknownModel");
+        return { kind: "model", name: qualifyInlineModelName(baseName, parentModelName) };
+      }
+      return schemaToTypeRef(refItem, contextName, parentModelName);
+    }
+    if (schema.allOf.length === 1) {
+      return schemaToTypeRef(schema.allOf[0], contextName, parentModelName);
+    }
+    const hasProperties = schema.allOf.some((s) => s.properties);
+    if (hasProperties) {
+      const baseName = toPascalCase(contextName ?? "UnknownModel");
+      return {
+        kind: "model",
+        name: qualifyInlineModelName(baseName, parentModelName)
+      };
+    }
+  }
+  if (schema.oneOf || schema.anyOf) {
+    const compositionKind = schema.oneOf ? "oneOf" : "anyOf";
+    const rawVariants = schema.oneOf ?? schema.anyOf ?? [];
+    const nullVariant = rawVariants.find(
+      (v) => v.type === "null" || Array.isArray(v.type) && v.type.length === 1 && v.type[0] === "null"
+    );
+    const nonNullVariants = rawVariants.filter((v) => v !== nullVariant);
+    if (nullVariant && nonNullVariants.length === 1) {
+      return {
+        kind: "nullable",
+        inner: schemaToTypeRef(nonNullVariants[0], contextName, parentModelName)
+      };
+    }
+    const variants = rawVariants.filter((v) => v.type !== "null").map((v) => schemaToTypeRef(v, contextName, parentModelName));
+    const hasNull = !!nullVariant;
+    const union = {
+      kind: "union",
+      variants,
+      compositionKind,
+      ...schema.discriminator ? {
+        discriminator: {
+          property: schema.discriminator.propertyName,
+          mapping: Object.fromEntries(
+            Object.entries(schema.discriminator.mapping ?? {}).map(([k, v]) => [
+              k,
+              v.replace(/^#\/components\/schemas\//, "")
+            ])
+          )
+        }
+      } : {}
+    };
+    return hasNull ? { kind: "nullable", inner: union } : union;
+  }
+  if (schema.const !== void 0) {
+    if (typeof schema.const === "string" || typeof schema.const === "number" || typeof schema.const === "boolean") {
+      return { kind: "literal", value: schema.const };
+    }
+    if (schema.const === null) {
+      return { kind: "nullable", inner: { kind: "primitive", type: "unknown" } };
+    }
+    if (typeof schema.const === "object") {
+      if (Array.isArray(schema.const)) {
+        return { kind: "array", items: { kind: "primitive", type: "unknown" } };
+      }
+      return { kind: "map", valueType: { kind: "primitive", type: "unknown" } };
+    }
+  }
+  if (schema.enum && schema.enum.length === 1) {
+    const v = schema.enum[0];
+    return { kind: "literal", value: typeof v === "number" ? v : String(v) };
+  }
+  if (schema.enum) {
+    const baseName = toPascalCase(contextName ?? "UnknownEnum");
+    const cleanParent = parentModelName ? stripListItemMarkers(parentModelName) : void 0;
+    const qualifiedName = cleanParent && !baseName.startsWith(cleanParent) ? `${cleanParent}${baseName}` : baseName;
+    return {
+      kind: "enum",
+      name: qualifiedName,
+      values: schema.enum.map((v) => typeof v === "number" ? v : String(v))
+    };
+  }
+  if (schema.type === "array" && schema.items) {
+    return {
+      kind: "array",
+      items: schemaToTypeRef(schema.items, contextName, parentModelName)
+    };
+  }
+  if (!schema.type && schema.items) {
+    return {
+      kind: "array",
+      items: schemaToTypeRef(schema.items, contextName, parentModelName)
+    };
+  }
+  if (schema.type === "object" && schema.properties) {
+    const baseName = toPascalCase(contextName ?? "UnknownModel");
+    return {
+      kind: "model",
+      name: qualifyInlineModelName(baseName, parentModelName)
+    };
+  }
+  if (schema.type === "object" && !schema.properties) {
+    let valueType = { kind: "primitive", type: "unknown" };
+    if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+      const apKeys = Object.keys(schema.additionalProperties);
+      if (apKeys.length > 0) {
+        valueType = schemaToTypeRef(schema.additionalProperties, contextName);
+      }
+    } else if (schema.patternProperties) {
+      const patterns = Object.values(schema.patternProperties);
+      if (patterns.length > 0) {
+        valueType = schemaToTypeRef(patterns[0], contextName);
+      }
+    }
+    return {
+      kind: "map",
+      valueType
+    };
+  }
+  const primitiveMap = {
+    string: "string",
+    integer: "integer",
+    number: "number",
+    boolean: "boolean"
+  };
+  const typeStr = Array.isArray(schema.type) ? schema.type[0] : schema.type;
+  if (typeStr && primitiveMap[typeStr]) {
+    return {
+      kind: "primitive",
+      type: primitiveMap[typeStr],
+      ...schema.format ? { format: schema.format } : {}
+    };
+  }
+  if (!schema.type && schema.properties) {
+    const baseName = toPascalCase(contextName ?? "UnknownModel");
+    return {
+      kind: "model",
+      name: qualifyInlineModelName(baseName, parentModelName)
+    };
+  }
+  if (!schema.type && !schema.$ref && !schema.oneOf && !schema.anyOf && !schema.allOf && !schema.enum && !schema.properties && !schema.items) {
+    return { kind: "primitive", type: "unknown" };
+  }
+  if (contextName) {
+    console.warn(`[oagen] Warning: Unknown schema shape treated as unknown (context: ${contextName})`);
+  }
+  return { kind: "primitive", type: "unknown" };
+}
+
+// src/parser/pagination.ts
+var CURSOR_PARAMS = ["cursor", "after", "before", "starting_after", "ending_before", "page_token", "next_token"];
+var OFFSET_PARAMS = ["offset", "page", "page_number", "skip"];
+var LIMIT_PARAMS = ["limit", "page_size", "per_page", "size", "count"];
+function detectPagination(response, queryParams, dataPath) {
+  const cursorParam = queryParams.find((p) => CURSOR_PARAMS.includes(p.name));
+  if (cursorParam) {
+    const itemType = response.kind === "array" ? response.items : response;
+    return {
+      strategy: "cursor",
+      param: cursorParam.name,
+      dataPath,
+      itemType
+    };
+  }
+  const offsetParam = queryParams.find((p) => OFFSET_PARAMS.includes(p.name));
+  const limitParam = queryParams.find((p) => LIMIT_PARAMS.includes(p.name));
+  if (offsetParam && limitParam) {
+    const itemType = response.kind === "array" ? response.items : response;
+    return {
+      strategy: "offset",
+      param: offsetParam.name,
+      limitParam: limitParam.name,
+      dataPath,
+      itemType
+    };
+  }
+  return null;
+}
+
+// src/parser/responses.ts
+function classifyAndExtractResponse(schema, contextName) {
+  if (schema.$ref) {
+    return { response: schemaToTypeRef(schema, contextName), inlineModels: [], isPaginated: false };
+  }
+  const envelope = detectListEnvelope(schema);
+  if (envelope.isEnvelope) {
+    return extractListResponse(schema, contextName, envelope.dataPath);
+  }
+  if (isSingleResourceWrapper(schema)) {
+    return extractWrappedResource(schema, contextName);
+  }
+  return extractDirectResource(schema, contextName);
+}
+function detectListEnvelope(schema) {
+  const propSources = [];
+  if (schema.allOf) {
+    for (const sub of schema.allOf) {
+      if (sub.properties) propSources.push(sub.properties);
+    }
+  }
+  if (schema.properties) {
+    propSources.push(schema.properties);
+  }
+  if (propSources.length === 0) return { isEnvelope: false, dataPath: null };
+  const mergedProps = {};
+  for (const source of propSources) {
+    Object.assign(mergedProps, source);
+  }
+  const arrayProps = [];
+  let nonArrayCount = 0;
+  for (const [key, propSchema] of Object.entries(mergedProps)) {
+    if (!propSchema) continue;
+    if (propSchema.type === "array") {
+      arrayProps.push(key);
+    } else {
+      nonArrayCount++;
+    }
+  }
+  if (arrayProps.length === 1 && nonArrayCount >= 1) {
+    return { isEnvelope: true, dataPath: arrayProps[0] };
+  }
+  return { isEnvelope: false, dataPath: null };
+}
+function extractListResponse(schema, contextName, dataPath) {
+  let itemTypeRef = { kind: "primitive", type: "string" };
+  const inlineModels = [];
+  const propSources = [];
+  if (schema.allOf) {
+    for (const sub of schema.allOf) {
+      if (sub.properties) propSources.push(sub.properties);
+    }
+  }
+  if (schema.properties) {
+    propSources.push(schema.properties);
+  }
+  for (const props of propSources) {
+    const dataProp = props[dataPath];
+    if (!dataProp) continue;
+    if (dataProp.type === "array" && dataProp.items) {
+      const items = dataProp.items;
+      if (items.$ref) {
+        itemTypeRef = schemaToTypeRef(items, contextName);
+      } else if (items.type === "object" && items.properties) {
+        const itemName = contextName.replace(/Response$/, "") + "Item";
+        itemTypeRef = { kind: "model", name: itemName };
+        inlineModels.push(...extractInlineModel(itemName, items));
+      }
+    }
+  }
+  return {
+    response: { kind: "array", items: itemTypeRef },
+    inlineModels,
+    isPaginated: true,
+    dataPath,
+    itemType: itemTypeRef
+  };
+}
+function hasDiscriminantConstField(schema) {
+  if (!schema.properties) return null;
+  const preferred = ["object", "type"];
+  for (const name of preferred) {
+    const field = schema.properties[name];
+    if (!field) continue;
+    if (field.const !== void 0 && typeof field.const === "string") {
+      return { property: name, value: field.const };
+    }
+    if (field.enum && field.enum.length === 1 && typeof field.enum[0] === "string") {
+      return { property: name, value: field.enum[0] };
+    }
+  }
+  for (const [name, field] of Object.entries(schema.properties)) {
+    if (!field) continue;
+    if (field.const !== void 0 && typeof field.const === "string") {
+      return { property: name, value: field.const };
+    }
+    if (field.enum && field.enum.length === 1 && typeof field.enum[0] === "string") {
+      return { property: name, value: field.enum[0] };
+    }
+  }
+  return null;
+}
+function isSingleResourceWrapper(schema) {
+  if (schema.type !== "object") return false;
+  if (!schema.properties) return false;
+  let wrapperKey;
+  if (schema.required && schema.required.length === 1) {
+    wrapperKey = schema.required[0];
+  } else {
+    const propKeys = Object.keys(schema.properties);
+    if (propKeys.length === 1) {
+      wrapperKey = propKeys[0];
+    }
+  }
+  if (!wrapperKey) return false;
+  const propSchema = schema.properties[wrapperKey];
+  if (!propSchema) return false;
+  if (propSchema.type === "object" && hasDiscriminantConstField(propSchema) !== null) return true;
+  if (propSchema.oneOf) {
+    return propSchema.oneOf.some((v) => v.type === "object" && hasDiscriminantConstField(v) !== null);
+  }
+  return false;
+}
+function extractWrappedResource(schema, contextName) {
+  const props = schema.properties;
+  const wrapperKey = schema.required && schema.required.length === 1 ? schema.required[0] : Object.keys(props)[0];
+  const propSchema = props[wrapperKey];
+  const inlineModels = [];
+  const resourceName = contextName.replace(/Response$/, "");
+  if (propSchema.oneOf) {
+    const objectVariant = propSchema.oneOf.find((v) => v.type === "object" && hasDiscriminantConstField(v) !== null);
+    if (objectVariant) {
+      const modelName2 = deriveModelName(objectVariant, resourceName);
+      inlineModels.push(...extractInlineModel(modelName2, objectVariant));
+      const hasNullVariant = propSchema.oneOf.some(
+        (v) => v.type === "null" || Array.isArray(v.type) && v.type.includes("null")
+      );
+      const modelRef = { kind: "model", name: modelName2 };
+      return {
+        response: hasNullVariant ? { kind: "nullable", inner: modelRef } : modelRef,
+        inlineModels,
+        isPaginated: false
+      };
+    }
+  }
+  const modelName = deriveModelName(propSchema, resourceName);
+  inlineModels.push(...extractInlineModel(modelName, propSchema));
+  return {
+    response: { kind: "model", name: modelName },
+    inlineModels,
+    isPaginated: false
+  };
+}
+function extractDirectResource(schema, contextName) {
+  const inlineModels = [];
+  if (schema.properties && (schema.type === "object" || !schema.type)) {
+    const modelName = deriveModelName(schema, contextName);
+    inlineModels.push(...extractInlineModel(modelName, schema));
+    return {
+      response: { kind: "model", name: modelName },
+      inlineModels,
+      isPaginated: false
+    };
+  }
+  if (schema.allOf) {
+    const mergedProperties = {};
+    const mergedRequired = [];
+    for (const sub of schema.allOf) {
+      if (sub.properties) {
+        Object.assign(mergedProperties, sub.properties);
+      }
+      if (sub.required) {
+        mergedRequired.push(...sub.required);
+      }
+    }
+    if (Object.keys(mergedProperties).length > 0) {
+      const merged = { type: "object", properties: mergedProperties, required: mergedRequired };
+      const modelName = deriveModelName(merged, contextName);
+      inlineModels.push(...extractInlineModel(modelName, merged));
+      return {
+        response: { kind: "model", name: modelName },
+        inlineModels,
+        isPaginated: false
+      };
+    }
+  }
+  if (schema.oneOf) {
+    for (const variant of schema.oneOf) {
+      if (variant.properties && (variant.type === "object" || !variant.type)) {
+        const modelName = deriveModelName(variant, contextName);
+        const existingNames = new Set(inlineModels.map((m) => m.name));
+        if (!existingNames.has(modelName)) {
+          inlineModels.push(...extractInlineModel(modelName, variant));
+        }
+      }
+    }
+  }
+  if (schema.type === "array" && schema.items) {
+    const items = schema.items;
+    if (items.$ref) {
+      return {
+        response: { kind: "array", items: schemaToTypeRef(items, contextName) },
+        inlineModels,
+        isPaginated: false
+      };
+    }
+    if (items.properties && (items.type === "object" || !items.type)) {
+      const itemName = contextName.replace(/Response$/, "") + "Item";
+      inlineModels.push(...extractInlineModel(itemName, items));
+      return {
+        response: { kind: "array", items: { kind: "model", name: itemName } },
+        inlineModels,
+        isPaginated: false
+      };
+    }
+  }
+  return {
+    response: schemaToTypeRef(schema, contextName),
+    inlineModels,
+    isPaginated: false
+  };
+}
+function deriveModelName(schema, fallback) {
+  if (!schema.properties) return toPascalCase(fallback);
+  const preferred = ["object", "type"];
+  for (const name of preferred) {
+    const field = schema.properties[name];
+    if (field && field.const && typeof field.const === "string") {
+      return toPascalCase(field.const);
+    }
+  }
+  for (const [, field] of Object.entries(schema.properties)) {
+    if (field && field.const && typeof field.const === "string") {
+      return toPascalCase(field.const);
+    }
+  }
+  return toPascalCase(fallback);
+}
+function qualifyNestedName(parentName, fieldName) {
+  const pascalField = toPascalCase(fieldName);
+  if (pascalField.startsWith(parentName)) return pascalField;
+  const cleanParent = stripListItemMarkers(parentName);
+  const qualified = `${cleanParent}${pascalField}`;
+  const match = qualified.match(/^(.+?)([A-Z][a-z]+s?)$/);
+  if (match && match[2]) {
+    const trailing = singularize(match[2]);
+    return match[1] + trailing;
+  }
+  return qualified;
+}
+function extractInlineModel(name, schema) {
+  const requiredSet = new Set(schema.required ?? []);
+  const fields = [];
+  const properties = schema.properties ?? {};
+  const nestedModels = [];
+  for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+    if (!fieldSchema) continue;
+    fields.push(buildFieldFromSchema(fieldName, fieldSchema, name, requiredSet));
+    if (fieldSchema.type === "object" && fieldSchema.properties) {
+      const nestedName = qualifyNestedName(name, fieldName);
+      nestedModels.push(...extractInlineModel(nestedName, fieldSchema));
+    }
+    if (fieldSchema.type === "array" && fieldSchema.items) {
+      const items = fieldSchema.items;
+      if (items.type === "object" && items.properties) {
+        const nestedName = qualifyNestedName(name, fieldName);
+        nestedModels.push(...extractInlineModel(nestedName, items));
+      }
+    }
+    if (fieldSchema.allOf) {
+      const mergedProperties = {};
+      const mergedRequired = [];
+      for (const sub of fieldSchema.allOf) {
+        if (sub.properties) Object.assign(mergedProperties, sub.properties);
+        if (sub.required) mergedRequired.push(...sub.required);
+      }
+      if (Object.keys(mergedProperties).length > 0) {
+        const nestedName = qualifyNestedName(name, fieldName);
+        const merged = { type: "object", properties: mergedProperties, required: mergedRequired };
+        const existingNames = new Set(nestedModels.map((m) => m.name));
+        if (!existingNames.has(nestedName)) {
+          nestedModels.push(...extractInlineModel(nestedName, merged));
+        }
+      }
+    }
+    if (fieldSchema.oneOf) {
+      const objectVariant = fieldSchema.oneOf.find((v) => v.properties && (v.type === "object" || !v.type));
+      if (objectVariant) {
+        const nestedName = qualifyNestedName(name, fieldName);
+        const existingNames = new Set(nestedModels.map((m) => m.name));
+        if (!existingNames.has(nestedName)) {
+          nestedModels.push(...extractInlineModel(nestedName, objectVariant));
+        }
+      }
+    }
+  }
+  return [{ name, description: schema.description, fields }, ...nestedModels];
+}
+
+// src/parser/operations.ts
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete", "head", "options", "trace"];
+function extractOperations(paths, operationIdTransform) {
+  if (!paths) return { services: [], inlineModels: [] };
+  const serviceMap = /* @__PURE__ */ new Map();
+  const inlineModels = [];
+  for (const [path, pathItem] of Object.entries(paths)) {
+    const pathLevelParams = pathItem.parameters ?? [];
+    for (const method of HTTP_METHODS) {
+      const op = pathItem[method];
+      if (!op) continue;
+      const serviceName = inferServiceName(path, op.tags?.[0]);
+      const { operation, inlineModels: opModels } = buildOperation(
+        method,
+        path,
+        op,
+        pathLevelParams,
+        operationIdTransform
+      );
+      inlineModels.push(...opModels);
+      const ops = serviceMap.get(serviceName) ?? [];
+      ops.push(operation);
+      serviceMap.set(serviceName, ops);
+    }
+  }
+  for (const [, operations] of serviceMap) {
+    disambiguateOperationNames(operations);
+  }
+  const services = Array.from(serviceMap.entries()).map(([name, operations]) => ({
+    name,
+    operations
+  }));
+  return { services, inlineModels };
+}
+function inferServiceName(path, tag) {
+  if (tag) {
+    return toPascalCase(tag);
+  }
+  const segments = path.split("/").filter(Boolean);
+  const first = segments[0] ?? "Default";
+  if (first.startsWith("{")) return "Default";
+  return toPascalCase(first);
+}
+function inferOperationName(method, path, operationId, operationIdTransform) {
+  if (operationId) {
+    if (operationIdTransform) {
+      return operationIdTransform(operationId);
+    }
+    return toCamelCase(operationId);
+  }
+  const verb = inferVerb(method, path);
+  const resource = inferResourceFromPath(path);
+  return resource ? toCamelCase(`${verb}_${resource}`) : verb;
+}
+function inferVerb(method, path) {
+  const segments = path.split("/").filter(Boolean);
+  const hasTrailingParam = segments.length > 0 && segments[segments.length - 1].startsWith("{");
+  switch (method) {
+    case "get":
+      return hasTrailingParam ? "get" : "list";
+    case "post":
+      return "create";
+    case "put":
+    case "patch":
+      return "update";
+    case "delete":
+      return "delete";
+    case "head":
+      return "check";
+    case "options":
+      return "options";
+    case "trace":
+      return "trace";
+    default:
+      return method;
+  }
+}
+function inferResourceFromPath(path) {
+  const segments = path.split("/").filter(Boolean);
+  if (segments.length <= 1) return null;
+  let resourceSegment = null;
+  for (let i = segments.length - 1; i >= 0; i--) {
+    if (!segments[i].startsWith("{")) {
+      resourceSegment = segments[i];
+      break;
+    }
+  }
+  if (!resourceSegment) return null;
+  if (resourceSegment === segments[0]) return null;
+  return toPascalCase(resourceSegment);
+}
+function disambiguateOperationNames(operations) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const op of operations) {
+    const group = byName.get(op.name) ?? [];
+    group.push(op);
+    byName.set(op.name, group);
+  }
+  for (const [name, group] of byName) {
+    if (group.length <= 1) continue;
+    const uniquePaths = new Set(group.map((op) => op.path));
+    if (uniquePaths.size <= 1) continue;
+    for (const op of group) {
+      const resource = inferResourceFromPath(op.path);
+      if (resource) {
+        const newName = toCamelCase(`${name}_${resource}`);
+        op.name = newName;
+      }
+    }
+    const renamed = /* @__PURE__ */ new Map();
+    for (const op of group) {
+      const rGroup = renamed.get(op.name) ?? [];
+      rGroup.push(op);
+      renamed.set(op.name, rGroup);
+    }
+    for (const [, rGroup] of renamed) {
+      if (rGroup.length <= 1) continue;
+      for (const op of rGroup) {
+        const deeper = inferDeeperContext(op.path);
+        if (deeper) {
+          op.name = toCamelCase(`${op.name}_${deeper}`);
+        }
+      }
+    }
+  }
+}
+function inferDeeperContext(path) {
+  const segments = path.split("/").filter(Boolean);
+  const nonParams = segments.filter((s) => !s.startsWith("{"));
+  if (nonParams.length >= 3) {
+    return toPascalCase(nonParams.slice(1, -1).join("_"));
+  }
+  return null;
+}
+function buildOperation(method, path, op, pathLevelParams, operationIdTransform) {
+  const allParams = [...pathLevelParams, ...op.parameters ?? []];
+  const hasIdempotencyHeader = allParams.some((p) => p.in === "header" && p.name.toLowerCase() === "idempotency-key");
+  const pathParams = extractParams(allParams, "path");
+  const queryParams = extractParams(allParams, "query");
+  const headerParams = extractParams(allParams, "header").filter((p) => p.name.toLowerCase() !== "idempotency-key");
+  const cookieParams = extractParams(allParams, "cookie");
+  const reqBodyModels = [];
+  const { body: requestBody, encoding: requestBodyEncoding } = extractRequestBody(op.requestBody, op, reqBodyModels);
+  const {
+    response,
+    successResponses,
+    errors,
+    inlineModels,
+    isPaginated,
+    dataPath: responseDataPath,
+    itemType: responseItemType
+  } = extractResponses(op.responses, op, path, method);
+  inlineModels.push(...reqBodyModels);
+  const paginationFromParams = detectPagination(response, queryParams, responseDataPath);
+  let pagination;
+  if (isPaginated) {
+    const itemType = responseItemType ?? (response.kind === "array" ? response.items : response);
+    pagination = {
+      strategy: paginationFromParams?.strategy ?? "cursor",
+      param: paginationFromParams?.param ?? "after",
+      limitParam: paginationFromParams?.limitParam,
+      dataPath: responseDataPath ?? paginationFromParams?.dataPath,
+      itemType
+    };
+  } else if (paginationFromParams) {
+    pagination = paginationFromParams;
+  }
+  return {
+    operation: {
+      name: inferOperationName(method, path, op.operationId, operationIdTransform),
+      description: buildDescription(op.summary, op.description),
+      httpMethod: method,
+      path,
+      pathParams,
+      queryParams,
+      headerParams,
+      cookieParams: cookieParams.length > 0 ? cookieParams : void 0,
+      requestBody,
+      requestBodyEncoding,
+      response,
+      successResponses,
+      errors,
+      pagination,
+      injectIdempotencyKey: hasIdempotencyHeader,
+      deprecated: op.deprecated || void 0,
+      async: op["x-oagen-async"]
+    },
+    inlineModels
+  };
+}
+function buildDescription(summary, description) {
+  if (summary && description && summary !== description) {
+    return `${summary}
+
+${description}`;
+  }
+  return description ?? summary;
+}
+function extractParams(params, location) {
+  return params.filter((p) => p.in === location).map((p) => ({
+    name: p.name,
+    type: p.schema ? schemaToTypeRef(p.schema, p.name) : { kind: "primitive", type: "string" },
+    required: p.required ?? false,
+    description: p.description,
+    deprecated: p.deprecated || p.schema?.deprecated || void 0,
+    default: p.schema?.default,
+    example: p.example ?? p.schema?.example
+  }));
+}
+function extractRequestBody(body, op, inlineModels) {
+  if (!body?.content) return {};
+  let encoding = "json";
+  let schema;
+  if (body.content["application/json"]?.schema) {
+    encoding = "json";
+    schema = body.content["application/json"].schema;
+  } else if (body.content["multipart/form-data"]?.schema) {
+    encoding = "form-data";
+    schema = body.content["multipart/form-data"].schema;
+  } else if (body.content["application/x-www-form-urlencoded"]?.schema) {
+    encoding = "form-urlencoded";
+    schema = body.content["application/x-www-form-urlencoded"].schema;
+  } else if (body.content["application/octet-stream"]) {
+    encoding = "binary";
+    schema = body.content["application/octet-stream"].schema;
+  } else if (body.content["text/plain"]) {
+    encoding = "text";
+    schema = body.content["text/plain"].schema;
+  }
+  if (!schema) {
+    if (encoding === "binary") {
+      return { body: { kind: "primitive", type: "string", format: "binary" }, encoding };
+    }
+    if (encoding === "text") {
+      return { body: { kind: "primitive", type: "string" }, encoding };
+    }
+    return {};
+  }
+  const rawName = op?.operationId ? toPascalCase(op.operationId) + "Request" : "RequestBody";
+  const contextName = cleanSchemaName(rawName);
+  if (schema.properties && (schema.type === "object" || !schema.type)) {
+    const requiredSet = new Set(schema.required ?? []);
+    const fields = [];
+    for (const [fieldName, fieldSchema] of Object.entries(schema.properties)) {
+      if (!fieldSchema) continue;
+      fields.push(buildFieldFromSchema(fieldName, fieldSchema, contextName, requiredSet));
+    }
+    inlineModels.push({ name: contextName, description: void 0, fields });
+    return { body: { kind: "model", name: contextName }, encoding };
+  }
+  if (schema.oneOf) {
+    const variants = [];
+    for (const variant of schema.oneOf) {
+      if (variant.$ref) {
+        const ref = schemaToTypeRef(variant, contextName);
+        variants.push(ref);
+      } else if (variant.type === "null") {
+      } else if (variant.properties && (variant.type === "object" || !variant.type)) {
+        const variantName = deriveOneOfVariantName(variant, contextName, inlineModels);
+        const requiredSet = new Set(variant.required ?? []);
+        const fields = [];
+        for (const [fieldName, fieldSchema] of Object.entries(variant.properties)) {
+          if (!fieldSchema) continue;
+          fields.push(buildFieldFromSchema(fieldName, fieldSchema, variantName, requiredSet));
+        }
+        inlineModels.push({ name: variantName, description: variant.description, fields });
+        variants.push({ kind: "model", name: variantName });
+      } else {
+        variants.push(schemaToTypeRef(variant, contextName));
+      }
+    }
+    const hasNull = schema.oneOf.some(
+      (v) => v.type === "null" || Array.isArray(v.type) && v.type.includes("null")
+    );
+    const union = {
+      kind: "union",
+      variants,
+      ...schema.discriminator ? {
+        discriminator: { property: schema.discriminator.propertyName, mapping: schema.discriminator.mapping ?? {} }
+      } : {}
+    };
+    const body2 = hasNull ? { kind: "nullable", inner: union } : union;
+    return { body: body2, encoding };
+  }
+  return { body: schemaToTypeRef(schema, contextName), encoding };
+}
+function deriveOneOfVariantName(variant, baseName, existingModels) {
+  if (variant.properties) {
+    for (const [, propSchema] of Object.entries(variant.properties)) {
+      if (propSchema?.const && typeof propSchema.const === "string") {
+        return toPascalCase(propSchema.const) + baseName.replace(/Request$/, "") + "Request";
+      }
+    }
+  }
+  const existingNames = new Set(existingModels.map((m) => m.name));
+  let name = baseName;
+  let suffix = 2;
+  while (existingNames.has(name)) {
+    name = `${baseName}${suffix}`;
+    suffix++;
+  }
+  return name;
+}
+function deriveResponseName(op, path, method) {
+  if (op?.operationId) {
+    return cleanSchemaName(toPascalCase(op.operationId) + "Response");
+  }
+  const segments = path.split("/").filter(Boolean);
+  const resource = segments[0] ?? "Unknown";
+  return toPascalCase(resource) + toPascalCase(method) + "Response";
+}
+function extractResponses(responses, op, path, method) {
+  const errors = [];
+  let response = { kind: "primitive", type: "string" };
+  let inlineModels = [];
+  let isPaginated = false;
+  let dataPath;
+  let itemType;
+  if (!responses) return { response, errors, inlineModels, isPaginated };
+  const allSuccessResponses = [];
+  for (const [statusCode, resp] of Object.entries(responses)) {
+    const code = parseInt(statusCode, 10);
+    if (code >= 200 && code < 300) {
+      let extractedType = { kind: "primitive", type: "unknown" };
+      const jsonContent = resp.content?.["application/json"];
+      if (jsonContent?.schema) {
+        const contextName = deriveResponseName(op, path ?? "/", method ?? "get");
+        const result = classifyAndExtractResponse(jsonContent.schema, contextName);
+        extractedType = result.response;
+        inlineModels = result.inlineModels;
+        isPaginated = result.isPaginated;
+        dataPath = result.dataPath;
+        itemType = result.itemType;
+      } else if (resp.content) {
+        if (resp.content["application/octet-stream"] || resp.content["application/pdf"]) {
+          extractedType = { kind: "primitive", type: "string", format: "binary" };
+        } else if (resp.content["text/plain"] || resp.content["text/html"] || resp.content["text/xml"] || resp.content["application/xml"]) {
+          extractedType = { kind: "primitive", type: "string" };
+        } else {
+          const firstKey = Object.keys(resp.content)[0];
+          if (firstKey) {
+            const firstContent = resp.content[firstKey];
+            if (firstContent?.schema) {
+              extractedType = schemaToTypeRef(
+                firstContent.schema,
+                deriveResponseName(op, path ?? "/", method ?? "get")
+              );
+            }
+          }
+        }
+      }
+      allSuccessResponses.push({ statusCode: code, type: extractedType });
+    } else if (code >= 400) {
+      const jsonContent = resp.content?.["application/json"];
+      const type = jsonContent?.schema ? schemaToTypeRef(jsonContent.schema, `Error${code}`) : void 0;
+      errors.push({ statusCode: code, type });
+    }
+  }
+  if (allSuccessResponses.length > 0) {
+    const sorted = [...allSuccessResponses].sort((a, b) => a.statusCode - b.statusCode);
+    const primary = sorted.find((r) => r.type.kind !== "primitive" || r.type.type !== "unknown") ?? sorted[0];
+    response = primary.type;
+  }
+  const successResponses = allSuccessResponses.length > 1 ? allSuccessResponses : void 0;
+  return { response, successResponses, errors, inlineModels, isPaginated, dataPath, itemType };
+}
+
+// src/parser/normalize-inline-models.ts
+function keepLargestByName(models) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    const existing = byName.get(model.name);
+    if (!existing || model.fields.length > existing.fields.length) {
+      byName.set(model.name, model);
+    }
+  }
+  return [...byName.values()];
+}
+function rewriteModelRefsInServices(services, oldName, newName) {
+  for (const service of services) {
+    for (const op of service.operations) {
+      walkTypeRef(op.response, {
+        model: (r) => {
+          if (r.name === oldName) r.name = newName;
+        }
+      });
+      if (op.requestBody) {
+        walkTypeRef(op.requestBody, {
+          model: (r) => {
+            if (r.name === oldName) r.name = newName;
+          }
+        });
+      }
+    }
+  }
+}
+function mergeInlineResponseModels(schemaModels, inlineModels) {
+  const mergedSchemaModels = [...schemaModels];
+  const schemaModelNames = new Set(mergedSchemaModels.map((m) => m.name));
+  const schemaModelsByName = new Map(mergedSchemaModels.map((m) => [m.name, m]));
+  const deduplicatedInlineModels = inlineModels.filter((model) => {
+    if (!schemaModelNames.has(model.name)) return true;
+    const existing = schemaModelsByName.get(model.name);
+    const existingFieldNames = new Set(existing.fields.map((f) => f.name));
+    const inlineFieldNames = new Set(model.fields.map((f) => f.name));
+    const hasDifference = model.fields.some((f) => !existingFieldNames.has(f.name)) || existing.fields.some((f) => !inlineFieldNames.has(f.name));
+    if (hasDifference && model.fields.length > existing.fields.length) {
+      const idx = mergedSchemaModels.indexOf(existing);
+      if (idx !== -1) mergedSchemaModels[idx] = model;
+      schemaModelsByName.set(model.name, model);
+      console.warn(
+        `[oagen] Warning: Inline model "${model.name}" has more fields than component schema (${model.fields.length} vs ${existing.fields.length}) \u2014 using inline response model`
+      );
+    } else if (hasDifference) {
+      console.warn(
+        `[oagen] Warning: Inline model "${model.name}" has different fields than component schema \u2014 using component schema`
+      );
+    }
+    return false;
+  });
+  return [...mergedSchemaModels, ...keepLargestByName(deduplicatedInlineModels)];
+}
+function mergeFieldInlineModels(existingModels, fieldInlineModels) {
+  const modelNames = new Set(existingModels.map((m) => m.name));
+  const modelsByName = new Map(existingModels.map((m) => [m.name, m]));
+  const deduplicatedFieldModels = fieldInlineModels.filter((model) => {
+    if (!modelNames.has(model.name)) return true;
+    const existing = modelsByName.get(model.name);
+    const existingFieldNames = new Set(existing.fields.map((f) => f.name));
+    const inlineFieldNames = new Set(model.fields.map((f) => f.name));
+    const hasDifference = model.fields.some((f) => !existingFieldNames.has(f.name)) || existing.fields.some((f) => !inlineFieldNames.has(f.name));
+    if (hasDifference) {
+      console.warn(
+        `[oagen] Warning: Inline model "${model.name}" has different fields than component schema \u2014 using component schema`
+      );
+    }
+    return false;
+  });
+  return [...existingModels, ...keepLargestByName(deduplicatedFieldModels)];
+}
+function collapseJsonSuffixModels(models, services) {
+  const normalizedModels = [...models];
+  const byName = new Map(normalizedModels.map((m) => [m.name, m]));
+  for (const model of normalizedModels) {
+    if (!model.name.endsWith("Json")) continue;
+    const baseName = model.name.slice(0, -4);
+    const baseModel = byName.get(baseName);
+    if (!baseModel || model.fields.length <= baseModel.fields.length) continue;
+    const isSuperset = baseModel.fields.every((f) => model.fields.some((mf) => mf.name === f.name));
+    if (!isSuperset) continue;
+    baseModel.fields = model.fields;
+    const jsonIdx = normalizedModels.indexOf(model);
+    if (jsonIdx !== -1) normalizedModels.splice(jsonIdx, 1);
+    rewriteModelRefsInServices(services, model.name, baseName);
+    console.warn(`[oagen] Merged "${model.name}" into "${baseName}" (${model.fields.length} fields, superset)`);
+  }
+  return normalizedModels;
+}
+
+// src/parser/collect-inline-enums.ts
+function collectInlineEnumsFromModels(models, enums) {
+  const enumNames = new Set(enums.map((e) => e.name));
+  for (const model of models) {
+    for (const field of model.fields) {
+      collectInlineEnumFromRef(field.type, enums, enumNames);
+    }
+  }
+}
+
+// src/parser/normalize-model-refs.ts
+function validateModelRefs(spec) {
+  const knownNames = /* @__PURE__ */ new Set();
+  for (const m of spec.models) knownNames.add(m.name);
+  for (const e of spec.enums) knownNames.add(e.name);
+  function walkRef(ref, context) {
+    walkTypeRef(ref, {
+      model: (r) => {
+        if (!knownNames.has(r.name)) {
+          console.warn(`[oagen] Warning: Unresolved model reference "${r.name}" (context: ${context})`);
+        }
+      }
+    });
+  }
+  for (const model of spec.models) {
+    for (const field of model.fields) {
+      walkRef(field.type, `${model.name}.${field.name}`);
+    }
+  }
+  for (const service of spec.services) {
+    for (const op of service.operations) {
+      for (const p of [...op.pathParams, ...op.queryParams, ...op.headerParams]) {
+        walkRef(p.type, `${service.name}.${op.name}.${p.name}`);
+      }
+      if (op.requestBody) walkRef(op.requestBody, `${service.name}.${op.name}.requestBody`);
+      walkRef(op.response, `${service.name}.${op.name}.response`);
+    }
+  }
+}
+
+// src/parser/parse.ts
+async function parseSpec(specPath, options) {
+  const { parsed } = await loadAndBundleSpec(specPath);
+  const spec = parsed;
+  const version = spec.openapi ?? "";
+  if (!version.startsWith("3.")) {
+    throw new SpecParseError(
+      `Unsupported OpenAPI version: ${version}. oagen requires OpenAPI 3.x`,
+      `Update the spec to OpenAPI 3.0 or 3.1. If you are using Swagger 2.x, convert it first with \`npx swagger2openapi ${specPath}\`.`
+    );
+  }
+  const { models, enums } = extractSchemas(
+    spec.components?.schemas
+  );
+  const { services, inlineModels } = extractOperations(
+    spec.paths,
+    options?.operationIdTransform
+  );
+  const responseNormalizedModels = mergeInlineResponseModels(models, inlineModels);
+  const jsonCollapsedModels = collapseJsonSuffixModels(responseNormalizedModels, services);
+  const fieldInlineModels = extractInlineModelsFromSchemas(
+    spec.components?.schemas
+  );
+  const finalModels = mergeFieldInlineModels(jsonCollapsedModels, fieldInlineModels);
+  collectInlineEnumsFromModels(finalModels, enums);
+  const auth = extractAuthSchemes(spec.components?.securitySchemes);
+  const serverEntries = (spec.servers ?? []).map((s) => ({ url: s.url ?? "", description: s.description })).filter((s) => s.url);
+  const result = {
+    name: spec.info?.title ?? "Unknown API",
+    version: spec.info?.version ?? "0.0.0",
+    description: spec.info?.description,
+    baseUrl: serverEntries[0]?.url ?? "",
+    servers: serverEntries.length > 0 ? serverEntries : void 0,
+    services,
+    models: finalModels,
+    enums,
+    auth
+  };
+  validateModelRefs(result);
+  return result;
+}
+function extractAuthSchemes(securitySchemes) {
+  if (!securitySchemes) return void 0;
+  const schemes = [];
+  for (const [, scheme] of Object.entries(securitySchemes)) {
+    if (scheme.type === "http" && scheme.scheme === "bearer") {
+      schemes.push({ kind: "bearer" });
+    } else if (scheme.type === "apiKey" && scheme.in && scheme.name) {
+      schemes.push({ kind: "apiKey", in: scheme.in, name: scheme.name });
+    } else if (scheme.type === "oauth2" && scheme.flows) {
+      schemes.push({ kind: "oauth2", flows: scheme.flows });
+    }
+  }
+  return schemes.length > 0 ? schemes : void 0;
+}
+
+// scripts/smoke/shared.ts
+import "dotenv/config";
+import { readFileSync } from "fs";
+var SKIP_OPERATIONS = /* @__PURE__ */ new Set();
+var SKIP_SERVICES = /* @__PURE__ */ new Set();
+var SERVICE_PRIORITY = {};
+var SERVICE_PROPERTY_MAP = {};
+function loadSmokeConfig(configPath) {
+  if (!configPath) return;
+  const raw = readFileSync(configPath, "utf-8");
+  const config = JSON.parse(raw);
+  if (config.skipOperations) SKIP_OPERATIONS = new Set(config.skipOperations);
+  if (config.skipServices) SKIP_SERVICES = new Set(config.skipServices);
+  if (config.servicePriority) SERVICE_PRIORITY = config.servicePriority;
+  if (config.servicePropertyMap) SERVICE_PROPERTY_MAP = config.servicePropertyMap;
+}
+function operationSortKey(op) {
+  const hasParams = op.pathParams.length > 0;
+  const method = op.httpMethod;
+  if (method === "post" && !hasParams) return 0;
+  if (method === "get" && !hasParams && op.pagination) return 1;
+  if (method === "get" && !hasParams) return 2;
+  if (method === "post" && hasParams) return 3;
+  if (method === "get" && hasParams && op.pagination) return 4;
+  if (method === "get" && hasParams) return 5;
+  if (method === "put" || method === "patch") return 6;
+  if (method === "delete") return 7;
+  return 99;
+}
+function planOperations(spec) {
+  const groups = [];
+  for (const service of spec.services) {
+    if (SKIP_SERVICES.has(service.name)) continue;
+    const ops = [];
+    for (const op of service.operations) {
+      if (SKIP_OPERATIONS.has(op.name)) continue;
+      ops.push({ service: service.name, operation: op });
+    }
+    if (ops.length === 0) continue;
+    ops.sort((a, b) => {
+      return operationSortKey(a.operation) - operationSortKey(b.operation);
+    });
+    groups.push({ service: service.name, operations: ops });
+  }
+  groups.sort((a, b) => {
+    const aPri = SERVICE_PRIORITY[a.service] ?? 50;
+    const bPri = SERVICE_PRIORITY[b.service] ?? 50;
+    return aPri - bPri;
+  });
+  return groups;
+}
+function generateFixtureValue(typeRef, fieldName, spec) {
+  switch (typeRef.kind) {
+    case "primitive":
+      return generatePrimitiveFixture(typeRef.type, typeRef.format, fieldName);
+    case "array":
+      return [generateFixtureValue(typeRef.items, fieldName, spec)];
+    case "model": {
+      const model = spec.models.find((m) => m.name === typeRef.name);
+      if (model) {
+        const obj = {};
+        for (const field of model.fields) {
+          if (field.required) {
+            obj[toSnakeCase(field.name)] = generateFixtureValue(field.type, field.name, spec);
+          }
+        }
+        return obj;
+      }
+      return {};
+    }
+    case "enum": {
+      const e = spec.enums.find((en) => en.name === typeRef.name);
+      return e?.values[0]?.value ?? "unknown";
+    }
+    case "nullable":
+      return generateFixtureValue(typeRef.inner, fieldName, spec);
+    case "union":
+      if (typeRef.variants.length > 0) {
+        return generateFixtureValue(typeRef.variants[0], fieldName, spec);
+      }
+      return null;
+  }
+}
+function generatePrimitiveFixture(type, format, fieldName) {
+  if (type === "string") {
+    if (format === "uuid") return "550e8400-e29b-41d4-a716-446655440000";
+    if (format === "date") return "2024-01-01";
+    if (format === "date-time") return "2024-01-01T00:00:00Z";
+    if (format === "email") return "test@example.com";
+    if (format === "uri" || format === "url") return "https://example.com";
+    return `test_${toSnakeCase(fieldName)}`;
+  }
+  if (type === "integer") return 1;
+  if (type === "number") return 1;
+  if (type === "boolean") return true;
+  return null;
+}
+function generatePayload(op, spec) {
+  if (!op.requestBody) return null;
+  const bodyType = op.requestBody;
+  if (bodyType.kind === "model") {
+    const model = spec.models.find((m) => m.name === bodyType.name);
+    if (!model) return {};
+    const payload = {};
+    for (const field of model.fields) {
+      if (!field.required) continue;
+      const key = toSnakeCase(field.name);
+      let value = generateFixtureValue(field.type, field.name, spec);
+      if ((key === "name" || key === "slug") && typeof value === "string") {
+        value = `smoke-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+      }
+      payload[key] = value;
+    }
+    return payload;
+  }
+  return {};
+}
+function generateQueryParams(op, spec) {
+  const params = {};
+  if (op.pagination) {
+    params["limit"] = "1";
+  }
+  for (const p of op.queryParams) {
+    if (!p.required) continue;
+    const value = generateFixtureValue(p.type, p.name, spec);
+    params[toSnakeCase(p.name)] = String(value);
+  }
+  const sorted = {};
+  for (const key of Object.keys(params).sort()) {
+    sorted[key] = params[key];
+  }
+  return sorted;
+}
+function resolvePath(op, pathParams) {
+  let path = op.path;
+  for (const [name, value] of Object.entries(pathParams)) {
+    path = path.replace(`{${name}}`, value);
+  }
+  return path;
+}
+function parseCliArgs() {
+  const args = process.argv.slice(2);
+  const specIdx = args.indexOf("--spec");
+  const spec = specIdx !== -1 && args[specIdx + 1] ? args[specIdx + 1] : process.env.OPENAPI_SPEC_PATH;
+  if (!spec) {
+    console.error("OpenAPI spec path is required. Set OPENAPI_SPEC_PATH env var or pass --spec <path>.");
+    process.exit(1);
+  }
+  const sdkPathIdx = args.indexOf("--sdk-path");
+  const sdkPath = sdkPathIdx !== -1 && args[sdkPathIdx + 1] ? args[sdkPathIdx + 1] : void 0;
+  const configIdx = args.indexOf("--smoke-config");
+  const smokeConfig = configIdx !== -1 && args[configIdx + 1] ? args[configIdx + 1] : process.env.SMOKE_CONFIG;
+  return { spec, sdkPath, smokeConfig };
+}
+
+// scripts/smoke/baseline.ts
+async function main() {
+  const { spec: specPath, smokeConfig } = parseCliArgs();
+  loadSmokeConfig(smokeConfig);
+  console.log("Parsing spec...");
+  const spec = await parseSpec(specPath);
+  console.log(`Spec: ${spec.name} v${spec.version}`);
+  const groups = planOperations(spec);
+  const exchanges = [];
+  for (const group of groups) {
+    for (const planned of group.operations) {
+      const op = planned.operation;
+      const operationId = `${group.service}.${op.name}`;
+      const placeholderParams = {};
+      for (const p of op.pathParams) {
+        placeholderParams[p.name] = "<ID>";
+      }
+      const path = resolvePath(op, placeholderParams);
+      const queryParams = generateQueryParams(op, spec);
+      const body = generatePayload(op, spec);
+      const defaultSuccess = {
+        post: 201,
+        get: 200,
+        put: 200,
+        patch: 200,
+        delete: 204
+      };
+      const status = defaultSuccess[op.httpMethod] ?? 200;
+      exchanges.push({
+        operationId,
+        service: group.service,
+        operationName: op.name,
+        request: {
+          method: op.httpMethod.toUpperCase(),
+          path,
+          queryParams,
+          body
+        },
+        response: {
+          status,
+          body: null
+        },
+        outcome: "success",
+        durationMs: 0
+      });
+    }
+  }
+  const results = {
+    source: "spec-baseline",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    specVersion: spec.version,
+    exchanges
+  };
+  writeFileSync("smoke-results-spec-baseline.json", JSON.stringify(results, null, 2));
+  console.log(`
+Generated ${exchanges.length} operations from spec`);
+  console.log("Written to smoke-results-spec-baseline.json");
+}
+main().catch((err) => {
+  console.error("Baseline generation failed:", err);
+  process.exit(1);
+});