@contractkit/explorer-ui 0.1.0

package/dist/index.js

@@ -0,0 +1,1359 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/html.ts
+var RAW = /* @__PURE__ */ Symbol("raw");
+function raw(value) {
+  return {
+    [RAW]: true,
+    value
+  };
+}
+__name(raw, "raw");
+function isRaw(value) {
+  return typeof value === "object" && value !== null && value[RAW] === true;
+}
+__name(isRaw, "isRaw");
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+__name(escapeHtml, "escapeHtml");
+function renderValue(value) {
+  if (value === null || value === void 0 || value === false) return "";
+  if (isRaw(value)) return value.value;
+  if (Array.isArray(value)) return value.map(renderValue).join("");
+  return escapeHtml(String(value));
+}
+__name(renderValue, "renderValue");
+function html(strings, ...values) {
+  let out = strings[0] ?? "";
+  for (let i = 0; i < values.length; i++) {
+    out += renderValue(values[i]) + (strings[i + 1] ?? "");
+  }
+  return out;
+}
+__name(html, "html");
+function slug(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+__name(slug, "slug");
+
+// src/markdown.ts
+function renderMarkdown(input) {
+  if (!input) return "";
+  const lines = input.replace(/\r\n/g, "\n").split("\n");
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i] ?? "";
+    const fence = /^```(\w*)\s*$/.exec(line);
+    if (fence) {
+      const lang = fence[1] ?? "";
+      const buf2 = [];
+      i++;
+      while (i < lines.length && !/^```\s*$/.test(lines[i] ?? "")) {
+        buf2.push(lines[i] ?? "");
+        i++;
+      }
+      i++;
+      const langAttr = lang ? ` data-lang="${escapeHtml(lang)}"` : "";
+      out.push(`<pre class="ce-code"${langAttr}><code>${escapeHtml(buf2.join("\n"))}</code></pre>`);
+      continue;
+    }
+    const heading = /^(#{1,6})\s+(.+)$/.exec(line);
+    if (heading) {
+      const level = heading[1].length;
+      out.push(`<h${level}>${renderInline(heading[2])}</h${level}>`);
+      i++;
+      continue;
+    }
+    if (/^\s*[-*]\s+/.test(line)) {
+      const items = [];
+      while (i < lines.length && /^\s*[-*]\s+/.test(lines[i] ?? "")) {
+        items.push(renderInline((lines[i] ?? "").replace(/^\s*[-*]\s+/, "")));
+        i++;
+      }
+      out.push(`<ul>${items.map((t) => `<li>${t}</li>`).join("")}</ul>`);
+      continue;
+    }
+    if (/^\s*\d+\.\s+/.test(line)) {
+      const items = [];
+      while (i < lines.length && /^\s*\d+\.\s+/.test(lines[i] ?? "")) {
+        items.push(renderInline((lines[i] ?? "").replace(/^\s*\d+\.\s+/, "")));
+        i++;
+      }
+      out.push(`<ol>${items.map((t) => `<li>${t}</li>`).join("")}</ol>`);
+      continue;
+    }
+    if (line.trim() === "") {
+      i++;
+      continue;
+    }
+    const buf = [
+      line
+    ];
+    i++;
+    while (i < lines.length) {
+      const next = lines[i] ?? "";
+      if (next.trim() === "" || /^```/.test(next) || /^#{1,6}\s/.test(next) || /^\s*[-*]\s/.test(next) || /^\s*\d+\.\s/.test(next)) break;
+      buf.push(next);
+      i++;
+    }
+    out.push(`<p>${renderInline(buf.join(" "))}</p>`);
+  }
+  return out.join("\n");
+}
+__name(renderMarkdown, "renderMarkdown");
+function renderInline(text) {
+  let s = escapeHtml(text);
+  s = s.replace(/`([^`]+)`/g, (_m, code) => `<code>${code}</code>`);
+  s = s.replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>");
+  s = s.replace(/(^|[^*])\*([^*\s][^*]*?)\*(?!\*)/g, (_m, before, body) => `${before}<em>${body}</em>`);
+  s = s.replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, (_m, label, url) => {
+    return `<a href="${url}" rel="noopener noreferrer">${label}</a>`;
+  });
+  return s;
+}
+__name(renderInline, "renderInline");
+
+// src/render-code-samples.ts
+import { resolveEffectiveFields } from "@contractkit/core/type-utils";
+import { faker } from "@faker-js/faker";
+function renderCodeSamples(op, baseUrl, ctx = {}) {
+  const curl = renderCurlSample(op, baseUrl, ctx);
+  const responseExample = renderResponseExample(op, ctx);
+  return `<section class="ce-rail-section">
+        <h4 class="ce-rail-heading">Request Sample</h4>
+        <pre class="ce-code ce-code-dark">${curl}</pre>
+    </section>
+    ${responseExample}`;
+}
+__name(renderCodeSamples, "renderCodeSamples");
+function renderCurlSample(op, baseUrl, ctx) {
+  const cleanBase = baseUrl ? baseUrl.replace(/\/$/, "") : "https://api.example.com";
+  const url = `${cleanBase}${op.routePath}`;
+  const lines = [];
+  lines.push(`curl --request ${op.method.toUpperCase()} \\`);
+  lines.push(`  --url ${url}`);
+  const hasJsonResponse = op.op.responses.some((r) => r.contentType?.includes("json"));
+  const jsonBody = op.op.request?.bodies.find((b) => b.contentType === "application/json" || b.contentType.endsWith("+json"));
+  if (hasJsonResponse) {
+    lines[lines.length - 1] += " \\";
+    lines.push(`  --header 'Accept: application/json'`);
+  }
+  if (jsonBody) {
+    lines[lines.length - 1] += " \\";
+    lines.push(`  --header 'Content-Type: application/json'`);
+    const sample = buildSampleJson(jsonBody.bodyType, ctx, `${op.method}:${op.routePath}:request-body`, "readonly");
+    const bodyJson = JSON.stringify(sample, null, 2).replace(/'/g, `'\\''`);
+    lines[lines.length - 1] += " \\";
+    lines.push(`  --data '${bodyJson}'`);
+  }
+  return escapeHtml(lines.join("\n"));
+}
+__name(renderCurlSample, "renderCurlSample");
+function renderResponseExample(op, ctx) {
+  const primary = op.op.responses.find((r) => r.statusCode >= 200 && r.statusCode < 300 && r.bodyType !== void 0 && r.contentType !== void 0 && r.contentType.includes("json"));
+  if (!primary || !primary.bodyType) return "";
+  faker.seed(hashString(`${op.method}:${op.routePath}:${primary.statusCode}`));
+  const sample = jsonSample(primary.bodyType, ctx, /* @__PURE__ */ new Set(), void 0, "writeonly");
+  const formatted = JSON.stringify(sample, null, 2);
+  return `<section class="ce-rail-section">
+        <h4 class="ce-rail-heading">Response Example</h4>
+        <pre class="ce-code ce-code-dark">${escapeHtml(formatted)}</pre>
+    </section>`;
+}
+__name(renderResponseExample, "renderResponseExample");
+function jsonSample(type, ctx, visited, fieldName, exclude) {
+  switch (type.kind) {
+    case "scalar":
+      return scalarSample(type, fieldName);
+    case "literal":
+      return type.value;
+    case "enum":
+      return type.values.length > 0 ? faker.helpers.arrayElement(type.values) : null;
+    case "array": {
+      const len = faker.number.int({
+        min: 1,
+        max: 3
+      });
+      return Array.from({
+        length: len
+      }, () => jsonSample(type.item, ctx, visited, fieldName, exclude));
+    }
+    case "tuple":
+      return type.items.map((t) => jsonSample(t, ctx, visited, fieldName, exclude));
+    case "record":
+      return {
+        key: jsonSample(type.value, ctx, visited, void 0, exclude)
+      };
+    case "union":
+    case "discriminatedUnion": {
+      const first = type.members[0];
+      return first ? jsonSample(first, ctx, visited, fieldName, exclude) : null;
+    }
+    case "intersection": {
+      const resolved = resolveEffectiveFields(type, modelIndexFromCtx(ctx));
+      if (resolved.fields.length > 0) {
+        const out = {};
+        for (const f of resolved.fields) {
+          if (f.visibility === exclude) continue;
+          out[f.name] = jsonSample(f.type, ctx, visited, f.name, exclude);
+        }
+        return out;
+      }
+      const first = type.members[0];
+      return first ? jsonSample(first, ctx, visited, fieldName, exclude) : null;
+    }
+    case "lazy":
+      return jsonSample(type.inner, ctx, visited, fieldName, exclude);
+    case "inlineObject": {
+      const out = {};
+      for (const f of type.fields) {
+        if (f.visibility === exclude) continue;
+        out[f.name] = jsonSample(f.type, ctx, visited, f.name, exclude);
+      }
+      return out;
+    }
+    case "ref": {
+      if (visited.has(type.name)) return null;
+      const entry = ctx.models?.get(type.name);
+      if (!entry) return null;
+      const next = /* @__PURE__ */ new Set([
+        ...visited,
+        type.name
+      ]);
+      const resolved = resolveEffectiveFields(type.name, modelIndexFromCtx(ctx));
+      if (resolved.fields.length > 0) {
+        const out = {};
+        for (const f of resolved.fields) {
+          if (f.visibility === exclude) continue;
+          out[f.name] = jsonSample(f.type, ctx, next, f.name, exclude);
+        }
+        return out;
+      }
+      const model = entry.model;
+      if (model.type) return jsonSample(model.type, ctx, next, fieldName, exclude);
+      return null;
+    }
+  }
+}
+__name(jsonSample, "jsonSample");
+function buildSampleJson(type, ctx, seed, exclude = "writeonly") {
+  faker.seed(hashString(seed));
+  return jsonSample(type, ctx, /* @__PURE__ */ new Set(), void 0, exclude);
+}
+__name(buildSampleJson, "buildSampleJson");
+function scalarSample(s, fieldName) {
+  switch (s.name) {
+    case "boolean":
+      return faker.datatype.boolean();
+    case "number":
+    case "int":
+    case "bigint":
+      return fakerNumber(fieldName, s);
+    case "uuid":
+      return faker.string.uuid();
+    case "datetime":
+      return faker.date.recent({
+        days: 90
+      }).toISOString();
+    case "date":
+      return faker.date.recent({
+        days: 90
+      }).toISOString().slice(0, 10);
+    case "time":
+      return faker.date.recent({
+        days: 1
+      }).toISOString().slice(11, 19);
+    case "interval":
+      return "P1D";
+    case "email":
+      return faker.internet.email().toLowerCase();
+    case "url":
+      return faker.internet.url();
+    case "string":
+      return fakerString(fieldName);
+    default:
+      return fakerString(fieldName);
+  }
+}
+__name(scalarSample, "scalarSample");
+function fakerString(fieldName) {
+  const name = (fieldName ?? "").toLowerCase();
+  if (/email/.test(name)) return faker.internet.email().toLowerCase();
+  if (/^url$|link|href|website/.test(name)) return faker.internet.url();
+  if (/^id$|_id$|guid|uuid/.test(name)) return faker.string.uuid();
+  if (/at$|_at$|date|time/.test(name)) return faker.date.recent({
+    days: 90
+  }).toISOString();
+  if (/firstname|first_name/.test(name)) return faker.person.firstName();
+  if (/lastname|last_name|surname/.test(name)) return faker.person.lastName();
+  if (/^name$|fullname|full_name|displayname|display_name/.test(name)) return faker.person.fullName();
+  if (/username|handle/.test(name)) return faker.internet.username();
+  if (/avatar|image|photo|picture/.test(name)) return faker.image.url();
+  if (/street|address/.test(name)) return faker.location.streetAddress();
+  if (/city/.test(name)) return faker.location.city();
+  if (/country/.test(name)) return faker.location.country();
+  if (/zip|postal/.test(name)) return faker.location.zipCode();
+  if (/state\b|region/.test(name)) return faker.location.state();
+  if (/company|organization|org\b/.test(name)) return faker.company.name();
+  if (/title|product|item/.test(name)) return faker.commerce.productName();
+  if (/color|colour/.test(name)) return faker.color.human();
+  if (/description|summary|bio|notes|message|content/.test(name)) return faker.lorem.sentence();
+  if (/phone/.test(name)) return faker.phone.number();
+  if (/password/.test(name)) return faker.internet.password();
+  if (/token|key|secret|apikey/.test(name)) return faker.string.alphanumeric(32);
+  if (/status|state/.test(name)) return faker.helpers.arrayElement([
+    "active",
+    "inactive",
+    "pending",
+    "archived",
+    "draft"
+  ]);
+  if (/currency/.test(name)) return faker.finance.currencyCode();
+  if (/locale|language/.test(name)) return faker.helpers.arrayElement([
+    "en-US",
+    "en-GB",
+    "de-DE",
+    "fr-FR",
+    "ja-JP",
+    "es-ES"
+  ]);
+  if (/slug/.test(name)) return faker.lorem.slug();
+  return faker.lorem.word();
+}
+__name(fakerString, "fakerString");
+function fakerNumber(fieldName, s) {
+  const name = (fieldName ?? "").toLowerCase();
+  if (/amount|price|cost|total|balance|fee|salary|revenue/.test(name)) {
+    return Number(faker.finance.amount({
+      min: 1,
+      max: 9999,
+      dec: 2
+    }));
+  }
+  if (/^age$/.test(name)) return faker.number.int({
+    min: 18,
+    max: 80
+  });
+  if (/year/.test(name)) return faker.number.int({
+    min: 2e3,
+    max: 2024
+  });
+  if (/month/.test(name)) return faker.number.int({
+    min: 1,
+    max: 12
+  });
+  if (/day/.test(name)) return faker.number.int({
+    min: 1,
+    max: 28
+  });
+  if (/count|quantity|qty/.test(name)) return faker.number.int({
+    min: 1,
+    max: 100
+  });
+  if (/percent|pct|ratio/.test(name)) return faker.number.int({
+    min: 0,
+    max: 100
+  });
+  if (/latitude|lat\b/.test(name)) return Number(faker.location.latitude().toFixed(2));
+  if (/longitude|lng\b|lon\b/.test(name)) return Number(faker.location.longitude().toFixed(2));
+  const lo = toFiniteNumber(s.min, 0);
+  const hi = toFiniteNumber(s.max, Math.max(lo + 1, 999));
+  if (s.name === "int" || s.name === "bigint") {
+    return faker.number.int({
+      min: lo,
+      max: hi
+    });
+  }
+  return Number(faker.number.float({
+    min: lo,
+    max: hi,
+    fractionDigits: 2
+  }));
+}
+__name(fakerNumber, "fakerNumber");
+function toFiniteNumber(value, fallback) {
+  if (typeof value === "number") return Number.isFinite(value) ? Math.floor(value) : fallback;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string") {
+    const n = Number(value);
+    return Number.isFinite(n) ? Math.floor(n) : fallback;
+  }
+  return fallback;
+}
+__name(toFiniteNumber, "toFiniteNumber");
+function modelIndexFromCtx(ctx) {
+  const out = /* @__PURE__ */ new Map();
+  if (ctx.models) {
+    for (const [name, resolved] of ctx.models) out.set(name, resolved.model);
+  }
+  return out;
+}
+__name(modelIndexFromCtx, "modelIndexFromCtx");
+function hashString(s) {
+  let h = 5381;
+  for (let i = 0; i < s.length; i++) h = (h << 5) + h + s.charCodeAt(i) | 0;
+  return h >>> 0;
+}
+__name(hashString, "hashString");
+
+// src/render-schema.ts
+import { resolveEffectiveFields as resolveEffectiveFields2 } from "@contractkit/core/type-utils";
+
+// src/constraints.ts
+function constraintSummary(scalar) {
+  const parts = [];
+  if (scalar.min !== void 0) parts.push(`min=${scalar.min}`);
+  if (scalar.max !== void 0) parts.push(`max=${scalar.max}`);
+  if (scalar.len !== void 0) parts.push(`len=${scalar.len}`);
+  if (scalar.regex !== void 0) parts.push(`regex=/${scalar.regex}/`);
+  if (scalar.format !== void 0) parts.push(`format=${scalar.format}`);
+  return parts.length > 0 ? `(${parts.join(", ")})` : "";
+}
+__name(constraintSummary, "constraintSummary");
+
+// src/render-model.ts
+function modelAnchor(name) {
+  return `model-${encodeURIComponent(name)}`;
+}
+__name(modelAnchor, "modelAnchor");
+function renderModel({ filePath, model }, ctx = {}) {
+  const badges = [];
+  if (model.deprecated) badges.push(badge("deprecated", "deprecated"));
+  if (model.mode) badges.push(badge(`mode=${model.mode}`, "mode"));
+  if (model.inputCase) badges.push(badge(`format(input=${model.inputCase})`, "format"));
+  if (model.outputCase) badges.push(badge(`format(output=${model.outputCase})`, "format"));
+  const fieldCtx = {
+    ...ctx,
+    visited: /* @__PURE__ */ new Set([
+      ...ctx.visited ?? [],
+      model.name
+    ])
+  };
+  const inheritance = model.bases && model.bases.length > 0 ? `<p class="ce-extends">extends ${model.bases.map((b) => `<a class="ce-ref" href="#model-${encodeURIComponent(b)}" data-open-model="${escapeHtml(b)}">${escapeHtml(b)}</a>`).join(", ")}</p>` : "";
+  const description = model.description ? `<div class="ce-description ce-markdown">${renderMarkdown(model.description)}</div>` : "";
+  const body = model.type ? `<div class="ce-type-alias">= ${renderType(model.type, fieldCtx)}</div>` : renderFieldRows(model.fields, fieldCtx);
+  return html`<section id="${raw(modelAnchor(model.name))}" class="ce-card ce-model-card">
+        <header class="ce-card-header">
+            <h2>
+                ${model.name}
+                ${raw(badges.join(""))}
+                <button
+                    class="ce-jump"
+                    data-jump-file="${filePath}"
+                    data-jump-line="${model.loc.line}"
+                    title="Open in editor"
+                    type="button"
+                >
+                    ↗
+                </button>
+            </h2>
+        </header>
+        ${raw(inheritance)}
+        ${raw(description)}
+        ${raw(body)}
+    </section>`;
+}
+__name(renderModel, "renderModel");
+function renderFieldRows(fields, ctx = {}) {
+  if (fields.length === 0) return `<p class="ce-empty">No fields.</p>`;
+  const rows = fields.map((f) => {
+    const modifiers = [];
+    if (f.optional) modifiers.push("optional");
+    if (f.nullable) modifiers.push("nullable");
+    if (f.visibility === "readonly") modifiers.push("readonly");
+    if (f.visibility === "writeonly") modifiers.push("writeonly");
+    if (f.deprecated) modifiers.push("deprecated");
+    if (f.override) modifiers.push("override");
+    const modifierHtml = modifiers.map((m) => badge(m, m)).join("");
+    const defaultHtml = f.default !== void 0 ? html`<code class="ce-default">= ${String(f.default)}</code>` : "";
+    const descHtml = f.description ? `<div class="ce-field-desc ce-markdown">${renderMarkdown(f.description)}</div>` : "";
+    return `<tr>
+            <td class="ce-field-name"><code>${escapeHtml(f.name)}</code>${modifierHtml}</td>
+            <td class="ce-field-type">${renderType(f.type, ctx)}${defaultHtml}${descHtml}</td>
+        </tr>`;
+  });
+  return `<table class="ce-fields"><tbody>${rows.join("")}</tbody></table>`;
+}
+__name(renderFieldRows, "renderFieldRows");
+function badge(label, kind) {
+  return `<span class="ce-badge ce-badge-${escapeHtml(kind)}">${escapeHtml(label)}</span>`;
+}
+__name(badge, "badge");
+
+// src/render-type.ts
+var DEFAULT_MAX_DEPTH = 4;
+function renderType(type, ctx = {}) {
+  switch (type.kind) {
+    case "scalar": {
+      const constraint = constraintSummary(type);
+      const constraintHtml = constraint ? `<span class="ce-type-constraint">${escapeHtml(constraint)}</span>` : "";
+      return `<span class="ce-type-scalar">${escapeHtml(type.name)}${constraintHtml}</span>`;
+    }
+    case "enum":
+      return `<span class="ce-type-enum">enum(${type.values.map(escapeHtml).join(", ")})</span>`;
+    case "literal":
+      return `<span class="ce-type-literal">${escapeHtml(typeof type.value === "string" ? `"${type.value}"` : String(type.value))}</span>`;
+    case "ref":
+      return renderRef(type.name, ctx);
+    case "array":
+      return `${tok("Array&lt;")}${renderType(type.item, ctx)}${tok("&gt;")}`;
+    case "tuple":
+      return `${tok("[")}${type.items.map((t) => renderType(t, ctx)).join(tok(", "))}${tok("]")}`;
+    case "record":
+      return `${tok("Record&lt;")}${renderType(type.key, ctx)}${tok(", ")}${renderType(type.value, ctx)}${tok("&gt;")}`;
+    case "union":
+      return type.members.map((m) => renderType(m, ctx)).join(tok(" | "));
+    case "discriminatedUnion":
+      return `${tok(`Union by ${escapeHtml(type.discriminator)}:`)} ` + type.members.map((m) => renderType(m, ctx)).join(tok(" | "));
+    case "intersection":
+      return type.members.map((m) => renderType(m, ctx)).join(tok(" &amp; "));
+    case "lazy":
+      return `${tok("Lazy&lt;")}${renderType(type.inner, ctx)}${tok("&gt;")}`;
+    case "inlineObject":
+      return `<details class="ce-inline-object"><summary>${tok("{ \u2026 }")}</summary>${renderFieldRows(type.fields, ctx)}</details>`;
+  }
+}
+__name(renderType, "renderType");
+function renderRef(name, ctx) {
+  const encName = encodeURIComponent(name);
+  const safeName = escapeHtml(name);
+  const entry = ctx.models?.get(name);
+  const visited = ctx.visited ?? /* @__PURE__ */ new Set();
+  const depth = ctx.depth ?? 0;
+  const maxDepth = ctx.maxDepth ?? DEFAULT_MAX_DEPTH;
+  if (!entry) {
+    return `<a class="ce-ref" href="#model-${encName}">${safeName}</a>`;
+  }
+  if (visited.has(name)) {
+    return `<span class="ce-ref ce-ref-cycle" title="recursive reference">${safeName} \u21BA</span>`;
+  }
+  const model = entry.model;
+  const jumpAttrs = `data-jump-file="${escapeHtml(entry.filePath)}" data-jump-line="${model.loc.line}"`;
+  if (depth >= maxDepth) {
+    return `<a class="ce-ref" href="#model-${encName}" ${jumpAttrs} title="Jump to source">${safeName}</a>`;
+  }
+  const nextCtx = {
+    models: ctx.models,
+    visited: /* @__PURE__ */ new Set([
+      ...visited,
+      name
+    ]),
+    maxDepth,
+    depth: depth + 1
+  };
+  const bases = model.bases && model.bases.length > 0 ? `<p class="ce-extends">extends ${model.bases.map((b) => renderRef(b, nextCtx)).join(", ")}</p>` : "";
+  const body = model.type ? `<div class="ce-type-alias">= ${renderType(model.type, nextCtx)}</div>` : renderFieldRows(model.fields, nextCtx);
+  const openButton = `<button class="ce-ref-open" type="button" ${jumpAttrs} title="Jump to source">\u2197</button>`;
+  return `<details class="ce-ref-expand">
+        <summary><span class="ce-ref-name">${safeName}</span>${openButton}</summary>
+        <div class="ce-ref-body">${bases}${body}</div>
+    </details>`;
+}
+__name(renderRef, "renderRef");
+function tok(text) {
+  return `<span class="ce-type-token">${text}</span>`;
+}
+__name(tok, "tok");
+
+// src/render-schema.ts
+var STRING_SCALARS = /* @__PURE__ */ new Set([
+  "string",
+  "uuid",
+  "email",
+  "url"
+]);
+function renderSchemaTree(type, ctx = {}, options = {}) {
+  return renderSchemaNode(type, ctx, options);
+}
+__name(renderSchemaTree, "renderSchemaTree");
+function renderSchemaNode(type, ctx, options) {
+  if (type.kind === "inlineObject") {
+    return renderSchemaFields(type.fields, ctx, options);
+  }
+  if (type.kind === "ref") {
+    const entry = ctx.models?.get(type.name);
+    const visited = ctx.visited ?? /* @__PURE__ */ new Set();
+    if (entry && !visited.has(type.name)) {
+      const next = {
+        ...ctx,
+        visited: /* @__PURE__ */ new Set([
+          ...visited,
+          type.name
+        ]),
+        depth: (ctx.depth ?? 0) + 1
+      };
+      const resolved = resolveEffectiveFields2(type.name, modelIndexFromCtx2(ctx));
+      if (resolved.fields.length > 0) {
+        const fieldsHtml = renderSchemaFields(resolved.fields, next, options);
+        const unresolvedHtml = renderUnresolvedRefs(resolved.unresolved);
+        return `${fieldsHtml}${unresolvedHtml}`;
+      }
+      if (resolved.unresolved.length > 0) {
+        return renderUnresolvedRefs(resolved.unresolved);
+      }
+      const model = entry.model;
+      if (model.type) {
+        return renderSchemaNode(model.type, next, options);
+      }
+    }
+    if (!entry) {
+      return renderUnresolvedRefs([
+        type.name
+      ]);
+    }
+    return `<div class="ce-schema-fallback">${renderType(type, ctx)}</div>`;
+  }
+  if (type.kind === "array") {
+    return `<div class="ce-schema-array-label">array of:</div>${renderSchemaNode(type.item, ctx, options)}`;
+  }
+  if (type.kind === "intersection") {
+    const resolved = resolveEffectiveFields2(type, modelIndexFromCtx2(ctx));
+    if (resolved.fields.length > 0 || resolved.unresolved.length > 0) {
+      const fieldsHtml = resolved.fields.length > 0 ? renderSchemaFields(resolved.fields, ctx, options) : "";
+      const unresolvedHtml = renderUnresolvedRefs(resolved.unresolved);
+      return `${fieldsHtml}${unresolvedHtml}`;
+    }
+    return `<div class="ce-schema-fallback">${renderType(type, ctx)}</div>`;
+  }
+  if (type.kind === "union" || type.kind === "discriminatedUnion") {
+    return renderUnion(type, ctx, options);
+  }
+  return `<div class="ce-schema-fallback">${renderType(type, ctx)}</div>`;
+}
+__name(renderSchemaNode, "renderSchemaNode");
+function modelIndexFromCtx2(ctx) {
+  const out = /* @__PURE__ */ new Map();
+  if (ctx.models) {
+    for (const [name, resolved] of ctx.models) out.set(name, resolved.model);
+  }
+  return out;
+}
+__name(modelIndexFromCtx2, "modelIndexFromCtx");
+function renderUnresolvedRefs(names) {
+  if (names.length === 0) return "";
+  const chips = names.map((n) => `<a class="ce-schema-unresolved-ref ce-ref" href="#model-${encodeURIComponent(n)}">${escapeHtml(n)}</a>`).join(", ");
+  return `<div class="ce-schema-unresolved">
+        <span class="ce-schema-unresolved-label">Unresolved</span>
+        ${chips}
+        <span class="ce-schema-unresolved-hint">\u2014 not loaded in the workspace.</span>
+    </div>`;
+}
+__name(renderUnresolvedRefs, "renderUnresolvedRefs");
+function renderUnion(type, ctx, options) {
+  const isDiscriminated = type.kind === "discriminatedUnion";
+  const label = isDiscriminated ? `One of <span class="ce-schema-union-disc">by <code>${escapeHtml(type.discriminator)}</code></span>` : "One of";
+  const variants = type.members.map((m) => renderVariant(m, ctx, isDiscriminated ? type.discriminator : void 0, options)).join("");
+  return `<div class="ce-schema-union">
+        <div class="ce-schema-union-label">${label}</div>
+        <div class="ce-schema-union-variants">${variants}</div>
+    </div>`;
+}
+__name(renderUnion, "renderUnion");
+function renderVariant(member, ctx, discriminator, options) {
+  const info = extractVariantInfo(member, ctx, discriminator, options);
+  const discBadge = info.discriminatorValue !== void 0 ? `<code class="ce-schema-variant-disc-value">${escapeHtml(discriminator)}: ${escapeHtml(info.discriminatorValue)}</code>` : "";
+  return `<details class="ce-schema-variant">
+        <summary>
+            <span class="ce-schema-variant-name">${info.name}</span>
+            ${discBadge}
+        </summary>
+        <div class="ce-schema-variant-body">${info.body}</div>
+    </details>`;
+}
+__name(renderVariant, "renderVariant");
+function extractVariantInfo(member, ctx, discriminator, options) {
+  if (member.kind === "ref") {
+    const entry = ctx.models?.get(member.name);
+    const visited = ctx.visited ?? /* @__PURE__ */ new Set();
+    if (entry && !visited.has(member.name)) {
+      const next = {
+        ...ctx,
+        visited: /* @__PURE__ */ new Set([
+          ...visited,
+          member.name
+        ]),
+        depth: (ctx.depth ?? 0) + 1
+      };
+      const model = entry.model;
+      const discriminatorValue = discriminator ? findDiscriminatorValue(model.fields, discriminator) : void 0;
+      const resolved = resolveEffectiveFields2(member.name, modelIndexFromCtx2(ctx));
+      let body;
+      if (resolved.fields.length > 0 || resolved.unresolved.length > 0) {
+        const fieldsHtml = resolved.fields.length > 0 ? renderSchemaFields(resolved.fields, next, options) : "";
+        body = `${fieldsHtml}${renderUnresolvedRefs(resolved.unresolved)}`;
+      } else if (model.type) {
+        body = renderSchemaNode(model.type, next, options);
+      } else {
+        body = `<p class="ce-empty">No fields.</p>`;
+      }
+      return {
+        name: escapeHtml(member.name),
+        body,
+        discriminatorValue
+      };
+    }
+    return {
+      name: escapeHtml(member.name),
+      body: `<div class="ce-schema-fallback">${renderType(member, ctx)}</div>`
+    };
+  }
+  if (member.kind === "inlineObject") {
+    return {
+      name: "object",
+      body: renderSchemaFields(member.fields, ctx, options),
+      discriminatorValue: discriminator ? findDiscriminatorValue(member.fields, discriminator) : void 0
+    };
+  }
+  return {
+    name: variantTypeName(member),
+    body: `<div class="ce-schema-fallback">${renderType(member, ctx)}</div>`
+  };
+}
+__name(extractVariantInfo, "extractVariantInfo");
+function findDiscriminatorValue(fields, discriminator) {
+  if (!fields) return void 0;
+  const f = fields.find((field) => field.name === discriminator);
+  if (!f) return void 0;
+  if (f.type.kind === "literal") {
+    return typeof f.type.value === "string" ? `"${f.type.value}"` : String(f.type.value);
+  }
+  if (f.type.kind === "enum" && f.type.values.length === 1) {
+    return `"${f.type.values[0]}"`;
+  }
+  return void 0;
+}
+__name(findDiscriminatorValue, "findDiscriminatorValue");
+function variantTypeName(type) {
+  switch (type.kind) {
+    case "scalar":
+      return escapeHtml(type.name);
+    case "literal":
+      return escapeHtml(typeof type.value === "string" ? `"${type.value}"` : String(type.value));
+    case "enum":
+      return "enum";
+    case "array":
+      return "array";
+    case "tuple":
+      return "tuple";
+    case "record":
+      return "record";
+    case "lazy":
+      return "lazy";
+    default:
+      return type.kind;
+  }
+}
+__name(variantTypeName, "variantTypeName");
+function renderSchemaFields(fields, ctx, options) {
+  const visible = options.exclude ? fields.filter((f) => f.visibility !== options.exclude) : fields;
+  if (visible.length === 0) return '<p class="ce-empty">No fields.</p>';
+  return `<div class="ce-schema-fields">${visible.map((f) => renderSchemaField(f, ctx, options)).join("")}</div>`;
+}
+__name(renderSchemaFields, "renderSchemaFields");
+function renderSchemaField(f, ctx, options) {
+  const required = !f.optional && f.default === void 0;
+  const typeLabel = renderTypeLabel(f.type);
+  const chips = renderConstraintChips(f.type);
+  const enumValues = renderEnumValues(f.type, ctx);
+  const desc = f.description ? `<div class="ce-schema-desc ce-markdown">${renderMarkdown(f.description)}</div>` : "";
+  const defaultHtml = f.default !== void 0 ? `<div class="ce-schema-default">Default: <code>${escapeHtml(String(f.default))}</code></div>` : "";
+  const requiredTag = required ? '<span class="ce-schema-required">required</span>' : "";
+  let nested = "";
+  if (f.type.kind === "inlineObject" || f.type.kind === "array" || f.type.kind === "ref" || f.type.kind === "intersection") {
+    const inner = renderSchemaNode(f.type, ctx, options);
+    if (inner.includes("ce-schema-fields") || inner.includes("ce-schema-array-label")) {
+      nested = `<div class="ce-schema-nested">${inner}</div>`;
+    }
+  }
+  return `<div class="ce-schema-row">
+        <div class="ce-schema-head">
+            <code class="ce-schema-name">${escapeHtml(f.name)}</code>
+            ${typeLabel}
+            ${requiredTag}
+        </div>
+        ${desc}
+        ${defaultHtml}
+        ${chips}
+        ${enumValues}
+        ${nested}
+    </div>`;
+}
+__name(renderSchemaField, "renderSchemaField");
+function renderEnumValues(type, ctx) {
+  const values = resolveEnumValues(type, ctx);
+  if (!values || values.length === 0) return "";
+  const chips = values.map((v) => `<code class="ce-schema-enum-value">${escapeHtml(v)}</code>`).join("");
+  return `<div class="ce-schema-enum">
+        <span class="ce-schema-enum-label">Allowed values:</span>
+        <span class="ce-schema-enum-list">${chips}</span>
+    </div>`;
+}
+__name(renderEnumValues, "renderEnumValues");
+function resolveEnumValues(type, ctx) {
+  if (type.kind === "enum") return type.values;
+  if (type.kind === "ref") {
+    const entry = ctx.models?.get(type.name);
+    if (entry?.model.type?.kind === "enum") return entry.model.type.values;
+  }
+  return null;
+}
+__name(resolveEnumValues, "resolveEnumValues");
+function renderTypeLabel(type) {
+  switch (type.kind) {
+    case "scalar":
+      return `<span class="ce-schema-type">${escapeHtml(type.name)}</span>`;
+    case "enum":
+      return `<span class="ce-schema-type">enum</span>`;
+    case "literal":
+      return `<span class="ce-schema-type">literal</span>`;
+    case "ref":
+      return `<a class="ce-schema-type ce-ref" href="#model-${encodeURIComponent(type.name)}">${escapeHtml(type.name)}</a>`;
+    case "array":
+      return `<span class="ce-schema-type">array&lt;${innerTypeName(type.item)}&gt;</span>`;
+    case "tuple":
+      return `<span class="ce-schema-type">tuple</span>`;
+    case "record":
+      return `<span class="ce-schema-type">record</span>`;
+    case "union":
+      return `<span class="ce-schema-type">union</span>`;
+    case "discriminatedUnion":
+      return `<span class="ce-schema-type">union</span>`;
+    case "intersection": {
+      const parts = type.members.map(intersectionMemberLabel);
+      return `<span class="ce-schema-type">${parts.join(" &amp; ")}</span>`;
+    }
+    case "lazy":
+      return `<span class="ce-schema-type">lazy</span>`;
+    case "inlineObject":
+      return `<span class="ce-schema-type">object</span>`;
+  }
+}
+__name(renderTypeLabel, "renderTypeLabel");
+function innerTypeName(type) {
+  if (type.kind === "scalar") return escapeHtml(type.name);
+  if (type.kind === "ref") return escapeHtml(type.name);
+  return type.kind;
+}
+__name(innerTypeName, "innerTypeName");
+function intersectionMemberLabel(type) {
+  if (type.kind === "ref") return escapeHtml(type.name);
+  if (type.kind === "inlineObject") return "{ \u2026 }";
+  if (type.kind === "scalar") return escapeHtml(type.name);
+  return type.kind;
+}
+__name(intersectionMemberLabel, "intersectionMemberLabel");
+function renderConstraintChips(type) {
+  if (type.kind !== "scalar") return "";
+  const chips = formatConstraints(type);
+  if (chips.length === 0) return "";
+  return `<div class="ce-schema-chips">${chips.map((c) => `<span class="ce-schema-chip">${escapeHtml(c)}</span>`).join("")}</div>`;
+}
+__name(renderConstraintChips, "renderConstraintChips");
+function formatConstraints(s) {
+  const chips = [];
+  const isString = STRING_SCALARS.has(s.name);
+  const unit = isString ? " characters" : "";
+  if (s.min !== void 0) chips.push(`>= ${s.min}${unit}`);
+  if (s.max !== void 0) chips.push(`<= ${s.max}${unit}`);
+  if (s.len !== void 0) chips.push(`= ${s.len}${unit}`);
+  if (s.format !== void 0) chips.push(`format: ${s.format}`);
+  if (s.regex !== void 0) chips.push(`matches /${s.regex}/`);
+  return chips;
+}
+__name(formatConstraints, "formatConstraints");
+
+// src/render-tryit.ts
+function renderTryIt(op, baseUrl, ctx = {}) {
+  const id = operationAnchor(op);
+  const pathParams = extractParams(op.routeParams);
+  const queryParams = extractParams(op.op.query);
+  const headerParams = extractParams(op.op.headers);
+  const jsonBody = op.op.request?.bodies.find((b) => b.contentType === "application/json" || b.contentType.endsWith("+json"));
+  const bodySeed = `${op.method}:${op.routePath}:request-body`;
+  const bodyPrefill = jsonBody ? JSON.stringify(buildSampleJson(jsonBody.bodyType, ctx, bodySeed, "readonly"), null, 2) : "";
+  return `<details class="ce-tryit" data-tryit-id="${escapeHtml(id)}">
+        <summary>Try it</summary>
+        <form class="ce-tryit-form" onsubmit="return false;">
+            <label class="ce-tryit-row">
+                <span class="ce-tryit-label">Base URL</span>
+                <input type="text" name="baseUrl" value="${escapeHtml(baseUrl)}" placeholder="https://api.example.com" />
+            </label>
+            ${renderInputSection("Path params", "path", pathParams, ctx, op)}
+            ${renderInputSection("Query", "query", queryParams, ctx, op)}
+            ${renderInputSection("Headers", "header", headerParams, ctx, op)}
+            ${jsonBody ? `<label class="ce-tryit-row ce-tryit-col">
+                        <span class="ce-tryit-label">Body (JSON)</span>
+                        <textarea name="body" rows="8" placeholder="{}">${escapeHtml(bodyPrefill)}</textarea>
+                    </label>` : ""}
+            <div class="ce-tryit-actions">
+                <button type="button" class="ce-tryit-send" data-tryit-action="send" data-tryit-target="${escapeHtml(id)}">
+                    Send ${escapeHtml(op.method.toUpperCase())} ${escapeHtml(op.routePath)}
+                </button>
+            </div>
+            <div class="ce-tryit-response" data-tryit-response="${escapeHtml(id)}"></div>
+        </form>
+    </details>`;
+}
+__name(renderTryIt, "renderTryIt");
+function extractParams(source) {
+  if (!source || source.kind !== "params") return [];
+  return source.nodes;
+}
+__name(extractParams, "extractParams");
+function renderInputSection(label, scope, params, ctx, op) {
+  if (params.length === 0) return "";
+  const rows = params.map((p) => {
+    const prefill = paramPrefill(p, ctx, op, scope);
+    return `<label class="ce-tryit-row">
+                <span class="ce-tryit-label"><code>${escapeHtml(p.name)}</code>${p.optional ? "" : " *"}</span>
+                <input type="text"
+                    name="${scope}.${escapeHtml(p.name)}"
+                    placeholder="${escapeHtml(typeHint(p))}"
+                    value="${escapeHtml(prefill)}" />
+            </label>`;
+  }).join("");
+  return `<fieldset class="ce-tryit-section"><legend>${escapeHtml(label)}</legend>${rows}</fieldset>`;
+}
+__name(renderInputSection, "renderInputSection");
+function paramPrefill(p, ctx, op, scope) {
+  if (p.default !== void 0) return String(p.default);
+  const seed = `${op.method}:${op.routePath}:${scope}:${p.name}`;
+  const sample = buildSampleJson(p.type, ctx, seed, "readonly");
+  if (sample === null || sample === void 0) return "";
+  if (typeof sample === "object") return JSON.stringify(sample);
+  return String(sample);
+}
+__name(paramPrefill, "paramPrefill");
+function typeHint(p) {
+  if (p.type.kind === "scalar") return p.type.name;
+  return p.type.kind;
+}
+__name(typeHint, "typeHint");
+
+// src/render-operation.ts
+function operationAnchor(op) {
+  const suffix = op.op.sdk ?? op.op.name ?? "";
+  const slug2 = `${op.method}-${op.routePath}-${suffix}`.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return `op-${slug2}`;
+}
+__name(operationAnchor, "operationAnchor");
+function renderOperation(op, options = {}) {
+  const ctx = options.ctx ?? {};
+  const badges = [];
+  for (const m of op.effectiveModifiers) {
+    badges.push(badge2(m, m));
+  }
+  const securityBadge = renderSecurityBadge(op.effectiveSecurity);
+  if (securityBadge) badges.push(securityBadge);
+  const description = op.op.description ? `<div class="ce-description ce-markdown">${renderMarkdown(op.op.description)}</div>` : "";
+  const service = op.op.service ? html`<p class="ce-meta"><strong>service:</strong> <code>${op.op.service}</code></p>` : "";
+  const signature = op.op.signature ? html`<p class="ce-meta"><strong>signature:</strong> <code>${op.op.signature}</code>${op.op.signatureDescription ? raw(` \u2014 ${escapeHtml(op.op.signatureDescription)}`) : ""}</p>` : "";
+  const pathParams = renderParamSection("Path Parameters", op.routeParams, ctx);
+  const queryParams = renderParamSection("Query Parameters", op.op.query, ctx);
+  const headerParams = renderParamSection("Request Headers", op.op.headers, ctx);
+  const requestBody = renderRequest(op.op.request, ctx);
+  const responses = renderResponses(op.op.responses, ctx);
+  const pluginExt = renderPluginExtensions(op.op.pluginExtensions);
+  const tryIt = options.tryItBaseUrl !== void 0 ? renderTryIt(op, options.tryItBaseUrl, ctx) : "";
+  const codeSamples = renderCodeSamples(op, options.tryItBaseUrl ?? "", ctx);
+  const title = op.op.name ?? op.op.sdk ?? `${op.method.toUpperCase()} ${op.routePath}`;
+  return html`<section id="${raw(operationAnchor(op))}" class="ce-card ce-op-card">
+        <header class="ce-card-header">
+            <div class="ce-op-title-row">
+                <h1 class="ce-op-title">${title}</h1>
+                <button
+                    class="ce-jump"
+                    data-jump-file="${op.filePath}"
+                    data-jump-line="${op.op.loc.line}"
+                    title="Open in editor"
+                    type="button"
+                >
+                    ↗
+                </button>
+            </div>
+            <div class="ce-endpoint-row">
+                <span class="ce-method ce-method-${raw(op.method)}">${op.method.toUpperCase()}</span>
+                <code class="ce-path">${op.routePath}</code>
+                ${raw(badges.length > 0 ? `<span class="ce-badge-row">${badges.join("")}</span>` : "")}
+            </div>
+        </header>
+        <div class="ce-op-body">
+            <div class="ce-op-main">
+                ${raw(description)}
+                ${raw(service)}
+                ${raw(signature)}
+                ${raw(pathParams)}
+                ${raw(queryParams)}
+                ${raw(headerParams)}
+                ${raw(requestBody)}
+                ${raw(responses)}
+                ${raw(pluginExt)}
+            </div>
+            <div class="ce-op-resize" data-resize-handle role="separator" aria-orientation="vertical" aria-label="Resize columns" tabindex="0"></div>
+            <aside class="ce-op-rail">
+                ${raw(tryIt)}
+                ${raw(codeSamples)}
+            </aside>
+        </div>
+    </section>`;
+}
+__name(renderOperation, "renderOperation");
+function renderSecurityBadge(security) {
+  if (security === void 0) return badge2("security: secured", "security-secured");
+  if (security === "none") return badge2("security: none", "security-none");
+  if (security.policy === false) return badge2("security: no policy", "security-no-policy");
+  if (typeof security.policy === "string") return badge2(`policy: ${security.policy}`, "security-policy");
+  return "";
+}
+__name(renderSecurityBadge, "renderSecurityBadge");
+function renderParamSection(label, source, ctx) {
+  if (!source) return "";
+  if (source.kind === "params") {
+    if (source.nodes.length === 0) return "";
+    return html`<section class="ce-subsection">
+            <h3>${label}</h3>
+            ${raw(renderParamTable(source.nodes, ctx))}
+        </section>`;
+  }
+  if (source.kind === "ref") {
+    return html`<section class="ce-subsection">
+            <h3>${label}</h3>
+            ${raw(renderSchemaTree({
+      kind: "ref",
+      name: source.name
+    }, ctx, {
+      exclude: "readonly"
+    }))}
+        </section>`;
+  }
+  return html`<section class="ce-subsection">
+        <h3>${label}</h3>
+        ${raw(renderSchemaTree(source.node, ctx, {
+    exclude: "readonly"
+  }))}
+    </section>`;
+}
+__name(renderParamSection, "renderParamSection");
+function renderParamTable(params, ctx) {
+  const rows = params.map((p) => {
+    const modifiers = [];
+    if (p.optional) modifiers.push("optional");
+    if (p.nullable) modifiers.push("nullable");
+    const modifierHtml = modifiers.map((m) => badge2(m, m)).join("");
+    const defaultHtml = p.default !== void 0 ? html`<code class="ce-default">= ${String(p.default)}</code>` : "";
+    const descHtml = p.description ? `<div class="ce-field-desc ce-markdown">${renderMarkdown(p.description)}</div>` : "";
+    return `<tr>
+            <td class="ce-field-name"><code>${escapeHtml(p.name)}</code>${modifierHtml}</td>
+            <td class="ce-field-type">${renderType(p.type, ctx)}${defaultHtml}${descHtml}</td>
+        </tr>`;
+  });
+  return `<table class="ce-fields"><tbody>${rows.join("")}</tbody></table>`;
+}
+__name(renderParamTable, "renderParamTable");
+function renderRequest(request, ctx) {
+  if (!request || request.bodies.length === 0) return "";
+  const blocks = request.bodies.map((body) => {
+    return `<div class="ce-body-block">
+            <div class="ce-body-header">
+                <span class="ce-body-title">Body</span>
+                <span class="ce-content-type"><code>${escapeHtml(body.contentType)}</code></span>
+            </div>
+            ${renderSchemaTree(body.bodyType, ctx, {
+      exclude: "readonly"
+    })}
+        </div>`;
+  });
+  return `<section class="ce-subsection"><h3>Request</h3>${blocks.join("")}</section>`;
+}
+__name(renderRequest, "renderRequest");
+function renderResponses(responses, ctx) {
+  if (responses.length === 0) return "";
+  const summary = responses.length > 1 ? responses.map((r) => {
+    const statusClass = `ce-status-${Math.floor(r.statusCode / 100)}xx`;
+    return `<a class="ce-status ${statusClass}" href="#response-${r.statusCode}">${r.statusCode}</a>`;
+  }).join("") : "";
+  const blocks = responses.map((r) => renderResponse(r, ctx));
+  return `<section class="ce-subsection">
+        <h3>Responses</h3>
+        ${summary ? `<div class="ce-status-summary">${summary}</div>` : ""}
+        ${blocks.join("")}
+    </section>`;
+}
+__name(renderResponses, "renderResponses");
+function renderResponse(response, ctx) {
+  const statusClass = `ce-status-${Math.floor(response.statusCode / 100)}xx`;
+  const contentTypeHtml = response.contentType ? `<span class="ce-content-type"><code>${escapeHtml(response.contentType)}</code></span>` : "";
+  const bodyHtml = response.bodyType ? renderSchemaTree(response.bodyType, ctx, {
+    exclude: "writeonly"
+  }) : '<p class="ce-empty">No response body.</p>';
+  const headersHtml = renderResponseHeaders(response.headers, ctx);
+  return `<div class="ce-response-block" id="response-${response.statusCode}">
+        <div class="ce-body-header">
+            <span class="ce-status ${statusClass}">${response.statusCode}</span>
+            ${contentTypeHtml}
+        </div>
+        ${bodyHtml}
+        ${headersHtml}
+    </div>`;
+}
+__name(renderResponse, "renderResponse");
+function renderResponseHeaders(headers, ctx) {
+  if (!headers || headers.length === 0) return "";
+  const rows = headers.map((h) => {
+    const optional = h.optional ? badge2("optional", "optional") : "";
+    const desc = h.description ? `<div class="ce-field-desc ce-markdown">${renderMarkdown(h.description)}</div>` : "";
+    return `<tr>
+            <td class="ce-field-name"><code>${escapeHtml(h.name)}</code>${optional}</td>
+            <td class="ce-field-type">${renderType(h.type, ctx)}${desc}</td>
+        </tr>`;
+  });
+  return `<h5>Headers</h5><table class="ce-fields"><tbody>${rows.join("")}</tbody></table>`;
+}
+__name(renderResponseHeaders, "renderResponseHeaders");
+function renderPluginExtensions(ext) {
+  if (!ext || Object.keys(ext).length === 0) return "";
+  const json = JSON.stringify(ext, null, 2);
+  return html`<section class="ce-subsection">
+        <h3>Plugin extensions</h3>
+        <details><summary>Show JSON</summary><pre class="ce-code">${json}</pre></details>
+    </section>`;
+}
+__name(renderPluginExtensions, "renderPluginExtensions");
+function badge2(label, kind) {
+  return `<span class="ce-badge ce-badge-${escapeHtml(kind)}">${escapeHtml(label)}</span>`;
+}
+__name(badge2, "badge");
+
+// src/render.ts
+var METHOD_ORDER = [
+  "get",
+  "post",
+  "put",
+  "patch",
+  "delete"
+];
+var SIDEBAR_MARKER_SVG = '<svg viewBox="0 0 16 16" width="16" height="16" fill="none" stroke="currentColor" stroke-width="1.5"><circle cx="8" cy="8" r="6.25" /><circle cx="8" cy="8" r="3.25" /><circle cx="8" cy="8" r="0.75" fill="currentColor" /></svg>';
+function renderApp(data) {
+  const warnings = renderWarnings(data.warnings);
+  const overview = renderOverview(data);
+  const sidebar = renderSidebar(data);
+  const operations = sortOperations(data.operations);
+  const opsHtml = operations.map((op) => renderOperation(op)).join("");
+  const modelsHtml = [
+    ...data.models
+  ].sort((a, b) => a.model.name.localeCompare(b.model.name)).map((m) => renderModel(m)).join("");
+  return html`<div class="ce-layout">
+        ${raw(sidebar)}
+        <main class="ce-detail">
+            ${raw(warnings)}
+            ${raw(overview)}
+            ${operations.length > 0 ? raw(`<section class="ce-section"><h1 id="endpoints">Endpoints</h1>${opsHtml}</section>`) : ""}
+            ${data.models.length > 0 ? raw(`<section class="ce-section"><h1 id="models">Models</h1>${modelsHtml}</section>`) : ""}
+        </main>
+    </div>`;
+}
+__name(renderApp, "renderApp");
+function renderOverview(data) {
+  const { configMeta } = data;
+  const description = configMeta.description ? html`<p class="ce-description">${configMeta.description}</p>` : "";
+  const servers = configMeta.servers && configMeta.servers.length > 0 ? `<section class="ce-subsection"><h3>Servers</h3><ul>${configMeta.servers.map((s) => `<li><code>${escapeHtml(s.url)}</code>${s.description ? ` \u2014 ${escapeHtml(s.description)}` : ""}</li>`).join("")}</ul></section>` : "";
+  return html`<section id="overview" class="ce-section ce-overview">
+        <h1>${configMeta.title}</h1>
+        <p class="ce-version">v${configMeta.version}</p>
+        ${raw(description)}
+        ${raw(servers)}
+    </section>`;
+}
+__name(renderOverview, "renderOverview");
+function renderSidebar(data) {
+  const operations = sortOperations(data.operations);
+  const groups = groupBy(operations, (op) => op.fileGroup);
+  const groupKeys = [
+    ...groups.keys()
+  ].sort();
+  const endpointGroups = groupKeys.map((key) => {
+    const items = groups.get(key).map((op) => {
+      const name = op.op.name ?? op.op.sdk ?? op.routePath;
+      return `<li><a class="ce-sidebar-row" href="#${escapeHtml(operationAnchor(op))}">
+                        <span class="ce-sidebar-marker" aria-hidden="true">${SIDEBAR_MARKER_SVG}</span>
+                        <span class="ce-sidebar-name">${escapeHtml(name)}</span>
+                        <span class="ce-sidebar-method ce-method-text-${escapeHtml(op.method)}">${escapeHtml(op.method.toUpperCase())}</span>
+                    </a></li>`;
+    }).join("");
+    return `<details open class="ce-sidebar-group">
+                <summary>${escapeHtml(key)}</summary>
+                <ul>${items}</ul>
+            </details>`;
+  }).join("");
+  const modelLinks = [
+    ...data.models
+  ].sort((a, b) => a.model.name.localeCompare(b.model.name)).map((m) => `<li><a href="#${escapeHtml(modelAnchor(m.model.name))}">${escapeHtml(m.model.name)}</a></li>`).join("");
+  return `<aside class="ce-sidebar">
+        <nav>
+            <section>
+                <h4><a href="#overview">Overview</a></h4>
+            </section>
+            ${operations.length > 0 ? `<section><h4><a href="#endpoints">Endpoints</a></h4>${endpointGroups}</section>` : ""}
+            ${data.models.length > 0 ? `<section><h4><a href="#models">Models</a></h4><ul class="ce-model-list">${modelLinks}</ul></section>` : ""}
+        </nav>
+    </aside>`;
+}
+__name(renderSidebar, "renderSidebar");
+function renderWarnings(warnings) {
+  if (warnings.length === 0) return "";
+  const items = warnings.map((w) => `<li>${escapeHtml(w.message)}${w.file ? ` <code>${escapeHtml(w.file)}${w.line ? `:${w.line}` : ""}</code>` : ""}</li>`).join("");
+  return `<div class="ce-warnings"><strong>${warnings.length} warning${warnings.length === 1 ? "" : "s"}</strong><ul>${items}</ul></div>`;
+}
+__name(renderWarnings, "renderWarnings");
+function sortOperations(operations) {
+  return [
+    ...operations
+  ].sort((a, b) => {
+    const groupCmp = a.fileGroup.localeCompare(b.fileGroup);
+    if (groupCmp !== 0) return groupCmp;
+    const pathCmp = a.routePath.localeCompare(b.routePath);
+    if (pathCmp !== 0) return pathCmp;
+    return METHOD_ORDER.indexOf(a.method) - METHOD_ORDER.indexOf(b.method);
+  });
+}
+__name(sortOperations, "sortOperations");
+function groupBy(items, keyFn) {
+  const out = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFn(item);
+    const arr = out.get(key);
+    if (arr) arr.push(item);
+    else out.set(key, [
+      item
+    ]);
+  }
+  return out;
+}
+__name(groupBy, "groupBy");
+
+// src/render-item.ts
+function renderItemPage(data, selection, options = {}) {
+  const body = renderBody(data, selection, options);
+  return html`<div class="ce-detail ce-detail-single">${raw(body)}</div>`;
+}
+__name(renderItemPage, "renderItemPage");
+function renderBody(data, selection, options) {
+  if (selection.kind === "overview") return renderOverviewPage(data);
+  const ctx = {
+    models: buildModelMap(data)
+  };
+  if (selection.kind === "operation") {
+    const op = data.operations.find((o) => operationAnchor(o) === selection.id);
+    if (!op) return renderMissing(`Operation \`${selection.id}\` is not in the current workspace.`);
+    return renderOperation(op, {
+      tryItBaseUrl: options.tryItBaseUrl,
+      ctx
+    });
+  }
+  if (selection.kind === "file") {
+    return renderFilePage(data, selection.path, options, ctx);
+  }
+  const model = data.models.find((m) => m.model.name === selection.name);
+  if (!model) {
+    return renderMissing(`Model \`${selection.name}\` isn't defined in any indexed \`.ck\` file. It's referenced from another contract but not declared anywhere in the workspace \u2014 check that the file containing \`contract ${selection.name}: { ... }\` (or its type alias) is present and saved. ${data.models.length} model${data.models.length === 1 ? "" : "s"} loaded.`);
+  }
+  return renderModel(model, ctx);
+}
+__name(renderBody, "renderBody");
+function renderFilePage(data, path, options, ctx) {
+  const ops = data.operations.filter((o) => o.filePath === path);
+  const models = data.models.filter((m) => m.filePath === path);
+  if (ops.length === 0 && models.length === 0) {
+    return renderMissing(`No contracts or operations found in \`${path}\`.`);
+  }
+  const opsHtml = ops.map((o) => renderOperation(o, {
+    tryItBaseUrl: options.tryItBaseUrl,
+    ctx
+  })).join("");
+  const modelsHtml = models.map((m) => renderModel(m, ctx)).join("");
+  const fileLabel = path.split("/").pop() ?? path;
+  return html`<section class="ce-section">
+        <h1>${fileLabel}</h1>
+        <p class="ce-version"><code>${path}</code></p>
+        ${raw(ops.length > 0 ? `<section class="ce-section"><h1 id="endpoints">Endpoints</h1>${opsHtml}</section>` : "")}
+        ${raw(models.length > 0 ? `<section class="ce-section"><h1 id="models">Models</h1>${modelsHtml}</section>` : "")}
+    </section>`;
+}
+__name(renderFilePage, "renderFilePage");
+function buildModelMap(data) {
+  const out = /* @__PURE__ */ new Map();
+  for (const entry of data.models) out.set(entry.model.name, entry);
+  return out;
+}
+__name(buildModelMap, "buildModelMap");
+function renderOverviewPage(data) {
+  const { configMeta } = data;
+  const description = configMeta.description ? `<div class="ce-description ce-markdown">${renderMarkdown(configMeta.description)}</div>` : "";
+  const servers = renderServersList(configMeta.servers);
+  const stats = `<dl class="ce-stats">
+        <dt>Endpoints</dt><dd>${data.operations.length}</dd>
+        <dt>Models</dt><dd>${data.models.length}</dd>
+    </dl>`;
+  return html`<section id="overview" class="ce-section ce-overview">
+        <h1>${configMeta.title}</h1>
+        <p class="ce-version">v${configMeta.version}</p>
+        ${raw(description)}
+        ${raw(stats)}
+        ${raw(servers)}
+        <p class="ce-hint">Pick an endpoint or model from the API Explorer in the sidebar to see details.</p>
+    </section>`;
+}
+__name(renderOverviewPage, "renderOverviewPage");
+function renderServersList(servers) {
+  if (!servers || servers.length === 0) return "";
+  const items = servers.map((s) => `<li><code>${escapeHtml(s.url)}</code>${s.description ? ` \u2014 ${escapeHtml(s.description)}` : ""}</li>`).join("");
+  return `<section class="ce-subsection"><h3>Servers</h3><ul>${items}</ul></section>`;
+}
+__name(renderServersList, "renderServersList");
+function renderMissing(message) {
+  return `<section class="ce-card ce-missing"><p class="ce-empty">${escapeHtml(message)}</p></section>`;
+}
+__name(renderMissing, "renderMissing");
+var operationId = operationAnchor;
+var modelId = /* @__PURE__ */ __name((name) => modelAnchor(name), "modelId");
+function listSelections(data) {
+  return [
+    ...data.operations.map((operation) => ({
+      kind: "operation",
+      id: operationId(operation),
+      operation
+    })),
+    ...data.models.map((model) => ({
+      kind: "model",
+      name: model.model.name,
+      model
+    }))
+  ];
+}
+__name(listSelections, "listSelections");
+export {
+  constraintSummary,
+  escapeHtml,
+  html,
+  listSelections,
+  modelAnchor,
+  modelId,
+  operationAnchor,
+  operationId,
+  raw,
+  renderApp,
+  renderCodeSamples,
+  renderFieldRows,
+  renderItemPage,
+  renderMarkdown,
+  renderModel,
+  renderOperation,
+  renderSchemaTree,
+  renderTryIt,
+  renderType,
+  slug
+};
+//# sourceMappingURL=index.js.map