swagger-digest 0.0.0-stage → 0.1.1

package/dist/chunk-UZQM2SHL.js

@@ -0,0 +1,1412 @@
+// src/fetcher.ts
+import { load } from "cheerio";
+import { parse as parseYaml } from "yaml";
+var SPEC_FILE_EXTENSION = /\.(?:json|ya?ml)$/i;
+var FALLBACK_PATHS = ["/v3/api-docs", "/swagger/v1/swagger.json", "/swagger.json", "/openapi.json", "/api-docs"];
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isOpenApiSpec(value) {
+  if (!isRecord(value)) return false;
+  const hasVersion = typeof value.openapi === "string" || typeof value.swagger === "string";
+  const hasInfo = isRecord(value.info) && typeof value.info.title === "string";
+  const hasPaths = value.paths === void 0 || isRecord(value.paths);
+  return hasVersion && hasInfo && hasPaths;
+}
+function parseSpecText(text, source = "response") {
+  const parsers = [() => JSON.parse(text), () => parseYaml(text)];
+  const errors = [];
+  for (const parser of parsers) {
+    try {
+      const parsed = parser();
+      if (isOpenApiSpec(parsed)) return parsed;
+      errors.push("document is not a recognizable OpenAPI/Swagger specification");
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+    }
+  }
+  throw new Error(`Could not parse OpenAPI spec from ${source}: ${[...new Set(errors)].join("; ")}`);
+}
+function isDirectSpecUrl(url) {
+  return SPEC_FILE_EXTENSION.test(url.pathname);
+}
+async function fetchText(url, timeoutMs) {
+  const response = await fetch(url, {
+    headers: {
+      accept: "application/json, application/yaml, text/yaml, text/plain, text/html;q=0.8, */*;q=0.5",
+      "user-agent": "swagger-digest/0.1.0"
+    },
+    signal: AbortSignal.timeout(timeoutMs),
+    redirect: "follow"
+  });
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status} ${response.statusText} for ${url}`);
+  }
+  return {
+    text: await response.text(),
+    contentType: response.headers.get("content-type") ?? ""
+  };
+}
+function extractScripts(html) {
+  const $ = load(html);
+  const inline = [];
+  const external = [];
+  $("script").each((_index, element) => {
+    const body = $(element).html();
+    if (body?.trim()) inline.push(body);
+    const src = $(element).attr("src");
+    if (src?.trim()) external.push(src.trim());
+  });
+  return { inline, external };
+}
+function extractSpecUrlFromScripts(scripts, pageUrl) {
+  const urlPattern = /\burl\s*:\s*(["'])(.*?)\1/s;
+  for (const script of scripts) {
+    const match = urlPattern.exec(script);
+    if (!match?.[2]) continue;
+    const candidate = match[2].trim();
+    if (!candidate || candidate.startsWith("data:")) continue;
+    try {
+      return new URL(candidate, pageUrl).toString();
+    } catch {
+    }
+  }
+  return void 0;
+}
+function extractSpecUrl(scripts, pageUrl) {
+  const fromScript = extractSpecUrlFromScripts(scripts, pageUrl);
+  if (fromScript) return fromScript;
+  const queryUrl = pageUrl.searchParams.get("url");
+  if (queryUrl) {
+    try {
+      return new URL(queryUrl, pageUrl).toString();
+    } catch {
+    }
+  }
+  return void 0;
+}
+async function fetchExternalConfigScripts(srcs, pageUrl, timeoutMs, errors) {
+  const candidates = srcs.map((src) => {
+    try {
+      return new URL(src, pageUrl);
+    } catch {
+      return void 0;
+    }
+  }).filter((url) => Boolean(url && url.origin === pageUrl.origin && /\.m?js(?:$|[?#])/i.test(url.href)));
+  const priority = (url) => /swagger[-_]?initializer|swagger[-_]?config|swagger[-_]?ui[-_]?init|openapi[-_]?config|(?:^|[\/_-])config(?:[._/-]|$)/i.test(
+    url.pathname
+  ) ? 0 : 1;
+  candidates.sort((a, b) => priority(a) - priority(b));
+  const scripts = [];
+  for (const candidate of candidates.slice(0, 10)) {
+    try {
+      const response = await fetchText(candidate.toString(), timeoutMs);
+      scripts.push(response.text);
+      if (extractSpecUrlFromScripts(scripts, pageUrl) || scripts.some((script) => findObjectLiteralAfterKey(script, "spec"))) {
+        break;
+      }
+    } catch (error) {
+      errors.push(`Swagger UI script (${candidate}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return scripts;
+}
+function getFallbackUrls(pageUrl) {
+  const relativePaths = [
+    "./v3/api-docs",
+    "./swagger/v1/swagger.json",
+    "./swagger.json",
+    "./openapi.json",
+    "./api-docs",
+    "./doc.json",
+    "../v3/api-docs",
+    "../swagger/v1/swagger.json",
+    "../swagger.json",
+    "../openapi.json",
+    "../api-docs"
+  ];
+  const absolutePaths = [...relativePaths, ...FALLBACK_PATHS];
+  return [...new Set(absolutePaths.map((path2) => new URL(path2, pageUrl).toString()))];
+}
+function formatAttemptErrors(errors) {
+  if (errors.length <= 10) return errors.join("\n  - ");
+  const visible = [...errors.slice(0, 6), `\u2026 ${errors.length - 9} additional attempts omitted \u2026`, ...errors.slice(-3)];
+  return visible.join("\n  - ");
+}
+function findObjectLiteralAfterKey(source, key) {
+  const keyPattern = new RegExp(`\\b${key}\\s*:`);
+  const match = keyPattern.exec(source);
+  if (!match) return void 0;
+  let index = match.index + match[0].length;
+  while (/\s/.test(source[index] ?? "")) index += 1;
+  if (source[index] !== "{") return void 0;
+  const start = index;
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  let lineComment = false;
+  let blockComment = false;
+  for (; index < source.length; index += 1) {
+    const char = source[index] ?? "";
+    const next = source[index + 1] ?? "";
+    if (lineComment) {
+      if (char === "\n") lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        index += 1;
+      }
+      continue;
+    }
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = void 0;
+      }
+      continue;
+    }
+    if (char === "/" && next === "/") {
+      lineComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      index += 1;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return source.slice(start, index + 1);
+    }
+  }
+  return void 0;
+}
+function parseInlineObjectLiteral(literal) {
+  const candidates = [
+    () => JSON.parse(literal),
+    () => parseYaml(literal),
+    // Swagger config often uses JS object syntax with trailing commas.
+    () => JSON.parse(literal.replace(/,\s*([}\]])/g, "$1"))
+  ];
+  for (const parse of candidates) {
+    try {
+      const result = parse();
+      if (isOpenApiSpec(result)) return result;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function extractInlineSpec(scripts) {
+  for (const script of scripts) {
+    const literal = findObjectLiteralAfterKey(script, "spec");
+    if (!literal) continue;
+    const spec = parseInlineObjectLiteral(literal);
+    if (spec) return spec;
+  }
+  return void 0;
+}
+async function tryFetchSpec(url, timeoutMs) {
+  const response = await fetchText(url, timeoutMs);
+  return parseSpecText(response.text, url);
+}
+async function tryBrowserFallback(pageUrl) {
+  let playwright;
+  try {
+    const optionalModuleName = "playwright";
+    playwright = await import(optionalModuleName);
+  } catch {
+    throw new Error(
+      "Headless fallback needs optional Playwright. Install it with `npm install playwright` and `npx playwright install chromium`, then rerun."
+    );
+  }
+  const browser = await playwright.chromium.launch({ headless: true });
+  try {
+    const page = await browser.newPage();
+    await page.goto(pageUrl, { waitUntil: "domcontentloaded", timeout: 3e4 });
+    await page.waitForFunction(
+      () => {
+        const w = window;
+        try {
+          const candidate = w.ui?.spec?.();
+          const document = candidate && typeof candidate.toJSON === "function" ? candidate.toJSON() : candidate;
+          return Boolean(document?.openapi || document?.swagger || w.swaggerDoc?.openapi || w.swaggerDoc?.swagger);
+        } catch {
+          return Boolean(w.swaggerDoc?.openapi || w.swaggerDoc?.swagger);
+        }
+      },
+      void 0,
+      { timeout: 8e3 }
+    ).catch(() => void 0);
+    const extracted = await page.evaluate(() => {
+      const w = window;
+      try {
+        const spec = w.ui?.spec?.();
+        if (spec) {
+          const json = typeof spec.toJSON === "function" ? spec.toJSON() : spec;
+          if (json && typeof json === "object") return json;
+        }
+      } catch {
+      }
+      if (w.swaggerDoc && typeof w.swaggerDoc === "object") return w.swaggerDoc;
+      try {
+        const state = w.ui?.getSystem?.().specSelectors?.specJson?.();
+        if (state) return typeof state.toJS === "function" ? state.toJS() : state;
+      } catch {
+      }
+      return null;
+    });
+    if (!isOpenApiSpec(extracted)) {
+      throw new Error("The page loaded in a browser, but no parsed OpenAPI spec was exposed by Swagger UI.");
+    }
+    return extracted;
+  } finally {
+    await browser.close();
+  }
+}
+async function fetchOpenApiSpec(input, options = {}) {
+  let pageUrl;
+  try {
+    pageUrl = new URL(input);
+  } catch {
+    throw new Error(`Invalid URL: ${input}`);
+  }
+  if (!["http:", "https:"].includes(pageUrl.protocol)) {
+    throw new Error("Only HTTP and HTTPS URLs are supported.");
+  }
+  const timeoutMs = options.timeoutMs ?? 15e3;
+  const errors = [];
+  if (isDirectSpecUrl(pageUrl)) {
+    try {
+      const spec = await tryFetchSpec(pageUrl.toString(), timeoutMs);
+      return { spec, sourceUrl: pageUrl.toString(), retrievalMethod: "direct-spec" };
+    } catch (error) {
+      errors.push(`Direct spec: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  let html;
+  try {
+    const response = await fetchText(pageUrl.toString(), timeoutMs);
+    try {
+      const spec = parseSpecText(response.text, pageUrl.toString());
+      return { spec, sourceUrl: pageUrl.toString(), retrievalMethod: "direct-spec" };
+    } catch {
+      html = response.text;
+    }
+  } catch (error) {
+    errors.push(`Swagger UI page: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (html !== void 0) {
+    const pageScripts = extractScripts(html);
+    let scripts = pageScripts.inline;
+    let specUrl = extractSpecUrl(scripts, pageUrl);
+    const inlineSpec = extractInlineSpec(scripts);
+    if (inlineSpec) {
+      return { spec: inlineSpec, sourceUrl: pageUrl.toString(), retrievalMethod: "inline-spec" };
+    }
+    if (specUrl) {
+      try {
+        const spec = await tryFetchSpec(specUrl, timeoutMs);
+        return { spec, sourceUrl: specUrl, retrievalMethod: "html-config" };
+      } catch (error) {
+        errors.push(`Configured spec (${specUrl}): ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    const externalScripts = await fetchExternalConfigScripts(pageScripts.external, pageUrl, timeoutMs, errors);
+    scripts = [...scripts, ...externalScripts];
+    specUrl = extractSpecUrl(scripts, pageUrl);
+    if (specUrl && specUrl !== pageUrl.searchParams.get("url")) {
+      try {
+        const spec = await tryFetchSpec(specUrl, timeoutMs);
+        return { spec, sourceUrl: specUrl, retrievalMethod: "html-config" };
+      } catch (error) {
+        errors.push(`Configured spec (${specUrl}): ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    for (const script of scripts) {
+      const literal = findObjectLiteralAfterKey(script, "spec");
+      if (!literal) continue;
+      const spec = parseInlineObjectLiteral(literal);
+      if (spec) return { spec, sourceUrl: pageUrl.toString(), retrievalMethod: "inline-spec" };
+    }
+  }
+  for (const candidate of getFallbackUrls(pageUrl)) {
+    try {
+      const spec = await tryFetchSpec(candidate, timeoutMs);
+      return { spec, sourceUrl: candidate, retrievalMethod: "fallback-path" };
+    } catch (error) {
+      errors.push(`${candidate}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  if (options.useBrowserFallback !== false) {
+    try {
+      const spec = await tryBrowserFallback(pageUrl.toString());
+      return { spec, sourceUrl: pageUrl.toString(), retrievalMethod: "headless-browser" };
+    } catch (error) {
+      errors.push(`Headless browser: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  const details = formatAttemptErrors(errors);
+  throw new Error(
+    `Unable to extract an OpenAPI definition from ${input}.
+  - ${details}
+
+Check that the URL is reachable from this terminal and points to a Swagger UI page or OpenAPI spec. If it opens only in a browser, verify that your VPN applies to terminal applications (browser VPN extensions do not automatically route Node.js requests). For JavaScript-only Swagger UI deployments, install Playwright and its Chromium browser; Playwright will also need the same network/VPN access.`
+  );
+}
+
+// src/transformer.ts
+var HTTP_METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+var COMMON_ERROR_CODES = /* @__PURE__ */ new Set([
+  "400",
+  "401",
+  "403",
+  "404",
+  "405",
+  "409",
+  "415",
+  "422",
+  "429",
+  "500",
+  "501",
+  "502",
+  "503",
+  "default"
+]);
+function isObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function entries(value) {
+  return isObject(value) ? Object.entries(value) : [];
+}
+function cleanText(value) {
+  return typeof value === "string" ? value.trim().replace(/\s+/g, " ") : "";
+}
+function markdownCell(value) {
+  return cleanText(value).replace(/\|/g, "\\|").replace(/`/g, "\\`") || "\u2014";
+}
+function safeSourceUrl(value) {
+  try {
+    const url = new URL(value);
+    url.username = "";
+    url.password = "";
+    for (const key of [...url.searchParams.keys()]) {
+      if (/(token|secret|password|signature|credential|api[-_]?key|authorization|auth)/i.test(key)) {
+        url.searchParams.set(key, "[redacted]");
+      }
+    }
+    return url.toString();
+  } catch {
+    return value;
+  }
+}
+function safeComment(value) {
+  return cleanText(value).replace(/\*\//g, "* /").replace(/[\r\n]+/g, " ");
+}
+function schemaMetadata(schemaValue) {
+  if (!isObject(schemaValue)) return [];
+  const schema = schemaValue;
+  const metadata = [];
+  if (cleanText(schema.description)) metadata.push(cleanText(schema.description));
+  if (cleanText(schema.format)) metadata.push(`format: ${cleanText(schema.format)}`);
+  const constraints = [
+    ["default", "default"],
+    ["pattern", "pattern"],
+    ["minLength", "minLength"],
+    ["maxLength", "maxLength"],
+    ["minimum", "minimum"],
+    ["maximum", "maximum"],
+    ["exclusiveMinimum", "exclusiveMinimum"],
+    ["exclusiveMaximum", "exclusiveMaximum"],
+    ["minItems", "minItems"],
+    ["maxItems", "maxItems"],
+    ["uniqueItems", "uniqueItems"],
+    ["multipleOf", "multipleOf"]
+  ];
+  for (const [property, label] of constraints) {
+    const value = schema[property];
+    if (value === void 0) continue;
+    if (property === "default" && (value === null || value === "")) continue;
+    metadata.push(
+      `${label}: ${property === "default" ? JSON.stringify(value) : typeof value === "string" ? value : JSON.stringify(value)}`
+    );
+  }
+  if (schema.readOnly === true) metadata.push("read-only");
+  if (schema.writeOnly === true) metadata.push("write-only");
+  if (schema.deprecated === true) metadata.push("deprecated");
+  return [...new Set(metadata)];
+}
+function toTypeScriptIdentifier(value) {
+  let identifier = value.replace(/[^\p{L}\p{N}_$]+/gu, "_").replace(/^([^\p{L}_$])/u, "_$1");
+  if (!identifier) identifier = "Unnamed";
+  const reserved = /* @__PURE__ */ new Set([
+    "abstract",
+    "any",
+    "as",
+    "asserts",
+    "async",
+    "await",
+    "boolean",
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "constructor",
+    "continue",
+    "debugger",
+    "declare",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "from",
+    "function",
+    "get",
+    "if",
+    "implements",
+    "import",
+    "in",
+    "infer",
+    "instanceof",
+    "interface",
+    "is",
+    "keyof",
+    "let",
+    "module",
+    "namespace",
+    "never",
+    "new",
+    "null",
+    "number",
+    "object",
+    "of",
+    "package",
+    "private",
+    "protected",
+    "public",
+    "readonly",
+    "require",
+    "return",
+    "set",
+    "static",
+    "string",
+    "super",
+    "switch",
+    "symbol",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "type",
+    "typeof",
+    "undefined",
+    "unique",
+    "unknown",
+    "var",
+    "void",
+    "while",
+    "with",
+    "yield"
+  ]);
+  if (reserved.has(identifier)) identifier = `${identifier}Model`;
+  return identifier;
+}
+function propertyKey(value) {
+  return /^[$A-Z_a-z][$\w]*$/.test(value) ? value : JSON.stringify(value);
+}
+function refName(ref) {
+  const parts = ref.split("/");
+  const last = parts[parts.length - 1];
+  if (!last) return void 0;
+  const decoded = last.replace(/~1/g, "/").replace(/~0/g, "~");
+  return toTypeScriptIdentifier(decoded);
+}
+function isSchemaRef(ref) {
+  return ref.includes("/components/schemas/") || ref.includes("/definitions/");
+}
+function nullableType(type, schema) {
+  const typeList = Array.isArray(schema.type) ? schema.type : [];
+  if (schema.nullable === true || typeList.includes("null")) {
+    if (!type.split(/\s*\|\s*/).includes("null")) return `${parenthesizeUnion(type)} | null`;
+  }
+  return type;
+}
+function parenthesizeUnion(type) {
+  return type.includes(" | ") ? `(${type})` : type;
+}
+function literalType(value) {
+  if (typeof value === "string") return JSON.stringify(value);
+  if (value === null) return "null";
+  if (typeof value === "number" || typeof value === "boolean") return String(value);
+  return "unknown";
+}
+function typeExpression(schemaValue, depth = 0) {
+  if (depth > 12 || !isObject(schemaValue)) return "unknown";
+  const schema = schemaValue;
+  if (typeof schema.$ref === "string") {
+    return refName(schema.$ref) ?? "unknown";
+  }
+  if (schema.const !== void 0) return nullableType(literalType(schema.const), schema);
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    return nullableType([...new Set(schema.enum.map(literalType))].join(" | "), schema);
+  }
+  if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0) {
+    return nullableType(schema.oneOf.map((item) => typeExpression(item, depth + 1)).join(" | "), schema);
+  }
+  if (Array.isArray(schema.anyOf) && schema.anyOf.length > 0) {
+    return nullableType(schema.anyOf.map((item) => typeExpression(item, depth + 1)).join(" | "), schema);
+  }
+  if (Array.isArray(schema.allOf) && schema.allOf.length > 0) {
+    const components = schema.allOf.map((item) => typeExpression(item, depth + 1));
+    if (schema.properties || schema.additionalProperties !== void 0) {
+      components.push(
+        typeExpression(
+          {
+            type: "object",
+            properties: schema.properties,
+            required: schema.required,
+            additionalProperties: schema.additionalProperties
+          },
+          depth + 1
+        )
+      );
+    }
+    return nullableType(components.join(" & "), schema);
+  }
+  const rawType = Array.isArray(schema.type) ? schema.type.filter((item) => item !== "null") : schema.type;
+  const type = Array.isArray(rawType) ? rawType[0] : rawType;
+  if (type === "array" || schema.items) {
+    const itemType = typeExpression(schema.items, depth + 1);
+    return nullableType(`${itemType.includes(" | ") ? `(${itemType})` : itemType}[]`, schema);
+  }
+  if (type === "object" || schema.properties || schema.additionalProperties !== void 0) {
+    const properties = entries(schema.properties);
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    const lines = properties.map(([name, propertySchema]) => {
+      const metadata = schemaMetadata(propertySchema).map(safeComment).filter(Boolean).join("; ");
+      const comment = metadata ? `/** ${metadata} */ ` : "";
+      return `${comment}${propertyKey(name)}${required.has(name) ? "" : "?"}: ${typeExpression(propertySchema, depth + 1)};`;
+    });
+    if (schema.additionalProperties === true) lines.push("[key: string]: unknown;");
+    else if (isObject(schema.additionalProperties))
+      lines.push(`[key: string]: ${typeExpression(schema.additionalProperties, depth + 1)};`);
+    return nullableType(lines.length ? `{ ${lines.join(" ")} }` : "Record<string, unknown>", schema);
+  }
+  let base;
+  switch (type) {
+    case "string":
+    case "file":
+      base = cleanText(schema.format) ? `string /* ${safeComment(schema.format)} */` : "string";
+      break;
+    case "integer":
+    case "number":
+      base = "number";
+      break;
+    case "boolean":
+      base = "boolean";
+      break;
+    case "null":
+      base = "null";
+      break;
+    default:
+      base = "unknown";
+  }
+  return nullableType(base, schema);
+}
+function getSchemaDictionary(spec) {
+  const schemas = spec.components?.schemas ?? spec.definitions ?? {};
+  return isObject(schemas) ? schemas : {};
+}
+function collectSchemaRefs(value, output, root, seen = /* @__PURE__ */ new Set(), followedRefs = /* @__PURE__ */ new Set()) {
+  if (!value || typeof value !== "object" || seen.has(value)) return;
+  seen.add(value);
+  if (Array.isArray(value)) {
+    for (const item of value) collectSchemaRefs(item, output, root, seen, followedRefs);
+    return;
+  }
+  const object = value;
+  if (typeof object.$ref === "string") {
+    if (isSchemaRef(object.$ref)) {
+      const name = refName(object.$ref);
+      if (name) output.add(name);
+    } else if (root && object.$ref.startsWith("#/") && !followedRefs.has(object.$ref)) {
+      followedRefs.add(object.$ref);
+      const target = resolvePointer(root, object.$ref);
+      if (target !== void 0) collectSchemaRefs(target, output, root, seen, followedRefs);
+    }
+  }
+  for (const [key, child] of Object.entries(object)) {
+    if (key !== "example" && key !== "examples" && key !== "externalDocs")
+      collectSchemaRefs(child, output, root, seen, followedRefs);
+  }
+}
+function referencedSchemas(spec) {
+  const dictionary = getSchemaDictionary(spec);
+  const knownByName = /* @__PURE__ */ new Map();
+  for (const [name, schema] of Object.entries(dictionary)) {
+    knownByName.set(toTypeScriptIdentifier(name), [name, schema]);
+  }
+  const refs = /* @__PURE__ */ new Set();
+  collectSchemaRefs(spec.paths ?? {}, refs, spec);
+  const selected = /* @__PURE__ */ new Set();
+  const queue = [...refs];
+  while (queue.length) {
+    const name = queue.shift();
+    if (!name || selected.has(name)) continue;
+    selected.add(name);
+    const model = knownByName.get(name);
+    if (!model) continue;
+    const childRefs = /* @__PURE__ */ new Set();
+    collectSchemaRefs(model[1], childRefs, spec);
+    for (const child of childRefs) if (!selected.has(child)) queue.push(child);
+  }
+  return [...selected].map((name) => knownByName.get(name)).filter((entry) => Boolean(entry));
+}
+function modelDeclaration(name, schema) {
+  const identifier = toTypeScriptIdentifier(name);
+  const description = safeComment(schema.description);
+  const comment = description ? `/** ${description} */
+` : "";
+  if (schema.$ref) return `${comment}export type ${identifier} = ${typeExpression(schema)};`;
+  if (Array.isArray(schema.enum) || schema.const !== void 0 || schema.oneOf || schema.anyOf || schema.allOf) {
+    return `${comment}export type ${identifier} = ${typeExpression(schema)};`;
+  }
+  const kind = Array.isArray(schema.type) ? schema.type.find((item) => item !== "null") : schema.type;
+  if (kind === "object" || schema.properties || schema.additionalProperties !== void 0) {
+    const properties = entries(schema.properties);
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    const fields = properties.map(([field, value]) => {
+      const metadata = schemaMetadata(value).map(safeComment).filter(Boolean).join("; ");
+      const doc = metadata ? `    /** ${metadata} */
+` : "";
+      return `${doc}    ${propertyKey(field)}${required.has(field) ? "" : "?"}: ${typeExpression(value)};`;
+    });
+    if (schema.additionalProperties === true) fields.push("    [key: string]: unknown;");
+    else if (isObject(schema.additionalProperties))
+      fields.push(`    [key: string]: ${typeExpression(schema.additionalProperties)};`);
+    return `${comment}export interface ${identifier} {
+${fields.join("\n")}
+}`;
+  }
+  return `${comment}export type ${identifier} = ${typeExpression(schema)};`;
+}
+function resolvePointer(root, ref) {
+  if (!ref.startsWith("#/")) return void 0;
+  let current = root;
+  for (const rawPart of ref.slice(2).split("/")) {
+    const part = rawPart.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (!isObject(current)) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function resolveReferenceObject(spec, value, seen = /* @__PURE__ */ new Set()) {
+  if (!isObject(value)) return {};
+  if (typeof value.$ref !== "string") return value;
+  const ref = value.$ref;
+  if (seen.has(ref)) return {};
+  const target = resolvePointer(spec, ref);
+  if (!isObject(target)) return value;
+  const nextSeen = new Set(seen).add(ref);
+  return {
+    ...resolveReferenceObject(spec, target, nextSeen),
+    ...Object.fromEntries(Object.entries(value).filter(([key]) => key !== "$ref"))
+  };
+}
+function getEndpoints(spec) {
+  const result = [];
+  const paths = isObject(spec.paths) ? spec.paths : {};
+  for (const [path2, pathItemValue] of Object.entries(paths)) {
+    if (!isObject(pathItemValue)) continue;
+    const pathParameters = Array.isArray(pathItemValue.parameters) ? pathItemValue.parameters.map((parameter) => resolveReferenceObject(spec, parameter)) : [];
+    for (const method of HTTP_METHODS) {
+      const operationValue = pathItemValue[method];
+      if (!isObject(operationValue)) continue;
+      const firstTag = Array.isArray(operationValue.tags) && operationValue.tags.length ? String(operationValue.tags[0]) : "General";
+      result.push({ method, path: path2, operation: operationValue, pathParameters, tag: firstTag });
+    }
+  }
+  return result;
+}
+function getServers(spec) {
+  if (Array.isArray(spec.servers) && spec.servers.length) {
+    return spec.servers.map((server) => cleanText(server?.url)).filter(Boolean);
+  }
+  if (isObject(spec)) {
+    const host = cleanText(spec.host);
+    if (host) {
+      const schemes = Array.isArray(spec.schemes) && spec.schemes.length ? spec.schemes : ["https"];
+      const basePath = cleanText(spec.basePath) || "/";
+      return schemes.map(
+        (scheme) => `${scheme}://${host}${basePath.startsWith("/") ? basePath : `/${basePath}`}`
+      );
+    }
+  }
+  return [];
+}
+function describeSecurityScheme(name, scheme) {
+  const type = cleanText(scheme.type).toLowerCase();
+  const label = cleanText(scheme.description);
+  let details = name;
+  if (type === "http" && cleanText(scheme.scheme).toLowerCase() === "bearer")
+    details += " (Bearer token via Authorization header)";
+  else if (type === "http" && cleanText(scheme.scheme).toLowerCase() === "basic")
+    details += " (HTTP Basic via Authorization header)";
+  else if (type === "apikey" || type === "apiKey")
+    details += ` (API key in ${cleanText(scheme.in) || "header"}: ${cleanText(scheme.name) || "key"})`;
+  else if (type === "oauth2") {
+    const flows = entries(scheme.flows).map(([flowName]) => flowName).join(", ") || cleanText(scheme.flow);
+    details += ` (OAuth2${flows ? `; ${flows}` : ""})`;
+  } else if (type === "openidconnect" || type === "openIdConnect") details += " (OpenID Connect)";
+  else if (type === "basic") details += " (HTTP Basic)";
+  else if (type) details += ` (${type})`;
+  if (label) details += ` \u2014 ${label}`;
+  return details;
+}
+function getSecuritySchemes(spec) {
+  const dictionary = spec.components?.securitySchemes ?? spec.securityDefinitions ?? {};
+  return entries(dictionary).filter((entry) => isObject(entry[1]));
+}
+function securityRequirement(spec, operation) {
+  const security = operation.security !== void 0 ? operation.security : spec.security;
+  if (!Array.isArray(security) || security.length === 0) return "None explicitly required";
+  const allSchemes = new Map(getSecuritySchemes(spec));
+  return security.map((requirement) => {
+    if (!isObject(requirement)) return "";
+    const names = Object.entries(requirement).map(([name, scopes]) => {
+      const label = allSchemes.has(name) ? name : `${name} (scheme not defined)`;
+      return Array.isArray(scopes) && scopes.length ? `${label} [scopes: ${scopes.join(", ")}]` : label;
+    });
+    return names.length ? names.join(" + ") : "No auth";
+  }).filter(Boolean).join(" OR ");
+}
+function mergedParameters(spec, endpoint) {
+  const operationParameters = Array.isArray(endpoint.operation.parameters) ? endpoint.operation.parameters.map((parameter) => resolveReferenceObject(spec, parameter)) : [];
+  const byIdentity = /* @__PURE__ */ new Map();
+  for (const parameter of [...endpoint.pathParameters, ...operationParameters]) {
+    if (parameter.in === "body") continue;
+    const key = `${cleanText(parameter.in)}:${cleanText(parameter.name)}`;
+    if (key !== ":") byIdentity.set(key, parameter);
+  }
+  return [...byIdentity.values()];
+}
+function parameterType(parameter) {
+  if (isObject(parameter.schema)) return typeExpression(parameter.schema);
+  if (parameter.type === "array") return `${typeExpression(parameter.items)}[]`;
+  if (parameter.type) return typeExpression({ type: parameter.type, format: parameter.format, enum: parameter.enum });
+  return "unknown";
+}
+function parameterDisplayType(parameter) {
+  return parameterType(parameter).replace(/\/\*\s*([^*]+?)\s*\*\//g, "($1)");
+}
+function parameterDefault(parameter) {
+  if (parameter.default !== void 0) return parameter.default;
+  if (isObject(parameter.schema)) return parameter.schema.default;
+  return void 0;
+}
+function isMeaningfulDefault(value) {
+  return value !== void 0 && value !== null && value !== "";
+}
+function parameterList(parameters) {
+  if (!parameters.length) return "_None._";
+  return parameters.map((parameter) => {
+    const required = parameter.required === true || parameter.in === "path";
+    const type = parameterDisplayType(parameter);
+    const defaultValue = parameterDefault(parameter);
+    const defaultSuffix = isMeaningfulDefault(defaultValue) ? ` (default: ${typeof defaultValue === "string" ? JSON.stringify(defaultValue) : String(defaultValue)})` : "";
+    const description = cleanText(parameter.description);
+    const details = description ? ` \u2014 ${description}` : "";
+    return `- \`${cleanText(parameter.name)}\` (\`${cleanText(parameter.in)}\`${required ? ", required" : ""}) \xB7 \`${type}\`${defaultSuffix}${details}`;
+  }).join("\n");
+}
+function chooseMediaType(content) {
+  const mediaTypes = Object.keys(content);
+  return mediaTypes.find((type) => type.toLowerCase() === "application/json") ?? mediaTypes.find((type) => type.toLowerCase().includes("+json")) ?? mediaTypes[0];
+}
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function firstDeclaredExample(spec, schemaValue, seen = /* @__PURE__ */ new Set()) {
+  if (!isObject(schemaValue)) return void 0;
+  let schema = schemaValue;
+  if (typeof schema.$ref === "string") {
+    if (seen.has(schema.$ref)) return void 0;
+    const target = resolvePointer(spec, schema.$ref);
+    if (!isObject(target)) return void 0;
+    const nextSeen = new Set(seen).add(schema.$ref);
+    schema = { ...target, ...Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "$ref")) };
+    const nested = firstDeclaredExample(spec, schema, nextSeen);
+    if (nested !== void 0) return nested;
+  }
+  if (hasOwn(schema, "example")) return schema.example;
+  if (Array.isArray(schema.examples) && schema.examples.length) return schema.examples[0];
+  return void 0;
+}
+function generateSchemaExample(spec, schemaValue, depth = 0, seenRefs = /* @__PURE__ */ new Set()) {
+  if (depth > 12 || !isObject(schemaValue)) return void 0;
+  let schema = schemaValue;
+  let nextSeen = seenRefs;
+  if (typeof schema.$ref === "string") {
+    if (seenRefs.has(schema.$ref)) return null;
+    const target = resolvePointer(spec, schema.$ref);
+    if (!isObject(target)) return void 0;
+    nextSeen = new Set(seenRefs).add(schema.$ref);
+    schema = { ...target, ...Object.fromEntries(Object.entries(schema).filter(([key]) => key !== "$ref")) };
+  }
+  if (hasOwn(schema, "example")) return schema.example;
+  if (Array.isArray(schema.examples) && schema.examples.length) return schema.examples[0];
+  if (schema.default !== void 0) return schema.default;
+  if (schema.const !== void 0) return schema.const;
+  if (Array.isArray(schema.enum) && schema.enum.length) return schema.enum[0];
+  for (const composition of ["oneOf", "anyOf"]) {
+    if (Array.isArray(schema[composition]) && schema[composition].length) {
+      return generateSchemaExample(spec, schema[composition][0], depth + 1, nextSeen);
+    }
+  }
+  if (Array.isArray(schema.allOf) && schema.allOf.length) {
+    const values = schema.allOf.map((part) => generateSchemaExample(spec, part, depth + 1, nextSeen)).filter((part) => part !== void 0);
+    if (values.every((part) => isObject(part))) return Object.assign({}, ...values);
+    return values[0];
+  }
+  const rawType = Array.isArray(schema.type) ? schema.type.find((item) => item !== "null") : schema.type;
+  const type = rawType ?? (schema.properties || schema.additionalProperties !== void 0 ? "object" : void 0);
+  if (type === "array" || schema.items || schema.prefixItems) {
+    const tupleSchemas = Array.isArray(schema.prefixItems) ? schema.prefixItems : void 0;
+    if (tupleSchemas?.length) {
+      return tupleSchemas.slice(0, 3).map((item2) => generateSchemaExample(spec, item2, depth + 1, nextSeen));
+    }
+    const item = generateSchemaExample(spec, schema.items, depth + 1, nextSeen);
+    return item === void 0 ? [] : [item];
+  }
+  if (type === "object") {
+    const result = {};
+    for (const [name, propertySchema] of entries(schema.properties)) {
+      const value = generateSchemaExample(spec, propertySchema, depth + 1, nextSeen);
+      if (value !== void 0) result[name] = value;
+    }
+    if (schema.additionalProperties === true) result.additionalProp1 = "string";
+    else if (isObject(schema.additionalProperties)) {
+      const value = generateSchemaExample(spec, schema.additionalProperties, depth + 1, nextSeen);
+      if (value !== void 0) result.additionalProp1 = value;
+    }
+    return result;
+  }
+  if (type === "string") {
+    switch (cleanText(schema.format).toLowerCase()) {
+      case "uuid":
+        return "00000000-0000-4000-8000-000000000001";
+      case "date":
+        return "2026-01-01";
+      case "date-time":
+        return "2026-01-01T00:00:00Z";
+      case "time":
+        return "12:00:00Z";
+      case "email":
+        return "user@example.com";
+      case "uri":
+      case "url":
+        return "https://example.com/resource";
+      case "hostname":
+        return "example.com";
+      case "ipv4":
+        return "192.0.2.1";
+      case "ipv6":
+        return "2001:db8::1";
+      case "byte":
+        return "c3RyaW5n";
+      default:
+        return "string";
+    }
+  }
+  if (type === "integer" || type === "number") {
+    if (typeof schema.minimum === "number") return schema.minimum;
+    if (typeof schema.exclusiveMinimum === "number") return schema.exclusiveMinimum + (type === "integer" ? 1 : 0.1);
+    return type === "integer" ? 0 : 0;
+  }
+  if (type === "boolean") return true;
+  if (type === "null") return null;
+  if (schema.properties || schema.additionalProperties !== void 0) return {};
+  return void 0;
+}
+function payloadExample(spec, mediaValue, schemaValue, legacyExamples) {
+  const media = isObject(mediaValue) ? mediaValue : {};
+  if (hasOwn(media, "example")) return { value: media.example, origin: "declared" };
+  for (const [name, exampleValue] of entries(media.examples)) {
+    const example = resolveReferenceObject(spec, exampleValue);
+    if (hasOwn(example, "value")) return { value: example.value, origin: "declared", name };
+  }
+  if (isObject(legacyExamples)) {
+    const mediaType = Object.keys(legacyExamples).find((key) => key.toLowerCase() === "application/json") ?? Object.keys(legacyExamples)[0];
+    if (mediaType && hasOwn(legacyExamples, mediaType)) {
+      return { value: legacyExamples[mediaType], origin: "declared" };
+    }
+  }
+  const declaredSchemaExample = firstDeclaredExample(spec, schemaValue);
+  if (declaredSchemaExample !== void 0) return { value: declaredSchemaExample, origin: "declared" };
+  const generated = generateSchemaExample(spec, schemaValue);
+  return generated === void 0 ? void 0 : { value: generated, origin: "schema-derived" };
+}
+function requestPayloadDescription(spec, operation) {
+  if (isObject(operation.requestBody) || operation.requestBody?.$ref) {
+    const body = resolveReferenceObject(spec, operation.requestBody);
+    const content = isObject(body.content) ? body.content : {};
+    const mediaType = chooseMediaType(content);
+    const media = mediaType ? content[mediaType] : void 0;
+    const schema = isObject(media?.schema) ? media.schema : void 0;
+    return {
+      type: schema ? typeExpression(schema) : "unknown",
+      mediaType: mediaType || "unknown media type",
+      example: media || schema ? payloadExample(spec, media, schema) : void 0,
+      required: body.required === true
+    };
+  }
+  const parameters = Array.isArray(operation.parameters) ? operation.parameters : [];
+  const bodyParameter = parameters.find((parameter) => isObject(parameter) && parameter.in === "body");
+  if (bodyParameter) {
+    const consumes = Array.isArray(operation.consumes) ? operation.consumes : Array.isArray(spec.consumes) ? spec.consumes : ["application/json"];
+    return {
+      type: typeExpression(bodyParameter.schema),
+      mediaType: consumes[0] ?? "application/json",
+      example: payloadExample(spec, void 0, bodyParameter.schema),
+      required: bodyParameter.required === true
+    };
+  }
+  return void 0;
+}
+function responseSchema(spec, responseValue) {
+  const response = resolveReferenceObject(spec, responseValue);
+  if (isObject(response.content)) {
+    const mediaType = chooseMediaType(response.content);
+    const media = mediaType ? response.content[mediaType] : void 0;
+    const schema = isObject(media?.schema) ? media.schema : void 0;
+    return {
+      type: schema ? typeExpression(schema) : void 0,
+      mediaType,
+      example: schema || media ? payloadExample(spec, media, schema, response.examples) : void 0
+    };
+  }
+  if (isObject(response.schema)) {
+    return {
+      type: typeExpression(response.schema),
+      mediaType: "application/json",
+      example: payloadExample(spec, void 0, response.schema, response.examples)
+    };
+  }
+  return {};
+}
+function formattedExample(value) {
+  try {
+    return JSON.stringify(value, null, 2) ?? "null";
+  } catch {
+    return "null";
+  }
+}
+function responseBlock(spec, code, responseValue) {
+  const response = resolveReferenceObject(spec, responseValue);
+  const description = cleanText(response.description);
+  const payload = responseSchema(spec, responseValue);
+  const suffix = payload.type ? ` \u2014 \`${payload.type}\`${payload.mediaType ? ` (${payload.mediaType})` : ""}` : " \u2014 no body schema declared";
+  const lines = [`- **${markdownCell(code)}${description ? ` ${description}` : ""}**${suffix}`];
+  if (payload.example?.origin === "declared") {
+    const label = payload.example.name ? ` \xB7 ${payload.example.name}` : "";
+    lines.push(
+      "",
+      `  **Example Value** *(declared in the spec${label})*`,
+      "",
+      "  ```json",
+      ...formattedExample(payload.example.value).split("\n").map((line) => `  ${line}`),
+      "  ```"
+    );
+  }
+  return lines.join("\n");
+}
+var COLLAPSIBLE_ERROR_CODES = /* @__PURE__ */ new Set(["400", "401", "403", "404", "500", "502", "503"]);
+var GENERIC_ERROR_DESCRIPTIONS = /* @__PURE__ */ new Set([
+  "",
+  "an error occurred",
+  "bad gateway",
+  "bad request",
+  "client error",
+  "error",
+  "failed",
+  "forbidden",
+  "internal error",
+  "internal server error",
+  "invalid request",
+  "not found",
+  "payment required",
+  "request error",
+  "request failed",
+  "server error",
+  "service unavailable",
+  "too many requests",
+  "unauthorized",
+  "unexpected error",
+  "unknown error"
+]);
+function isGenericErrorDescription(description) {
+  if (!description) return true;
+  return GENERIC_ERROR_DESCRIPTIONS.has(
+    description.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()
+  );
+}
+function responseSchemaValue(spec, responseValue) {
+  const response = resolveReferenceObject(spec, responseValue);
+  if (isObject(response.content)) {
+    const mediaType = chooseMediaType(response.content);
+    const media = mediaType ? response.content[mediaType] : void 0;
+    return isObject(media?.schema) ? media.schema : void 0;
+  }
+  if (isObject(response.schema)) return response.schema;
+  return void 0;
+}
+function collapsibleErrorEntry(spec, code, responseValue) {
+  if (!COLLAPSIBLE_ERROR_CODES.has(code)) return void 0;
+  const response = resolveReferenceObject(spec, responseValue);
+  if (!isGenericErrorDescription(cleanText(response.description))) return void 0;
+  if (isObject(response.headers) && Object.keys(response.headers).length) return void 0;
+  if (responseSchema(spec, responseValue).example?.origin === "declared") return void 0;
+  const schemaValue = responseSchemaValue(spec, responseValue);
+  if (schemaValue === void 0) return `\`${code}\``;
+  return `\`${code}\` (\`${typeExpression(schemaValue)}\`)`;
+}
+function responseSection(spec, operation) {
+  const responses = entries(operation.responses).filter(([, value]) => isObject(value));
+  if (!responses.length) return "_No responses declared._";
+  const success = responses.filter(([code]) => /^2\d\d$/.test(code));
+  success.sort(([a], [b]) => a === "200" ? -1 : b === "200" ? 1 : Number(a) - Number(b));
+  const errors = responses.filter(
+    ([code]) => (COMMON_ERROR_CODES.has(code) || /^([45])\d\d$/.test(code)) && !success.some(([successCode]) => successCode === code)
+  );
+  const detailedErrors = [];
+  const collapsedErrors = [];
+  for (const [code, responseValue] of errors) {
+    const entry = collapsibleErrorEntry(spec, code, responseValue);
+    if (entry === void 0) detailedErrors.push(responseBlock(spec, code, responseValue));
+    else collapsedErrors.push(entry);
+  }
+  const primarySuccess = success[0];
+  const lines = primarySuccess ? [responseBlock(spec, primarySuccess[0], primarySuccess[1])] : [];
+  lines.push(...detailedErrors);
+  if (collapsedErrors.length) lines.push(`- **Errors:** ${collapsedErrors.join(", ")}`);
+  if (success.length > 1) {
+    const others = success.slice(1).map(([code, response]) => responseBlock(spec, code, response));
+    lines.push("", "<details><summary>Other successful responses</summary>", "", ...others, "", "</details>");
+  }
+  if (!lines.length) {
+    return responses.map(([code, response]) => responseBlock(spec, code, response)).join("\n\n");
+  }
+  return lines.join("\n");
+}
+function shortOperationDescription(operation) {
+  return markdownCell(operation.summary || operation.operationId || operation.description || "\u2014");
+}
+function endpointMarkdown(spec, endpoint) {
+  const { operation, method, path: path2 } = endpoint;
+  const heading = `#### \`${method.toUpperCase()} ${path2}\``;
+  const summary = cleanText(operation.summary);
+  const description = cleanText(operation.description);
+  const lines = [heading];
+  if (summary) lines.push("", summary);
+  if (description && description !== summary) lines.push("", description);
+  lines.push("", `**Authentication:** ${securityRequirement(spec, operation)}`);
+  const parameters = mergedParameters(spec, endpoint);
+  const request = requestPayloadDescription(spec, operation);
+  lines.push("", "**Parameters**");
+  lines.push(parameterList(parameters));
+  if (request) {
+    lines.push(
+      "",
+      `**Request body:** \`${request.mediaType}\` \u2192 \`${request.type}\`${request.required ? " (required)" : " (optional)"}`
+    );
+    if (request.example?.origin === "declared") {
+      const label = request.example.name ? ` \xB7 ${request.example.name}` : "";
+      lines.push(
+        "",
+        `**Request Example Value** *(declared in the spec${label})*`,
+        "",
+        "```json",
+        formattedExample(request.example.value),
+        "```"
+      );
+    }
+  }
+  lines.push("", "**Responses**", responseSection(spec, operation));
+  return lines.join("\n");
+}
+function authOverview(spec) {
+  const schemes = getSecuritySchemes(spec);
+  if (!schemes.length) return ["- **Authentication:** No security schemes declared."];
+  const globalSecurity = securityRequirement(spec, {});
+  return [
+    `- **Authentication required globally:** ${globalSecurity}`,
+    "- **Available schemes:**",
+    ...schemes.map(([name, scheme]) => `  - ${describeSecurityScheme(name, scheme)}`)
+  ];
+}
+function collectTags(spec, endpoints) {
+  const declared = Array.isArray(spec.tags) ? spec.tags.map((tag) => cleanText(tag?.name)).filter(Boolean) : [];
+  const encountered = [...new Set(endpoints.map((endpoint) => endpoint.tag))];
+  return [
+    ...declared.filter((tag) => encountered.includes(tag)),
+    ...encountered.filter((tag) => !declared.includes(tag))
+  ];
+}
+function endpointTypeBase(method, path2, operation) {
+  if (cleanText(operation.operationId)) return toTypeScriptIdentifier(cleanText(operation.operationId));
+  const pathName = path2.replace(/[{}]/g, "").split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+  return toTypeScriptIdentifier(`${method.charAt(0).toUpperCase()}${method.slice(1)}${pathName}`);
+}
+function normalizeInlinePayloadSchemas(spec) {
+  const document = structuredClone(spec);
+  const isOpenApi3 = typeof document.openapi === "string";
+  const schemaPointer = isOpenApi3 ? "#/components/schemas/" : "#/definitions/";
+  let schemaBucket;
+  if (isOpenApi3) {
+    if (!isObject(document.components)) document.components = {};
+    if (!isObject(document.components.schemas)) document.components.schemas = {};
+    schemaBucket = document.components.schemas;
+  } else {
+    if (!isObject(document.definitions)) document.definitions = {};
+    schemaBucket = document.definitions;
+  }
+  const uniqueName = (suggestion) => {
+    const base = toTypeScriptIdentifier(suggestion);
+    let candidate = base;
+    let suffix = 2;
+    while (Object.prototype.hasOwnProperty.call(schemaBucket, candidate)) {
+      candidate = `${base}${suffix}`;
+      suffix += 1;
+    }
+    return candidate;
+  };
+  const replaceInline = (schema, name) => {
+    if (!isObject(schema) || typeof schema.$ref === "string" || Object.keys(schema).length === 0) return schema;
+    const unique = uniqueName(name);
+    schemaBucket[unique] = schema;
+    return { $ref: `${schemaPointer}${unique.replace(/~/g, "~0").replace(/\//g, "~1")}` };
+  };
+  const reusableBodies = isOpenApi3 ? document.components?.requestBodies : document.parameters;
+  for (const [bodyName, bodyValue] of entries(reusableBodies)) {
+    if (!isObject(bodyValue)) continue;
+    if (isOpenApi3 && isObject(bodyValue.content)) {
+      const mediaType = chooseMediaType(bodyValue.content);
+      const media = mediaType ? bodyValue.content[mediaType] : void 0;
+      if (isObject(media) && isObject(media.schema)) media.schema = replaceInline(media.schema, `${bodyName}Request`);
+    } else if (!isOpenApi3 && bodyValue.in === "body" && isObject(bodyValue.schema)) {
+      bodyValue.schema = replaceInline(bodyValue.schema, `${bodyName}Request`);
+    }
+  }
+  const reusableResponses = isOpenApi3 ? document.components?.responses : document.responses;
+  for (const [responseName, responseValue] of entries(reusableResponses)) {
+    if (!isObject(responseValue)) continue;
+    if (isOpenApi3 && isObject(responseValue.content)) {
+      const mediaType = chooseMediaType(responseValue.content);
+      const media = mediaType ? responseValue.content[mediaType] : void 0;
+      if (isObject(media) && isObject(media.schema))
+        media.schema = replaceInline(media.schema, `${responseName}Response`);
+    } else if (!isOpenApi3 && isObject(responseValue.schema)) {
+      responseValue.schema = replaceInline(responseValue.schema, `${responseName}Response`);
+    }
+  }
+  const paths = isObject(document.paths) ? document.paths : {};
+  for (const [path2, pathItemValue] of Object.entries(paths)) {
+    if (!isObject(pathItemValue)) continue;
+    for (const method of HTTP_METHODS) {
+      const operation = pathItemValue[method];
+      if (!isObject(operation)) continue;
+      const base = endpointTypeBase(method, path2, operation);
+      if (isOpenApi3 && isObject(operation.requestBody) && isObject(operation.requestBody.content)) {
+        const content = operation.requestBody.content;
+        const mediaType = chooseMediaType(content);
+        const media = mediaType ? content[mediaType] : void 0;
+        if (isObject(media) && isObject(media.schema)) {
+          media.schema = replaceInline(media.schema, `${base}Request`);
+        }
+      } else if (!isOpenApi3 && Array.isArray(operation.parameters)) {
+        for (const parameter of operation.parameters) {
+          if (isObject(parameter) && parameter.in === "body" && isObject(parameter.schema)) {
+            parameter.schema = replaceInline(parameter.schema, `${base}Request`);
+          }
+        }
+      }
+      if (isObject(operation.responses)) {
+        for (const [code, responseValue] of Object.entries(operation.responses)) {
+          if (!isObject(responseValue) || typeof responseValue.$ref === "string") continue;
+          const suffix = code === "default" ? "Default" : code.replace(/[^a-zA-Z0-9]/g, "");
+          if (isObject(responseValue.content)) {
+            const mediaType = chooseMediaType(responseValue.content);
+            const media = mediaType ? responseValue.content[mediaType] : void 0;
+            if (isObject(media) && isObject(media.schema)) {
+              media.schema = replaceInline(media.schema, `${base}${suffix}Response`);
+            }
+          } else if (!isOpenApi3 && isObject(responseValue.schema)) {
+            responseValue.schema = replaceInline(responseValue.schema, `${base}${suffix}Response`);
+          }
+        }
+      }
+    }
+  }
+  return document;
+}
+function transformOpenApiToMarkdown(spec, sourceUrl) {
+  const normalizedSpec = normalizeInlinePayloadSchemas(spec);
+  spec = normalizedSpec;
+  const info = isObject(spec.info) ? spec.info : {};
+  const title = cleanText(info.title) || "API";
+  const version = cleanText(info.version) || "unspecified";
+  const openApiVersion = cleanText(spec.openapi) || (spec.swagger ? `Swagger ${spec.swagger}` : "OpenAPI");
+  const servers = getServers(spec);
+  const endpoints = getEndpoints(spec);
+  const tags = collectTags(spec, endpoints);
+  const indexRows = endpoints.map(
+    (endpoint) => `| **${endpoint.method.toUpperCase()}** | \`${markdownCell(endpoint.path)}\` | ${shortOperationDescription(endpoint.operation)} | ${markdownCell(Array.isArray(endpoint.operation.tags) ? endpoint.operation.tags.join(", ") : endpoint.tag)} |`
+  );
+  const groupedEndpoints = tags.map((tag) => {
+    const members = endpoints.filter((endpoint) => endpoint.tag === tag);
+    if (!members.length) return "";
+    return [`### ${tag}`, ...members.map((endpoint) => endpointMarkdown(spec, endpoint))].join("\n\n");
+  }).filter(Boolean);
+  const models = referencedSchemas(spec);
+  const modelSection = models.length ? [
+    "## Data types",
+    "",
+    "```typescript",
+    models.map(([name, schema]) => modelDeclaration(name, schema)).join("\n\n"),
+    "```"
+  ].join("\n") : "";
+  const description = cleanText(info.description);
+  const sections = [
+    `# API Digest: ${title}`,
+    "",
+    `> Spec: ${openApiVersion} \xB7 API version: ${version}${sourceUrl ? ` \xB7 Source: \`${markdownCell(safeSourceUrl(sourceUrl))}\`` : ""}`,
+    "",
+    "## Overview",
+    ...description ? ["", description] : [],
+    "",
+    `- **Base URL(s):** ${servers.length ? servers.map((server) => `\`${markdownCell(server)}\``).join(", ") : "Not declared"}`,
+    ...authOverview(spec),
+    "",
+    "## Quick index",
+    "",
+    "| Method | Path | Summary | Tags |",
+    "|---|---|---|---|",
+    ...indexRows.length ? indexRows : ["| \u2014 | \u2014 | No operations declared | \u2014 |"],
+    "",
+    "## Endpoints",
+    "",
+    ...groupedEndpoints.length ? groupedEndpoints : ["_No endpoints declared._"],
+    ...modelSection ? ["", modelSection] : []
+  ];
+  return `${sections.join("\n").replace(/\n{3,}/g, "\n\n").trim()}
+`;
+}
+
+// src/tokens.ts
+function estimateTokens(text) {
+  const characters = text.length;
+  if (characters === 0) {
+    const zeroModel = (name, window2) => ({
+      name,
+      tokens: 0,
+      contextWindow: window2,
+      contextPercent: 0
+    });
+    return {
+      characters: 0,
+      models: {
+        claude: zeroModel("Claude (Sonnet / Opus)", 2e5),
+        openai: zeroModel("OpenAI (GPT-4o / o-series)", 128e3),
+        gemini: zeroModel("Google Gemini (Pro / Flash)", 1e6),
+        deepseek: zeroModel("DeepSeek (V3 / R1)", 128e3),
+        llama: zeroModel("Meta Llama (3.3 / 4)", 128e3)
+      }
+    };
+  }
+  const wordCount = (text.match(/\b[\w$]+\b/gu) || []).length;
+  const syntaxSymbols = (text.match(/[{}[\]()<>=:;,."`|/-]/g) || []).length;
+  const whitespaces = (text.match(/\s+/g) || []).length;
+  const baseTokens = wordCount * 1.18 + syntaxSymbols * 0.42 + whitespaces * 0.05;
+  const calculate = (name, ratio, contextWindow) => {
+    const tokens = Math.max(1, Math.round(baseTokens * ratio));
+    const contextPercent = Number((tokens / contextWindow * 100).toFixed(1));
+    return { name, tokens, contextWindow, contextPercent };
+  };
+  return {
+    characters,
+    models: {
+      // Claude BPE splits subwords and code tokens slightly finer
+      claude: calculate("Claude (Sonnet / Opus)", 1.08, 2e5),
+      // OpenAI o200k_base has efficient compression on whitespace and symbols
+      openai: calculate("OpenAI (GPT-4o / o-series)", 0.95, 128e3),
+      // Gemini 256k vocab is the most compressed on markdown & code
+      gemini: calculate("Google Gemini (Pro / Flash)", 0.9, 1e6),
+      // DeepSeek 128k tokenizer
+      deepseek: calculate("DeepSeek (V3 / R1)", 0.97, 128e3),
+      // Llama 3/4 128k tokenizer
+      llama: calculate("Meta Llama (3.3 / 4)", 0.98, 128e3)
+    }
+  };
+}
+
+// src/writer.ts
+import { mkdir, writeFile } from "fs/promises";
+import os from "os";
+import path from "path";
+function defaultOutputDirectory() {
+  return path.join(os.homedir(), "Downloads");
+}
+function defaultFilename(apiTitle) {
+  const slug = (apiTitle ?? "").normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `${slug || "api"}-digest.md`;
+}
+function resolveOutputDirectory(directory, cwd = process.cwd()) {
+  const expanded = directory === "~" ? os.homedir() : directory.startsWith(`~${path.sep}`) ? path.join(os.homedir(), directory.slice(2)) : directory;
+  return path.resolve(cwd, expanded);
+}
+function normalizeFilename(filename, fallback = "api-digest.md") {
+  const normalized = filename.trim().replace(/\\/g, "/");
+  const basename = path.posix.basename(normalized);
+  if (!basename || basename === "." || basename === "..") return fallback;
+  return basename.toLowerCase().endsWith(".md") ? basename : `${basename}.md`;
+}
+async function writeDigest(options) {
+  const directory = resolveOutputDirectory(options.directory);
+  const filename = normalizeFilename(options.filename);
+  const outputPath = path.join(directory, filename);
+  await mkdir(directory, { recursive: true });
+  await writeFile(outputPath, options.markdown, { encoding: "utf8" });
+  return outputPath;
+}
+
+export {
+  isOpenApiSpec,
+  parseSpecText,
+  fetchOpenApiSpec,
+  toTypeScriptIdentifier,
+  transformOpenApiToMarkdown,
+  estimateTokens,
+  defaultOutputDirectory,
+  defaultFilename,
+  resolveOutputDirectory,
+  normalizeFilename,
+  writeDigest
+};