@djangocfg/ui-tools 2.1.287 → 2.1.290

package/dist/DocsLayout-JPXFUKAR.mjs

@@ -0,0 +1,3457 @@
+import { deduplicateEndpoints, dereferenceSchema, resolveBaseUrl, usePlaygroundContext, toMarkdown, toCompactJson, toRawJson, formatBytes, MarkdownMessage, CODE_SAMPLE_TARGETS, buildHarRequest, resolveAbsolute, renderSnippet, PrettyCode_default, relativePath, endpointToMarkdown, isValidJson, findApiKeyById, parseRequestHeaders, UrlBuilder, sampleSchemaJson, joinUrl } from './chunk-EFWOJPA6.mjs';
+import { JsonTree_default } from './chunk-LFWQ36LJ.mjs';
+import './chunk-SSUOENAZ.mjs';
+import { __name } from './chunk-CGILA3WO.mjs';
+import React12, { createContext, useRef, useCallback, useEffect, useMemo, useState, useContext } from 'react';
+import { groupBy, orderBy, partition, sortBy, keyBy } from 'lodash-es';
+import { Tooltip, TooltipTrigger, TooltipContent, DropdownMenu, DropdownMenuTrigger, Button, DropdownMenuContent, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuItem, Input, Combobox, SafeTooltipProvider, CopyButton, Switch, Textarea, SidePanel, ResponsiveSheet, ResponsiveSheetContent, ResponsiveSheetHeader, ResponsiveSheetTitle, Skeleton, TooltipProvider } from '@djangocfg/ui-core/components';
+import { toast, useMediaQuery } from '@djangocfg/ui-core/hooks';
+import consola from 'consola';
+import { ChevronRight, Sparkles, ChevronDown, Check, Search, X, Link2, FileCode2, ChevronsDownUp, ChevronsUpDown, Play, Minus, Plus, RotateCcw, Send, Key, Terminal, Info, ShieldCheck, Loader2, WifiOff, AlertCircle } from 'lucide-react';
+import { cn } from '@djangocfg/ui-core/lib';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+import { create } from 'zustand';
+import { persist, createJSONStorage } from 'zustand/middleware';
+
+var HTTP_METHODS = ["get", "post", "put", "patch", "delete"];
+var extractEndpoints = /* @__PURE__ */ __name((schema, baseUrl, schemaId, specRoot) => {
+  const endpoints = [];
+  if (!schema.paths) return [];
+  for (const [path, methods] of Object.entries(schema.paths)) {
+    for (const method of HTTP_METHODS) {
+      const op = methods[method];
+      if (!op) continue;
+      const methodUpper = method.toUpperCase();
+      const summary = (op.summary || "").trim();
+      const description = op.description || summary || `${methodUpper} ${path}`;
+      const category = op.tags?.[0] || "Other";
+      const parameters = [];
+      const allParams = [...methods.parameters || [], ...op.parameters || []];
+      for (const param of allParams) {
+        parameters.push({
+          name: param.name,
+          type: param.schema?.type || "string",
+          required: param.required || false,
+          description: param.description
+        });
+      }
+      const responses = [];
+      if (op.responses) {
+        for (const [code, response] of Object.entries(op.responses)) {
+          const respContent = response.content;
+          const contentKeys = respContent ? Object.keys(respContent) : [];
+          const chosenContentType = respContent?.["application/json"] ? "application/json" : contentKeys[0];
+          const chosen = chosenContentType ? respContent?.[chosenContentType] : void 0;
+          const respSchema = chosen?.schema;
+          responses.push({
+            code,
+            description: response.description || `Response ${code}`,
+            contentType: chosenContentType,
+            schema: respSchema,
+            example: respSchema ? sampleSchemaJson(respSchema, { skipWriteOnly: true }, specRoot) : void 0
+          });
+        }
+      }
+      let requestBody;
+      if (op.requestBody) {
+        const content = op.requestBody.content;
+        const mediaType = content?.["application/json"] || content?.[Object.keys(content || {})[0]];
+        const rawSchema = mediaType?.schema;
+        requestBody = {
+          type: rawSchema?.type || "object",
+          description: op.requestBody.description,
+          schema: rawSchema,
+          example: rawSchema ? sampleSchemaJson(rawSchema, { skipReadOnly: true }, specRoot) : void 0
+        };
+      }
+      const endpoint = {
+        name: path.split("/").pop() || path,
+        method: methodUpper,
+        path: baseUrl ? joinUrl(baseUrl, path) : path,
+        summary,
+        description,
+        category,
+        parameters: parameters.length > 0 ? parameters : void 0,
+        requestBody,
+        responses: responses.length > 0 ? responses : void 0,
+        schemaId
+      };
+      endpoints.push(endpoint);
+    }
+  }
+  return endpoints;
+}, "extractEndpoints");
+var getCategories = /* @__PURE__ */ __name((endpoints) => {
+  const categories = /* @__PURE__ */ new Set();
+  endpoints.forEach((endpoint) => categories.add(endpoint.category));
+  return Array.from(categories).sort();
+}, "getCategories");
+var fetchSchema = /* @__PURE__ */ __name(async (url) => {
+  const response = await fetch(url, {
+    headers: {
+      "Accept": "application/json"
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch schema: ${response.statusText}`);
+  }
+  return response.json();
+}, "fetchSchema");
+function useOpenApiSchema({
+  schemas,
+  defaultSchemaId,
+  baseUrl: configBaseUrl,
+  preloadAll = false
+}) {
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [currentSchemaId, setCurrentSchemaId] = useState(
+    defaultSchemaId || schemas[0]?.id
+  );
+  const [loadedSchemas, setLoadedSchemas] = useState(
+    /* @__PURE__ */ new Map()
+  );
+  const [loadStates, setLoadStates] = useState(/* @__PURE__ */ new Map());
+  const currentSchema = useMemo(
+    () => schemas.find((s) => s.id === currentSchemaId) || null,
+    [schemas, currentSchemaId]
+  );
+  const currentOpenApiSchema = useMemo(
+    () => currentSchemaId ? loadedSchemas.get(currentSchemaId) : null,
+    [loadedSchemas, currentSchemaId]
+  );
+  const dereferencedSchema = useMemo(
+    () => currentOpenApiSchema ? dereferenceSchema(currentOpenApiSchema) : null,
+    [currentOpenApiSchema]
+  );
+  const resolvedBaseUrl = useMemo(
+    () => resolveBaseUrl({
+      schemaSource: currentSchema?.baseUrl,
+      config: configBaseUrl,
+      fromServers: currentOpenApiSchema?.servers?.[0]?.url
+    }),
+    [currentSchema?.baseUrl, configBaseUrl, currentOpenApiSchema]
+  );
+  const endpoints = useMemo(
+    () => dereferencedSchema ? extractEndpoints(dereferencedSchema, resolvedBaseUrl, currentSchemaId, currentOpenApiSchema ?? void 0) : [],
+    [dereferencedSchema, resolvedBaseUrl, currentSchemaId, currentOpenApiSchema]
+  );
+  const categories = useMemo(() => getCategories(endpoints), [endpoints]);
+  const schemaInfo = useMemo(() => {
+    if (!currentOpenApiSchema?.info) return null;
+    const { title, version, description } = currentOpenApiSchema.info;
+    return {
+      title,
+      version,
+      description,
+      servers: currentOpenApiSchema.servers
+    };
+  }, [currentOpenApiSchema]);
+  useEffect(() => {
+    if (preloadAll) return;
+    if (!currentSchema) return;
+    if (loadedSchemas.has(currentSchema.id)) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    fetchSchema(currentSchema.url).then((schema) => {
+      setLoadedSchemas((prev) => new Map(prev).set(currentSchema.id, schema));
+      consola.success(`Schema loaded: ${currentSchema.name}`);
+      setLoading(false);
+    }).catch((err) => {
+      consola.error(`Error loading schema from ${currentSchema.url}:`, err);
+      setError(err instanceof Error ? err.message : "Failed to load schema");
+      setLoading(false);
+    });
+  }, [currentSchema, loadedSchemas, preloadAll]);
+  useEffect(() => {
+    if (!preloadAll) return;
+    if (schemas.length === 0) {
+      setLoading(false);
+      return;
+    }
+    let cancelled = false;
+    const pending = schemas.filter((s) => !loadedSchemas.has(s.id));
+    if (pending.length === 0) {
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setLoadStates((prev) => {
+      const next = new Map(prev);
+      for (const s of pending) next.set(s.id, { loading: true, error: null });
+      return next;
+    });
+    Promise.allSettled(
+      pending.map(
+        (s) => fetchSchema(s.url).then((schema) => ({ id: s.id, name: s.name, schema }))
+      )
+    ).then((results) => {
+      if (cancelled) return;
+      setLoadedSchemas((prev) => {
+        const next = new Map(prev);
+        for (const r of results) {
+          if (r.status === "fulfilled") {
+            next.set(r.value.id, r.value.schema);
+            consola.success(`Schema loaded: ${r.value.name}`);
+          }
+        }
+        return next;
+      });
+      setLoadStates((prev) => {
+        const next = new Map(prev);
+        results.forEach((r, i) => {
+          const src = pending[i];
+          if (r.status === "fulfilled") {
+            next.set(src.id, { loading: false, error: null });
+          } else {
+            const msg = r.reason instanceof Error ? r.reason.message : "Failed to load schema";
+            consola.error(`Error loading schema from ${src.url}:`, r.reason);
+            next.set(src.id, { loading: false, error: msg });
+          }
+        });
+        return next;
+      });
+      setLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [preloadAll, schemas, loadedSchemas]);
+  const schemasData = useMemo(() => {
+    if (!preloadAll) return [];
+    return schemas.map((src) => {
+      const raw = loadedSchemas.get(src.id) ?? null;
+      const deref = raw ? dereferenceSchema(raw) : null;
+      const resolved = resolveBaseUrl({
+        schemaSource: src.baseUrl,
+        config: configBaseUrl,
+        fromServers: raw?.servers?.[0]?.url
+      });
+      const info = raw?.info ? {
+        title: raw.info.title,
+        version: raw.info.version,
+        description: raw.info.description,
+        servers: raw.servers
+      } : null;
+      const eps = deref ? extractEndpoints(deref, resolved, src.id, raw ?? void 0) : [];
+      const state = loadStates.get(src.id) ?? { loading: !raw, error: null };
+      return {
+        source: src,
+        info,
+        rawSchema: raw,
+        endpoints: eps,
+        resolvedBaseUrl: resolved || void 0,
+        loading: state.loading,
+        error: state.error
+      };
+    });
+  }, [preloadAll, schemas, loadedSchemas, loadStates, configBaseUrl]);
+  const setCurrentSchema = useCallback((schemaId) => {
+    setCurrentSchemaId(schemaId);
+  }, []);
+  const refresh = useCallback(() => {
+    if (!currentSchema) return;
+    setLoading(true);
+    setError(null);
+    setLoadedSchemas((prev) => {
+      const next = new Map(prev);
+      next.delete(currentSchema.id);
+      return next;
+    });
+    fetchSchema(currentSchema.url).then((schema) => {
+      setLoadedSchemas((prev) => new Map(prev).set(currentSchema.id, schema));
+      consola.success(`Schema refreshed: ${currentSchema.name}`);
+      setLoading(false);
+    }).catch((err) => {
+      consola.error(`Error refreshing schema from ${currentSchema.url}:`, err);
+      setError(err instanceof Error ? err.message : "Failed to refresh schema");
+      setLoading(false);
+    });
+  }, [currentSchema]);
+  return {
+    loading,
+    error,
+    endpoints,
+    categories,
+    schemas,
+    currentSchema,
+    schemaInfo,
+    rawSchema: currentOpenApiSchema ?? null,
+    // Consumers expect ``undefined`` when no base URL was resolved (for
+    // conditional ``{ baseUrl?: … }`` plumbing). Turn the empty-string
+    // convention from the resolver into undefined at the API boundary.
+    resolvedBaseUrl: resolvedBaseUrl || void 0,
+    setCurrentSchema,
+    refresh,
+    schemasData
+  };
+}
+__name(useOpenApiSchema, "useOpenApiSchema");
+function parseDocsHash(hash) {
+  const raw = hash.startsWith("#") ? hash.slice(1) : hash;
+  if (!raw) return { schemaId: null, anchor: null };
+  const [schemaId = null, ...rest] = raw.split("/");
+  const anchor = rest.length > 0 ? rest.join("/") : null;
+  return {
+    schemaId: schemaId || null,
+    anchor: anchor || null
+  };
+}
+__name(parseDocsHash, "parseDocsHash");
+function buildDocsHash(schemaId, anchor) {
+  if (!schemaId && !anchor) return "";
+  if (schemaId && anchor) return `#${schemaId}/${anchor}`;
+  if (schemaId) return `#${schemaId}`;
+  return anchor ? `#${anchor}` : "";
+}
+__name(buildDocsHash, "buildDocsHash");
+function useDocsUrlSync({
+  enabled,
+  currentSchemaId,
+  activeAnchor,
+  onHashTarget
+}) {
+  const primedRef = useRef(false);
+  const onHashTargetRef = useRef(onHashTarget);
+  useEffect(() => {
+    onHashTargetRef.current = onHashTarget;
+  }, [onHashTarget]);
+  useEffect(() => {
+    if (!enabled || typeof window === "undefined") return;
+    const apply = /* @__PURE__ */ __name(() => {
+      onHashTargetRef.current(parseDocsHash(window.location.hash));
+    }, "apply");
+    apply();
+    primedRef.current = true;
+    window.addEventListener("hashchange", apply);
+    window.addEventListener("popstate", apply);
+    return () => {
+      window.removeEventListener("hashchange", apply);
+      window.removeEventListener("popstate", apply);
+    };
+  }, [enabled]);
+  useEffect(() => {
+    if (!enabled || typeof window === "undefined") return;
+    if (!primedRef.current) return;
+    const next = buildDocsHash(currentSchemaId, activeAnchor);
+    const current = window.location.hash;
+    if (next === current) return;
+    const url = next ? `${window.location.pathname}${window.location.search}${next}` : `${window.location.pathname}${window.location.search}`;
+    window.history.replaceState(window.history.state, "", url);
+  }, [enabled, currentSchemaId, activeAnchor]);
+  const pushTarget = useCallback(
+    (schemaId, anchor) => {
+      if (!enabled || typeof window === "undefined") return;
+      const next = buildDocsHash(schemaId, anchor);
+      const url = next ? `${window.location.pathname}${window.location.search}${next}` : `${window.location.pathname}${window.location.search}`;
+      window.history.pushState(window.history.state, "", url);
+    },
+    [enabled]
+  );
+  return { pushTarget };
+}
+__name(useDocsUrlSync, "useDocsUrlSync");
+var EMPTY_DRAFT = { parameters: {}, requestBody: "" };
+function storageKey(schemaId, ep) {
+  if (!schemaId || !ep) return null;
+  return `openapi-playground:draft:${schemaId}:${ep.method}:${ep.path}`;
+}
+__name(storageKey, "storageKey");
+function readDraft(key) {
+  if (!key || typeof window === "undefined") return EMPTY_DRAFT;
+  try {
+    const raw = window.localStorage.getItem(key);
+    if (!raw) return EMPTY_DRAFT;
+    const parsed = JSON.parse(raw);
+    return {
+      parameters: parsed?.parameters ?? {},
+      requestBody: typeof parsed?.requestBody === "string" ? parsed.requestBody : ""
+    };
+  } catch {
+    return EMPTY_DRAFT;
+  }
+}
+__name(readDraft, "readDraft");
+function writeDraft(key, value) {
+  if (!key || typeof window === "undefined") return;
+  try {
+    if (Object.keys(value.parameters).length === 0 && !value.requestBody) {
+      window.localStorage.removeItem(key);
+      return;
+    }
+    window.localStorage.setItem(key, JSON.stringify(value));
+  } catch {
+  }
+}
+__name(writeDraft, "writeDraft");
+function useEndpointDraft(schemaId, endpoint) {
+  const key = storageKey(schemaId, endpoint);
+  const [draft, setDraftSnapshot] = useState(() => readDraft(key));
+  const loadedKeyRef = useRef(key);
+  useEffect(() => {
+    if (loadedKeyRef.current === key) return;
+    loadedKeyRef.current = key;
+    setDraftSnapshot(readDraft(key));
+  }, [key]);
+  const keyRef = useRef(key);
+  useEffect(() => {
+    keyRef.current = key;
+  }, [key]);
+  const latestRef = useRef(draft);
+  useEffect(() => {
+    latestRef.current = draft;
+  }, [draft]);
+  const setParameters = useCallback((params) => {
+    const next = {
+      parameters: params,
+      requestBody: latestRef.current.requestBody
+    };
+    latestRef.current = next;
+    writeDraft(keyRef.current, next);
+  }, []);
+  const setRequestBody = useCallback((body) => {
+    const next = {
+      parameters: latestRef.current.parameters,
+      requestBody: body
+    };
+    latestRef.current = next;
+    writeDraft(keyRef.current, next);
+  }, []);
+  const reset = useCallback(() => {
+    latestRef.current = EMPTY_DRAFT;
+    if (keyRef.current && typeof window !== "undefined") {
+      try {
+        window.localStorage.removeItem(keyRef.current);
+      } catch {
+      }
+    }
+    setDraftSnapshot(EMPTY_DRAFT);
+  }, []);
+  return { draft, setParameters, setRequestBody, reset };
+}
+__name(useEndpointDraft, "useEndpointDraft");
+
+// src/tools/OpenapiViewer/components/shared/EndpointDraftSync.tsx
+function EndpointDraftSync({ schemaId }) {
+  const { state, setParameters, setRequestBody, setActiveSchemaId } = usePlaygroundContext();
+  const ep = state.selectedEndpoint;
+  useEffect(() => {
+    setActiveSchemaId(schemaId);
+  }, [schemaId, setActiveSchemaId]);
+  const { draft, setParameters: persistParams, setRequestBody: persistBody } = useEndpointDraft(schemaId, ep);
+  const lastLoadedKeyRef = useRef(null);
+  const lastPersistedParamsRef = useRef("");
+  const lastPersistedBodyRef = useRef("");
+  const currentKey = ep ? `${ep.method}|${ep.path}` : null;
+  useEffect(() => {
+    if (!ep || !currentKey) {
+      lastLoadedKeyRef.current = null;
+      return;
+    }
+    if (lastLoadedKeyRef.current === currentKey) return;
+    lastLoadedKeyRef.current = currentKey;
+    const hasStoredParams = draft.parameters && Object.keys(draft.parameters).length > 0;
+    const hasStoredBody = typeof draft.requestBody === "string" && draft.requestBody !== "";
+    if (hasStoredParams) {
+      setParameters(draft.parameters);
+      lastPersistedParamsRef.current = JSON.stringify(draft.parameters);
+    } else {
+      lastPersistedParamsRef.current = JSON.stringify(state.parameters);
+    }
+    if (hasStoredBody) {
+      setRequestBody(draft.requestBody);
+      lastPersistedBodyRef.current = draft.requestBody;
+    } else {
+      lastPersistedBodyRef.current = state.requestBody;
+    }
+  }, [currentKey]);
+  useEffect(() => {
+    if (!ep || lastLoadedKeyRef.current !== currentKey) return;
+    const serialised = JSON.stringify(state.parameters);
+    if (serialised === lastPersistedParamsRef.current) return;
+    lastPersistedParamsRef.current = serialised;
+    persistParams(state.parameters);
+  }, [state.parameters, ep, currentKey, persistParams]);
+  useEffect(() => {
+    if (!ep || lastLoadedKeyRef.current !== currentKey) return;
+    if (state.requestBody === lastPersistedBodyRef.current) return;
+    lastPersistedBodyRef.current = state.requestBody;
+    persistBody(state.requestBody);
+  }, [state.requestBody, ep, currentKey, persistBody]);
+  return null;
+}
+__name(EndpointDraftSync, "EndpointDraftSync");
+
+// src/tools/OpenapiViewer/components/DocsLayout/anchor.ts
+function endpointAnchor(ep, schemaId) {
+  const slug = ep.path.replace(/^https?:\/\/[^/]+/, "").replace(/[{}]/g, "").replace(/[^a-zA-Z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+  const schemaSlug = schemaId ? `${slugifySchemaId(schemaId)}-` : "";
+  return `ep-${schemaSlug}${ep.method.toLowerCase()}-${slug}`;
+}
+__name(endpointAnchor, "endpointAnchor");
+function slugifySchemaId(id) {
+  return id.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+__name(slugifySchemaId, "slugifySchemaId");
+var METHOD_STYLES = {
+  GET: "bg-emerald-500/10 text-emerald-600 dark:text-emerald-400 border-emerald-500/25",
+  POST: "bg-blue-500/10    text-blue-600    dark:text-blue-400    border-blue-500/25",
+  PUT: "bg-amber-500/10   text-amber-600   dark:text-amber-400   border-amber-500/25",
+  PATCH: "bg-orange-500/10  text-orange-600  dark:text-orange-400  border-orange-500/25",
+  DELETE: "bg-red-500/10     text-red-600     dark:text-red-400     border-red-500/25"
+};
+var METHOD_FALLBACK = "bg-muted text-muted-foreground border-border";
+function getMethodStyle(method) {
+  return METHOD_STYLES[method.toUpperCase()] ?? METHOD_FALLBACK;
+}
+__name(getMethodStyle, "getMethodStyle");
+function getStatusStyle(status) {
+  if (status >= 500) return "bg-red-500/10 text-red-500 dark:text-red-400 border-red-500/25";
+  if (status >= 400) return "bg-amber-500/10 text-amber-600 dark:text-amber-400 border-amber-500/25";
+  if (status >= 300) return "bg-blue-500/10 text-blue-600 dark:text-blue-400 border-blue-500/25";
+  return "bg-emerald-500/10 text-emerald-600 dark:text-emerald-400 border-emerald-500/25";
+}
+__name(getStatusStyle, "getStatusStyle");
+function MethodBadge({ method }) {
+  return /* @__PURE__ */ jsx("span", { className: cn(
+    "inline-flex shrink-0 items-center rounded border px-1.5 py-px",
+    "font-mono text-[10px] font-bold uppercase tracking-wider leading-none",
+    getMethodStyle(method)
+  ), children: method });
+}
+__name(MethodBadge, "MethodBadge");
+function StatusBadge({ status }) {
+  return /* @__PURE__ */ jsx("span", { className: cn(
+    "inline-flex items-center rounded border px-1.5 py-px",
+    "font-mono text-[11px] font-bold leading-none",
+    getStatusStyle(status)
+  ), children: status });
+}
+__name(StatusBadge, "StatusBadge");
+function SectionLabel({ children }) {
+  return /* @__PURE__ */ jsx("p", { className: "text-[10px] font-semibold uppercase tracking-wider text-muted-foreground/60 select-none", children });
+}
+__name(SectionLabel, "SectionLabel");
+function Panel({ children, className }) {
+  return /* @__PURE__ */ jsx("div", { className: cn("flex flex-col min-h-0 overflow-hidden", className), children });
+}
+__name(Panel, "Panel");
+function ScrollArea({ children, className }) {
+  return /* @__PURE__ */ jsx("div", { className: cn("flex-1 overflow-y-auto min-h-0", className), children });
+}
+__name(ScrollArea, "ScrollArea");
+function EmptyState({
+  icon: Icon,
+  text,
+  className
+}) {
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "flex flex-col items-center justify-center h-full gap-3 px-6 text-center",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx(Icon, { className: "h-7 w-7 text-muted-foreground/25" }),
+        /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground", children: text })
+      ]
+    }
+  );
+}
+__name(EmptyState, "EmptyState");
+function CollapsibleSection({
+  label,
+  action,
+  children,
+  defaultOpen = false
+}) {
+  const [open, setOpen] = React12.useState(defaultOpen);
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-0", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between", children: [
+      /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          onClick: () => setOpen((v) => !v),
+          className: "flex items-center gap-1.5 text-[10px] font-semibold uppercase tracking-wider text-muted-foreground/60 hover:text-muted-foreground transition-colors py-1",
+          children: [
+            /* @__PURE__ */ jsx(ChevronRight, { className: cn("h-3 w-3 transition-transform", open && "rotate-90") }),
+            label
+          ]
+        }
+      ),
+      action && /* @__PURE__ */ jsx("div", { className: "shrink-0", children: action })
+    ] }),
+    open && /* @__PURE__ */ jsx("div", { children })
+  ] });
+}
+__name(CollapsibleSection, "CollapsibleSection");
+var FLAVOUR_LABELS = {
+  markdown: {
+    title: "Markdown for LLM",
+    hint: "Endpoints + params as prose. Smallest."
+  },
+  compact: {
+    title: "Compact JSON",
+    hint: "Dereferenced, no examples, minified."
+  },
+  raw: {
+    title: "Raw JSON",
+    hint: "Full OpenAPI document with $refs."
+  }
+};
+function SchemaCopyMenu({ schema, endpoints, baseUrl, variant = "button" }) {
+  const [sizeCache, setSizeCache] = useState({});
+  const [justCopied, setJustCopied] = useState(null);
+  const [open, setOpen] = useState(false);
+  const isReady = schema !== null && endpoints.length > 0;
+  const build = useCallback(
+    (flavour) => {
+      if (!schema) return "";
+      if (flavour === "markdown") return toMarkdown(schema, endpoints, baseUrl);
+      if (flavour === "compact") return toCompactJson(schema, baseUrl);
+      return toRawJson(schema, baseUrl);
+    },
+    [schema, endpoints, baseUrl]
+  );
+  const handleCopy = useCallback(
+    async (flavour) => {
+      if (!isReady) return;
+      const text = build(flavour);
+      const label = FLAVOUR_LABELS[flavour].title;
+      try {
+        await navigator.clipboard.writeText(text);
+        const size = formatBytes(text);
+        setSizeCache((prev) => ({ ...prev, [flavour]: size }));
+        setJustCopied(flavour);
+        setTimeout(() => setJustCopied(null), 1500);
+        setOpen(false);
+        toast.success(`Copied ${label}`, { description: size });
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Clipboard permission denied";
+        toast.error("Copy failed", { description: message });
+      }
+    },
+    [build, isReady]
+  );
+  const flavours = useMemo(() => ["markdown", "compact", "raw"], []);
+  return /* @__PURE__ */ jsxs(DropdownMenu, { open, onOpenChange: setOpen, children: [
+    /* @__PURE__ */ jsx(DropdownMenuTrigger, { asChild: true, children: variant === "icon" ? /* @__PURE__ */ jsx(
+      Button,
+      {
+        variant: "ghost",
+        size: "icon",
+        className: "h-7 w-7 shrink-0",
+        disabled: !isReady,
+        title: "Copy schema for AI",
+        "aria-label": "Copy schema for AI",
+        children: /* @__PURE__ */ jsx(Sparkles, { className: "h-3.5 w-3.5" })
+      }
+    ) : /* @__PURE__ */ jsxs(Button, { variant: "outline", size: "sm", className: "h-8 gap-1.5 text-xs", disabled: !isReady, children: [
+      /* @__PURE__ */ jsx(Sparkles, { className: "h-3 w-3" }),
+      "Copy for AI",
+      /* @__PURE__ */ jsx(ChevronDown, { className: "h-3 w-3 opacity-60" })
+    ] }) }),
+    /* @__PURE__ */ jsxs(
+      DropdownMenuContent,
+      {
+        side: "right",
+        align: "start",
+        sideOffset: 6,
+        collisionPadding: 8,
+        className: "w-60 max-w-[calc(100vw-16px)]",
+        children: [
+          /* @__PURE__ */ jsx(DropdownMenuLabel, { className: "text-[10px] uppercase tracking-wider text-muted-foreground/70", children: "Copy schema" }),
+          /* @__PURE__ */ jsx(DropdownMenuSeparator, {}),
+          flavours.map((f) => {
+            const label = FLAVOUR_LABELS[f];
+            const size = sizeCache[f];
+            const isDone = justCopied === f;
+            return /* @__PURE__ */ jsxs(
+              DropdownMenuItem,
+              {
+                onClick: (e) => {
+                  e.preventDefault();
+                  void handleCopy(f);
+                },
+                className: "flex flex-col items-start gap-0.5 py-2 cursor-pointer",
+                children: [
+                  /* @__PURE__ */ jsxs("div", { className: "flex w-full items-center gap-2", children: [
+                    /* @__PURE__ */ jsx("span", { className: "text-xs font-medium flex-1", children: label.title }),
+                    isDone ? /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1 text-[10px] text-emerald-500", children: [
+                      /* @__PURE__ */ jsx(Check, { className: "h-3 w-3" }),
+                      " Copied"
+                    ] }) : size ? /* @__PURE__ */ jsx("span", { className: "text-[10px] font-mono text-muted-foreground/70 tabular-nums", children: size }) : null
+                  ] }),
+                  /* @__PURE__ */ jsx("span", { className: "text-[10px] text-muted-foreground/70 leading-snug line-clamp-1", children: label.hint })
+                ]
+              },
+              f
+            );
+          })
+        ]
+      }
+    )
+  ] });
+}
+__name(SchemaCopyMenu, "SchemaCopyMenu");
+function BrandHeader({ info, endpoints, rawSchema, resolvedBaseUrl }) {
+  const apiTitle = info?.title ?? "API Reference";
+  const copyReady = rawSchema !== null && rawSchema !== void 0 && endpoints.length > 0;
+  return /* @__PURE__ */ jsxs("div", { className: "shrink-0 border-b px-3 py-2.5 flex items-start gap-2", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex-1 min-w-0", children: [
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "text-[13px] font-semibold text-foreground leading-tight truncate",
+          title: apiTitle,
+          children: apiTitle
+        }
+      ),
+      info?.version && /* @__PURE__ */ jsxs("div", { className: "font-mono text-[10px] text-muted-foreground/60 leading-tight mt-0.5", children: [
+        "v",
+        info.version
+      ] })
+    ] }),
+    copyReady && /* @__PURE__ */ jsx(
+      SchemaCopyMenu,
+      {
+        schema: rawSchema ?? null,
+        endpoints,
+        baseUrl: resolvedBaseUrl,
+        variant: "icon"
+      }
+    )
+  ] });
+}
+__name(BrandHeader, "BrandHeader");
+
+// src/tools/OpenapiViewer/components/DocsLayout/sidebarLabel.ts
+function longestCommonPrefix(paths) {
+  if (paths.length === 0) return "";
+  if (paths.length === 1) return "";
+  const segments = paths.map((p) => p.split("/"));
+  const minLen = Math.min(...segments.map((s) => s.length));
+  const shared = [];
+  for (let i = 0; i < minLen; i++) {
+    const first = segments[0][i];
+    if (segments.every((s) => s[i] === first)) {
+      shared.push(first);
+    } else {
+      break;
+    }
+  }
+  const joined = shared.join("/");
+  return joined;
+}
+__name(longestCommonPrefix, "longestCommonPrefix");
+function sidebarLabel(ep, groupCommonPrefix) {
+  if (ep.summary) return ep.summary;
+  if (groupCommonPrefix && ep.path.startsWith(groupCommonPrefix)) {
+    const tail = ep.path.slice(groupCommonPrefix.length) || "/";
+    return tail;
+  }
+  return relativePath2(ep.path);
+}
+__name(sidebarLabel, "sidebarLabel");
+function relativePath2(full) {
+  try {
+    return new URL(full).pathname;
+  } catch {
+    return full;
+  }
+}
+__name(relativePath2, "relativePath");
+function sidebarTooltip(ep) {
+  return `${ep.method} ${relativePath2(ep.path)}`;
+}
+__name(sidebarTooltip, "sidebarTooltip");
+
+// src/tools/OpenapiViewer/components/DocsLayout/grouping.ts
+var METHOD_ORDER = {
+  GET: 0,
+  POST: 1,
+  PUT: 2,
+  PATCH: 3,
+  DELETE: 4
+};
+var methodRank = /* @__PURE__ */ __name((ep) => METHOD_ORDER[ep.method] ?? 99, "methodRank");
+function groupEndpoints(list) {
+  const byCategory = groupBy(list, "category");
+  const all = Object.entries(byCategory).map(([category, endpoints]) => ({
+    category,
+    endpoints: orderBy(endpoints, ["path", methodRank], ["asc", "asc"]),
+    commonPrefix: longestCommonPrefix(endpoints.map((e) => e.path))
+  }));
+  const [other, named] = partition(all, (g) => g.category === "Other");
+  return [...sortBy(named, (g) => g.category.toLowerCase()), ...other];
+}
+__name(groupEndpoints, "groupEndpoints");
+function buildSchemaSections(sources, endpointsBySchema) {
+  return sources.map((source) => ({
+    source,
+    groups: groupEndpoints(endpointsBySchema[source.id] ?? [])
+  }));
+}
+__name(buildSchemaSections, "buildSchemaSections");
+
+// src/tools/OpenapiViewer/components/DocsLayout/Sidebar/buildVM.ts
+function filterEndpoints(list, query, method) {
+  let out = list;
+  if (method !== "ALL") {
+    out = out.filter((e) => e.method === method);
+  }
+  if (query) {
+    const q = query.toLowerCase();
+    out = out.filter(
+      (e) => e.summary.toLowerCase().includes(q) || e.name.toLowerCase().includes(q) || e.description.toLowerCase().includes(q) || e.path.toLowerCase().includes(q)
+    );
+  }
+  return out;
+}
+__name(filterEndpoints, "filterEndpoints");
+function buildCategory(group, activeEndpointId, schemaId, keyPrefix) {
+  const rows = group.endpoints.map((ep) => {
+    const anchor = endpointAnchor(ep, schemaId ?? ep.schemaId ?? null);
+    return {
+      key: `${ep.method}-${ep.path}`,
+      anchor,
+      schemaId: schemaId ?? ep.schemaId ?? null,
+      label: sidebarLabel(ep, group.commonPrefix),
+      tooltip: sidebarTooltip(ep),
+      method: ep.method,
+      useMono: !ep.summary,
+      isActive: activeEndpointId === anchor
+    };
+  });
+  return {
+    key: `${keyPrefix}${group.category}`,
+    category: group.category,
+    rows
+  };
+}
+__name(buildCategory, "buildCategory");
+function emptyTextFor(query, method, defaultText) {
+  if (query && method !== "ALL") return `No ${method} endpoints match "${query}"`;
+  if (query) return `No endpoints match "${query}"`;
+  if (method !== "ALL") return `No ${method} endpoints`;
+  return defaultText;
+}
+__name(emptyTextFor, "emptyTextFor");
+function buildFlatVM(endpoints, selectedVersion, query, method, activeEndpointId) {
+  const filtered = filterEndpoints(
+    deduplicateEndpoints(endpoints, selectedVersion),
+    query,
+    method
+  );
+  const groups = groupEndpoints(filtered);
+  return {
+    kind: "flat",
+    categories: groups.map((g) => buildCategory(g, activeEndpointId, null, "")),
+    emptyText: emptyTextFor(query, method, "No endpoints in this schema")
+  };
+}
+__name(buildFlatVM, "buildFlatVM");
+function buildSectionsVM(schemas, endpointsBySchema, selectedVersion, query, method, activeEndpointId) {
+  const filteredMap = {};
+  for (const src of schemas) {
+    const raw = endpointsBySchema[src.id] ?? [];
+    filteredMap[src.id] = filterEndpoints(
+      deduplicateEndpoints(raw, selectedVersion),
+      query,
+      method
+    );
+  }
+  const rawSections = buildSchemaSections(schemas, filteredMap);
+  const sections = rawSections.filter((s) => s.groups.length > 0).map((s) => ({
+    sourceId: s.source.id,
+    sourceName: s.source.name,
+    categories: s.groups.map(
+      (g) => buildCategory(g, activeEndpointId, s.source.id, `${s.source.id}-`)
+    )
+  }));
+  return {
+    kind: "sections",
+    sections,
+    emptyText: emptyTextFor(query, method, "No endpoints in any schema")
+  };
+}
+__name(buildSectionsVM, "buildSectionsVM");
+var EndpointRow = React12.memo(/* @__PURE__ */ __name(function EndpointRow2({
+  row,
+  onNavigate
+}) {
+  const displayLabel = row.label.replace(/\.$/, "");
+  return /* @__PURE__ */ jsxs(Tooltip, { delayDuration: 350, children: [
+    /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsxs(
+      "button",
+      {
+        onClick: () => onNavigate(row.anchor, row.schemaId),
+        "aria-current": row.isActive ? "location" : void 0,
+        className: cn(
+          "relative w-full text-left grid grid-cols-[52px_minmax(0,1fr)] items-baseline gap-2 pl-3 pr-3 py-1 transition-colors",
+          row.isActive ? "bg-primary/10 text-foreground" : "hover:bg-muted/40 text-foreground/75 hover:text-foreground"
+        ),
+        children: [
+          row.isActive && /* @__PURE__ */ jsx("span", { className: "absolute left-0 top-1 bottom-1 w-0.5 rounded-r bg-primary" }),
+          /* @__PURE__ */ jsx("span", { className: "justify-self-start", children: /* @__PURE__ */ jsx(MethodBadge, { method: row.method }) }),
+          /* @__PURE__ */ jsx(
+            "span",
+            {
+              className: cn(
+                "line-clamp-2 leading-snug min-w-0",
+                row.useMono ? "font-mono text-[11px] break-all" : "text-[12px]",
+                row.isActive && "text-foreground font-medium"
+              ),
+              children: displayLabel
+            }
+          )
+        ]
+      }
+    ) }),
+    /* @__PURE__ */ jsx(TooltipContent, { side: "right", align: "center", className: "font-mono text-[11px]", children: row.tooltip })
+  ] });
+}, "EndpointRow"));
+var CategoryBlock = React12.memo(/* @__PURE__ */ __name(function CategoryBlock2({
+  category,
+  onNavigate
+}) {
+  return /* @__PURE__ */ jsxs("div", { className: "mb-2.5 last:mb-1", children: [
+    /* @__PURE__ */ jsx("div", { className: "px-3 pt-3 pb-1 text-[10px] font-semibold uppercase tracking-[0.14em] text-muted-foreground/50 select-none", children: category.category }),
+    /* @__PURE__ */ jsx("div", { children: category.rows.map((row) => /* @__PURE__ */ jsx(EndpointRow, { row, onNavigate }, row.key)) })
+  ] });
+}, "CategoryBlock"));
+function SchemaSection({ section, onNavigate }) {
+  return /* @__PURE__ */ jsxs("div", { className: "mb-4 last:mb-2", children: [
+    /* @__PURE__ */ jsx("div", { className: "px-3 py-1.5 sticky top-0 z-[1] bg-background/95 backdrop-blur-[2px] border-b border-border/40", children: /* @__PURE__ */ jsx("span", { className: "text-[11px] font-bold uppercase tracking-[0.12em] text-foreground/80", children: section.sourceName }) }),
+    section.categories.map((cat) => /* @__PURE__ */ jsx(CategoryBlock, { category: cat, onNavigate }, cat.key))
+  ] });
+}
+__name(SchemaSection, "SchemaSection");
+function SidebarBody({ body, onNavigate }) {
+  if (body.kind === "flat") {
+    if (body.categories.length === 0) {
+      return /* @__PURE__ */ jsx("div", { className: "py-10 px-4 text-center text-xs text-muted-foreground", children: body.emptyText });
+    }
+    return /* @__PURE__ */ jsx("nav", { className: "py-1.5", children: body.categories.map((cat) => /* @__PURE__ */ jsx(CategoryBlock, { category: cat, onNavigate }, cat.key)) });
+  }
+  if (body.sections.length === 0) {
+    return /* @__PURE__ */ jsx("div", { className: "py-10 px-4 text-center text-xs text-muted-foreground", children: body.emptyText });
+  }
+  return /* @__PURE__ */ jsx("nav", { className: "py-1.5", children: body.sections.map((section) => /* @__PURE__ */ jsx(SchemaSection, { section, onNavigate }, section.sourceId)) });
+}
+__name(SidebarBody, "SidebarBody");
+
+// src/tools/OpenapiViewer/components/DocsLayout/Sidebar/types.ts
+var METHOD_FILTERS = ["ALL", "GET", "POST", "PUT", "PATCH", "DELETE"];
+function MethodChips({ value, onChange }) {
+  return /* @__PURE__ */ jsx("div", { className: "flex items-center gap-1 overflow-x-auto -mx-1 px-1 pb-px", children: METHOD_FILTERS.map((m) => {
+    const active = value === m;
+    return /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick: () => onChange(m),
+        "aria-pressed": active,
+        className: cn(
+          "shrink-0 px-2 h-6 rounded font-mono text-[10px] font-semibold tracking-wide uppercase transition-colors",
+          active ? "bg-foreground text-background" : "text-muted-foreground/70 hover:text-foreground hover:bg-muted"
+        ),
+        children: m
+      },
+      m
+    );
+  }) });
+}
+__name(MethodChips, "MethodChips");
+function SearchInput({ value, onChange, placeholder }) {
+  return /* @__PURE__ */ jsxs("div", { className: "relative", children: [
+    /* @__PURE__ */ jsx(Search, { className: "absolute left-2.5 top-1/2 -translate-y-1/2 h-3.5 w-3.5 text-muted-foreground/50 pointer-events-none" }),
+    /* @__PURE__ */ jsx(
+      Input,
+      {
+        placeholder: placeholder ?? "Search endpoints\u2026",
+        value,
+        onChange: (e) => onChange(e.target.value),
+        className: "pl-8 pr-7 h-8 text-xs"
+      }
+    ),
+    value && /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick: () => onChange(""),
+        "aria-label": "Clear search",
+        className: cn(
+          "absolute right-1.5 top-1/2 -translate-y-1/2 h-5 w-5 rounded",
+          "inline-flex items-center justify-center",
+          "text-muted-foreground/50 hover:text-foreground hover:bg-muted transition-colors"
+        ),
+        children: /* @__PURE__ */ jsx(X, { className: "h-3 w-3" })
+      }
+    )
+  ] });
+}
+__name(SearchInput, "SearchInput");
+function Toolbar({
+  schemas,
+  currentSchemaId,
+  onSchemaChange,
+  showSchemaSelector,
+  search,
+  onSearchChange,
+  methodFilter,
+  onMethodFilterChange
+}) {
+  const schemaOptions = React12.useMemo(
+    () => schemas.map((s) => ({ value: s.id, label: s.name })),
+    [schemas]
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "shrink-0 border-b px-3 py-2.5 space-y-2", children: [
+    showSchemaSelector && /* @__PURE__ */ jsx(
+      Combobox,
+      {
+        options: schemaOptions,
+        value: currentSchemaId ?? "",
+        onValueChange: (id) => id && onSchemaChange(id),
+        placeholder: "Select API",
+        searchPlaceholder: "Search APIs\u2026",
+        emptyText: "No APIs found",
+        className: "w-full h-8 text-xs"
+      }
+    ),
+    /* @__PURE__ */ jsx(SearchInput, { value: search, onChange: onSearchChange }),
+    /* @__PURE__ */ jsx(MethodChips, { value: methodFilter, onChange: onMethodFilterChange })
+  ] });
+}
+__name(Toolbar, "Toolbar");
+function useDebouncedValue(value, delayMs = 120) {
+  const [debounced, setDebounced] = useState(value);
+  useEffect(() => {
+    const id = setTimeout(() => setDebounced(value), delayMs);
+    return () => clearTimeout(id);
+  }, [value, delayMs]);
+  return debounced;
+}
+__name(useDebouncedValue, "useDebouncedValue");
+function DocsSidebar({
+  info,
+  endpoints,
+  schemas,
+  currentSchemaId,
+  onSchemaChange,
+  activeEndpointId,
+  selectedVersion,
+  onNavigate,
+  grouping = "selector",
+  endpointsBySchema,
+  rawSchema,
+  resolvedBaseUrl
+}) {
+  const [search, setSearch] = useState("");
+  const [methodFilter, setMethodFilter] = useState("ALL");
+  const debouncedSearch = useDebouncedValue(search);
+  const body = useMemo(() => {
+    if (grouping === "sections") {
+      return buildSectionsVM(
+        schemas,
+        endpointsBySchema ?? {},
+        selectedVersion,
+        debouncedSearch,
+        methodFilter,
+        activeEndpointId
+      );
+    }
+    return buildFlatVM(
+      endpoints,
+      selectedVersion,
+      debouncedSearch,
+      methodFilter,
+      activeEndpointId
+    );
+  }, [
+    grouping,
+    schemas,
+    endpointsBySchema,
+    endpoints,
+    selectedVersion,
+    debouncedSearch,
+    methodFilter,
+    activeEndpointId
+  ]);
+  const hasMultipleSchemas = schemas.length > 1;
+  const showSchemaSelector = grouping === "selector" && hasMultipleSchemas;
+  return /* @__PURE__ */ jsxs("aside", { className: "flex flex-col h-full min-h-0 border-r bg-muted/10", children: [
+    /* @__PURE__ */ jsx(
+      BrandHeader,
+      {
+        info,
+        endpoints,
+        rawSchema,
+        resolvedBaseUrl
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      Toolbar,
+      {
+        schemas,
+        currentSchemaId,
+        onSchemaChange,
+        showSchemaSelector,
+        search,
+        onSearchChange: setSearch,
+        methodFilter,
+        onMethodFilterChange: setMethodFilter
+      }
+    ),
+    /* @__PURE__ */ jsx(ScrollArea, { children: /* @__PURE__ */ jsx(SidebarBody, { body, onNavigate }) })
+  ] });
+}
+__name(DocsSidebar, "DocsSidebar");
+
+// src/tools/OpenapiViewer/utils/scrollParent.ts
+function getScrollParent(el) {
+  if (typeof window === "undefined") return null;
+  if (!el) return window;
+  let cur = el.parentElement;
+  while (cur && cur !== document.body && cur !== document.documentElement) {
+    const style = getComputedStyle(cur);
+    const overflowY = style.overflowY;
+    const canScroll = (overflowY === "auto" || overflowY === "scroll" || overflowY === "overlay") && cur.scrollHeight > cur.clientHeight;
+    if (canScroll) return cur;
+    cur = cur.parentElement;
+  }
+  return window;
+}
+__name(getScrollParent, "getScrollParent");
+function getScrollTop(target) {
+  return target === window ? window.scrollY : target.scrollTop;
+}
+__name(getScrollTop, "getScrollTop");
+function getViewportHeight(target) {
+  return target === window ? window.innerHeight : target.clientHeight;
+}
+__name(getViewportHeight, "getViewportHeight");
+function getTargetTop(target) {
+  return target === window ? 0 : target.getBoundingClientRect().top;
+}
+__name(getTargetTop, "getTargetTop");
+function scrollTargetTo(target, top) {
+  if (target === window) {
+    window.scrollTo({ top, behavior: "smooth" });
+    return;
+  }
+  target.scrollTop = top;
+}
+__name(scrollTargetTo, "scrollTargetTo");
+function ApiIntroSection({ info, schema, endpoints, resolvedBaseUrl }) {
+  const baseUrlRows = resolvedBaseUrl ? [{ url: resolvedBaseUrl, description: info.servers?.[0]?.description }] : (info.servers ?? []).map((s) => ({ url: s.url, description: s.description }));
+  return /* @__PURE__ */ jsxs("section", { className: "pb-10 mb-10 border-b", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-start justify-between gap-4 flex-wrap", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3 flex-wrap min-w-0", children: [
+        /* @__PURE__ */ jsx("h1", { className: "text-3xl font-semibold tracking-tight text-foreground leading-tight", children: info.title }),
+        /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center rounded-full bg-muted px-2 py-0.5 font-mono text-[11px] text-muted-foreground", children: [
+          "v",
+          info.version
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx(
+        SchemaCopyMenu,
+        {
+          schema,
+          endpoints,
+          baseUrl: resolvedBaseUrl
+        }
+      )
+    ] }),
+    info.description && /* @__PURE__ */ jsx("div", { className: "mt-4 text-muted-foreground", children: /* @__PURE__ */ jsx(MarkdownMessage, { content: info.description }) }),
+    baseUrlRows.length > 0 && /* @__PURE__ */ jsxs("div", { className: "mt-6 space-y-2", children: [
+      /* @__PURE__ */ jsx("h4", { className: "text-[10px] font-semibold uppercase tracking-wider text-muted-foreground/60", children: "Base URL" }),
+      /* @__PURE__ */ jsx("div", { className: "space-y-1.5", children: baseUrlRows.map((row, i) => /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-2 flex-wrap", children: [
+        /* @__PURE__ */ jsx("code", { className: "font-mono text-xs px-2 py-1 rounded bg-muted border", children: row.url }),
+        row.description && /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: row.description })
+      ] }, `${row.url}-${i}`)) })
+    ] })
+  ] });
+}
+__name(ApiIntroSection, "ApiIntroSection");
+var EndpointDocContext = createContext(null);
+function EndpointDocProvider({ endpointId, method, children }) {
+  const value = useMemo(() => ({ endpointId, method }), [endpointId, method]);
+  return /* @__PURE__ */ jsx(EndpointDocContext.Provider, { value, children });
+}
+__name(EndpointDocProvider, "EndpointDocProvider");
+function useEndpointDocContext() {
+  const ctx = useContext(EndpointDocContext);
+  if (!ctx) {
+    throw new Error(
+      "[OpenapiViewer] useEndpointDocContext must be used inside <EndpointDocProvider>."
+    );
+  }
+  return ctx;
+}
+__name(useEndpointDocContext, "useEndpointDocContext");
+var sectionKey = /* @__PURE__ */ __name((endpointId, sectionId) => `${endpointId}:${sectionId}`, "sectionKey");
+var initialState = {
+  openSections: {},
+  activeCodeTab: {}
+};
+var useEndpointDocStore = create()(
+  persist(
+    (set) => ({
+      ...initialState,
+      toggleSection: /* @__PURE__ */ __name((endpointId, sectionId) => set((state) => {
+        const key = sectionKey(endpointId, sectionId);
+        const current = state.openSections[key];
+        return {
+          openSections: {
+            ...state.openSections,
+            // If there's no explicit override yet, the user's
+            // first click means "flip from the default". We
+            // assume the default was ``true`` for the most
+            // common case (bodies/responses) and ``false``
+            // otherwise; the Section component tracks this
+            // via its ``defaultOpen`` prop and never calls
+            // toggle on sections whose defaults match the
+            // next state.
+            [key]: current === void 0 ? false : !current
+          }
+        };
+      }), "toggleSection"),
+      setSectionOpen: /* @__PURE__ */ __name((endpointId, sectionId, open) => set((state) => ({
+        openSections: {
+          ...state.openSections,
+          [sectionKey(endpointId, sectionId)]: open
+        }
+      })), "setSectionOpen"),
+      setCodeTab: /* @__PURE__ */ __name((endpointId, tab) => set((state) => ({
+        activeCodeTab: {
+          ...state.activeCodeTab,
+          [endpointId]: tab
+        }
+      })), "setCodeTab"),
+      expandAll: /* @__PURE__ */ __name((endpointId, sectionIds) => set((state) => {
+        const next = { ...state.openSections };
+        for (const sid of sectionIds) {
+          next[sectionKey(endpointId, sid)] = true;
+        }
+        return { openSections: next };
+      }), "expandAll"),
+      collapseAll: /* @__PURE__ */ __name((endpointId, sectionIds) => set((state) => {
+        const next = { ...state.openSections };
+        for (const sid of sectionIds) {
+          next[sectionKey(endpointId, sid)] = false;
+        }
+        return { openSections: next };
+      }), "collapseAll")
+    }),
+    {
+      name: "openapi-viewer:endpoint-doc",
+      storage: createJSONStorage(() => {
+        if (typeof window === "undefined") {
+          return {
+            getItem: /* @__PURE__ */ __name(() => null, "getItem"),
+            setItem: /* @__PURE__ */ __name(() => {
+            }, "setItem"),
+            removeItem: /* @__PURE__ */ __name(() => {
+            }, "removeItem")
+          };
+        }
+        return window.sessionStorage;
+      }),
+      // Only persist user overrides, not the functions. Zustand
+      // serialises everything by default and logs a warning on
+      // non-serialisable values; partialize keeps the payload lean.
+      partialize: /* @__PURE__ */ __name((state) => ({
+        openSections: state.openSections,
+        activeCodeTab: state.activeCodeTab
+      }), "partialize")
+    }
+  )
+);
+
+// src/tools/OpenapiViewer/components/DocsLayout/EndpointDoc/store/selectors.ts
+function useIsSectionOpen(endpointId, sectionId, defaultOpen) {
+  return useEndpointDocStore((s) => {
+    const explicit = s.openSections[sectionKey(endpointId, sectionId)];
+    return explicit === void 0 ? defaultOpen : explicit;
+  });
+}
+__name(useIsSectionOpen, "useIsSectionOpen");
+function useActiveCodeTab(endpointId, fallback = "curl") {
+  return useEndpointDocStore((s) => s.activeCodeTab[endpointId] ?? fallback);
+}
+__name(useActiveCodeTab, "useActiveCodeTab");
+function LanguageTabs({ activeId, onChange }) {
+  return /* @__PURE__ */ jsx("div", { className: "flex items-center gap-1 overflow-x-auto -mx-1 px-1", children: CODE_SAMPLE_TARGETS.map((t) => /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick: () => onChange(t.id),
+      className: cn(
+        "shrink-0 h-7 px-2.5 rounded text-xs font-medium transition-colors",
+        activeId === t.id ? "bg-muted text-foreground" : "text-muted-foreground/70 hover:text-foreground hover:bg-muted/50"
+      ),
+      children: t.label
+    },
+    t.id
+  )) });
+}
+__name(LanguageTabs, "LanguageTabs");
+function useCodeSnippet({
+  endpoint,
+  body,
+  parameters,
+  headers,
+  baseUrl,
+  activeId
+}) {
+  const effectiveBody = body ?? endpoint.requestBody?.example;
+  const har = useMemo(() => {
+    const h = buildHarRequest({
+      endpoint,
+      body: effectiveBody,
+      parameters,
+      headers,
+      baseUrl
+    });
+    return baseUrl ? h : { ...h, url: resolveAbsolute(h.url) };
+  }, [endpoint, effectiveBody, parameters, headers, baseUrl]);
+  return useMemo(() => {
+    const target = CODE_SAMPLE_TARGETS.find((t) => t.id === activeId);
+    const code = renderSnippet(har, activeId);
+    return {
+      snippet: code ?? `// Snippet for ${target.label} is unavailable for this request.`,
+      prism: target.prism
+    };
+  }, [har, activeId]);
+}
+__name(useCodeSnippet, "useCodeSnippet");
+function CodeSamples({ endpoint, body, parameters, headers, baseUrl }) {
+  const { endpointId } = useEndpointDocContext();
+  const activeId = useActiveCodeTab(endpointId);
+  const setCodeTab = useEndpointDocStore((s) => s.setCodeTab);
+  const { snippet, prism } = useCodeSnippet({
+    endpoint,
+    body,
+    parameters,
+    headers,
+    baseUrl,
+    activeId
+  });
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2.5", children: [
+    /* @__PURE__ */ jsx(LanguageTabs, { activeId, onChange: (id) => setCodeTab(endpointId, id) }),
+    /* @__PURE__ */ jsx(
+      PrettyCode_default,
+      {
+        data: snippet,
+        language: prism,
+        isCompact: true,
+        maxLines: 20
+      }
+    )
+  ] });
+}
+__name(CodeSamples, "CodeSamples");
+function IconButton({ label, onClick, children, active }) {
+  return /* @__PURE__ */ jsxs(Tooltip, { children: [
+    /* @__PURE__ */ jsx(TooltipTrigger, { asChild: true, children: /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        onClick,
+        "aria-label": label,
+        className: cn(
+          "shrink-0 h-6 w-6 inline-flex items-center justify-center rounded",
+          "text-muted-foreground/60 hover:text-foreground hover:bg-muted transition-colors",
+          active && "text-emerald-500 hover:text-emerald-500"
+        ),
+        children
+      }
+    ) }),
+    /* @__PURE__ */ jsx(TooltipContent, { side: "bottom", className: "text-[11px]", children: label })
+  ] });
+}
+__name(IconButton, "IconButton");
+function MetaActions({ anchor, endpointMarkdown, presentSections }) {
+  const { endpointId } = useEndpointDocContext();
+  const expandAll = useEndpointDocStore((s) => s.expandAll);
+  const collapseAll = useEndpointDocStore((s) => s.collapseAll);
+  const openSections = useEndpointDocStore((s) => s.openSections);
+  const [justCopied, setJustCopied] = useState(null);
+  const flash = useCallback((which) => {
+    setJustCopied(which);
+    setTimeout(() => setJustCopied(null), 1200);
+  }, []);
+  const mostlyOpen = useMemo(() => {
+    if (presentSections.length === 0) return false;
+    let openCount = 0;
+    for (const sid of presentSections) {
+      if (openSections[sectionKey(endpointId, sid)]) openCount += 1;
+    }
+    return openCount > presentSections.length / 2;
+  }, [openSections, presentSections, endpointId]);
+  const copyLink = useCallback(() => {
+    if (typeof window === "undefined") return;
+    const url = `${window.location.origin}${window.location.pathname}#${anchor}`;
+    void navigator.clipboard?.writeText(url).then(() => flash("link"));
+  }, [anchor, flash]);
+  const copyMarkdown = useCallback(() => {
+    if (typeof window === "undefined") return;
+    void navigator.clipboard?.writeText(endpointMarkdown).then(() => flash("md"));
+  }, [endpointMarkdown, flash]);
+  const toggleAll = useCallback(() => {
+    if (mostlyOpen) collapseAll(endpointId, presentSections);
+    else expandAll(endpointId, presentSections);
+  }, [mostlyOpen, collapseAll, expandAll, endpointId, presentSections]);
+  return /* @__PURE__ */ jsx(SafeTooltipProvider, { delayDuration: 200, children: /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-0.5", children: [
+    /* @__PURE__ */ jsx(
+      IconButton,
+      {
+        label: justCopied === "link" ? "Copied!" : "Copy link to endpoint",
+        onClick: copyLink,
+        active: justCopied === "link",
+        children: justCopied === "link" ? /* @__PURE__ */ jsx(Check, { className: "h-3.5 w-3.5" }) : /* @__PURE__ */ jsx(Link2, { className: "h-3.5 w-3.5" })
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      IconButton,
+      {
+        label: justCopied === "md" ? "Copied!" : "Copy as Markdown (for AI)",
+        onClick: copyMarkdown,
+        active: justCopied === "md",
+        children: justCopied === "md" ? /* @__PURE__ */ jsx(Check, { className: "h-3.5 w-3.5" }) : /* @__PURE__ */ jsx(FileCode2, { className: "h-3.5 w-3.5" })
+      }
+    ),
+    presentSections.length >= 2 && /* @__PURE__ */ jsx(
+      IconButton,
+      {
+        label: mostlyOpen ? "Collapse all sections" : "Expand all sections",
+        onClick: toggleAll,
+        children: mostlyOpen ? /* @__PURE__ */ jsx(ChevronsDownUp, { className: "h-3.5 w-3.5" }) : /* @__PURE__ */ jsx(ChevronsUpDown, { className: "h-3.5 w-3.5" })
+      }
+    )
+  ] }) });
+}
+__name(MetaActions, "MetaActions");
+function PathDisplay({ path }) {
+  return /* @__PURE__ */ jsx(
+    "code",
+    {
+      className: "block font-mono text-lg md:text-xl font-semibold text-foreground leading-tight",
+      style: { overflowWrap: "anywhere", wordBreak: "break-word" },
+      children: relativePath(path)
+    }
+  );
+}
+__name(PathDisplay, "PathDisplay");
+function EndpointHeader({
+  endpoint,
+  anchor,
+  isLoadedInPlayground,
+  onTryIt,
+  presentSections
+}) {
+  const endpointMd = useMemo(() => endpointToMarkdown(endpoint), [endpoint]);
+  return /* @__PURE__ */ jsxs("header", { className: "space-y-3", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3 flex-wrap", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 min-w-0", children: [
+        /* @__PURE__ */ jsx(MethodBadge, { method: endpoint.method }),
+        /* @__PURE__ */ jsx(
+          MetaActions,
+          {
+            anchor,
+            endpointMarkdown: endpointMd,
+            presentSections
+          }
+        )
+      ] }),
+      /* @__PURE__ */ jsxs(
+        Button,
+        {
+          size: "sm",
+          variant: isLoadedInPlayground ? "secondary" : "default",
+          onClick: onTryIt,
+          className: "ml-auto h-7 text-xs gap-1.5 px-2.5",
+          children: [
+            /* @__PURE__ */ jsx(Play, { className: "h-3 w-3" }),
+            isLoadedInPlayground ? "Loaded" : "Try it"
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: "min-w-0", children: /* @__PURE__ */ jsx(PathDisplay, { path: endpoint.path }) }),
+    endpoint.description && /* @__PURE__ */ jsx("div", { className: "text-muted-foreground text-sm", children: /* @__PURE__ */ jsx(MarkdownMessage, { content: endpoint.description }) })
+  ] });
+}
+__name(EndpointHeader, "EndpointHeader");
+function ParamRow({ param }) {
+  return /* @__PURE__ */ jsxs("div", { className: "px-3 py-2.5 bg-background space-y-1", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-2 flex-wrap", children: [
+      /* @__PURE__ */ jsx("code", { className: "font-mono text-xs font-medium text-foreground", children: param.name }),
+      param.required && /* @__PURE__ */ jsx(
+        "span",
+        {
+          title: "Required",
+          className: "text-[9px] text-destructive font-bold leading-none",
+          children: "*"
+        }
+      ),
+      /* @__PURE__ */ jsx("code", { className: "font-mono text-[11px] text-muted-foreground/70", children: param.type })
+    ] }),
+    param.description && /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground leading-relaxed break-words", children: param.description })
+  ] });
+}
+__name(ParamRow, "ParamRow");
+function ParamGroup({ label, params }) {
+  if (params.length === 0) return null;
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+    /* @__PURE__ */ jsx("div", { className: "text-[10px] font-semibold uppercase tracking-[0.1em] text-muted-foreground/60 px-1", children: label }),
+    /* @__PURE__ */ jsx("div", { className: "divide-y border rounded-md overflow-hidden", children: params.map((p) => /* @__PURE__ */ jsx(ParamRow, { param: p }, `${label}-${p.name}`)) })
+  ] });
+}
+__name(ParamGroup, "ParamGroup");
+function Parameters({ pathParams, queryParams }) {
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-4", children: [
+    /* @__PURE__ */ jsx(ParamGroup, { label: "Path", params: pathParams }),
+    /* @__PURE__ */ jsx(ParamGroup, { label: "Query", params: queryParams })
+  ] });
+}
+__name(Parameters, "Parameters");
+
+// src/tools/OpenapiViewer/components/DocsLayout/EndpointDoc/SchemaFields/buildTree.ts
+var MAX_DEPTH = 5;
+function mergeAllOf(branches) {
+  const properties = {};
+  const required = [];
+  for (const b of branches) {
+    if (b.properties) Object.assign(properties, b.properties);
+    if (Array.isArray(b.required)) required.push(...b.required);
+  }
+  return { type: "object", properties, required };
+}
+__name(mergeAllOf, "mergeAllOf");
+function describeType(node) {
+  if (node.type === "array") {
+    const itemLabel = node.items ? describeType(node.items).label : "any";
+    return { label: `array<${itemLabel}>`, kind: "array" };
+  }
+  if (node.type === "object" || node.properties) {
+    return { label: "object", kind: "object" };
+  }
+  const base = node.type || "any";
+  if (Array.isArray(node.enum) && node.enum.length > 0) {
+    return { label: `${base} enum`, kind: "primitive" };
+  }
+  if (node.format) {
+    return { label: `${base} (${node.format})`, kind: "primitive" };
+  }
+  return { label: base, kind: "primitive" };
+}
+__name(describeType, "describeType");
+function resolveCombinators(node) {
+  if (Array.isArray(node.allOf) && node.allOf.length > 0) {
+    return { ...mergeAllOf(node.allOf), description: node.description };
+  }
+  if (Array.isArray(node.oneOf) && node.oneOf.length > 0) {
+    return { ...node.oneOf[0], description: node.description ?? node.oneOf[0].description };
+  }
+  if (Array.isArray(node.anyOf) && node.anyOf.length > 0) {
+    return { ...node.anyOf[0], description: node.description ?? node.anyOf[0].description };
+  }
+  return node;
+}
+__name(resolveCombinators, "resolveCombinators");
+function buildNode(name, schema, isRequired, depth) {
+  const resolved = resolveCombinators(schema);
+  const { label, kind } = describeType(resolved);
+  const node = {
+    name,
+    type: label,
+    kind,
+    required: isRequired,
+    description: resolved.description
+  };
+  if (Array.isArray(resolved.enum) && resolved.enum.length > 0) {
+    node.enumValues = resolved.enum.map((v) => String(v));
+  }
+  if (depth >= MAX_DEPTH) return node;
+  if (kind === "object" && resolved.properties) {
+    const required = new Set(resolved.required ?? []);
+    node.children = Object.entries(resolved.properties).map(
+      ([key, child]) => buildNode(key, child, required.has(key), depth + 1)
+    );
+  } else if (kind === "array" && resolved.items) {
+    node.children = [buildNode("[]", resolved.items, false, depth + 1)];
+  }
+  return node;
+}
+__name(buildNode, "buildNode");
+function buildSchemaTree(schema) {
+  if (!schema) return [];
+  const root = buildNode("", schema, false, 0);
+  if (root.children && root.children.length > 0) return root.children;
+  if (root.kind === "primitive" || !root.children && root.name === "") {
+    return [{ ...root, name: root.name || "(body)" }];
+  }
+  return [];
+}
+__name(buildSchemaTree, "buildSchemaTree");
+function FieldRow({ field, depth, showTreeLine = true }) {
+  const isExpandable = (field.kind === "object" || field.kind === "array") && Array.isArray(field.children) && field.children.length > 0;
+  const [open, setOpen] = useState(depth < 2);
+  const padLeft = showTreeLine ? depth * 14 : 0;
+  return /* @__PURE__ */ jsxs("div", { className: "bg-background", children: [
+    /* @__PURE__ */ jsxs(
+      "div",
+      {
+        className: cn(
+          "grid grid-cols-[16px_minmax(0,1fr)] items-baseline gap-2 px-3 py-2",
+          isExpandable && "cursor-pointer hover:bg-muted/30"
+        ),
+        style: { paddingLeft: 12 + padLeft },
+        onClick: () => isExpandable && setOpen((v) => !v),
+        role: isExpandable ? "button" : void 0,
+        "aria-expanded": isExpandable ? open : void 0,
+        children: [
+          /* @__PURE__ */ jsx(
+            ChevronRight,
+            {
+              className: cn(
+                "h-3.5 w-3.5 text-muted-foreground/50 shrink-0 transition-transform",
+                !isExpandable && "opacity-0",
+                open && "rotate-90"
+              )
+            }
+          ),
+          /* @__PURE__ */ jsxs("div", { className: "min-w-0 space-y-1", children: [
+            /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-2 flex-wrap", children: [
+              /* @__PURE__ */ jsx("code", { className: "font-mono text-xs font-medium text-foreground", children: field.name }),
+              field.required && /* @__PURE__ */ jsx(
+                "span",
+                {
+                  title: "Required",
+                  className: "text-[9px] text-destructive font-bold leading-none",
+                  children: "*"
+                }
+              ),
+              /* @__PURE__ */ jsx("code", { className: "font-mono text-[11px] text-muted-foreground/70", children: field.type })
+            ] }),
+            field.description && /* @__PURE__ */ jsx("p", { className: "text-xs text-muted-foreground leading-relaxed break-words", children: field.description }),
+            field.enumValues && field.enumValues.length > 0 && /* @__PURE__ */ jsx("div", { className: "flex flex-wrap gap-1 pt-0.5", children: field.enumValues.map((v) => /* @__PURE__ */ jsx(
+              "code",
+              {
+                className: "inline-flex items-center rounded border border-border/60 bg-muted/40 px-1.5 py-px font-mono text-[10px] text-muted-foreground",
+                children: v
+              },
+              v
+            )) })
+          ] })
+        ]
+      }
+    ),
+    isExpandable && open && /* @__PURE__ */ jsx("div", { children: field.children.map((child, i) => /* @__PURE__ */ jsx(
+      FieldRow,
+      {
+        field: child,
+        depth: depth + 1
+      },
+      `${child.name}-${i}`
+    )) })
+  ] });
+}
+__name(FieldRow, "FieldRow");
+function SchemaFields({ schema }) {
+  const tree = useMemo(() => buildSchemaTree(schema), [schema]);
+  if (tree.length === 0) return null;
+  return /* @__PURE__ */ jsx("div", { className: "divide-y border rounded-md overflow-hidden", children: tree.map((node, i) => /* @__PURE__ */ jsx(FieldRow, { field: node, depth: 0 }, `${node.name}-${i}`)) });
+}
+__name(SchemaFields, "SchemaFields");
+function RequestBody({ body }) {
+  const typeLabel = body.schema ? body.type === "array" ? `array<${body.schema.items?.type ?? "object"}>` : body.type : body.type;
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-2 flex-wrap", children: [
+      /* @__PURE__ */ jsx("code", { className: "font-mono text-[11px] text-muted-foreground/80", children: typeLabel }),
+      body.description && /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: body.description })
+    ] }),
+    body.schema && /* @__PURE__ */ jsx(SchemaFields, { schema: body.schema })
+  ] });
+}
+__name(RequestBody, "RequestBody");
+var EXAMPLE_JSON_TREE_CONFIG = {
+  maxAutoExpandDepth: 2,
+  maxAutoExpandArrayItems: 5,
+  maxAutoExpandObjectKeys: 8,
+  maxStringLength: 160,
+  collectionLimit: 25,
+  showCollectionInfo: true,
+  showExpandControls: false,
+  showActionButtons: false,
+  preserveKeyOrder: true,
+  className: "border-0 rounded-none"
+};
+function ResponseBody({ example, contentType }) {
+  const parsed = useMemo(() => {
+    try {
+      return JSON.parse(example);
+    } catch {
+      return null;
+    }
+  }, [example]);
+  return /* @__PURE__ */ jsxs("div", { className: "border-t bg-muted/20", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between px-3 py-1.5 border-b border-border/50", children: [
+      /* @__PURE__ */ jsx("code", { className: "font-mono text-[10px] uppercase tracking-wider text-muted-foreground/70", children: contentType ?? "application/json" }),
+      /* @__PURE__ */ jsx(
+        CopyButton,
+        {
+          value: example,
+          variant: "ghost",
+          size: "sm",
+          className: "h-6 px-2 text-[10px] text-muted-foreground",
+          children: "Copy"
+        }
+      )
+    ] }),
+    parsed != null ? /* @__PURE__ */ jsx(
+      JsonTree_default,
+      {
+        title: "",
+        data: parsed,
+        mode: "compact",
+        config: EXAMPLE_JSON_TREE_CONFIG
+      }
+    ) : /* @__PURE__ */ jsx("pre", { className: "p-3 text-[11px] font-mono text-foreground/70 whitespace-pre-wrap break-all leading-relaxed", children: example })
+  ] });
+}
+__name(ResponseBody, "ResponseBody");
+function StatusTag({ code }) {
+  const numeric = Number.parseInt(code, 10);
+  const cls = !Number.isFinite(numeric) ? "bg-muted text-muted-foreground border-border" : numeric >= 500 ? "bg-red-500/10 text-red-600 dark:text-red-400 border-red-500/25" : numeric >= 400 ? "bg-amber-500/10 text-amber-600 dark:text-amber-400 border-amber-500/25" : numeric >= 300 ? "bg-blue-500/10 text-blue-600 dark:text-blue-400 border-blue-500/25" : "bg-emerald-500/10 text-emerald-600 dark:text-emerald-400 border-emerald-500/25";
+  return /* @__PURE__ */ jsx("span", { className: cn(
+    "inline-flex items-center justify-center rounded border px-2 py-0.5 font-mono text-[11px] font-bold leading-none shrink-0 tabular-nums",
+    cls
+  ), children: code });
+}
+__name(StatusTag, "StatusTag");
+function ResponseRow({ response }) {
+  const hasExample = Boolean(response.example);
+  const numeric = Number.parseInt(response.code, 10);
+  const isSuccess = Number.isFinite(numeric) && numeric >= 200 && numeric < 300;
+  const [open, setOpen] = useState(hasExample && isSuccess);
+  if (!hasExample) {
+    return /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-3 px-3 py-2 bg-background", children: [
+      /* @__PURE__ */ jsx("div", { className: "w-12 shrink-0 flex justify-start", children: /* @__PURE__ */ jsx(StatusTag, { code: response.code }) }),
+      /* @__PURE__ */ jsx("span", { className: "text-sm text-muted-foreground leading-relaxed break-words min-w-0", children: response.description })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "bg-background", children: [
+    /* @__PURE__ */ jsxs(
+      "button",
+      {
+        type: "button",
+        onClick: () => setOpen((v) => !v),
+        className: "w-full flex items-center gap-3 px-3 py-2 text-left hover:bg-muted/40 cursor-pointer transition-colors",
+        "aria-expanded": open,
+        children: [
+          /* @__PURE__ */ jsx(
+            ChevronRight,
+            {
+              className: cn(
+                "h-3.5 w-3.5 text-muted-foreground/60 transition-transform shrink-0",
+                open && "rotate-90"
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx("div", { className: "w-12 shrink-0 flex justify-start", children: /* @__PURE__ */ jsx(StatusTag, { code: response.code }) }),
+          /* @__PURE__ */ jsx("span", { className: "text-sm text-muted-foreground leading-relaxed break-words min-w-0 flex-1", children: response.description })
+        ]
+      }
+    ),
+    open && /* @__PURE__ */ jsx(
+      ResponseBody,
+      {
+        example: response.example,
+        contentType: response.contentType
+      }
+    )
+  ] });
+}
+__name(ResponseRow, "ResponseRow");
+function Responses({ responses }) {
+  return /* @__PURE__ */ jsx("div", { className: "divide-y border rounded-md overflow-hidden", children: responses.map((r) => /* @__PURE__ */ jsx(ResponseRow, { response: r }, r.code)) });
+}
+__name(Responses, "Responses");
+
+// src/tools/OpenapiViewer/components/DocsLayout/EndpointDoc/Section/defaults.ts
+var DEFAULTS_BY_METHOD = {
+  GET: { parameters: true, responses: true },
+  DELETE: { parameters: true, responses: true },
+  POST: { requestBody: true, responses: true },
+  PUT: { requestBody: true, responses: true },
+  PATCH: { requestBody: true, responses: true }
+};
+function defaultSectionOpen(method, sectionId) {
+  return DEFAULTS_BY_METHOD[method.toUpperCase()]?.[sectionId] ?? false;
+}
+__name(defaultSectionOpen, "defaultSectionOpen");
+
+// src/tools/OpenapiViewer/components/DocsLayout/EndpointDoc/types.ts
+var ALL_SECTION_IDS = [
+  "parameters",
+  "requestBody",
+  "responses",
+  "codeSamples"
+];
+
+// src/tools/OpenapiViewer/components/DocsLayout/EndpointDoc/hooks/useSectionHash.ts
+function parseSectionHash(hash) {
+  const raw = hash.startsWith("#") ? hash.slice(1) : hash;
+  if (!raw.startsWith("section=")) return null;
+  const value = raw.slice("section=".length);
+  const dot = value.lastIndexOf(".");
+  if (dot <= 0 || dot === value.length - 1) return null;
+  const endpointId = value.slice(0, dot);
+  const sectionIdCandidate = value.slice(dot + 1);
+  if (!ALL_SECTION_IDS.includes(sectionIdCandidate)) return null;
+  return { endpointId, sectionId: sectionIdCandidate };
+}
+__name(parseSectionHash, "parseSectionHash");
+function buildSectionHash(endpointId, sectionId) {
+  return `section=${endpointId}.${sectionId}`;
+}
+__name(buildSectionHash, "buildSectionHash");
+function useSectionHashRouter() {
+  const setSectionOpen = useEndpointDocStore((s) => s.setSectionOpen);
+  useEffect(() => {
+    if (typeof window === "undefined") return;
+    function apply() {
+      const parsed = parseSectionHash(window.location.hash);
+      if (!parsed) return;
+      setSectionOpen(parsed.endpointId, parsed.sectionId, true);
+      requestAnimationFrame(() => {
+        const el = document.getElementById(parsed.endpointId);
+        el?.scrollIntoView({ behavior: "smooth", block: "start" });
+      });
+    }
+    __name(apply, "apply");
+    apply();
+    window.addEventListener("hashchange", apply);
+    return () => window.removeEventListener("hashchange", apply);
+  }, [setSectionOpen]);
+}
+__name(useSectionHashRouter, "useSectionHashRouter");
+function SectionHeader({ sectionId, title, badge, open, onToggle }) {
+  const { endpointId } = useEndpointDocContext();
+  const [copied, setCopied] = useState(false);
+  const copyHash = /* @__PURE__ */ __name((e) => {
+    e.stopPropagation();
+    if (typeof window === "undefined") return;
+    const hash = buildSectionHash(endpointId, sectionId);
+    const url = `${window.location.origin}${window.location.pathname}#${hash}`;
+    void navigator.clipboard?.writeText(url).then(() => {
+      setCopied(true);
+      setTimeout(() => setCopied(false), 1200);
+    });
+  }, "copyHash");
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: cn(
+        "group/section w-full flex items-center gap-2 py-1.5 -ml-1 px-1 rounded cursor-pointer",
+        "hover:bg-muted/30 transition-colors"
+      ),
+      onClick: onToggle,
+      role: "button",
+      "aria-expanded": open,
+      tabIndex: 0,
+      onKeyDown: (e) => {
+        if (e.key === "Enter" || e.key === " ") {
+          e.preventDefault();
+          onToggle();
+        }
+      },
+      children: [
+        /* @__PURE__ */ jsx(
+          ChevronDown,
+          {
+            className: cn(
+              "h-3.5 w-3.5 text-muted-foreground/50 transition-transform shrink-0",
+              !open && "-rotate-90"
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx("h4", { className: "text-[10px] font-semibold uppercase tracking-[0.12em] text-muted-foreground/80", children: title }),
+        typeof badge === "number" && badge > 0 && /* @__PURE__ */ jsx("span", { className: "font-mono text-[10px] text-muted-foreground/50 tabular-nums", children: badge }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: copyHash,
+            title: "Copy link to this section",
+            className: cn(
+              "ml-auto shrink-0 p-1 rounded text-muted-foreground/40 hover:text-foreground hover:bg-muted transition-all",
+              "opacity-0 group-hover/section:opacity-100 focus-visible:opacity-100",
+              copied && "opacity-100 text-emerald-500"
+            ),
+            children: copied ? /* @__PURE__ */ jsx(Check, { className: "h-3 w-3" }) : /* @__PURE__ */ jsx(Link2, { className: "h-3 w-3" })
+          }
+        )
+      ]
+    }
+  );
+}
+__name(SectionHeader, "SectionHeader");
+function Section({ id, title, badge, children }) {
+  const { endpointId, method } = useEndpointDocContext();
+  const defaultOpen = defaultSectionOpen(method, id);
+  const open = useIsSectionOpen(endpointId, id, defaultOpen);
+  const toggleSection = useEndpointDocStore((s) => s.toggleSection);
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2.5", children: [
+    /* @__PURE__ */ jsx(
+      SectionHeader,
+      {
+        sectionId: id,
+        title,
+        badge,
+        open,
+        onToggle: () => toggleSection(endpointId, id)
+      }
+    ),
+    open && /* @__PURE__ */ jsx("div", { children })
+  ] });
+}
+__name(Section, "Section");
+function EndpointDoc({ endpoint, isLoadedInPlayground, onTryIt, schemaId }) {
+  const scopedSchemaId = schemaId ?? endpoint.schemaId ?? null;
+  const anchor = endpointAnchor(endpoint, scopedSchemaId);
+  const pathParams = endpoint.parameters?.filter((p) => endpoint.path.includes(`{${p.name}}`)) ?? [];
+  const queryParams = endpoint.parameters?.filter((p) => !endpoint.path.includes(`{${p.name}}`)) ?? [];
+  const hasParameters = pathParams.length > 0 || queryParams.length > 0;
+  const hasResponses = (endpoint.responses?.length ?? 0) > 0;
+  const presentSections = [];
+  if (hasParameters) presentSections.push("parameters");
+  if (endpoint.requestBody) presentSections.push("requestBody");
+  presentSections.push("codeSamples");
+  if (hasResponses) presentSections.push("responses");
+  return /* @__PURE__ */ jsx(EndpointDocProvider, { endpointId: anchor, method: endpoint.method, children: /* @__PURE__ */ jsxs(
+    "section",
+    {
+      id: anchor,
+      "data-endpoint-anchor": anchor,
+      "data-schema-id": scopedSchemaId ?? "",
+      className: "scroll-mt-24 py-10 first:pt-0",
+      children: [
+        /* @__PURE__ */ jsx(
+          EndpointHeader,
+          {
+            endpoint,
+            anchor,
+            isLoadedInPlayground,
+            onTryIt,
+            presentSections
+          }
+        ),
+        /* @__PURE__ */ jsxs("div", { className: "mt-8 space-y-5", children: [
+          hasParameters && /* @__PURE__ */ jsx(
+            Section,
+            {
+              id: "parameters",
+              title: "Parameters",
+              badge: pathParams.length + queryParams.length,
+              children: /* @__PURE__ */ jsx(Parameters, { pathParams, queryParams })
+            }
+          ),
+          endpoint.requestBody && /* @__PURE__ */ jsx(Section, { id: "requestBody", title: "Request body", children: /* @__PURE__ */ jsx(RequestBody, { body: endpoint.requestBody }) }),
+          /* @__PURE__ */ jsx(Section, { id: "codeSamples", title: "Code samples", children: /* @__PURE__ */ jsx(CodeSamples, { endpoint }) }),
+          hasResponses && /* @__PURE__ */ jsx(
+            Section,
+            {
+              id: "responses",
+              title: "Responses",
+              badge: endpoint.responses.length,
+              children: /* @__PURE__ */ jsx(Responses, { responses: endpoint.responses })
+            }
+          )
+        ] })
+      ]
+    }
+  ) });
+}
+__name(EndpointDoc, "EndpointDoc");
+var readNavbarOffset = /* @__PURE__ */ __name(() => {
+  if (typeof document === "undefined") return 0;
+  const raw = getComputedStyle(document.documentElement).getPropertyValue("--navbar-height");
+  const parsed = parseInt(raw || "", 10);
+  return Number.isFinite(parsed) ? parsed : 0;
+}, "readNavbarOffset");
+var isSameEndpoint = /* @__PURE__ */ __name((a, b) => a !== null && a.method === b.method && a.path === b.path, "isSameEndpoint");
+function buildEndpointRow(ep, loadedEndpoint, schemaId) {
+  const keySchema = schemaId ? `${schemaId}-` : "";
+  return {
+    key: `${keySchema}${ep.method}-${ep.path}`,
+    endpoint: ep,
+    isLoaded: isSameEndpoint(loadedEndpoint, ep),
+    schemaId
+  };
+}
+__name(buildEndpointRow, "buildEndpointRow");
+function buildSchemaSectionVM(entry, selectedVersion, loadedEndpoint) {
+  const title = entry.info?.title ?? entry.source.name;
+  const version = entry.info?.version ?? null;
+  const description = entry.info?.description ?? null;
+  let state;
+  if (entry.loading) {
+    state = { kind: "loading" };
+  } else if (entry.error) {
+    state = { kind: "error", message: entry.error };
+  } else {
+    const visible = deduplicateEndpoints(entry.endpoints, selectedVersion);
+    state = visible.length === 0 ? { kind: "empty" } : {
+      kind: "ready",
+      rows: visible.map((ep) => buildEndpointRow(ep, loadedEndpoint, entry.source.id))
+    };
+  }
+  return {
+    schemaId: entry.source.id,
+    title,
+    version,
+    description,
+    state,
+    rawSchema: entry.rawSchema,
+    baseUrl: entry.resolvedBaseUrl,
+    allEndpoints: entry.endpoints
+  };
+}
+__name(buildSchemaSectionVM, "buildSchemaSectionVM");
+var DocsView = React12.forwardRef(/* @__PURE__ */ __name(function DocsView2(props, ref) {
+  const scrollRef = useRef(null);
+  const scrollTargetRef = useRef(null);
+  const { onActiveChange } = props;
+  useSectionHashRouter();
+  const ensureScrollTarget = useCallback(() => {
+    if (scrollTargetRef.current) return scrollTargetRef.current;
+    if (!scrollRef.current) return null;
+    scrollTargetRef.current = getScrollParent(scrollRef.current);
+    return scrollTargetRef.current;
+  }, []);
+  const scrollToAnchor = useCallback(
+    (anchor) => {
+      const root = scrollRef.current;
+      if (!root) return;
+      const el = root.querySelector(`[data-endpoint-anchor="${anchor}"]`);
+      if (!el) return;
+      const target = ensureScrollTarget();
+      if (!target) return;
+      const navbar = readNavbarOffset();
+      const top = el.getBoundingClientRect().top - getTargetTop(target) + getScrollTop(target) - navbar - 8;
+      scrollTargetTo(target, top);
+    },
+    [ensureScrollTarget]
+  );
+  React12.useImperativeHandle(ref, () => ({ scrollToAnchor }), [scrollToAnchor]);
+  useEffect(() => {
+    const root = scrollRef.current;
+    if (!root) return;
+    const target = ensureScrollTarget();
+    if (!target) return;
+    let rafId = 0;
+    let lastActive = null;
+    const compute = /* @__PURE__ */ __name(() => {
+      rafId = 0;
+      const sections = root.querySelectorAll("[data-endpoint-anchor]");
+      if (sections.length === 0) return;
+      const navbar = readNavbarOffset();
+      const viewportTop = getTargetTop(target);
+      const threshold = viewportTop + navbar + getViewportHeight(target) * 0.25;
+      let active = null;
+      for (const s of Array.from(sections)) {
+        const top = s.getBoundingClientRect().top;
+        if (top <= threshold) {
+          active = s;
+        } else {
+          break;
+        }
+      }
+      const anchor = active?.dataset.endpointAnchor ?? null;
+      if (anchor !== lastActive) {
+        lastActive = anchor;
+        onActiveChange(anchor, active?.dataset.schemaId || null);
+      }
+    }, "compute");
+    const onScroll = /* @__PURE__ */ __name(() => {
+      if (rafId) return;
+      rafId = requestAnimationFrame(compute);
+    }, "onScroll");
+    compute();
+    target.addEventListener("scroll", onScroll, { passive: true });
+    window.addEventListener("resize", onScroll, { passive: true });
+    return () => {
+      target.removeEventListener("scroll", onScroll);
+      window.removeEventListener("resize", onScroll);
+      if (rafId) cancelAnimationFrame(rafId);
+    };
+  }, [onActiveChange, ensureScrollTarget, props]);
+  if (props.grouping === "sections") {
+    return /* @__PURE__ */ jsx(SectionsBody, { scrollRef, ...props });
+  }
+  return /* @__PURE__ */ jsx(SelectorBody, { scrollRef, ...props });
+}, "DocsView"));
+function SelectorBody({
+  scrollRef,
+  info,
+  rawSchema,
+  resolvedBaseUrl,
+  endpoints,
+  selectedVersion,
+  loadedEndpoint,
+  onTryEndpoint
+}) {
+  const visibleEndpoints = useMemo(
+    () => deduplicateEndpoints(endpoints, selectedVersion),
+    [endpoints, selectedVersion]
+  );
+  const rows = useMemo(
+    () => visibleEndpoints.map((ep) => buildEndpointRow(ep, loadedEndpoint, ep.schemaId ?? null)),
+    [visibleEndpoints, loadedEndpoint]
+  );
+  const isEmpty = rows.length === 0;
+  return /* @__PURE__ */ jsx("div", { ref: scrollRef, children: /* @__PURE__ */ jsxs("div", { className: "mx-auto w-full max-w-[860px] px-6 md:px-10 lg:px-14 py-12", children: [
+    info && /* @__PURE__ */ jsx(
+      ApiIntroSection,
+      {
+        info,
+        schema: rawSchema,
+        endpoints: visibleEndpoints,
+        resolvedBaseUrl
+      }
+    ),
+    isEmpty ? /* @__PURE__ */ jsx("div", { className: "py-16 text-center text-sm text-muted-foreground", children: "No endpoints to display." }) : /* @__PURE__ */ jsx("div", { className: "divide-y divide-border/60", children: rows.map((row) => /* @__PURE__ */ jsx(
+      EndpointDoc,
+      {
+        endpoint: row.endpoint,
+        isLoadedInPlayground: row.isLoaded,
+        onTryIt: () => onTryEndpoint(row.endpoint),
+        schemaId: row.schemaId
+      },
+      row.key
+    )) })
+  ] }) });
+}
+__name(SelectorBody, "SelectorBody");
+function SectionsBody({
+  scrollRef,
+  schemasData,
+  selectedVersion,
+  loadedEndpoint,
+  onTryEndpoint
+}) {
+  const sections = useMemo(
+    () => schemasData.map((e) => buildSchemaSectionVM(e, selectedVersion, loadedEndpoint)),
+    [schemasData, selectedVersion, loadedEndpoint]
+  );
+  return /* @__PURE__ */ jsx("div", { ref: scrollRef, children: /* @__PURE__ */ jsx("div", { className: "mx-auto w-full max-w-[860px] px-6 md:px-10 lg:px-14 py-12 space-y-16", children: sections.map((section) => /* @__PURE__ */ jsx(SchemaSectionView, { section, onTryEndpoint }, section.schemaId)) }) });
+}
+__name(SectionsBody, "SectionsBody");
+var SchemaSectionView = React12.memo(/* @__PURE__ */ __name(function SchemaSectionView2({
+  section,
+  onTryEndpoint
+}) {
+  const canCopy = section.rawSchema !== null && section.allEndpoints.length > 0;
+  return /* @__PURE__ */ jsxs("section", { "data-schema-anchor": section.schemaId, className: "scroll-mt-20", children: [
+    /* @__PURE__ */ jsxs("header", { className: "mb-8 pb-4 border-b", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-start justify-between gap-4", children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-3 min-w-0", children: [
+          /* @__PURE__ */ jsx("h2", { className: "text-2xl font-semibold tracking-tight", children: section.title }),
+          section.version && /* @__PURE__ */ jsxs("span", { className: "font-mono text-xs text-muted-foreground/70", children: [
+            "v",
+            section.version
+          ] })
+        ] }),
+        canCopy && /* @__PURE__ */ jsx(
+          SchemaCopyMenu,
+          {
+            schema: section.rawSchema,
+            endpoints: section.allEndpoints,
+            baseUrl: section.baseUrl
+          }
+        )
+      ] }),
+      section.description && /* @__PURE__ */ jsx("p", { className: "mt-2 text-sm text-muted-foreground whitespace-pre-wrap", children: section.description })
+    ] }),
+    /* @__PURE__ */ jsx(SchemaSectionStateView, { section, onTryEndpoint })
+  ] });
+}, "SchemaSectionView"));
+function SchemaSectionStateView({
+  section,
+  onTryEndpoint
+}) {
+  switch (section.state.kind) {
+    case "loading":
+      return /* @__PURE__ */ jsxs("div", { className: "py-8 text-center text-sm text-muted-foreground", children: [
+        "Loading ",
+        section.title,
+        "\u2026"
+      ] });
+    case "error":
+      return /* @__PURE__ */ jsxs("div", { className: "py-8 text-center text-sm text-destructive", children: [
+        "Failed to load ",
+        section.title,
+        ": ",
+        section.state.message
+      ] });
+    case "empty":
+      return /* @__PURE__ */ jsx("div", { className: "py-8 text-center text-sm text-muted-foreground", children: "No endpoints in this schema." });
+    case "ready":
+      return /* @__PURE__ */ jsx("div", { className: "divide-y divide-border/60", children: section.state.rows.map((row) => /* @__PURE__ */ jsx(
+        EndpointDoc,
+        {
+          endpoint: row.endpoint,
+          isLoadedInPlayground: row.isLoaded,
+          onTryIt: () => onTryEndpoint(row.endpoint),
+          schemaId: row.schemaId
+        },
+        row.key
+      )) });
+  }
+}
+__name(SchemaSectionStateView, "SchemaSectionStateView");
+var MAX_DEPTH2 = 6;
+function defaultForSchema(schema) {
+  if (!schema) return null;
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) return schema.enum[0];
+  switch (schema.type) {
+    case "object": {
+      const out = {};
+      for (const [k, v] of Object.entries(schema.properties ?? {})) {
+        out[k] = defaultForSchema(v);
+      }
+      return out;
+    }
+    case "array":
+      return [];
+    case "integer":
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "string":
+      return "";
+    default:
+      if (schema.properties) {
+        const out = {};
+        for (const [k, v] of Object.entries(schema.properties)) {
+          out[k] = defaultForSchema(v);
+        }
+        return out;
+      }
+      return "";
+  }
+}
+__name(defaultForSchema, "defaultForSchema");
+function BodyFormEditor({ schema, value, onChange }) {
+  return /* @__PURE__ */ jsx(
+    SchemaField,
+    {
+      schema,
+      value,
+      onChange,
+      depth: 0,
+      required: false
+    }
+  );
+}
+__name(BodyFormEditor, "BodyFormEditor");
+function SchemaField({ schema, value, onChange, depth, required, label }) {
+  if (depth > MAX_DEPTH2) {
+    return /* @__PURE__ */ jsx(RawJsonField, { label, value, onChange });
+  }
+  if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+    return /* @__PURE__ */ jsx(EnumField, { schema, value, onChange, label, required });
+  }
+  switch (schema.type) {
+    case "object":
+      return /* @__PURE__ */ jsx(ObjectField, { schema, value, onChange, depth, label });
+    case "array":
+      return /* @__PURE__ */ jsx(ArrayField, { schema, value, onChange, depth, label, required });
+    case "boolean":
+      return /* @__PURE__ */ jsx(BooleanField, { value, onChange, label, schema, required });
+    case "integer":
+    case "number":
+      return /* @__PURE__ */ jsx(NumberField, { value, onChange, label, schema, required });
+    case "string":
+    default:
+      if (!schema.type && schema.properties) {
+        return /* @__PURE__ */ jsx(ObjectField, { schema, value, onChange, depth, label });
+      }
+      return /* @__PURE__ */ jsx(StringField, { value, onChange, label, schema, required });
+  }
+}
+__name(SchemaField, "SchemaField");
+function FieldHeader({
+  label,
+  type,
+  required,
+  description
+}) {
+  if (!label) return null;
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-0.5", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-1.5", children: [
+      /* @__PURE__ */ jsx("span", { className: "font-mono text-[11px] text-foreground/80", children: label }),
+      required && /* @__PURE__ */ jsx("span", { className: "text-[9px] text-destructive font-bold leading-none", children: "*" }),
+      /* @__PURE__ */ jsx("span", { className: "font-mono text-[10px] text-muted-foreground/50", children: type })
+    ] }),
+    description && /* @__PURE__ */ jsx("p", { className: "text-[10px] text-muted-foreground/70 leading-snug", children: description })
+  ] });
+}
+__name(FieldHeader, "FieldHeader");
+function StringField({
+  value,
+  onChange,
+  label,
+  schema,
+  required
+}) {
+  const stringValue = typeof value === "string" ? value : value == null ? "" : String(value);
+  const placeholder = schema.format ? `${schema.type ?? "string"} (${schema.format})` : schema.description || schema.type || "string";
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+    /* @__PURE__ */ jsx(FieldHeader, { label, type: schema.format ? `string (${schema.format})` : "string", required, description: schema.description }),
+    /* @__PURE__ */ jsx(
+      Input,
+      {
+        value: stringValue,
+        onChange: (e) => onChange(e.target.value),
+        placeholder,
+        className: "h-8 text-xs font-mono"
+      }
+    )
+  ] });
+}
+__name(StringField, "StringField");
+function NumberField({
+  value,
+  onChange,
+  label,
+  schema,
+  required
+}) {
+  const raw = value == null ? "" : String(value);
+  const type = schema.type === "integer" ? "integer" : "number";
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+    /* @__PURE__ */ jsx(FieldHeader, { label, type: schema.format ? `${type} (${schema.format})` : type, required, description: schema.description }),
+    /* @__PURE__ */ jsx(
+      Input,
+      {
+        type: "number",
+        value: raw,
+        onChange: (e) => {
+          const v = e.target.value;
+          if (v === "") return onChange(null);
+          const n = schema.type === "integer" ? parseInt(v, 10) : parseFloat(v);
+          onChange(Number.isNaN(n) ? null : n);
+        },
+        placeholder: type,
+        className: "h-8 text-xs font-mono"
+      }
+    )
+  ] });
+}
+__name(NumberField, "NumberField");
+function BooleanField({
+  value,
+  onChange,
+  label,
+  schema,
+  required
+}) {
+  const bool = value === true;
+  return /* @__PURE__ */ jsxs("div", { className: "flex items-start justify-between gap-3", children: [
+    /* @__PURE__ */ jsx(FieldHeader, { label, type: "boolean", required, description: schema.description }),
+    /* @__PURE__ */ jsx(Switch, { checked: bool, onCheckedChange: onChange, className: "mt-0.5 shrink-0" })
+  ] });
+}
+__name(BooleanField, "BooleanField");
+function EnumField({
+  schema,
+  value,
+  onChange,
+  label,
+  required
+}) {
+  const options = (schema.enum ?? []).map((v) => ({
+    value: String(v),
+    label: String(v)
+  }));
+  const strValue = value == null ? "" : String(value);
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+    /* @__PURE__ */ jsx(FieldHeader, { label, type: `${schema.type ?? "enum"} enum`, required, description: schema.description }),
+    /* @__PURE__ */ jsx(
+      Combobox,
+      {
+        options,
+        value: strValue,
+        onValueChange: (v) => {
+          if (schema.type === "integer") onChange(parseInt(v, 10));
+          else if (schema.type === "number") onChange(parseFloat(v));
+          else onChange(v);
+        },
+        placeholder: "Select\u2026",
+        searchPlaceholder: "Search\u2026",
+        className: "h-8 text-xs"
+      }
+    )
+  ] });
+}
+__name(EnumField, "EnumField");
+function RawJsonField({
+  label,
+  value,
+  onChange
+}) {
+  const [text, setText] = React12.useState(() => JSON.stringify(value ?? null, null, 2));
+  React12.useEffect(() => {
+    setText(JSON.stringify(value ?? null, null, 2));
+  }, [value]);
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+    label && /* @__PURE__ */ jsxs(SectionLabel, { children: [
+      label,
+      " (raw)"
+    ] }),
+    /* @__PURE__ */ jsx(
+      Textarea,
+      {
+        value: text,
+        onChange: (e) => {
+          setText(e.target.value);
+          try {
+            onChange(JSON.parse(e.target.value));
+          } catch {
+          }
+        },
+        className: "font-mono text-[11px] min-h-[80px]",
+        rows: 4
+      }
+    )
+  ] });
+}
+__name(RawJsonField, "RawJsonField");
+function ObjectField({
+  schema,
+  value,
+  onChange,
+  depth,
+  label
+}) {
+  const obj = value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  const required = new Set(schema.required ?? []);
+  const entries = Object.entries(schema.properties ?? {});
+  const setKey = useCallback(
+    (key) => (next) => {
+      onChange({ ...obj, [key]: next });
+    },
+    [obj, onChange]
+  );
+  if (entries.length === 0) {
+    return /* @__PURE__ */ jsx(RawJsonField, { label, value: obj, onChange });
+  }
+  const wrapperClass = depth === 0 ? "space-y-3" : "space-y-2 border-l-2 border-border/60 pl-3 ml-px";
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+    label && depth > 0 && /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-1.5", children: [
+      /* @__PURE__ */ jsx("span", { className: "font-mono text-[11px] text-foreground/80", children: label }),
+      /* @__PURE__ */ jsx("span", { className: "font-mono text-[10px] text-muted-foreground/50", children: "object" })
+    ] }),
+    /* @__PURE__ */ jsx("div", { className: cn(wrapperClass), children: entries.map(([key, subSchema]) => /* @__PURE__ */ jsx(
+      SchemaField,
+      {
+        schema: subSchema,
+        value: obj[key],
+        onChange: setKey(key),
+        depth: depth + 1,
+        required: required.has(key),
+        label: key
+      },
+      key
+    )) })
+  ] });
+}
+__name(ObjectField, "ObjectField");
+function ArrayField({
+  schema,
+  value,
+  onChange,
+  depth,
+  label,
+  required
+}) {
+  const arr = Array.isArray(value) ? value : [];
+  const items = schema.items ?? { type: "string" };
+  const addItem = /* @__PURE__ */ __name(() => onChange([...arr, defaultForSchema(items)]), "addItem");
+  const removeAt = /* @__PURE__ */ __name((i) => onChange(arr.filter((_, idx) => idx !== i)), "removeAt");
+  const setAt = /* @__PURE__ */ __name((i) => (next) => onChange(arr.map((v, idx) => idx === i ? next : v)), "setAt");
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+    label && /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-1.5", children: [
+      /* @__PURE__ */ jsx("span", { className: "font-mono text-[11px] text-foreground/80", children: label }),
+      required && /* @__PURE__ */ jsx("span", { className: "text-[9px] text-destructive font-bold leading-none", children: "*" }),
+      /* @__PURE__ */ jsx("span", { className: "font-mono text-[10px] text-muted-foreground/50", children: `array<${items.type ?? "any"}>` })
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "space-y-2 border-l-2 border-border/60 pl-3 ml-px", children: [
+      arr.length === 0 && /* @__PURE__ */ jsx("p", { className: "text-[10px] text-muted-foreground/50 italic", children: "Empty array" }),
+      arr.map((v, i) => /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-2", children: [
+        /* @__PURE__ */ jsx("div", { className: "flex-1 min-w-0", children: /* @__PURE__ */ jsx(
+          SchemaField,
+          {
+            schema: items,
+            value: v,
+            onChange: setAt(i),
+            depth: depth + 1,
+            required: false,
+            label: `${label ?? ""}[${i}]`
+          }
+        ) }),
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            type: "button",
+            onClick: () => removeAt(i),
+            title: "Remove item",
+            className: "shrink-0 h-7 w-7 inline-flex items-center justify-center rounded-md text-muted-foreground hover:text-destructive hover:bg-destructive/10 transition-colors",
+            children: /* @__PURE__ */ jsx(Minus, { className: "h-3.5 w-3.5" })
+          }
+        )
+      ] }, i)),
+      /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          onClick: addItem,
+          className: "inline-flex items-center gap-1.5 text-[10px] text-muted-foreground hover:text-foreground transition-colors py-1",
+          children: [
+            /* @__PURE__ */ jsx(Plus, { className: "h-3 w-3" }),
+            "Add item"
+          ]
+        }
+      )
+    ] })
+  ] });
+}
+__name(ArrayField, "ArrayField");
+function EndpointResetButton() {
+  const { state, setParameters, setRequestBody } = usePlaygroundContext();
+  const ep = state.selectedEndpoint;
+  const { reset } = useEndpointDraft(state.activeSchemaId, ep);
+  const hasDraft = Object.keys(state.parameters).length > 0 || state.requestBody.length > 0;
+  const onClick = useCallback(() => {
+    setParameters({});
+    setRequestBody("");
+    reset();
+  }, [setParameters, setRequestBody, reset]);
+  if (!ep || !hasDraft) return null;
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      type: "button",
+      onClick,
+      title: "Reset parameters & body (keeps auth)",
+      className: cn(
+        "inline-flex items-center gap-1 text-[10px] text-muted-foreground",
+        "hover:text-foreground transition-colors"
+      ),
+      children: [
+        /* @__PURE__ */ jsx(RotateCcw, { className: "h-2.5 w-2.5" }),
+        "Reset"
+      ]
+    }
+  );
+}
+__name(EndpointResetButton, "EndpointResetButton");
+function ParamFields({ label, params }) {
+  const { state, setParameters } = usePlaygroundContext();
+  function handleChange(name, value) {
+    setParameters({ ...state.parameters, [name]: value });
+  }
+  __name(handleChange, "handleChange");
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+    /* @__PURE__ */ jsx(SectionLabel, { children: label }),
+    /* @__PURE__ */ jsx("div", { className: "space-y-2", children: params.map((p) => {
+      const value = state.parameters[p.name] ?? "";
+      const placeholder = p.description || p.name;
+      return /* @__PURE__ */ jsxs("div", { className: "space-y-1", children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5", children: [
+          /* @__PURE__ */ jsx("span", { className: "font-mono text-[11px] text-foreground/80", children: p.name }),
+          p.required && /* @__PURE__ */ jsx("span", { className: "text-[9px] text-destructive font-bold leading-none", children: "*" }),
+          /* @__PURE__ */ jsx("span", { className: "font-mono text-[10px] text-muted-foreground/50", children: p.type })
+        ] }),
+        /* @__PURE__ */ jsx(
+          Input,
+          {
+            value,
+            onChange: (e) => handleChange(p.name, e.target.value),
+            placeholder,
+            className: "h-8 text-xs font-mono"
+          }
+        )
+      ] }, p.name);
+    }) })
+  ] });
+}
+__name(ParamFields, "ParamFields");
+function RequestPanel() {
+  const {
+    state,
+    apiKeys,
+    apiKeysLoading,
+    setRequestBody,
+    setRequestHeaders,
+    setSelectedApiKey,
+    setManualApiToken,
+    sendRequest
+  } = usePlaygroundContext();
+  const apiKeyOptions = useMemo(
+    () => apiKeys.map((k) => ({
+      value: k.id,
+      label: k.name || "Unnamed key",
+      // Surface the first 8 chars of the secret so the user
+      // can tell two similarly-named keys apart at a glance.
+      description: k.secret ? `${k.secret.slice(0, 8)}\u2026` : void 0
+    })),
+    [apiKeys]
+  );
+  const hasApiKeys = apiKeyOptions.length > 0;
+  const ep = state.selectedEndpoint;
+  const isJsonValid = state.requestBody ? isValidJson(state.requestBody) : true;
+  const curlCommand = useMemo(() => {
+    if (!state.requestUrl) return "";
+    const absoluteUrl = resolveAbsolute(state.requestUrl);
+    const apiKey = state.selectedApiKey ? findApiKeyById(apiKeys, state.selectedApiKey) : null;
+    const hdrs = parseRequestHeaders(state.requestHeaders);
+    if (apiKey) hdrs["X-API-Key"] = apiKey.secret || apiKey.id;
+    let cmd = `curl -X ${state.requestMethod} "${absoluteUrl}"`;
+    Object.entries(hdrs).forEach(([k, v]) => {
+      cmd += ` \\
+  -H "${k}: ${v}"`;
+    });
+    if (state.requestBody && state.requestMethod !== "GET" && isJsonValid) {
+      cmd += ` \\
+  -d '${state.requestBody}'`;
+    }
+    return cmd;
+  }, [state, apiKeys, isJsonValid]);
+  const pathParams = useMemo(
+    () => ep?.parameters?.filter((p) => ep.path.includes(`{${p.name}}`)) ?? [],
+    [ep]
+  );
+  const queryParams = useMemo(
+    () => ep?.parameters?.filter((p) => !ep.path.includes(`{${p.name}}`)) ?? [],
+    [ep]
+  );
+  state.loading || !state.requestUrl || !isJsonValid;
+  const displayUrl = resolveAbsolute(state.requestUrl || ep?.path || "");
+  const hasBody = ep?.method !== "GET";
+  const bodyType = ep?.requestBody?.type ?? "";
+  const hasPathParams = pathParams.length > 0;
+  const hasQueryParams = queryParams.length > 0;
+  const hasCurl = Boolean(curlCommand);
+  const epPath = ep ? relativePath(ep.path) : "";
+  const urlChanged = displayUrl !== "" && displayUrl !== epPath;
+  if (!ep) {
+    return /* @__PURE__ */ jsx(EmptyState, { icon: Send, text: "Select an endpoint to build a request" });
+  }
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    (urlChanged || ep) && /* @__PURE__ */ jsxs("div", { className: "shrink-0 border-b px-4 py-2 bg-muted/10 flex items-center gap-2 min-h-[28px]", children: [
+      urlChanged ? /* @__PURE__ */ jsx("span", { className: "font-mono text-[10px] text-muted-foreground/60 break-all leading-snug truncate min-w-0 flex-1", children: displayUrl }) : /* @__PURE__ */ jsx("span", { className: "flex-1" }),
+      /* @__PURE__ */ jsx(EndpointResetButton, {})
+    ] }),
+    /* @__PURE__ */ jsxs(ScrollArea, { className: "px-4 py-3 space-y-3", children: [
+      hasPathParams && /* @__PURE__ */ jsx(ParamFields, { label: "Path Parameters", params: pathParams }),
+      hasQueryParams && /* @__PURE__ */ jsx(ParamFields, { label: "Query Parameters", params: queryParams }),
+      hasBody && /* @__PURE__ */ jsx(
+        BodySection,
+        {
+          schema: ep.requestBody?.schema,
+          bodyType,
+          bodyDescription: ep.requestBody?.description,
+          value: state.requestBody,
+          onChange: setRequestBody,
+          isJsonValid
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        CollapsibleSection,
+        {
+          label: /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1", children: [
+            /* @__PURE__ */ jsx(Key, { className: "h-2.5 w-2.5" }),
+            "Auth & Headers"
+          ] }),
+          children: /* @__PURE__ */ jsxs("div", { className: "space-y-3 pt-2", children: [
+            /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+              /* @__PURE__ */ jsx(SectionLabel, { children: "API Key" }),
+              /* @__PURE__ */ jsx(
+                Combobox,
+                {
+                  options: apiKeyOptions,
+                  value: state.selectedApiKey ?? "",
+                  onValueChange: (v) => setSelectedApiKey(v || null),
+                  placeholder: apiKeysLoading ? "Loading keys\u2026" : hasApiKeys ? "Select an API key" : "No API keys yet",
+                  searchPlaceholder: "Search keys\u2026",
+                  emptyText: "No matching key",
+                  disabled: apiKeysLoading || !hasApiKeys,
+                  className: "h-8"
+                }
+              ),
+              /* @__PURE__ */ jsxs("p", { className: "text-[10px] text-muted-foreground", children: [
+                "Picks are sent via the",
+                " ",
+                /* @__PURE__ */ jsx("span", { className: "font-mono", children: "X-API-Key" }),
+                " header."
+              ] })
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+              /* @__PURE__ */ jsx(SectionLabel, { children: "Bearer Token" }),
+              /* @__PURE__ */ jsx(
+                Input,
+                {
+                  type: "password",
+                  placeholder: "Leave empty to use JWT from localStorage",
+                  value: state.manualApiToken,
+                  onChange: (e) => setManualApiToken(e.target.value),
+                  className: "font-mono text-xs h-8"
+                }
+              )
+            ] }),
+            /* @__PURE__ */ jsxs("div", { className: "space-y-1.5", children: [
+              /* @__PURE__ */ jsx(SectionLabel, { children: "Headers" }),
+              /* @__PURE__ */ jsx(
+                Textarea,
+                {
+                  value: state.requestHeaders,
+                  onChange: (e) => setRequestHeaders(e.target.value),
+                  className: "font-mono text-[11px] min-h-[60px] resize-y",
+                  rows: 3
+                }
+              )
+            ] })
+          ] })
+        }
+      ),
+      hasCurl && /* @__PURE__ */ jsx(
+        CollapsibleSection,
+        {
+          label: /* @__PURE__ */ jsxs("span", { className: "inline-flex items-center gap-1", children: [
+            /* @__PURE__ */ jsx(Terminal, { className: "h-2.5 w-2.5" }),
+            "cURL"
+          ] }),
+          children: /* @__PURE__ */ jsx("div", { className: "mt-2", children: /* @__PURE__ */ jsx(
+            PrettyCode_default,
+            {
+              data: curlCommand,
+              language: "bash",
+              isCompact: true,
+              maxLines: 50
+            }
+          ) })
+        }
+      ),
+      /* @__PURE__ */ jsx("div", { className: "h-4" })
+    ] })
+  ] });
+}
+__name(RequestPanel, "RequestPanel");
+function BodySection({ schema, bodyType, bodyDescription, value, onChange, isJsonValid }) {
+  const hasSchema = !!schema;
+  const [mode, setMode] = React12.useState(hasSchema ? "form" : "json");
+  const parsed = React12.useMemo(() => {
+    if (!value) return null;
+    try {
+      return JSON.parse(value);
+    } catch {
+      return null;
+    }
+  }, [value]);
+  const handleFormChange = useCallback(
+    (next) => {
+      onChange(JSON.stringify(next, null, 2));
+    },
+    [onChange]
+  );
+  return /* @__PURE__ */ jsxs("div", { className: "space-y-2", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-between gap-2 flex-wrap", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex items-baseline gap-2 min-w-0", children: [
+        /* @__PURE__ */ jsx(SectionLabel, { children: "Body" }),
+        bodyType && /* @__PURE__ */ jsx("span", { className: "text-[10px] text-muted-foreground/40 font-mono", children: bodyType }),
+        bodyDescription && /* @__PURE__ */ jsx("span", { className: "text-[10px] text-muted-foreground/60 truncate", children: bodyDescription })
+      ] }),
+      hasSchema && /* @__PURE__ */ jsxs("div", { className: "inline-flex rounded-md border overflow-hidden text-[10px]", children: [
+        /* @__PURE__ */ jsx(ModeButton, { active: mode === "form", onClick: () => setMode("form"), children: "Form" }),
+        /* @__PURE__ */ jsx(ModeButton, { active: mode === "json", onClick: () => setMode("json"), children: "JSON" })
+      ] }),
+      mode === "json" && isJsonValid && value && /* @__PURE__ */ jsxs(
+        "button",
+        {
+          type: "button",
+          onClick: () => {
+            try {
+              onChange(JSON.stringify(JSON.parse(value), null, 2));
+            } catch {
+            }
+          },
+          className: "inline-flex items-center gap-1 text-[10px] text-muted-foreground hover:text-foreground transition-colors",
+          children: [
+            /* @__PURE__ */ jsx(Sparkles, { className: "h-2.5 w-2.5" }),
+            "Format"
+          ]
+        }
+      )
+    ] }),
+    mode === "form" && hasSchema ? /* @__PURE__ */ jsx(
+      BodyFormEditor,
+      {
+        schema,
+        value: parsed,
+        onChange: handleFormChange
+      }
+    ) : /* @__PURE__ */ jsxs(Fragment, { children: [
+      /* @__PURE__ */ jsx(
+        Textarea,
+        {
+          placeholder: '{\n  "key": "value"\n}',
+          value,
+          onChange: (e) => onChange(e.target.value),
+          className: cn(
+            "font-mono text-[11px] min-h-[90px] resize-y",
+            !isJsonValid && "border-destructive focus-visible:ring-destructive/30"
+          ),
+          rows: 4
+        }
+      ),
+      !isJsonValid && /* @__PURE__ */ jsx("p", { className: "text-[10px] text-destructive", children: "Invalid JSON" })
+    ] })
+  ] });
+}
+__name(BodySection, "BodySection");
+function ModeButton({
+  active,
+  onClick,
+  children
+}) {
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick,
+      className: cn(
+        "px-2 py-0.5 font-medium transition-colors",
+        active ? "bg-primary/10 text-foreground" : "text-muted-foreground hover:text-foreground"
+      ),
+      children
+    }
+  );
+}
+__name(ModeButton, "ModeButton");
+function looksLikeSpaShell(html) {
+  const bodyMatch = html.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
+  const bodyContent = (bodyMatch?.[1] ?? html).replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<!--[\s\S]*?-->/g, "").trim();
+  if (bodyContent.length === 0) return true;
+  const singleEmptyContainer = /^<(div|main|section)[^>]*>\s*<\/\1>$/i;
+  if (singleEmptyContainer.test(bodyContent)) return true;
+  return false;
+}
+__name(looksLikeSpaShell, "looksLikeSpaShell");
+function PreviewView({ html }) {
+  const isSpaShell = useMemo(() => looksLikeSpaShell(html), [html]);
+  if (!html) {
+    return /* @__PURE__ */ jsx("div", { className: "py-10 text-center text-xs text-muted-foreground", children: "Empty response body" });
+  }
+  if (isSpaShell) {
+    return /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-center justify-center py-16 px-6 text-center gap-3 min-h-[400px]", children: [
+      /* @__PURE__ */ jsx("div", { className: "inline-flex items-center justify-center h-10 w-10 rounded-full bg-muted", children: /* @__PURE__ */ jsx(Info, { className: "h-5 w-5 text-muted-foreground" }) }),
+      /* @__PURE__ */ jsxs("div", { className: "max-w-sm space-y-1.5", children: [
+        /* @__PURE__ */ jsx("p", { className: "text-sm font-medium text-foreground", children: "Looks like a single-page app shell" }),
+        /* @__PURE__ */ jsxs("p", { className: "text-xs text-muted-foreground leading-relaxed", children: [
+          "This page renders its content with JavaScript at runtime. Scripts are disabled in the sandbox, so Preview would show a blank page. Switch to ",
+          /* @__PURE__ */ jsx("strong", { children: "Pretty" }),
+          " or",
+          " ",
+          /* @__PURE__ */ jsx("strong", { children: "Raw" }),
+          " to inspect the HTML source."
+        ] })
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs("div", { className: "flex flex-col h-full min-h-[400px]", children: [
+    /* @__PURE__ */ jsxs("div", { className: "shrink-0 flex items-center gap-1.5 px-3 py-1.5 bg-muted/30 border-b text-[10px] text-muted-foreground/70", children: [
+      /* @__PURE__ */ jsx(ShieldCheck, { className: "h-3 w-3" }),
+      "Sandboxed preview \u2014 scripts, forms and popups are disabled"
+    ] }),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "flex-1 min-h-[360px] p-2",
+        style: {
+          backgroundColor: "#fff",
+          backgroundImage: "linear-gradient(45deg, #f3f4f6 25%, transparent 25%), linear-gradient(-45deg, #f3f4f6 25%, transparent 25%), linear-gradient(45deg, transparent 75%, #f3f4f6 75%), linear-gradient(-45deg, transparent 75%, #f3f4f6 75%)",
+          backgroundSize: "16px 16px",
+          backgroundPosition: "0 0, 0 8px, 8px -8px, -8px 0px"
+        },
+        children: /* @__PURE__ */ jsx(
+          "iframe",
+          {
+            title: "Response preview",
+            srcDoc: html,
+            sandbox: "",
+            className: "w-full h-full min-h-[360px] bg-white border-0 rounded shadow-sm"
+          }
+        )
+      }
+    )
+  ] });
+}
+__name(PreviewView, "PreviewView");
+var JSON_TREE_CONFIG = {
+  maxAutoExpandDepth: 2,
+  maxAutoExpandArrayItems: 10,
+  maxAutoExpandObjectKeys: 5,
+  maxStringLength: 200,
+  collectionLimit: 50,
+  showCollectionInfo: true,
+  showExpandControls: true,
+  showActionButtons: false,
+  preserveKeyOrder: true,
+  className: "border-0 rounded-none"
+};
+function PrettyView({ treeData, rawText, detected }) {
+  if (detected.kind === "json" && treeData != null) {
+    return /* @__PURE__ */ jsx(JsonTree_default, { title: "Response Body", data: treeData, config: JSON_TREE_CONFIG });
+  }
+  if (!rawText) {
+    return /* @__PURE__ */ jsx("div", { className: "py-10 text-center text-xs text-muted-foreground", children: "Empty response body" });
+  }
+  return /* @__PURE__ */ jsx(
+    PrettyCode_default,
+    {
+      data: rawText,
+      language: detected.prism,
+      variant: "plain",
+      isCompact: true
+    }
+  );
+}
+__name(PrettyView, "PrettyView");
+function RawView({ rawText }) {
+  if (!rawText) {
+    return /* @__PURE__ */ jsx("div", { className: "py-10 text-center text-xs text-muted-foreground", children: "Empty response body" });
+  }
+  return /* @__PURE__ */ jsx("pre", { className: "p-4 text-[11px] font-mono text-foreground/70 whitespace-pre-wrap break-all leading-relaxed", children: rawText });
+}
+__name(RawView, "RawView");
+function StatusBar({ response, rawText, contentType }) {
+  const sizeKb = rawText ? `${(rawText.length / 1024).toFixed(1)} KB` : "";
+  const duration = response.duration != null ? `${response.duration}ms` : "";
+  const hasStatus = response.status != null;
+  const hasCopy = Boolean(rawText);
+  return /* @__PURE__ */ jsxs("div", { className: "shrink-0 border-b px-4 py-2 flex items-center justify-between gap-3 bg-muted/20", children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 min-w-0", children: [
+      hasStatus && /* @__PURE__ */ jsx(StatusBadge, { status: response.status }),
+      response.statusText && /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground truncate", children: response.statusText }),
+      sizeKb && /* @__PURE__ */ jsx("span", { className: "text-[10px] text-muted-foreground/50 tabular-nums shrink-0", children: sizeKb }),
+      duration && /* @__PURE__ */ jsx("span", { className: "text-[10px] text-muted-foreground/50 tabular-nums shrink-0", children: duration }),
+      contentType && /* @__PURE__ */ jsx("span", { className: "text-[10px] text-muted-foreground/50 font-mono truncate", children: contentType })
+    ] }),
+    hasCopy && /* @__PURE__ */ jsx(
+      CopyButton,
+      {
+        value: rawText,
+        variant: "ghost",
+        size: "sm",
+        className: "h-6 px-2 text-[10px] text-muted-foreground shrink-0",
+        children: "Copy"
+      }
+    )
+  ] });
+}
+__name(StatusBar, "StatusBar");
+
+// src/tools/OpenapiViewer/components/shared/ResponsePanel/detectContent.ts
+function normaliseContentType(raw) {
+  if (!raw) return null;
+  const semi = raw.indexOf(";");
+  return (semi === -1 ? raw : raw.slice(0, semi)).trim().toLowerCase();
+}
+__name(normaliseContentType, "normaliseContentType");
+function readContentType(headers) {
+  if (!headers) return null;
+  if (typeof headers.get === "function") {
+    return headers.get("content-type");
+  }
+  if (typeof headers === "object") {
+    for (const [k, v] of Object.entries(headers)) {
+      if (k.toLowerCase() === "content-type") {
+        return typeof v === "string" ? v : null;
+      }
+    }
+  }
+  return null;
+}
+__name(readContentType, "readContentType");
+function kindFromContentType(mime) {
+  if (!mime) return "text";
+  if (mime === "application/json" || mime.endsWith("+json")) return "json";
+  if (mime === "text/html" || mime === "application/xhtml+xml") return "html";
+  if (mime === "application/xml" || mime === "text/xml" || mime.endsWith("+xml")) return "xml";
+  if (mime === "text/css") return "css";
+  if (mime === "application/javascript" || mime === "text/javascript" || mime === "application/x-javascript") return "javascript";
+  return "text";
+}
+__name(kindFromContentType, "kindFromContentType");
+function kindFromBody(body) {
+  const trimmed = body.trimStart();
+  if (!trimmed) return null;
+  if (trimmed.startsWith("<!DOCTYPE") || /^<html[\s>]/i.test(trimmed)) return "html";
+  if (trimmed.startsWith("<?xml")) return "xml";
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      JSON.parse(trimmed);
+      return "json";
+    } catch {
+    }
+  }
+  return null;
+}
+__name(kindFromBody, "kindFromBody");
+var PRISM_BY_KIND = {
+  json: "json",
+  // ``markup`` is Prism's HTML/XML grammar — there isn't a separate
+  // ``html`` language. XML piggy-backs on the same tokeniser.
+  html: "markup",
+  xml: "markup",
+  css: "css",
+  javascript: "javascript",
+  text: "markup"
+};
+function detectContent(headers, rawBody) {
+  const contentType = normaliseContentType(readContentType(headers));
+  const headerKind = kindFromContentType(contentType);
+  const kind = headerKind === "text" ? kindFromBody(rawBody) ?? "text" : headerKind;
+  return {
+    kind,
+    prism: PRISM_BY_KIND[kind],
+    contentType
+  };
+}
+__name(detectContent, "detectContent");
+
+// src/tools/OpenapiViewer/components/shared/ResponsePanel/useResponseView.ts
+function useResponseView(data, headers) {
+  return useMemo(() => {
+    if (data == null) {
+      return {
+        treeData: null,
+        rawText: "",
+        detected: detectContent(headers, "")
+      };
+    }
+    if (typeof data === "string") {
+      try {
+        return {
+          treeData: JSON.parse(data),
+          rawText: data,
+          detected: detectContent(headers, data)
+        };
+      } catch {
+        return {
+          treeData: null,
+          rawText: data,
+          detected: detectContent(headers, data)
+        };
+      }
+    }
+    const stringified = (() => {
+      try {
+        return JSON.stringify(data, null, 2);
+      } catch {
+        return String(data);
+      }
+    })();
+    return {
+      treeData: data,
+      rawText: stringified,
+      detected: detectContent(headers, stringified)
+    };
+  }, [data, headers]);
+}
+__name(useResponseView, "useResponseView");
+var LABELS = {
+  pretty: "Pretty",
+  raw: "Raw",
+  preview: "Preview"
+};
+function ViewTabs({ active, onChange, showPreview }) {
+  const tabs = showPreview ? ["pretty", "raw", "preview"] : ["pretty", "raw"];
+  return /* @__PURE__ */ jsx("div", { className: "shrink-0 border-b px-3 py-1.5 flex items-center gap-1", children: tabs.map((t) => /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      onClick: () => onChange(t),
+      className: cn(
+        "h-6 px-2.5 rounded text-[11px] font-medium transition-colors",
+        active === t ? "bg-muted text-foreground" : "text-muted-foreground/70 hover:text-foreground hover:bg-muted/50"
+      ),
+      children: LABELS[t]
+    },
+    t
+  )) });
+}
+__name(ViewTabs, "ViewTabs");
+function ResponsePanel() {
+  const { state } = usePlaygroundContext();
+  const { response, loading, selectedEndpoint } = state;
+  const { treeData, rawText, detected } = useResponseView(response?.data, response?.headers);
+  const showPreview = detected.kind === "html";
+  const [mode, setMode] = useState(showPreview ? "preview" : "pretty");
+  useEffect(() => {
+    setMode(showPreview ? "preview" : "pretty");
+  }, [selectedEndpoint, response, showPreview]);
+  if (loading) {
+    return /* @__PURE__ */ jsxs("div", { className: "flex items-center justify-center h-full gap-2", children: [
+      /* @__PURE__ */ jsx(Loader2, { className: "h-4 w-4 animate-spin text-muted-foreground" }),
+      /* @__PURE__ */ jsx("span", { className: "text-xs text-muted-foreground", children: "Sending\u2026" })
+    ] });
+  }
+  if (!selectedEndpoint) return /* @__PURE__ */ jsx(EmptyState, { icon: Terminal, text: "Response will appear here" });
+  if (!response) return /* @__PURE__ */ jsx(EmptyState, { icon: Send, text: 'Press "Send Request" to see the response' });
+  const hasError = Boolean(response.error);
+  const hasStatus = response.status != null;
+  if (hasError && !hasStatus) {
+    return /* @__PURE__ */ jsx(
+      EmptyState,
+      {
+        icon: WifiOff,
+        text: response.error,
+        className: "text-destructive [&_svg]:text-destructive"
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(StatusBar, { response, rawText, contentType: detected.contentType }),
+    hasError && /* @__PURE__ */ jsx("div", { className: "shrink-0 mx-4 mt-3 rounded border border-destructive/20 bg-destructive/5 px-3 py-2", children: /* @__PURE__ */ jsx("p", { className: "text-xs text-destructive", children: response.error }) }),
+    /* @__PURE__ */ jsx(ViewTabs, { active: mode, onChange: setMode, showPreview }),
+    /* @__PURE__ */ jsxs(ScrollArea, { children: [
+      mode === "pretty" && /* @__PURE__ */ jsx(PrettyView, { treeData, rawText, detected }),
+      mode === "raw" && /* @__PURE__ */ jsx(RawView, { rawText }),
+      mode === "preview" && /* @__PURE__ */ jsx(PreviewView, { html: rawText })
+    ] })
+  ] });
+}
+__name(ResponsePanel, "ResponsePanel");
+function SendButton({ className }) {
+  const { state, sendRequest } = usePlaygroundContext();
+  const ep = state.selectedEndpoint;
+  const builder = useMemo(
+    () => ep ? new UrlBuilder(ep, state.parameters) : null,
+    [ep, state.parameters]
+  );
+  const missingRequired = builder?.missingRequired() ?? [];
+  const unsubstituted = builder?.unfilledPlaceholders() ?? [];
+  const isJsonValid = state.requestBody ? isValidJson(state.requestBody) : true;
+  const blockers = [];
+  if (missingRequired.length > 0) {
+    blockers.push(
+      `Fill required parameter${missingRequired.length > 1 ? "s" : ""}: ${missingRequired.join(", ")}`
+    );
+  } else if (unsubstituted.length > 0) {
+    blockers.push(`URL still has unfilled placeholder${unsubstituted.length > 1 ? "s" : ""}: ${unsubstituted.map((n) => `{${n}}`).join(", ")}`);
+  }
+  if (!isJsonValid) blockers.push("Request body is not valid JSON");
+  const disabled = state.loading || !state.requestUrl || blockers.length > 0;
+  const tooltip = blockers.length > 0 ? blockers.join("\n") : void 0;
+  return /* @__PURE__ */ jsxs("div", { className: cn("space-y-2", className), children: [
+    blockers.length > 0 && /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-2 rounded-md border border-amber-500/25 bg-amber-500/[0.06] px-3 py-2 text-[11px] text-amber-600 dark:text-amber-400", children: [
+      /* @__PURE__ */ jsx(AlertCircle, { className: "h-3.5 w-3.5 shrink-0 mt-px" }),
+      /* @__PURE__ */ jsx("span", { className: "leading-snug", children: blockers[0] })
+    ] }),
+    /* @__PURE__ */ jsx(
+      Button,
+      {
+        onClick: sendRequest,
+        disabled,
+        size: "sm",
+        title: tooltip,
+        className: "w-full gap-2 h-9",
+        children: state.loading ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Loader2, { className: "h-3.5 w-3.5 animate-spin" }),
+          "Sending\u2026"
+        ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(Send, { className: "h-3.5 w-3.5" }),
+          "Send Request"
+        ] })
+      }
+    )
+  ] });
+}
+__name(SendButton, "SendButton");
+var WIDTH_NARROW = "clamp(380px, 30vw, 480px)";
+var WIDTH_WIDE = "clamp(720px, 60vw, 1280px)";
+function SlideInPlayground({ open, onClose }) {
+  const { state } = usePlaygroundContext();
+  const ep = state.selectedEndpoint;
+  const showResponse = state.response !== null || state.loading;
+  const width = showResponse ? WIDTH_WIDE : WIDTH_NARROW;
+  return /* @__PURE__ */ jsx(SidePanel, { open, onOpenChange: (v) => !v && onClose(), side: "right", children: /* @__PURE__ */ jsxs(SidePanel.Content, { width, className: "max-w-[95vw]", children: [
+    /* @__PURE__ */ jsxs(SidePanel.Header, { children: [
+      /* @__PURE__ */ jsx(SidePanel.Title, { children: "Playground" }),
+      ep && /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 min-w-0 flex-1", children: [
+        /* @__PURE__ */ jsx(MethodBadge, { method: ep.method }),
+        /* @__PURE__ */ jsx("code", { className: "font-mono text-[11px] text-muted-foreground truncate", children: relativePath(ep.path) })
+      ] }),
+      /* @__PURE__ */ jsx(SidePanel.Close, { className: "ml-auto" })
+    ] }),
+    /* @__PURE__ */ jsxs(
+      SidePanel.Body,
+      {
+        className: cn(
+          "overflow-hidden grid divide-x transition-[grid-template-columns] duration-250",
+          showResponse ? "grid-cols-[minmax(0,1fr)_minmax(0,1fr)]" : "grid-cols-1"
+        ),
+        children: [
+          /* @__PURE__ */ jsxs(Panel, { children: [
+            /* @__PURE__ */ jsx(RequestPanel, {}),
+            ep && /* @__PURE__ */ jsx("div", { className: "shrink-0 border-t px-4 py-3 bg-background", children: /* @__PURE__ */ jsx(SendButton, {}) })
+          ] }),
+          showResponse && /* @__PURE__ */ jsx(Panel, { children: /* @__PURE__ */ jsx(ResponsePanel, {}) })
+        ]
+      }
+    )
+  ] }) });
+}
+__name(SlideInPlayground, "SlideInPlayground");
+function TryItSheet({ open, onOpenChange }) {
+  const { state } = usePlaygroundContext();
+  const showResponse = state.response !== null || state.loading;
+  return /* @__PURE__ */ jsx(ResponsiveSheet, { open, onOpenChange, children: /* @__PURE__ */ jsxs(ResponsiveSheetContent, { className: "sm:max-w-xl flex flex-col h-full p-0", children: [
+    /* @__PURE__ */ jsx(ResponsiveSheetHeader, { className: "px-4 py-3 border-b shrink-0", children: /* @__PURE__ */ jsx(ResponsiveSheetTitle, { className: "text-sm", children: "Playground" }) }),
+    /* @__PURE__ */ jsxs("div", { className: "flex-1 min-h-0 flex flex-col divide-y", children: [
+      /* @__PURE__ */ jsxs("div", { className: "flex-1 min-h-0 flex flex-col", children: [
+        /* @__PURE__ */ jsx(RequestPanel, {}),
+        state.selectedEndpoint && /* @__PURE__ */ jsx("div", { className: "shrink-0 border-t px-4 py-3 bg-background", children: /* @__PURE__ */ jsx(SendButton, {}) })
+      ] }),
+      showResponse && /* @__PURE__ */ jsx("div", { className: "flex-1 min-h-0 flex flex-col", children: /* @__PURE__ */ jsx(ResponsePanel, {}) })
+    ] })
+  ] }) });
+}
+__name(TryItSheet, "TryItSheet");
+var DocsLayout = /* @__PURE__ */ __name(() => {
+  const { state, config, setSelectedEndpoint } = usePlaygroundContext();
+  const isDesktop = useMediaQuery("(min-width: 1024px)");
+  const isMobile = !isDesktop;
+  const grouping = config.schemaGrouping ?? "selector";
+  const preloadAll = grouping === "sections";
+  const urlSyncEnabled = typeof config.urlSync === "boolean" ? config.urlSync : Boolean(config.urlSync?.enabled);
+  const {
+    endpoints,
+    schemaInfo,
+    rawSchema,
+    resolvedBaseUrl,
+    loading,
+    error,
+    schemas,
+    currentSchema,
+    setCurrentSchema,
+    schemasData
+  } = useOpenApiSchema({
+    schemas: config.schemas,
+    defaultSchemaId: config.defaultSchemaId,
+    baseUrl: config.baseUrl,
+    preloadAll
+  });
+  const [activeAnchor, setActiveAnchor] = useState(null);
+  const [activeSchemaId, setActiveSchemaId] = useState(null);
+  const [sheetOpen, setSheetOpen] = useState(false);
+  const docsRef = useRef(null);
+  const slideOpen = !isMobile && state.selectedEndpoint !== null;
+  const endpointsBySchema = useMemo(() => {
+    if (grouping !== "sections") return {};
+    const byId = keyBy(schemasData, (e) => e.source.id);
+    const out = {};
+    for (const src of schemas) out[src.id] = byId[src.id]?.endpoints ?? [];
+    return out;
+  }, [grouping, schemasData, schemas]);
+  const handleTry = useCallback(
+    (ep) => {
+      setSelectedEndpoint(ep);
+      if (isMobile) setSheetOpen(true);
+    },
+    [isMobile, setSelectedEndpoint]
+  );
+  const handleCloseSlide = useCallback(() => {
+    setSelectedEndpoint(null);
+  }, [setSelectedEndpoint]);
+  const handleNavigate = useCallback(
+    (anchor, schemaId) => {
+      if (schemaId && schemaId !== currentSchema?.id && grouping === "selector") {
+        setCurrentSchema(schemaId);
+        requestAnimationFrame(() => {
+          docsRef.current?.scrollToAnchor(anchor);
+        });
+        return;
+      }
+      docsRef.current?.scrollToAnchor(anchor);
+    },
+    [currentSchema?.id, grouping, setCurrentSchema]
+  );
+  const handleActiveChange = useCallback((anchor, schemaId) => {
+    setActiveAnchor(anchor);
+    setActiveSchemaId(schemaId);
+  }, []);
+  const effectiveSchemaId = grouping === "sections" ? activeSchemaId : currentSchema?.id ?? null;
+  const handleHashTarget = useCallback(
+    (target) => {
+      if (!target.schemaId && !target.anchor) return;
+      const matched = target.schemaId ? schemas.find((s) => s.id === target.schemaId || slugifySchemaId(s.id) === target.schemaId) : null;
+      const needsSchemaSwitch = matched && grouping === "selector" && matched.id !== currentSchema?.id;
+      if (needsSchemaSwitch) {
+        setCurrentSchema(matched.id);
+      }
+      if (target.anchor) {
+        const anchor = target.anchor;
+        if (needsSchemaSwitch) {
+          requestAnimationFrame(() => {
+            docsRef.current?.scrollToAnchor(anchor);
+          });
+        } else {
+          docsRef.current?.scrollToAnchor(anchor);
+        }
+      }
+    },
+    [schemas, grouping, currentSchema?.id, setCurrentSchema]
+  );
+  useDocsUrlSync({
+    enabled: urlSyncEnabled,
+    currentSchemaId: effectiveSchemaId,
+    activeAnchor,
+    onHashTarget: handleHashTarget
+  });
+  if (loading) {
+    return /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-[260px_1fr] items-start", children: [
+      /* @__PURE__ */ jsx(
+        "div",
+        {
+          className: "sticky top-[var(--navbar-height,64px)] border-r p-3 space-y-1.5 overflow-y-auto",
+          style: { height: "calc(100dvh - var(--navbar-height, 64px))" },
+          children: Array.from({ length: 12 }).map((_, i) => /* @__PURE__ */ jsx(Skeleton, { className: "h-8 w-full rounded" }, i))
+        }
+      ),
+      /* @__PURE__ */ jsxs("div", { className: "p-8 space-y-4", children: [
+        /* @__PURE__ */ jsx(Skeleton, { className: "h-8 w-1/2" }),
+        /* @__PURE__ */ jsx(Skeleton, { className: "h-4 w-full" }),
+        /* @__PURE__ */ jsx(Skeleton, { className: "h-4 w-3/4" }),
+        /* @__PURE__ */ jsx("div", { className: "mt-8 space-y-6", children: Array.from({ length: 3 }).map((_, i) => /* @__PURE__ */ jsxs("div", { className: "space-y-3", children: [
+          /* @__PURE__ */ jsx(Skeleton, { className: "h-6 w-1/3" }),
+          /* @__PURE__ */ jsx(Skeleton, { className: "h-20 w-full" })
+        ] }, i)) })
+      ] })
+    ] });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "flex items-center justify-center p-8",
+        style: { height: "calc(100dvh - var(--navbar-height, 64px))" },
+        children: /* @__PURE__ */ jsxs("p", { className: "text-sm text-destructive", children: [
+          "Failed to load schema: ",
+          error
+        ] })
+      }
+    );
+  }
+  if (isMobile) {
+    return /* @__PURE__ */ jsxs("div", { className: "flex flex-col", children: [
+      /* @__PURE__ */ jsx(EndpointDraftSync, { schemaId: currentSchema?.id ?? null }),
+      grouping === "sections" ? /* @__PURE__ */ jsx(
+        DocsView,
+        {
+          ref: docsRef,
+          grouping: "sections",
+          schemasData,
+          selectedVersion: state.selectedVersion,
+          loadedEndpoint: state.selectedEndpoint,
+          onTryEndpoint: handleTry,
+          onActiveChange: handleActiveChange
+        }
+      ) : /* @__PURE__ */ jsx(
+        DocsView,
+        {
+          ref: docsRef,
+          info: schemaInfo,
+          rawSchema,
+          resolvedBaseUrl,
+          endpoints,
+          selectedVersion: state.selectedVersion,
+          loadedEndpoint: state.selectedEndpoint,
+          onTryEndpoint: handleTry,
+          onActiveChange: handleActiveChange
+        }
+      ),
+      /* @__PURE__ */ jsx(TryItSheet, { open: sheetOpen, onOpenChange: setSheetOpen })
+    ] });
+  }
+  return /* @__PURE__ */ jsx(TooltipProvider, { delayDuration: 350, children: /* @__PURE__ */ jsxs("div", { className: "grid grid-cols-[260px_minmax(0,1fr)] items-start", children: [
+    /* @__PURE__ */ jsx(EndpointDraftSync, { schemaId: currentSchema?.id ?? null }),
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        className: "sticky top-[var(--navbar-height,64px)]",
+        style: { height: "calc(100dvh - var(--navbar-height, 64px))" },
+        children: /* @__PURE__ */ jsx(
+          DocsSidebar,
+          {
+            info: schemaInfo,
+            endpoints,
+            schemas,
+            currentSchemaId: currentSchema?.id ?? null,
+            onSchemaChange: setCurrentSchema,
+            activeEndpointId: activeAnchor,
+            selectedVersion: state.selectedVersion,
+            onNavigate: handleNavigate,
+            grouping,
+            endpointsBySchema,
+            rawSchema,
+            resolvedBaseUrl
+          }
+        )
+      }
+    ),
+    grouping === "sections" ? /* @__PURE__ */ jsx(
+      DocsView,
+      {
+        ref: docsRef,
+        grouping: "sections",
+        schemasData,
+        selectedVersion: state.selectedVersion,
+        loadedEndpoint: state.selectedEndpoint,
+        onTryEndpoint: handleTry,
+        onActiveChange: handleActiveChange
+      }
+    ) : /* @__PURE__ */ jsx(
+      DocsView,
+      {
+        ref: docsRef,
+        info: schemaInfo,
+        rawSchema,
+        resolvedBaseUrl,
+        endpoints,
+        selectedVersion: state.selectedVersion,
+        loadedEndpoint: state.selectedEndpoint,
+        onTryEndpoint: handleTry,
+        onActiveChange: handleActiveChange
+      }
+    ),
+    /* @__PURE__ */ jsx(SlideInPlayground, { open: slideOpen, onClose: handleCloseSlide })
+  ] }) });
+}, "DocsLayout");
+
+export { DocsLayout };
+//# sourceMappingURL=DocsLayout-JPXFUKAR.mjs.map
+//# sourceMappingURL=DocsLayout-JPXFUKAR.mjs.map