swagger-digest 0.0.0-stage → 0.1.2

package/dist/chunk-CBSDTIKN.js

@@ -0,0 +1,2149 @@
+// src/version.ts
+import { createRequire } from "module";
+function readPackageVersion(moduleUrl) {
+  try {
+    const require2 = createRequire(moduleUrl);
+    const pkg = require2("../package.json");
+    if (typeof pkg?.version === "string" && pkg.version) return pkg.version;
+    return "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var VERSION = readPackageVersion(import.meta.url);
+var USER_AGENT = `swagger-digest/${VERSION}`;
+
+// src/transformer/utils.ts
+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 propertyKey(value) {
+  return /^[$A-Z_a-z][$\w]*$/.test(value) ? value : JSON.stringify(value);
+}
+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;
+}
+
+// src/fetcher.ts
+import { load } from "cheerio";
+import { parse as parseYaml2 } from "yaml";
+
+// src/errors.ts
+var FetchError = class extends Error {
+  kind;
+  constructor(kind, message) {
+    super(message);
+    this.name = "FetchError";
+    this.kind = kind;
+  }
+};
+var FetchSizeError = class extends FetchError {
+  constructor(message) {
+    super("size", message);
+    this.name = "FetchSizeError";
+  }
+};
+var BlockedNetworkError = class extends FetchError {
+  constructor(message) {
+    super("blocked", message);
+    this.name = "BlockedNetworkError";
+  }
+};
+var FetchNetworkError = class extends FetchError {
+  constructor(message) {
+    super("network", message);
+    this.name = "FetchNetworkError";
+  }
+};
+var FetchHttpError = class extends FetchError {
+  status;
+  constructor(message, status) {
+    super("http", message);
+    this.name = "FetchHttpError";
+    this.status = status;
+  }
+};
+function isFailFastFetchError(error) {
+  return error instanceof FetchError && (error.kind === "size" || error.kind === "blocked" || error.kind === "network");
+}
+
+// src/hardened-fetch.ts
+import { lookup } from "dns/promises";
+import { isIP } from "net";
+var DEFAULT_MAX_BYTES = 10 * 1024 * 1024;
+var DEFAULT_MAX_REDIRECTS = 5;
+var REDIRECT_STATUSES = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+function isPrivateAddress(address) {
+  const family = isIP(address);
+  if (family === 4) return isPrivateIPv4(address);
+  if (family === 6) {
+    const normalized = address.toLowerCase();
+    const mapped = normalized.match(/^::ffff:(\d+\.\d+\.\d+\.\d+)$/);
+    if (mapped?.[1]) return isPrivateIPv4(mapped[1]);
+    if (normalized === "::1" || normalized === "::") return true;
+    if (/^f[cd][0-9a-f]{2}(?::|$)/.test(normalized)) return true;
+    if (/^fe[89ab][0-9a-f](?::|$)/.test(normalized)) return true;
+    return false;
+  }
+  return true;
+}
+function isPrivateIPv4(address) {
+  const parts = address.split(".").map(Number);
+  if (parts.length !== 4 || parts.some((part) => Number.isNaN(part))) return true;
+  const [a, b] = parts;
+  if (a === 0) return true;
+  if (a === 10) return true;
+  if (a === 127) return true;
+  if (a === 169 && b === 254) return true;
+  if (a === 172 && b >= 16 && b <= 31) return true;
+  if (a === 192 && b === 168) return true;
+  return false;
+}
+async function assertPublicHost(hostname) {
+  if (isIP(hostname) !== 0) {
+    if (isPrivateAddress(hostname)) {
+      throw new BlockedNetworkError(
+        `Blocked request to private network address (host resolved to a loopback/private/metadata address). Enable this only for hosts you trust; use it against internal corporate APIs without this option.`
+      );
+    }
+    return;
+  }
+  let addresses;
+  try {
+    addresses = await lookup(hostname, { all: true, verbatim: true });
+  } catch (error) {
+    throw new FetchNetworkError(
+      `DNS resolution failed for ${hostname}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!addresses.length) {
+    throw new FetchNetworkError(`DNS resolution returned no addresses for ${hostname}`);
+  }
+  for (const { address } of addresses) {
+    if (isPrivateAddress(address)) {
+      throw new BlockedNetworkError(
+        `Blocked request to ${hostname}: it resolves to a private/loopback/metadata address while blockPrivateNetworks is enabled.`
+      );
+    }
+  }
+}
+function normalizeHeaders(headers) {
+  return Object.fromEntries(Object.entries(headers ?? {}).map(([name, value]) => [name.toLowerCase(), value]));
+}
+async function fetchWithLimits(url, options) {
+  const maxBytes = options.maxBytes ?? DEFAULT_MAX_BYTES;
+  const maxRedirects = options.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
+  const defaultHeaders = normalizeHeaders({
+    accept: "application/json, application/yaml, text/yaml, text/plain, text/html;q=0.8, */*;q=0.5",
+    "user-agent": USER_AGENT
+  });
+  const userHeaders = normalizeHeaders(options.headers ?? {});
+  return await follow(url, defaultHeaders, userHeaders, options, maxBytes, maxRedirects);
+}
+async function follow(url, defaultHeaders, userHeaders, options, maxBytes, redirectsLeft) {
+  let target;
+  try {
+    target = new URL(url);
+  } catch {
+    throw new FetchNetworkError(`Invalid URL: ${url}`);
+  }
+  if (target.protocol !== "http:" && target.protocol !== "https:") {
+    throw new FetchNetworkError(`Only HTTP and HTTPS URLs are supported: ${url}`);
+  }
+  if (options.blockPrivateNetworks) {
+    await assertPublicHost(target.hostname);
+  }
+  const sameOrigin = !options.allowedHeaderOrigin || !options.headers || target.origin === options.allowedHeaderOrigin;
+  if (!sameOrigin && options.allowedHeaderOrigin && options.headers && Object.keys(options.headers).length > 0) {
+    options.onCrossOriginHeadersDropped?.(target.origin);
+  }
+  const requestHeaders = sameOrigin ? { ...defaultHeaders, ...userHeaders } : defaultHeaders;
+  const controller = new AbortController();
+  const timeout = AbortSignal.timeout(options.timeoutMs);
+  timeout.addEventListener("abort", () => controller.abort(), { once: true });
+  let response;
+  try {
+    response = await fetch(target, {
+      headers: requestHeaders,
+      redirect: "manual",
+      signal: controller.signal
+    });
+  } catch (error) {
+    if (error instanceof FetchError) throw error;
+    const reason = error instanceof Error ? error.message : String(error);
+    throw new FetchNetworkError(`Request to ${target} failed: ${describeNetworkError(reason)}`);
+  }
+  if (REDIRECT_STATUSES.has(response.status)) {
+    const location = response.headers.get("location");
+    if (!location) {
+      throw new FetchNetworkError(`Redirect response without a Location header from ${target}`);
+    }
+    if (redirectsLeft <= 0) {
+      throw new FetchNetworkError(`Too many redirects (limit ${options.maxRedirects ?? 5}) while fetching ${url}`);
+    }
+    try {
+      await response.arrayBuffer();
+    } catch {
+    }
+    const next = new URL(response.headers.get("location") ?? "", target);
+    return follow(next.toString(), defaultHeaders, userHeaders, options, maxBytes, redirectsLeft - 1);
+  }
+  if (!response.ok) {
+    await discardBodySafely(response);
+    throw new FetchHttpError(`HTTP ${response.status} ${response.statusText} for ${url}`, response.status);
+  }
+  const contentLength = response.headers.get("content-length");
+  if (contentLength !== null) {
+    const declared = Number(contentLength);
+    if (Number.isFinite(declared) && declared > maxBytes) {
+      await discardBodySafely(response);
+      throw new FetchSizeError(
+        `Response from ${target} is ${declared} bytes, exceeding the ${maxBytes} byte limit (content-length). Increase --max-bytes if the spec is genuinely large.`
+      );
+    }
+  }
+  const text = await readBodyWithCap(response, target.toString(), maxBytes);
+  return {
+    text,
+    contentType: response.headers.get("content-type") ?? "",
+    status: response.status,
+    url: target.toString()
+  };
+}
+function describeNetworkError(reason) {
+  if (/timeouterror|timed out|aborted/i.test(reason)) return "request timed out";
+  if (/enotfound|getaddrinfo/i.test(reason)) return "host not found (DNS)";
+  if (/econnrefused/i.test(reason)) return "connection refused";
+  return reason;
+}
+async function readBodyWithCap(response, url, maxBytes) {
+  const body = response.body;
+  if (!body) return "";
+  const chunks = [];
+  let total = 0;
+  try {
+    for await (const chunk of body) {
+      chunks.push(chunk);
+      total += chunk.byteLength;
+      if (total > maxBytes) {
+        try {
+          await body.cancel();
+        } catch {
+        }
+        throw new FetchSizeError(
+          `Response body from ${url} exceeded the ${maxBytes} byte limit while streaming (content-length was ${response.headers.get("content-length") ?? "not declared"}). Use --max-bytes to raise the cap if the spec is genuinely large.`
+        );
+      }
+    }
+  } catch (error) {
+    if (error instanceof FetchSizeError) throw error;
+    throw new FetchNetworkError(`Failed to read response body from ${url}: ${describeNetworkError(String(error))}`);
+  }
+  const decoder = new TextDecoder("utf-8");
+  const parts = [];
+  for (const chunk of chunks) parts.push(decoder.decode(chunk, { stream: true }));
+  parts.push(decoder.decode());
+  return parts.join("");
+}
+async function discardBodySafely(response) {
+  try {
+    await response.arrayBuffer();
+  } catch {
+  }
+}
+
+// src/bundler.ts
+import { parse as parseYaml } from "yaml";
+var MAX_EXTERNAL_DOCUMENTS = 5;
+async function bundleExternalRefs(spec, sourceUrl, fetchDocument) {
+  if (!sourceUrl) return spec;
+  const externalRefs = collectExternalRefs(spec);
+  if (externalRefs.size === 0) return spec;
+  const schemaBucket = openSchemaBucket(spec);
+  const usedNames = new Set(Object.keys(schemaBucket));
+  const mapping = /* @__PURE__ */ new Map();
+  let fetched = 0;
+  for (const ref of externalRefs) {
+    if (fetched >= MAX_EXTERNAL_DOCUMENTS) break;
+    const { docUrl, pointer } = splitExternalRef(ref, sourceUrl);
+    if (!docUrl) continue;
+    try {
+      const text = await fetchDocument(docUrl);
+      const parsed = parseDocumentText(text);
+      if (parsed === void 0) continue;
+      fetched += 1;
+      const target = resolvePointer(parsed, pointer);
+      if (target === void 0) continue;
+      const localName = uniqueNameFor(localNameFor(docUrl, pointer), usedNames);
+      schemaBucket[localName] = target;
+      mapping.set(ref, localName);
+    } catch {
+    }
+  }
+  if (mapping.size === 0) return spec;
+  const rewritten = rewriteRefs(spec, mapping);
+  return isObject(rewritten) ? rewritten : spec;
+}
+function collectExternalRefs(node) {
+  const found = /* @__PURE__ */ new Set();
+  const walk = (value) => {
+    if (Array.isArray(value)) {
+      for (const item of value) walk(item);
+      return;
+    }
+    if (!isObject(value)) return;
+    for (const [key, refValue] of Object.entries(value)) {
+      if (key === "$ref" && typeof refValue === "string" && !refValue.startsWith("#")) {
+        found.add(refValue);
+        continue;
+      }
+      if (key === "example" || key === "examples" || key === "externalDocs") continue;
+      walk(refValue);
+    }
+  };
+  walk(node);
+  return found;
+}
+function rewriteRefs(node, mapping) {
+  if (Array.isArray(node)) return node.map((item) => rewriteRefs(item, mapping));
+  if (!isObject(node)) return node;
+  const result = {};
+  for (const [key, value] of Object.entries(node)) {
+    if (key === "$ref" && typeof value === "string") {
+      const localName = mapping.get(value);
+      if (localName === void 0) {
+        result[key] = value;
+        continue;
+      }
+      result[key] = `#/${bucketPath(bucketStyle(value))}/${localName}`;
+      continue;
+    }
+    result[key] = rewriteRefs(value, mapping);
+  }
+  return result;
+}
+function bucketStyle(ref) {
+  return ref.includes("/components/") ? "openapi" : "swagger";
+}
+function bucketPath(style) {
+  return style === "openapi" ? "components/schemas" : "definitions";
+}
+function openSchemaBucket(spec) {
+  if (isObject(spec.components)) {
+    if (!isObject(spec.components.schemas)) spec.components.schemas = {};
+    return spec.components.schemas;
+  }
+  if (!isObject(spec.definitions)) spec.definitions = {};
+  return spec.definitions;
+}
+function splitExternalRef(ref, baseUrl) {
+  const hashIndex = ref.indexOf("#");
+  if (hashIndex < 0) return { docUrl: void 0, pointer: "" };
+  const docPart = ref.slice(0, hashIndex);
+  const pointer = ref.slice(hashIndex + 1);
+  try {
+    return { docUrl: new URL(docPart, baseUrl).toString(), pointer };
+  } catch {
+    return { docUrl: void 0, pointer };
+  }
+}
+function parseDocumentText(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    try {
+      return parseYaml(text);
+    } catch {
+      return void 0;
+    }
+  }
+}
+function resolvePointer(root, pointer) {
+  if (!pointer.startsWith("/")) return void 0;
+  let current = root;
+  for (const rawPart of pointer.slice(1).split("/")) {
+    const part = rawPart.replace(/~1/g, "/").replace(/~0/g, "~");
+    if (!isObject(current)) return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function localNameFor(docUrl, pointer) {
+  try {
+    const url = new URL(docUrl);
+    const file = url.pathname.split("/").pop() ?? "external";
+    const stem = file.replace(/\.(json|ya?ml)$/i, "").replace(/[^A-Za-z0-9_$]+/g, "_") || "external";
+    const segments = pointer.split("/").filter(Boolean);
+    const pointerName = segments.length > 0 ? segments[segments.length - 1] : void 0;
+    const cleanedPointer = pointerName?.replace(/[^A-Za-z0-9_$]+/g, "_");
+    return [stem, cleanedPointer].filter(Boolean).join("_") || "external";
+  } catch {
+    return "external";
+  }
+}
+function uniqueNameFor(base, used) {
+  let candidate = base;
+  let suffix = 2;
+  while (used.has(candidate)) {
+    candidate = `${candidate}${suffix}`;
+    suffix += 1;
+  }
+  used.add(candidate);
+  return candidate;
+}
+
+// src/fetcher.ts
+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), () => parseYaml2(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, ctx) {
+  const response = await fetchWithLimits(url, {
+    timeoutMs: ctx.timeoutMs,
+    maxBytes: ctx.maxBytes,
+    maxRedirects: ctx.maxRedirects,
+    blockPrivateNetworks: ctx.blockPrivateNetworks,
+    headers: ctx.headers,
+    allowedHeaderOrigin: ctx.allowedHeaderOrigin,
+    onCrossOriginHeadersDropped: ctx.onCrossOriginHeadersDropped
+  });
+  return {
+    text: response.text,
+    contentType: response.contentType
+  };
+}
+function extractScripts(html) {
+  const $ = load(html);
+  const inline = [];
+  const external = [];
+  for (const element of $("script").toArray()) {
+    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) {
+  return extractSpecUrlsFromScripts(scripts, pageUrl)[0];
+}
+function extractSpecUrlsFromScripts(scripts, pageUrl) {
+  const found = [];
+  const pushCandidate = (candidate) => {
+    const trimmed = candidate.trim();
+    if (!trimmed || trimmed.startsWith("data:")) return;
+    try {
+      const resolved = new URL(trimmed, pageUrl).toString();
+      if (!found.includes(resolved)) found.push(resolved);
+    } catch {
+    }
+  };
+  for (const script of scripts) {
+    const urlsArray = findObjectLiteralArrayAfterKey(script, "urls");
+    if (urlsArray) {
+      const entryPattern = /\burl\s*:\s*(["'])(.*?)\1/gs;
+      for (const match of urlsArray.matchAll(entryPattern)) {
+        pushCandidate(match[2] ?? "");
+      }
+    }
+    if (!urlsArray) {
+      const urlPattern = /\burl\s*:\s*(["'])(.*?)\1/s;
+      const match = urlPattern.exec(script);
+      if (match?.[2]) pushCandidate(match[2]);
+    }
+  }
+  return found;
+}
+function findObjectLiteralArrayAfterKey(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 extractSpecUrls(scripts, pageUrl) {
+  const fromScripts = extractSpecUrlsFromScripts(scripts, pageUrl);
+  const queryUrl = pageUrl.searchParams.get("url");
+  if (queryUrl) {
+    try {
+      const resolved = new URL(queryUrl, pageUrl).toString();
+      if (!fromScripts.includes(resolved)) fromScripts.push(resolved);
+    } catch {
+    }
+  }
+  return fromScripts;
+}
+async function probeSpecUrls(candidates, ctx, recordFailure, onMultiple) {
+  if (candidates.length === 0) return void 0;
+  if (candidates.length > 1) {
+    onMultiple?.(candidates[0] ?? "", candidates);
+  }
+  const batchSize = 4;
+  for (let start = 0; start < candidates.length; start += batchSize) {
+    const batch = candidates.slice(start, start + batchSize);
+    const attempts = await Promise.all(
+      batch.map(async (candidate) => {
+        try {
+          return { candidate, spec: await tryFetchSpec(candidate, ctx) };
+        } catch (error) {
+          return { candidate, error };
+        }
+      })
+    );
+    const winner = attempts.find(
+      (attempt) => attempt.spec !== void 0
+    );
+    if (winner) {
+      return { spec: winner.spec, sourceUrl: winner.candidate, retrievalMethod: "html-config" };
+    }
+    for (const attempt of attempts) {
+      recordFailure("Configured spec", attempt.error, attempt.candidate);
+    }
+  }
+  return void 0;
+}
+async function fetchExternalConfigScripts(srcs, pageUrl, ctx, 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(), ctx);
+      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),
+    () => parseYaml2(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, ctx) {
+  const response = await fetchText(url, ctx);
+  const parsed = parseSpecText(response.text, url);
+  try {
+    return await bundleExternalRefs(parsed, url, async (docUrl) => (await fetchText(docUrl, ctx)).text);
+  } catch {
+    return parsed;
+  }
+}
+function headersForBrowserRequest(requestUrl, headers, allowedOrigin) {
+  if (!headers || Object.keys(headers).length === 0) return void 0;
+  let requestOrigin;
+  try {
+    requestOrigin = new URL(requestUrl).origin;
+  } catch {
+    return void 0;
+  }
+  return requestOrigin === allowedOrigin ? headers : void 0;
+}
+async function tryBrowserFallback(pageUrl, headers) {
+  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();
+    const allowedOrigin = new URL(pageUrl).origin;
+    if (headers && Object.keys(headers).length > 0) {
+      const browserHeaders = Object.fromEntries(
+        Object.entries(headers).map(([name, value]) => [name.toLowerCase(), value])
+      );
+      await page.route("**/*", async (route) => {
+        const extra = headersForBrowserRequest(route.request().url(), browserHeaders, allowedOrigin);
+        if (!extra) {
+          await route.continue();
+          return;
+        }
+        await route.continue({ headers: { ...route.request().headers(), ...extra } });
+      });
+    }
+    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;
+          const doc = document;
+          return Boolean(doc?.openapi || doc?.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 ctx = {
+    timeoutMs,
+    maxBytes: options.maxBytes,
+    maxRedirects: options.maxRedirects,
+    blockPrivateNetworks: options.blockPrivateNetworks,
+    allowedHeaderOrigin: pageUrl.origin,
+    headers: options.headers,
+    onCrossOriginHeadersDropped: (origin) => options.warn?.(
+      `Custom headers were withheld: ${origin} is a different origin from the URL you supplied. Only tool defaults were sent.`
+    )
+  };
+  const errors = [];
+  const recordFailure = (label, error, subject) => {
+    if (isFailFastFetchError(error)) throw error;
+    const prefix = subject ? `${label} (${subject}):` : `${label}:`;
+    errors.push(`${prefix} ${error instanceof Error ? error.message : String(error)}`);
+  };
+  if (isDirectSpecUrl(pageUrl)) {
+    try {
+      const spec = await tryFetchSpec(pageUrl.toString(), ctx);
+      return { spec, sourceUrl: pageUrl.toString(), retrievalMethod: "direct-spec" };
+    } catch (error) {
+      recordFailure("Direct spec", error);
+    }
+  }
+  if (options.specUrl) {
+    try {
+      const spec = await tryFetchSpec(options.specUrl, ctx);
+      return { spec, sourceUrl: options.specUrl, retrievalMethod: "direct-spec" };
+    } catch (error) {
+      recordFailure("Specified spec (--spec)", error, options.specUrl);
+    }
+  }
+  let html;
+  try {
+    const response = await fetchText(pageUrl.toString(), ctx);
+    try {
+      const spec = parseSpecText(response.text, pageUrl.toString());
+      return { spec, sourceUrl: pageUrl.toString(), retrievalMethod: "direct-spec" };
+    } catch {
+      html = response.text;
+    }
+  } catch (error) {
+    recordFailure("Swagger UI page", error);
+  }
+  if (html !== void 0) {
+    const pageScripts = extractScripts(html);
+    const scripts = pageScripts.inline;
+    const inlineSpec = extractInlineSpec(scripts);
+    if (inlineSpec) {
+      return { spec: inlineSpec, sourceUrl: pageUrl.toString(), retrievalMethod: "inline-spec" };
+    }
+    const noteMultiple = (picked, all) => {
+      if (all.length > 1) {
+        options.warn?.(
+          `Multiple spec definitions found (${String(all.length)}); using ${picked}. Others: ${all.filter((url) => url !== picked).join(", ")}.`
+        );
+      }
+    };
+    const fromInline = await probeSpecUrls(extractSpecUrls(scripts, pageUrl), ctx, recordFailure, noteMultiple);
+    if (fromInline) return fromInline;
+    const externalScripts = await fetchExternalConfigScripts(pageScripts.external, pageUrl, ctx, errors);
+    const inlineUrls = extractSpecUrls(scripts, pageUrl);
+    const externalUrls = extractSpecUrls(externalScripts, pageUrl).filter((url) => !inlineUrls.includes(url));
+    const fromExternal = await probeSpecUrls([...inlineUrls, ...externalUrls], ctx, recordFailure, noteMultiple);
+    if (fromExternal) return fromExternal;
+    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" };
+    }
+  }
+  const probeCtx = { ...ctx, timeoutMs: options.probeTimeoutMs ?? 5e3 };
+  const candidates = getFallbackUrls(pageUrl);
+  const probeBatchSize = 4;
+  for (let start = 0; start < candidates.length; start += probeBatchSize) {
+    const batch = candidates.slice(start, start + probeBatchSize);
+    const attempts = await Promise.all(
+      batch.map(async (candidate) => {
+        try {
+          return { candidate, spec: await tryFetchSpec(candidate, probeCtx) };
+        } catch (error) {
+          return { candidate, error };
+        }
+      })
+    );
+    const winner = attempts.find(
+      (attempt) => attempt.spec !== void 0
+    );
+    if (winner) {
+      return { spec: winner.spec, sourceUrl: winner.candidate, retrievalMethod: "fallback-path" };
+    }
+    for (const attempt of attempts) {
+      recordFailure(attempt.candidate, attempt.error);
+    }
+  }
+  if (options.useBrowserFallback !== false) {
+    try {
+      const spec = await tryBrowserFallback(pageUrl.toString(), ctx.headers);
+      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/tokens.ts
+var MODEL_CONFIGS = {
+  claude: { name: "Claude (Sonnet / Opus)", contextWindow: 2e5, ratio: 1.08 },
+  openai: { name: "OpenAI (GPT-4o / o-series)", contextWindow: 128e3, ratio: 0.95 },
+  gemini: { name: "Google Gemini (Pro / Flash)", contextWindow: 1e6, ratio: 0.9 },
+  deepseek: { name: "DeepSeek (V3 / R1)", contextWindow: 128e3, ratio: 0.97 },
+  llama: { name: "Meta Llama (3.3 / 4)", contextWindow: 128e3, ratio: 0.98 }
+};
+function estimateTokens(text) {
+  const characters = text.length;
+  if (characters === 0) {
+    const zeroModel = ({ name, contextWindow }) => ({
+      name,
+      tokens: 0,
+      contextWindow,
+      contextPercent: 0
+    });
+    return {
+      characters: 0,
+      models: {
+        claude: zeroModel(MODEL_CONFIGS.claude),
+        openai: zeroModel(MODEL_CONFIGS.openai),
+        gemini: zeroModel(MODEL_CONFIGS.gemini),
+        deepseek: zeroModel(MODEL_CONFIGS.deepseek),
+        llama: zeroModel(MODEL_CONFIGS.llama)
+      }
+    };
+  }
+  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: calculate(MODEL_CONFIGS.claude.name, MODEL_CONFIGS.claude.ratio, MODEL_CONFIGS.claude.contextWindow),
+      openai: calculate(MODEL_CONFIGS.openai.name, MODEL_CONFIGS.openai.ratio, MODEL_CONFIGS.openai.contextWindow),
+      gemini: calculate(MODEL_CONFIGS.gemini.name, MODEL_CONFIGS.gemini.ratio, MODEL_CONFIGS.gemini.contextWindow),
+      deepseek: calculate(
+        MODEL_CONFIGS.deepseek.name,
+        MODEL_CONFIGS.deepseek.ratio,
+        MODEL_CONFIGS.deepseek.contextWindow
+      ),
+      llama: calculate(MODEL_CONFIGS.llama.name, MODEL_CONFIGS.llama.ratio, MODEL_CONFIGS.llama.contextWindow)
+    }
+  };
+}
+
+// src/transformer/security.ts
+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 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)}`)
+  ];
+}
+
+// src/transformer/render-style.ts
+var FULL_STYLE = { includeExamples: true, collapsed: false };
+function shortenDescription(text, limit) {
+  if (limit === void 0 || text.length <= limit) return text;
+  return `${text.slice(0, limit).trimEnd()}\u2026`;
+}
+
+// src/transformer/schema-type.ts
+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 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 resolvePointer2(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 = resolvePointer2(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"))
+  };
+}
+
+// src/transformer/examples.ts
+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 = resolvePointer2(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 = resolvePointer2(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 formattedExample(value) {
+  try {
+    return JSON.stringify(value, null, 2) ?? "null";
+  } catch {
+    return "null";
+  }
+}
+
+// src/transformer/parameters.ts
+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, style = FULL_STYLE) {
+  if (!parameters.length) return "_None._";
+  if (style.collapsed) {
+    return `- _${parameters.length} parameter${parameters.length === 1 ? "" : "s"} (detail collapsed for token budget)._`;
+  }
+  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 = shortenDescription(cleanText(parameter.description), style.descriptionLimit);
+    const details = description ? ` \u2014 ${description}` : "";
+    return `- \`${cleanText(parameter.name)}\` (\`${cleanText(parameter.in)}\`${required ? ", required" : ""}) \xB7 \`${type}\`${defaultSuffix}${details}`;
+  }).join("\n");
+}
+function requestPayloadDescription(spec, operation, style = FULL_STYLE) {
+  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: style.includeExamples && (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: style.includeExamples ? payloadExample(spec, void 0, bodyParameter.schema) : void 0,
+      required: bodyParameter.required === true
+    };
+  }
+  return void 0;
+}
+
+// src/transformer/responses.ts
+var COMMON_ERROR_CODES = /* @__PURE__ */ new Set([
+  "400",
+  "401",
+  "403",
+  "404",
+  "405",
+  "409",
+  "415",
+  "422",
+  "429",
+  "500",
+  "501",
+  "502",
+  "503",
+  "default"
+]);
+function responseSchema(spec, responseValue, style = FULL_STYLE) {
+  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: style.includeExamples && (schema || media) ? payloadExample(spec, media, schema, response.examples) : void 0
+    };
+  }
+  if (isObject(response.schema)) {
+    return {
+      type: typeExpression(response.schema),
+      mediaType: "application/json",
+      example: style.includeExamples ? payloadExample(spec, void 0, response.schema, response.examples) : void 0
+    };
+  }
+  return {};
+}
+function responseBlock(spec, code, responseValue, style = FULL_STYLE) {
+  const response = resolveReferenceObject(spec, responseValue);
+  const description = style.collapsed ? "" : shortenDescription(cleanText(response.description), style.descriptionLimit);
+  const payload = responseSchema(spec, responseValue, style);
+  const suffix = payload.type ? ` \u2014 \`${payload.type}\`${payload.mediaType ? ` (${payload.mediaType})` : ""}` : " \u2014 no body schema declared";
+  if (style.collapsed) {
+    return [`- **${markdownCell(code)}**${suffix}`].join("\n");
+  }
+  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, style = FULL_STYLE) {
+  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)
+  );
+  if (style.collapsed) {
+    const collapsedLines = success.map(([code, response]) => responseBlock(spec, code, response, style));
+    collapsedLines.push(...errors.map(([code, responseValue]) => responseBlock(spec, code, responseValue, style)));
+    return collapsedLines.join("\n");
+  }
+  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, style));
+    else collapsedErrors.push(entry);
+  }
+  const primarySuccess = success[0];
+  const lines = primarySuccess ? [responseBlock(spec, primarySuccess[0], primarySuccess[1], style)] : [];
+  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, style));
+    lines.push("", "<details><summary>Other successful responses</summary>", "", ...others, "", "</details>");
+  }
+  if (!lines.length) {
+    return responses.map(([code, response]) => responseBlock(spec, code, response, style)).join("\n\n");
+  }
+  return lines.join("\n");
+}
+
+// src/transformer/endpoints.ts
+var HTTP_METHODS = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+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(isObject(server) ? server.url : void 0)).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 collectTags(spec, endpoints) {
+  const declared = Array.isArray(spec.tags) ? spec.tags.map((tag) => cleanText(isObject(tag) ? tag.name : void 0)).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 shortOperationDescription(operation) {
+  return markdownCell(operation.summary || operation.operationId || operation.description || "\u2014");
+}
+function endpointMarkdown(spec, endpoint, style = FULL_STYLE) {
+  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("", shortenDescription(summary, style.descriptionLimit));
+  if (description && description !== summary) {
+    lines.push("", shortenDescription(description, style.descriptionLimit));
+  }
+  lines.push("", `**Authentication:** ${securityRequirement(spec, operation)}`);
+  const parameters = mergedParameters(spec, endpoint);
+  const request = requestPayloadDescription(spec, operation, style);
+  lines.push("", "**Parameters**");
+  lines.push(parameterList(parameters, style));
+  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, style));
+  return lines.join("\n");
+}
+
+// src/transformer/models.ts
+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 = resolvePointer2(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 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;
+}
+
+// src/transformer/index.ts
+var HTTP_METHODS2 = ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+function tagsOfEndpoint(endpoint) {
+  const tags = endpoint.operation.tags;
+  return Array.isArray(tags) && tags.length ? tags.map(String) : ["General"];
+}
+function filterSpec(spec, endpoints, options, warnings) {
+  const includeTags = options.includeTags ?? [];
+  const excludeTags = options.excludeTags ?? [];
+  const hasFilter = includeTags.length > 0 || excludeTags.length > 0 || options.pathPrefix !== void 0;
+  if (!hasFilter) return spec;
+  const declared = Array.isArray(spec.tags) ? spec.tags.map((tag) => isObject(tag) && typeof tag.name === "string" ? tag.name : "").filter(Boolean) : [];
+  const available = [.../* @__PURE__ */ new Set([...declared, ...endpoints.map((endpoint) => endpoint.tag)])];
+  const unknownTags = [
+    ...includeTags.filter((tag) => !available.includes(tag)),
+    ...excludeTags.filter((tag) => !available.includes(tag))
+  ];
+  if (unknownTags.length > 0) {
+    warnings.push(
+      `Unknown tag(s): ${[...new Set(unknownTags)].join(", ")}. Available tags: ${available.join(", ") || "none"}.`
+    );
+  }
+  const keep = (endpoint) => {
+    if (options.pathPrefix && !endpoint.path.startsWith(options.pathPrefix)) return false;
+    const tags = tagsOfEndpoint(endpoint);
+    if (includeTags.length > 0 && !tags.some((tag) => includeTags.includes(tag))) return false;
+    if (excludeTags.length > 0 && tags.some((tag) => excludeTags.includes(tag))) return false;
+    return true;
+  };
+  const paths = {};
+  for (const endpoint of endpoints.filter(keep)) {
+    const source = isObject(spec.paths?.[endpoint.path]) ? spec.paths[endpoint.path] : {};
+    const item = paths[endpoint.path] ?? { ...source };
+    for (const method of HTTP_METHODS2) delete item[method];
+    item[endpoint.method] = source[endpoint.method];
+    paths[endpoint.path] = item;
+  }
+  return { ...spec, paths };
+}
+function buildTrimStages(_endpoints, tags) {
+  const stages = [];
+  const emptyTags = /* @__PURE__ */ new Set();
+  stages.push({
+    includeExamples: true,
+    collapsedTags: emptyTags,
+    indexOnly: false
+  });
+  stages.push({
+    includeExamples: false,
+    collapsedTags: emptyTags,
+    indexOnly: false,
+    action: "removed declared example payloads"
+  });
+  stages.push({
+    includeExamples: false,
+    descriptionLimit: 200,
+    collapsedTags: emptyTags,
+    indexOnly: false,
+    action: "shortened long descriptions"
+  });
+  const collapsedSoFar = /* @__PURE__ */ new Set();
+  for (const tag of [...tags].reverse()) {
+    collapsedSoFar.add(tag);
+    stages.push({
+      includeExamples: false,
+      descriptionLimit: 200,
+      collapsedTags: new Set(collapsedSoFar),
+      indexOnly: false,
+      action: `collapsed parameter and response detail for tag "${tag}"`
+    });
+  }
+  stages.push({
+    includeExamples: false,
+    descriptionLimit: 200,
+    collapsedTags: new Set(tags),
+    indexOnly: true,
+    action: "kept only the Quick index entries for the remaining tags"
+  });
+  return stages;
+}
+function renderDigest(spec, sourceUrl, endpoints, tags, stage) {
+  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 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 detailEndpoints = stage.indexOnly ? [] : endpoints.filter((endpoint) => !stage.collapsedTags.has(endpoint.tag));
+  const groupedEndpoints = tags.map((tag) => {
+    const members = endpoints.filter((endpoint) => endpoint.tag === tag);
+    if (!members.length) return "";
+    const rendered = members.map(
+      (endpoint) => endpointMarkdown(spec, endpoint, {
+        includeExamples: stage.includeExamples,
+        descriptionLimit: stage.descriptionLimit,
+        collapsed: stage.collapsedTags.has(endpoint.tag)
+      })
+    );
+    return [`### ${tag}`, ...rendered].join("\n\n");
+  }).filter(Boolean);
+  let modelSpec = spec;
+  if (detailEndpoints.length !== endpoints.length) {
+    const scopedPaths = {};
+    for (const endpoint of detailEndpoints) {
+      const source = isObject(spec.paths?.[endpoint.path]) ? spec.paths[endpoint.path] : {};
+      const item = scopedPaths[endpoint.path] ?? { ...source };
+      for (const method of HTTP_METHODS2) delete item[method];
+      item[endpoint.method] = source[endpoint.method];
+      scopedPaths[endpoint.path] = item;
+    }
+    modelSpec = { ...spec, paths: scopedPaths };
+  }
+  const models = referencedSchemas(modelSpec);
+  const modelSection = !stage.indexOnly && 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 |"]
+  ];
+  if (!stage.indexOnly) {
+    sections.push(
+      "",
+      "## Endpoints",
+      "",
+      ...groupedEndpoints.length ? groupedEndpoints : ["_No endpoints declared._"]
+    );
+  }
+  if (modelSection) {
+    sections.push("", modelSection);
+  }
+  return `${sections.join("\n").replace(/\n{3,}/g, "\n\n").trim()}
+`;
+}
+function appendTrimNote(markdown, actions, budget) {
+  return `${markdown}
+## Trimmed
+
+> _Trimmed to fit the ~${budget.toLocaleString()}-token budget: ${actions.join("; ")}._
+`;
+}
+function transformOpenApiToMarkdown(spec, sourceUrl, options = {}) {
+  const warnings = [];
+  const filteredSpec = filterSpec(spec, getEndpoints(spec), options, warnings);
+  for (const message of warnings) options.onWarning?.(message);
+  const normalizedSpec = normalizeInlinePayloadSchemas(filteredSpec);
+  const endpoints = getEndpoints(normalizedSpec);
+  const tags = collectTags(normalizedSpec, endpoints);
+  const fullStage = {
+    includeExamples: true,
+    collapsedTags: /* @__PURE__ */ new Set(),
+    indexOnly: false
+  };
+  if (options.maxTokens === void 0) {
+    return renderDigest(normalizedSpec, sourceUrl, endpoints, tags, fullStage);
+  }
+  const worst = (markdown2) => {
+    const report = estimateTokens(markdown2);
+    return Math.max(...Object.values(report.models).map((model) => model.tokens));
+  };
+  const fits = (markdown2) => worst(markdown2) <= options.maxTokens;
+  const full = renderDigest(normalizedSpec, sourceUrl, endpoints, tags, fullStage);
+  if (fits(full)) return full;
+  const stages = buildTrimStages(endpoints, tags);
+  for (let i = 1; i < stages.length; i += 1) {
+    const stage = stages[i];
+    const markdown2 = renderDigest(normalizedSpec, sourceUrl, endpoints, tags, stage);
+    if (fits(markdown2)) {
+      return appendTrimNote(
+        markdown2,
+        stages.slice(1, i + 1).map((entry) => entry.action).filter((action) => Boolean(action)),
+        options.maxTokens
+      );
+    }
+  }
+  const last = stages[stages.length - 1];
+  const markdown = renderDigest(normalizedSpec, sourceUrl, endpoints, tags, last);
+  const allActions = stages.slice(1).map((stage) => stage.action).filter((action) => Boolean(action));
+  return appendTrimNote(markdown, allActions, options.maxTokens);
+}
+
+// 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 {
+  VERSION,
+  toTypeScriptIdentifier,
+  isOpenApiSpec,
+  parseSpecText,
+  fetchOpenApiSpec,
+  estimateTokens,
+  transformOpenApiToMarkdown,
+  defaultOutputDirectory,
+  defaultFilename,
+  resolveOutputDirectory,
+  normalizeFilename,
+  writeDigest
+};