saturndocs 0.1.0

package/dist/chunk-SABK3R2P.js

@@ -0,0 +1,2452 @@
+import {
+  loadDocsConfig
+} from "./chunk-R3X2DPFF.js";
+import {
+  messageOf
+} from "./chunk-VNYDYHXM.js";
+
+// src/commands/init.ts
+import { existsSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { basename, join, relative, resolve } from "path";
+
+// ../brand/dist/index.js
+var DEFAULT_PAGE_MAX_BYTES = 2 * 1024 * 1024;
+var DEFAULT_AUX_MAX_BYTES = 500 * 1024;
+var DEFAULT_STYLESHEET_MAX_BYTES = 1024 * 1024;
+var DEFAULT_LOGO_MAX_BYTES = 2 * 1024 * 1024;
+var DEFAULT_MAX_REQUESTS = 25;
+var DEFAULT_TIMEOUT_MS = 1e4;
+var DEFAULT_MAX_REDIRECTS = 3;
+var USER_AGENT = "SaturnDocsBrandExtractor/0.1 (+https://saturndocs.com; docs onboarding)";
+var BrandFetcher = class {
+  fetchImpl;
+  maxRequests;
+  timeoutMs;
+  maxRedirects;
+  validateUrl;
+  count = 0;
+  constructor(options = {}) {
+    this.fetchImpl = options.fetchImpl ?? fetch;
+    this.maxRequests = options.maxRequests ?? DEFAULT_MAX_REQUESTS;
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxRedirects = options.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
+    this.validateUrl = options.validateUrl;
+  }
+  get requestCount() {
+    return this.count;
+  }
+  get remainingRequests() {
+    return Math.max(0, this.maxRequests - this.count);
+  }
+  async fetchText(input, options = {}) {
+    const result = await this.fetchBytes(input, options);
+    return { ...result, text: new TextDecoder().decode(result.bytes) };
+  }
+  async fetchBytes(input, options = {}) {
+    let url = normalizeHttpUrl(input);
+    let redirects = 0;
+    await this.validate(url);
+    while (true) {
+      if (this.count >= this.maxRequests) {
+        throw new Error(`request budget exceeded (${this.maxRequests})`);
+      }
+      this.count += 1;
+      const response = await this.fetchOnce(url, options.accept);
+      const location = response.headers.get("location");
+      if (isRedirect(response.status) && location) {
+        if (redirects >= this.maxRedirects) {
+          throw new Error(`redirect limit exceeded (${this.maxRedirects})`);
+        }
+        const next = new URL(location, url);
+        if (next.protocol !== "http:" && next.protocol !== "https:") {
+          throw new Error(`redirect target is not http/https: ${next.href}`);
+        }
+        await this.validate(next);
+        redirects += 1;
+        url = next;
+        continue;
+      }
+      if (!response.ok) {
+        throw new Error(`fetch failed for ${url.href}: HTTP ${response.status}`);
+      }
+      const maxBytes = options.maxBytes ?? DEFAULT_PAGE_MAX_BYTES;
+      const body = await readResponseBytes(
+        response,
+        maxBytes,
+        options.truncate === true
+      );
+      const contentType = response.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase();
+      return {
+        url: url.toString(),
+        status: response.status,
+        contentType,
+        bytes: body.bytes,
+        truncated: body.truncated
+      };
+    }
+  }
+  async fetchOnce(url, accept) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      return await this.fetchImpl(url, {
+        redirect: "manual",
+        signal: controller.signal,
+        headers: {
+          "user-agent": USER_AGENT,
+          accept: accept ?? "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        }
+      });
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async validate(url) {
+    await this.validateUrl?.(url);
+  }
+};
+function normalizeHttpUrl(input) {
+  if (input instanceof URL) {
+    assertHttpUrl(input);
+    return input;
+  }
+  const raw = input.trim();
+  const hasHierarchicalScheme = /^[a-zA-Z][a-zA-Z\d+.-]*:\/\//.test(raw);
+  const hasAnyScheme = /^[a-zA-Z][a-zA-Z\d+.-]*:/.test(raw);
+  const candidate = hasHierarchicalScheme || hasAnyScheme ? raw : `https://${raw}`;
+  const url = new URL(candidate);
+  assertHttpUrl(url);
+  return url;
+}
+async function readResponseBytes(response, maxBytes, truncate2) {
+  const contentLength = response.headers.get("content-length");
+  let declaredExceedsCap = false;
+  if (contentLength !== null) {
+    const declared = Number(contentLength);
+    if (Number.isFinite(declared) && declared > maxBytes) {
+      declaredExceedsCap = true;
+      if (!truncate2) {
+        throw new Error(`response exceeded size cap (${maxBytes} bytes)`);
+      }
+    }
+  }
+  if (!response.body) {
+    const buffer = await response.arrayBuffer();
+    if (buffer.byteLength > maxBytes) {
+      if (!truncate2) {
+        throw new Error(`response exceeded size cap (${maxBytes} bytes)`);
+      }
+      return {
+        bytes: new Uint8Array(buffer.slice(0, maxBytes)),
+        truncated: true
+      };
+    }
+    return { bytes: new Uint8Array(buffer), truncated: false };
+  }
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  while (true) {
+    const { value, done } = await reader.read();
+    if (done) break;
+    if (!value) continue;
+    if (total + value.byteLength > maxBytes) {
+      await reader.cancel();
+      if (!truncate2) {
+        throw new Error(`response exceeded size cap (${maxBytes} bytes)`);
+      }
+      const remaining = maxBytes - total;
+      if (remaining > 0) {
+        chunks.push(value.subarray(0, remaining));
+        total += remaining;
+      }
+      return { bytes: concatChunks(chunks, total), truncated: true };
+    }
+    chunks.push(value);
+    total += value.byteLength;
+    if (truncate2 && declaredExceedsCap && total >= maxBytes) {
+      await reader.cancel();
+      return { bytes: concatChunks(chunks, total), truncated: true };
+    }
+  }
+  return { bytes: concatChunks(chunks, total), truncated: false };
+}
+function concatChunks(chunks, total) {
+  const output = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    output.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return output;
+}
+function assertHttpUrl(url) {
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error(`Only http/https URLs are supported: ${url.href}`);
+  }
+}
+function isRedirect(status) {
+  return status >= 300 && status < 400;
+}
+var COLOR_LITERAL_RE = /#(?:[0-9a-f]{8}|[0-9a-f]{6}|[0-9a-f]{3})(?![0-9a-f])|rgba?\([^)]*\)|hsla?\([^)]*\)|oklch\([^)]*\)/gi;
+var SRGB_LINEAR_EPSILON = 8e-4;
+function parseCssColor(value) {
+  const input = value.trim();
+  const hex = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6}|[0-9a-fA-F]{8})$/.exec(
+    input
+  );
+  if (hex) return parseHexColor(hex[1]);
+  const rgb = /^rgba?\((.*)\)$/i.exec(input);
+  if (rgb) return parseRgbColor(rgb[1]);
+  const hsl = /^hsla?\((.*)\)$/i.exec(input);
+  if (hsl) return parseHslColor(hsl[1]);
+  const oklch = /^oklch\((.*)\)$/i.exec(input);
+  if (oklch) return parseOklchColor(oklch[1]);
+  return void 0;
+}
+function colorToHex(color) {
+  return `#${toHexByte(color.r)}${toHexByte(color.g)}${toHexByte(color.b)}`;
+}
+function normalizeHexColor(value) {
+  const parsed = parseCssColor(value);
+  return parsed ? colorToHex(parsed) : void 0;
+}
+function rgbToHsl(color) {
+  const r = color.r / 255;
+  const g = color.g / 255;
+  const b = color.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  if (max === min) return { h: 0, s: 0, l };
+  const delta = max - min;
+  const s = l > 0.5 ? delta / (2 - max - min) : delta / (max + min);
+  let h;
+  if (max === r) {
+    h = (g - b) / delta + (g < b ? 6 : 0);
+  } else if (max === g) {
+    h = (b - r) / delta + 2;
+  } else {
+    h = (r - g) / delta + 4;
+  }
+  return { h: h * 60, s, l };
+}
+function saturationFitness(color) {
+  const hsl = rgbToHsl(color);
+  if (hsl.s < 0.15) return 0;
+  if (hsl.l > 0.93) return 0;
+  if (hsl.l < 0.07) return 0;
+  const midLightnessBoost = hsl.l >= 0.3 && hsl.l <= 0.7 ? 1.2 : 1;
+  return hsl.s * midLightnessBoost;
+}
+function scoreColorCandidates(candidates) {
+  const byHex = /* @__PURE__ */ new Map();
+  candidates.forEach((candidate, index) => {
+    const color = parseCssColor(candidate.value);
+    if (!color) return;
+    const fitness = saturationFitness(color);
+    if (fitness <= 0) return;
+    const hex = colorToHex(color);
+    const frequency = candidate.frequency ?? 1;
+    const score = candidate.weight * frequency * fitness;
+    const existing = byHex.get(hex);
+    if (existing) {
+      existing.score += score;
+      existing.frequency += frequency;
+      existing.provenance.add(candidate.provenance);
+      return;
+    }
+    byHex.set(hex, {
+      color,
+      score,
+      provenance: /* @__PURE__ */ new Set([candidate.provenance]),
+      frequency,
+      firstIndex: index
+    });
+  });
+  return [...byHex.entries()].map(([hex, value]) => ({
+    hex,
+    score: value.score,
+    color: value.color,
+    provenance: [...value.provenance],
+    frequency: value.frequency,
+    firstIndex: value.firstIndex
+  })).sort((a, b) => b.score - a.score || a.firstIndex - b.firstIndex).map((value) => {
+    const { firstIndex, ...rest } = value;
+    void firstIndex;
+    return rest;
+  });
+}
+function pickPrimaryColor(candidates) {
+  return scoreColorCandidates(candidates)[0];
+}
+function extractCssColorCandidates(css, provenance = "css") {
+  const candidates = [];
+  const declarationRe = /(?:^|[;{])\s*([-\w]+)\s*:\s*([^;{}]+)/g;
+  for (const match of css.matchAll(declarationRe)) {
+    const property = match[1];
+    const body = match[2];
+    const colorLiterals = extractColorLiterals(body);
+    if (colorLiterals.length === 0) continue;
+    const isBrandProperty = /primary|brand|accent/i.test(property);
+    for (const value of colorLiterals) {
+      candidates.push({
+        value,
+        weight: isBrandProperty ? 4 : 1,
+        provenance: `${provenance}:${property}`
+      });
+    }
+  }
+  return candidates;
+}
+function extractColorLiterals(input) {
+  const values = [];
+  for (const match of input.matchAll(COLOR_LITERAL_RE)) {
+    const value = match[0];
+    if (parseCssColor(value)) values.push(value);
+  }
+  return values;
+}
+function parseHexColor(hex) {
+  if (hex.length === 3) {
+    return {
+      r: parseInt(`${hex[0]}${hex[0]}`, 16),
+      g: parseInt(`${hex[1]}${hex[1]}`, 16),
+      b: parseInt(`${hex[2]}${hex[2]}`, 16),
+      a: 1
+    };
+  }
+  if (hex.length === 6 || hex.length === 8) {
+    return {
+      r: parseInt(hex.slice(0, 2), 16),
+      g: parseInt(hex.slice(2, 4), 16),
+      b: parseInt(hex.slice(4, 6), 16),
+      a: hex.length === 8 ? parseInt(hex.slice(6, 8), 16) / 255 : 1
+    };
+  }
+  return void 0;
+}
+function parseRgbColor(body) {
+  const parts = splitFunctionArgs(body);
+  if (parts.length < 3 || parts.length > 4) return void 0;
+  const r = parseRgbComponent(parts[0]);
+  const g = parseRgbComponent(parts[1]);
+  const b = parseRgbComponent(parts[2]);
+  if (r === void 0 || g === void 0 || b === void 0) return void 0;
+  const a = parts[3] === void 0 ? 1 : parseAlpha(parts[3]);
+  if (a === void 0) return void 0;
+  return { r, g, b, a };
+}
+function parseHslColor(body) {
+  const parts = splitFunctionArgs(body);
+  if (parts.length < 3 || parts.length > 4) return void 0;
+  const hue = parseHue(parts[0]);
+  const saturation = parsePercent(parts[1]);
+  const lightness = parsePercent(parts[2]);
+  if (hue === void 0 || saturation === void 0 || lightness === void 0) {
+    return void 0;
+  }
+  const alpha = parts[3] === void 0 ? 1 : parseAlpha(parts[3]);
+  if (alpha === void 0) return void 0;
+  const rgb = hslToRgb(hue, saturation, lightness);
+  return { ...rgb, a: alpha };
+}
+function parseOklchColor(body) {
+  const args = splitOklchArgs(body);
+  if (!args || args.components.length !== 3) return void 0;
+  const lightness = parseOklchLightness(args.components[0]);
+  const chroma = parseOklchChroma(args.components[1]);
+  const hue = parseOklchHue(args.components[2]);
+  if (lightness === void 0 || chroma === void 0 || hue === void 0) {
+    return void 0;
+  }
+  const alpha = args.alpha === void 0 ? 1 : parseOklchAlpha(args.alpha);
+  if (alpha === void 0) return void 0;
+  const rgb = oklchToRgb(lightness, chroma, hue);
+  return { ...rgb, a: alpha };
+}
+function splitFunctionArgs(body) {
+  const slashParts = body.trim().split("/");
+  if (slashParts.length > 2) return [];
+  const colorPart = slashParts[0] ?? "";
+  const alphaPart = slashParts[1];
+  const parts = colorPart.includes(",") ? colorPart.split(",").map((part) => part.trim()) : colorPart.split(/\s+/).map((part) => part.trim());
+  if (alphaPart !== void 0) parts.push(alphaPart.trim());
+  return parts.filter((part) => part.length > 0);
+}
+function splitOklchArgs(body) {
+  const slashParts = body.trim().split("/");
+  if (slashParts.length > 2) return void 0;
+  const colorPart = slashParts[0]?.trim() ?? "";
+  if (colorPart.includes(",")) return void 0;
+  const components = colorPart.split(/\s+/).map((part) => part.trim()).filter((part) => part.length > 0);
+  if (slashParts.length === 1) return { components };
+  const alpha = slashParts[1]?.trim();
+  if (!alpha || /\s/.test(alpha)) return void 0;
+  return { components, alpha };
+}
+function parseRgbComponent(value) {
+  if (value.endsWith("%")) {
+    const percent = parseNumber(value.slice(0, -1));
+    if (percent === void 0 || percent < 0 || percent > 100) return void 0;
+    return Math.round(percent / 100 * 255);
+  }
+  const number = parseNumber(value);
+  if (number === void 0 || number < 0 || number > 255) return void 0;
+  return Math.round(number);
+}
+function parseOklchLightness(value) {
+  const input = value.trim();
+  if (isNone(input)) return 0;
+  if (input.endsWith("%")) {
+    const percent = parseNumber(input.slice(0, -1));
+    if (percent === void 0 || percent < 0 || percent > 100) {
+      return void 0;
+    }
+    return percent / 100;
+  }
+  const number = parseNumber(input);
+  if (number === void 0 || number < 0 || number > 1) return void 0;
+  return number;
+}
+function parseOklchChroma(value) {
+  const input = value.trim();
+  if (isNone(input)) return 0;
+  if (input.endsWith("%")) {
+    const percent = parseNumber(input.slice(0, -1));
+    if (percent === void 0 || percent < 0) return void 0;
+    return percent / 100 * 0.4;
+  }
+  const number = parseNumber(input);
+  if (number === void 0 || number < 0) return void 0;
+  return number;
+}
+function parseOklchHue(value) {
+  const input = value.trim();
+  if (isNone(input)) return 0;
+  if (/(?:rad|grad|turn)$/i.test(input)) return void 0;
+  const normalized = input.replace(/deg$/i, "");
+  const number = parseNumber(normalized);
+  if (number === void 0) return void 0;
+  return (number % 360 + 360) % 360;
+}
+function parseOklchAlpha(value) {
+  return isNone(value) ? 0 : parseAlpha(value);
+}
+function parseHue(value) {
+  const normalized = value.trim().replace(/deg$/i, "");
+  const number = parseNumber(normalized);
+  if (number === void 0) return void 0;
+  return (number % 360 + 360) % 360;
+}
+function parsePercent(value) {
+  const input = value.trim();
+  if (!input.endsWith("%")) return void 0;
+  const number = parseNumber(input.slice(0, -1));
+  if (number === void 0 || number < 0 || number > 100) return void 0;
+  return number / 100;
+}
+function parseAlpha(value) {
+  const input = value.trim();
+  if (input.endsWith("%")) {
+    const percent = parseNumber(input.slice(0, -1));
+    if (percent === void 0 || percent < 0 || percent > 100) return void 0;
+    return percent / 100;
+  }
+  const number = parseNumber(input);
+  if (number === void 0 || number < 0 || number > 1) return void 0;
+  return number;
+}
+function parseNumber(value) {
+  if (!/^-?(?:\d+|\d*\.\d+)$/.test(value.trim())) return void 0;
+  const number = Number(value);
+  return Number.isFinite(number) ? number : void 0;
+}
+function isNone(value) {
+  return value.trim().toLowerCase() === "none";
+}
+function hslToRgb(h, s, l) {
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r1 = 0;
+  let g1 = 0;
+  let b1 = 0;
+  if (h < 60) {
+    r1 = c;
+    g1 = x;
+  } else if (h < 120) {
+    r1 = x;
+    g1 = c;
+  } else if (h < 180) {
+    g1 = c;
+    b1 = x;
+  } else if (h < 240) {
+    g1 = x;
+    b1 = c;
+  } else if (h < 300) {
+    r1 = x;
+    b1 = c;
+  } else {
+    r1 = c;
+    b1 = x;
+  }
+  return {
+    r: Math.round((r1 + m) * 255),
+    g: Math.round((g1 + m) * 255),
+    b: Math.round((b1 + m) * 255),
+    a: 1
+  };
+}
+function oklchToRgb(lightness, chroma, hue) {
+  const hueRadians = hue * Math.PI / 180;
+  const okA = chroma * Math.cos(hueRadians);
+  const okB = chroma * Math.sin(hueRadians);
+  const lPrime = lightness + 0.3963377774 * okA + 0.2158037573 * okB;
+  const mPrime = lightness - 0.1055613458 * okA - 0.0638541728 * okB;
+  const sPrime = lightness - 0.0894841775 * okA - 1.291485548 * okB;
+  const l = lPrime * lPrime * lPrime;
+  const m = mPrime * mPrime * mPrime;
+  const s = sPrime * sPrime * sPrime;
+  const linearR = 4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s;
+  const linearG = -1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s;
+  const linearB = -0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s;
+  return {
+    r: Math.round(gammaEncodeSrgb(linearR) * 255),
+    g: Math.round(gammaEncodeSrgb(linearG) * 255),
+    b: Math.round(gammaEncodeSrgb(linearB) * 255),
+    a: 1
+  };
+}
+function gammaEncodeSrgb(value) {
+  const clamped = value <= SRGB_LINEAR_EPSILON ? 0 : Math.max(0, Math.min(1, value));
+  if (clamped <= 31308e-7) return 12.92 * clamped;
+  return 1.055 * Math.pow(clamped, 1 / 2.4) - 0.055;
+}
+function toHexByte(value) {
+  return Math.max(0, Math.min(255, Math.round(value))).toString(16).padStart(2, "0").toUpperCase();
+}
+var TITLE_SEPARATOR_RE = /\s*(?:\||—|–|·|:)\s*|\s+-\s+/;
+var GENERIC_TITLE_SEGMENTS = /* @__PURE__ */ new Set([
+  "blog",
+  "docs",
+  "documentation",
+  "home",
+  "login",
+  "overview",
+  "pricing",
+  "sign in",
+  "welcome"
+]);
+function extractBrandText(html, pageUrl) {
+  const ogSiteName = getMetaContent(html, "property", "og:site_name");
+  const title = extractTitle(html);
+  const name = cleanText(ogSiteName) ?? (title ? stripTitleSuffix(title, pageUrl?.hostname) : void 0);
+  const description = cleanText(getMetaContent(html, "name", "description")) ?? cleanText(getMetaContent(html, "property", "og:description"));
+  return { name, description };
+}
+function extractThemeColorMetas(html) {
+  const metas = getTags(html, "meta").filter((tag) => tag.attrs.name?.toLowerCase() === "theme-color").flatMap((tag) => {
+    const value = cleanText(tag.attrs.content);
+    if (!value) return [];
+    return [{ value, media: cleanText(tag.attrs.media) }];
+  });
+  const light = metas.filter((meta) => /light/i.test(meta.media ?? ""));
+  if (light.length > 0) return light;
+  const nonDark = metas.filter((meta) => !/dark/i.test(meta.media ?? ""));
+  return nonDark.length > 0 ? nonDark : metas;
+}
+function extractManifestUrl(html, pageUrl) {
+  for (const tag of getTags(html, "link")) {
+    if (!relIncludes(tag.attrs.rel, "manifest")) continue;
+    const href = cleanText(tag.attrs.href);
+    if (!href) continue;
+    const resolved = resolveHttpUrl(href, pageUrl);
+    if (resolved) return resolved;
+  }
+  return void 0;
+}
+function extractStylesheetUrls(html, pageUrl, limit = 5) {
+  const urls = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const tag of getTags(html, "link")) {
+    if (!relIncludes(tag.attrs.rel, "stylesheet")) continue;
+    const href = cleanText(tag.attrs.href);
+    if (!href) continue;
+    const resolved = resolveHttpUrl(href, pageUrl);
+    if (!resolved) continue;
+    if (seen.has(resolved)) continue;
+    seen.add(resolved);
+    urls.push(resolved);
+    if (urls.length >= limit) break;
+  }
+  return urls;
+}
+function extractInlineStyleBlocks(html) {
+  const blocks = [];
+  const styleRe = /<style\b[^>]*>([\s\S]*?)<\/style>/gi;
+  for (const match of html.matchAll(styleRe)) {
+    blocks.push(match[1] ?? "");
+  }
+  return blocks;
+}
+function getMetaContent(html, key, expectedValue) {
+  const expected = expectedValue.toLowerCase();
+  for (const tag of getTags(html, "meta")) {
+    if (tag.attrs[key]?.toLowerCase() !== expected) continue;
+    const content = cleanText(tag.attrs.content);
+    if (content) return content;
+  }
+  return void 0;
+}
+function getTags(html, tagName) {
+  const escaped = escapeRegExp(tagName);
+  const tagRe = new RegExp(`<${escaped}\\b[^>]*>`, "gi");
+  const tags = [];
+  for (const match of html.matchAll(tagRe)) {
+    const raw = match[0];
+    tags.push({ raw, attrs: parseAttributes(raw), index: match.index ?? 0 });
+  }
+  return tags;
+}
+function parseAttributes(tag) {
+  const attrs = {};
+  const body = tag.replace(/^<\s*\/?\s*[\w:-]+/, "").replace(/\/?\s*>$/, "");
+  const attrRe = /([:\w.-]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
+  for (const match of body.matchAll(attrRe)) {
+    const name = match[1].toLowerCase();
+    const value = match[2] ?? match[3] ?? match[4] ?? "";
+    attrs[name] = decodeHtml(value);
+  }
+  return attrs;
+}
+function relIncludes(rel, token) {
+  if (!rel) return false;
+  return rel.toLowerCase().split(/\s+/).filter(Boolean).includes(token.toLowerCase());
+}
+function resolveHttpUrl(value, baseUrl) {
+  const input = value.trim();
+  if (input.length === 0 || input.startsWith("#")) return void 0;
+  try {
+    const url = new URL(input, baseUrl);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return void 0;
+    url.hash = "";
+    return url.toString();
+  } catch {
+    return void 0;
+  }
+}
+function cleanText(value) {
+  if (value === void 0) return void 0;
+  const cleaned = decodeHtml(stripTags(value)).replace(/\s+/g, " ").trim();
+  return cleaned.length > 0 ? cleaned : void 0;
+}
+function stripTitleSuffix(title, hostname) {
+  const cleaned = cleanText(title);
+  if (!cleaned) return void 0;
+  const segments = cleaned.split(TITLE_SEPARATOR_RE).map((segment) => segment.trim()).filter((segment) => segment.length > 1);
+  if (segments.length === 0) return cleaned;
+  const meaningful = segments.filter(
+    (segment) => !GENERIC_TITLE_SEGMENTS.has(segment.toLowerCase())
+  );
+  const pool = meaningful.length > 0 ? meaningful : segments;
+  const domainLabel = domainLabelOf(hostname);
+  if (domainLabel) {
+    const byDomain = pool.find(
+      (segment) => normalizeForMatch(segment) === domainLabel
+    );
+    if (byDomain) return byDomain;
+  }
+  return pool[0];
+}
+function domainLabelOf(hostname) {
+  if (!hostname) return void 0;
+  const labels = hostname.toLowerCase().split(".").filter(Boolean);
+  if (labels.length < 2) return labels[0];
+  return labels[labels.length - 2];
+}
+function normalizeForMatch(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function extractTitle(html) {
+  const match = /<title\b[^>]*>([\s\S]*?)<\/title>/i.exec(html);
+  return cleanText(match?.[1]);
+}
+function stripTags(value) {
+  return value.replace(/<[^>]+>/g, "");
+}
+function decodeHtml(value) {
+  return value.replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/&apos;/gi, "'").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function selectLogoAssets(html, pageUrl) {
+  const header = findHeaderLogoCandidates(html, pageUrl).sort(compareHeaderLogos);
+  const ogImage = findOgLogoCandidate(html, pageUrl);
+  const appleIcons = findLinkIconCandidates(
+    html,
+    pageUrl,
+    "apple-touch-icon"
+  ).sort(compareBySize);
+  const icons = findLinkIconCandidates(html, pageUrl, "icon").sort(compareBySize);
+  const logo = header[0] ?? ogImage ?? appleIcons[0] ?? icons[0];
+  const favicon = icons[0];
+  return {
+    logo,
+    favicon,
+    candidates: [
+      ...header,
+      ...ogImage ? [ogImage] : [],
+      ...appleIcons,
+      ...icons
+    ]
+  };
+}
+async function fetchBrandAsset(fetcher, url, kind) {
+  const fetched = await fetcher.fetchBytes(url, {
+    accept: "image/svg+xml,image/png,image/jpeg,image/webp,image/x-icon,*/*;q=0.8",
+    maxBytes: DEFAULT_LOGO_MAX_BYTES
+  });
+  const contentType = fetched.contentType;
+  const ext = extensionForContentType(contentType, kind);
+  if (!contentType || !ext) {
+    throw new Error(
+      `unsupported ${kind} content type${contentType ? `: ${contentType}` : ""}`
+    );
+  }
+  return {
+    url: fetched.url,
+    bytes: fetched.bytes,
+    contentType,
+    suggestedFilename: `${kind}.${ext}`
+  };
+}
+function extensionForContentType(contentType, kind = "logo") {
+  switch (contentType?.toLowerCase().split(";")[0]?.trim()) {
+    case "image/svg+xml":
+      return "svg";
+    case "image/png":
+      return "png";
+    case "image/jpeg":
+    case "image/jpg":
+      return "jpg";
+    case "image/webp":
+      return "webp";
+    // .ico is the most common favicon format but makes a poor logo.
+    case "image/x-icon":
+    case "image/vnd.microsoft.icon":
+      return kind === "favicon" ? "ico" : void 0;
+    default:
+      return void 0;
+  }
+}
+function findHeaderLogoCandidates(html, pageUrl) {
+  const regions = headerRegions(html);
+  const candidates = [];
+  let order = 0;
+  for (const region of regions) {
+    for (const tag of getTags(region, "img")) {
+      const haystack = [
+        tag.attrs.src,
+        tag.attrs.class,
+        tag.attrs.id,
+        tag.attrs.alt
+      ].join(" ");
+      if (!/logo/i.test(haystack)) continue;
+      const src = cleanText(tag.attrs.src);
+      if (!src) continue;
+      const url = resolveHttpUrl(src, pageUrl);
+      if (!url) continue;
+      candidates.push({
+        url,
+        source: "header-image",
+        isSvg: isSvgUrl(url) || tag.attrs.type === "image/svg+xml",
+        size: parseLargestSize(tag.attrs.sizes),
+        order: order++
+      });
+    }
+    const svgRe = /<svg\b[^>]*>[\s\S]*?<\/svg>/gi;
+    for (const match of region.matchAll(svgRe)) {
+      const svgMarkup = match[0];
+      const openTag = /^<svg\b[^>]*>/i.exec(svgMarkup)?.[0];
+      const svgAttrs = openTag ? parseAttributes(openTag) : {};
+      const useTags = getTags(svgMarkup, "use");
+      for (const useTag of useTags) {
+        const href = cleanText(useTag.attrs.href ?? useTag.attrs["xlink:href"]);
+        const haystack = [
+          svgAttrs.class,
+          svgAttrs.id,
+          svgAttrs["aria-label"],
+          href,
+          useTag.attrs.class,
+          useTag.attrs.id
+        ].join(" ");
+        if (!/logo/i.test(haystack) || !href) continue;
+        const url = resolveHttpUrl(href, pageUrl);
+        if (!url) continue;
+        candidates.push({
+          url,
+          source: "header-svg-use",
+          isSvg: true,
+          size: 0,
+          order: order++
+        });
+      }
+    }
+  }
+  return candidates;
+}
+function findOgLogoCandidate(html, pageUrl) {
+  const content = getMetaContent(html, "property", "og:image") ?? getMetaContent(html, "name", "og:image");
+  if (!content) return void 0;
+  const url = resolveHttpUrl(content, pageUrl);
+  if (!url) return void 0;
+  const parsed = new URL(url);
+  if (!parsed.pathname.toLowerCase().includes("logo")) return void 0;
+  return {
+    url,
+    source: "og-image",
+    isSvg: isSvgUrl(url),
+    size: 0,
+    order: 0
+  };
+}
+function findLinkIconCandidates(html, pageUrl, kind) {
+  const candidates = [];
+  let order = 0;
+  for (const tag of getTags(html, "link")) {
+    const rel = tag.attrs.rel?.toLowerCase() ?? "";
+    const isApple = rel.includes("apple-touch-icon");
+    const matches = kind === "apple-touch-icon" ? isApple : relIncludes(rel, "icon") && !isApple;
+    if (!matches) continue;
+    const href = cleanText(tag.attrs.href);
+    if (!href) continue;
+    const url = resolveHttpUrl(href, pageUrl);
+    if (!url) continue;
+    candidates.push({
+      url,
+      source: kind,
+      isSvg: isSvgUrl(url) || tag.attrs.type === "image/svg+xml",
+      size: parseLargestSize(tag.attrs.sizes),
+      order: order++
+    });
+  }
+  return candidates;
+}
+function headerRegions(html) {
+  const body = /<body\b[^>]*>([\s\S]*?)<\/body>/i.exec(html)?.[1] ?? html;
+  const regions = [];
+  const regionRe = /<(header|nav)\b[^>]*>[\s\S]*?<\/\1>/gi;
+  for (const match of body.matchAll(regionRe)) {
+    regions.push(match[0]);
+  }
+  if (regions.length > 0) return regions;
+  return [body.slice(0, Math.ceil(body.length * 0.3))];
+}
+function compareHeaderLogos(a, b) {
+  if (a.isSvg !== b.isSvg) return a.isSvg ? -1 : 1;
+  return a.order - b.order;
+}
+function compareBySize(a, b) {
+  return b.size - a.size || a.order - b.order;
+}
+function parseLargestSize(value) {
+  if (!value) return 0;
+  let largest = 0;
+  for (const token of value.split(/\s+/)) {
+    const match = /^(\d+)x(\d+)$/i.exec(token);
+    if (!match) continue;
+    const width = Number(match[1]);
+    const height = Number(match[2]);
+    if (!Number.isFinite(width) || !Number.isFinite(height)) continue;
+    largest = Math.max(largest, width * height);
+  }
+  return largest;
+}
+function isSvgUrl(url) {
+  return new URL(url).pathname.toLowerCase().endsWith(".svg");
+}
+var FONT_FAMILY_PATTERN = /^[A-Za-z0-9 +-]+$/;
+var MAX_AVAILABILITY_PROBES = 3;
+var IGNORED_FAMILIES = new Set(
+  [
+    "serif",
+    "sans-serif",
+    "monospace",
+    "system-ui",
+    "ui-sans-serif",
+    "ui-serif",
+    "ui-monospace",
+    "cursive",
+    "fantasy",
+    "math",
+    "emoji",
+    "-apple-system",
+    "BlinkMacSystemFont",
+    "Segoe UI",
+    "Roboto",
+    "Helvetica",
+    "Helvetica Neue",
+    "Arial",
+    "Times",
+    "Times New Roman",
+    "Georgia",
+    "Courier",
+    "Courier New",
+    "Menlo",
+    "Monaco",
+    "Consolas",
+    "SF Mono",
+    "SFMono-Regular",
+    "Liberation Mono",
+    "Noto Sans",
+    "Noto Serif"
+  ].map((family) => family.toLowerCase())
+);
+async function detectFonts({
+  html,
+  stylesheets,
+  fetcher,
+  warnings
+}) {
+  const cssSources = [
+    ...extractInlineStyleBlocks(html).map((text) => ({
+      text,
+      provenance: "inline style"
+    })),
+    ...stylesheets
+  ];
+  const googleFonts = collectGoogleFontSignals(html, cssSources, warnings);
+  const googleByFamily = new Map(
+    googleFonts.map((font) => [font.family.toLowerCase(), font])
+  );
+  const selfHostedFamilies = collectSelfHostedFamilies(stylesheets);
+  const declared = collectDeclaredFontSignals(cssSources);
+  const fonts = {};
+  const usedGoogleFamilies = /* @__PURE__ */ new Set();
+  const probes = /* @__PURE__ */ new Map();
+  let probeCount = 0;
+  const resolveDeclaredFont = async (slot, signal) => {
+    if ("unresolvedReference" in signal) {
+      warnings.push(
+        `Could not resolve font-family ${signal.unresolvedReference} for the ${slot} slot.`
+      );
+      return;
+    }
+    if (!validateFamily(signal.family, slot, warnings)) return;
+    const key = signal.family.toLowerCase();
+    const googleSignal = googleByFamily.get(key);
+    if (googleSignal) {
+      fonts[slot] = {
+        family: googleSignal.family,
+        source: "google",
+        ...googleSignal.weights ? { weights: googleSignal.weights } : {},
+        provenance: `${signal.provenance} ${slot} font-family + ${googleSignal.provenance}`
+      };
+      usedGoogleFamilies.add(key);
+      return;
+    }
+    let probe = probes.get(key);
+    if (!probe) {
+      if (probeCount >= MAX_AVAILABILITY_PROBES || fetcher.remainingRequests === 0) {
+        warnings.push(
+          `Could not verify detected ${slot} font "${signal.family}" on Google Fonts because the request budget is exhausted; keeping the starter font.`
+        );
+        return;
+      }
+      probeCount += 1;
+      probe = probeGoogleFonts(fetcher, signal.family);
+      probes.set(key, probe);
+    }
+    const probeResult = await probe;
+    if (probeResult === "available") {
+      fonts[slot] = {
+        family: signal.family,
+        source: "google",
+        provenance: `${signal.provenance} ${slot} font-family + google probe`
+      };
+      return;
+    }
+    if (probeResult === "inconclusive") {
+      warnings.push(
+        `Could not verify detected ${slot} font "${signal.family}" on Google Fonts; keeping the starter font.`
+      );
+      return;
+    }
+    if (selfHostedFamilies.has(key)) {
+      warnings.push(
+        `Detected ${slot} font "${signal.family}" is self-hosted and not on Google Fonts; keeping the starter font. The SaturnDocs team can license and self-host it later.`
+      );
+    } else {
+      warnings.push(
+        `Detected ${slot} font "${signal.family}" is not on Google Fonts; keeping the starter font.`
+      );
+    }
+  };
+  for (const slot of ["body", "heading", "mono"]) {
+    const signal = declared[slot];
+    if (signal) await resolveDeclaredFont(slot, signal);
+  }
+  for (const [index, slot] of ["body", "heading"].entries()) {
+    if (fonts[slot] || declared[slot]) continue;
+    let signal = googleFonts[index];
+    if (signal && usedGoogleFamilies.has(signal.family.toLowerCase())) {
+      signal = googleFonts.find(
+        (font) => !usedGoogleFamilies.has(font.family.toLowerCase())
+      );
+    }
+    if (!signal) break;
+    if (!validateFamily(signal.family, slot, warnings)) continue;
+    fonts[slot] = googleFontForSlot(signal, "order-of-appearance assumption");
+    usedGoogleFamilies.add(signal.family.toLowerCase());
+  }
+  if (!fonts.mono && !declared.mono) {
+    const monoSignal = googleFonts.find(
+      (font) => /(?:mono|code)/i.test(font.family)
+    );
+    if (monoSignal && validateFamily(monoSignal.family, "mono", warnings)) {
+      fonts.mono = googleFontForSlot(
+        monoSignal,
+        "family name indicates a mono font"
+      );
+    }
+  }
+  return Object.keys(fonts).length > 0 ? fonts : void 0;
+}
+function collectGoogleFontSignals(html, cssSources, warnings) {
+  const signals = [];
+  for (const tag of getTags(html, "link")) {
+    if (!relIncludes(tag.attrs.rel, "stylesheet")) continue;
+    const href = tag.attrs.href?.trim();
+    if (!href) continue;
+    signals.push(...parseGoogleFontsUrl(href, "google-fonts link"));
+  }
+  for (const source of cssSources) {
+    for (const url of extractImportUrls(source.text)) {
+      signals.push(...parseGoogleFontsUrl(url, "google-fonts @import"));
+    }
+  }
+  const deduplicated = /* @__PURE__ */ new Map();
+  for (const signal of signals) {
+    if (!FONT_FAMILY_PATTERN.test(signal.family)) {
+      warnings.push(
+        `Detected font "${signal.family}" has characters that are not allowed in docs.json; ignoring it.`
+      );
+      continue;
+    }
+    const key = signal.family.toLowerCase();
+    const current = deduplicated.get(key);
+    if (!current) {
+      deduplicated.set(key, signal);
+      continue;
+    }
+    const weights = uniqueSortedWeights([
+      ...current.weights ?? [],
+      ...signal.weights ?? []
+    ]);
+    if (weights.length > 0) current.weights = weights;
+  }
+  return [...deduplicated.values()];
+}
+function parseGoogleFontsUrl(rawUrl, provenance) {
+  let url;
+  try {
+    url = new URL(rawUrl.replace(/&amp;/gi, "&"), "https://example.invalid");
+  } catch {
+    return [];
+  }
+  if (url.hostname.toLowerCase() !== "fonts.googleapis.com") return [];
+  if (url.pathname !== "/css" && url.pathname !== "/css2") return [];
+  const signals = [];
+  for (const parameter of url.searchParams.getAll("family")) {
+    const families = url.pathname === "/css" ? parameter.split("|") : [parameter];
+    for (const familyParameter of families) {
+      const parsed = parseGoogleFamilyParameter(familyParameter);
+      if (parsed) signals.push({ ...parsed, provenance });
+    }
+  }
+  return signals;
+}
+function parseGoogleFamilyParameter(parameter) {
+  const separator = parameter.indexOf(":");
+  const rawFamily = separator === -1 ? parameter : parameter.slice(0, separator);
+  const family = rawFamily.replace(/\+/g, " ").replace(/\s+/g, " ").trim();
+  if (!family) return void 0;
+  const axesAndValues = separator === -1 ? "" : parameter.slice(separator + 1);
+  const weights = parseGoogleWeights(axesAndValues);
+  return {
+    family,
+    ...weights.length > 0 ? { weights } : {}
+  };
+}
+function parseGoogleWeights(value) {
+  if (!value) return [];
+  const at = value.indexOf("@");
+  if (at === -1) return [];
+  const axes = value.slice(0, at).split(",").map((axis) => axis.trim().toLowerCase());
+  const weightIndex = axes.indexOf("wght");
+  if (weightIndex === -1) return [];
+  const weights = value.slice(at + 1).split(";").map((tuple) => tuple.split(",")[weightIndex]?.trim()).filter(
+    (weight) => typeof weight === "string" && weight.length > 0 && !weight.includes("..")
+  ).map(Number);
+  return uniqueSortedWeights(weights);
+}
+function uniqueSortedWeights(weights) {
+  return [...new Set(weights)].filter((weight) => Number.isInteger(weight) && weight >= 1 && weight <= 1e3).sort((a, b) => a - b);
+}
+function extractImportUrls(css) {
+  const urls = [];
+  const importRe = /@import\s+(?:url\(\s*)?(?:(["'])(.*?)\1|([^\s)'";]+))\s*\)?[^;]*;/gi;
+  for (const match of stripCssComments(css).matchAll(importRe)) {
+    const url = (match[2] ?? match[3] ?? "").trim();
+    if (url) urls.push(url);
+  }
+  return urls;
+}
+function collectSelfHostedFamilies(cssSources) {
+  const families = /* @__PURE__ */ new Set();
+  for (const source of cssSources) {
+    for (const match of stripCssComments(source.text).matchAll(
+      /@font-face\s*\{([^{}]*)\}/gi
+    )) {
+      const family = firstUsableFamily(declarationValue(match[1] ?? ""));
+      if (family) families.add(family.toLowerCase());
+    }
+  }
+  return families;
+}
+function collectDeclaredFontSignals(cssSources) {
+  const signals = {};
+  const customProperties = collectCustomProperties(cssSources);
+  for (const source of cssSources) {
+    const css = stripCssComments(source.text).replace(
+      /@font-face\s*\{[^{}]*\}/gi,
+      ""
+    );
+    for (const rule of parseCssRules(css)) {
+      const selector = rule.selector;
+      const familyValue = declarationValue(rule.declarations);
+      if (!selector || !familyValue) continue;
+      const slots = slotsForSelector(selector);
+      if (slots.length === 0) continue;
+      const variable = parseLeadingVarReference(familyValue);
+      const resolvedValue = variable ? resolveLeadingVarReference(familyValue, customProperties, 1) : familyValue;
+      if (variable && resolvedValue === void 0) {
+        for (const slot of slots) {
+          signals[slot] ??= {
+            unresolvedReference: `var(${variable.property})`,
+            provenance: source.provenance
+          };
+        }
+        continue;
+      }
+      const family = firstUsableFamily(resolvedValue);
+      if (!family) continue;
+      for (const slot of slots) {
+        signals[slot] ??= { family, provenance: source.provenance };
+      }
+    }
+  }
+  return signals;
+}
+function collectCustomProperties(cssSources) {
+  const properties = /* @__PURE__ */ new Map();
+  for (const source of cssSources) {
+    const css = stripCssComments(source.text).replace(
+      /@font-face\s*\{[^{}]*\}/gi,
+      ""
+    );
+    for (const rule of parseCssRules(css)) {
+      if (!slotsForSelector(rule.selector).includes("body")) continue;
+      for (const match of rule.declarations.matchAll(
+        /(?:^|;)\s*(--[^:\s;{}]+)\s*:\s*([^;}]+)/g
+      )) {
+        const property = match[1];
+        const value = match[2]?.replace(/\s*!important\s*$/i, "").trim();
+        if (property && value !== void 0) properties.set(property, value);
+      }
+    }
+  }
+  return properties;
+}
+function resolveLeadingVarReference(value, customProperties, remainingIndirections) {
+  const reference = parseLeadingVarReference(value);
+  if (!reference) return value;
+  const declaredValue = customProperties.get(reference.property);
+  const replacement = declaredValue ?? reference.fallback;
+  if (replacement === void 0) return void 0;
+  let resolvedReplacement = replacement;
+  if (parseLeadingVarReference(replacement)) {
+    if (remainingIndirections === 0) return void 0;
+    const resolved = resolveLeadingVarReference(
+      replacement,
+      customProperties,
+      remainingIndirections - 1
+    );
+    if (resolved === void 0) return void 0;
+    resolvedReplacement = resolved;
+  }
+  return `${resolvedReplacement}${value.slice(reference.endIndex)}`;
+}
+function parseLeadingVarReference(value) {
+  const startIndex = value.search(/\S/);
+  if (startIndex === -1 || !value.slice(startIndex).toLowerCase().startsWith("var(")) {
+    return void 0;
+  }
+  const openIndex = startIndex + 3;
+  let depth = 1;
+  let quote;
+  let escaped = false;
+  for (let index = openIndex + 1; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (character === "\\") {
+        escaped = true;
+      } else if (character === quote) {
+        quote = void 0;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === "(") {
+      depth += 1;
+      continue;
+    }
+    if (character !== ")") continue;
+    depth -= 1;
+    if (depth !== 0) continue;
+    const contents = value.slice(openIndex + 1, index);
+    const separator = findTopLevelComma(contents);
+    const property = contents.slice(0, separator === -1 ? void 0 : separator).trim();
+    if (!property.startsWith("--") || /\s/.test(property)) return void 0;
+    const fallback = separator === -1 ? void 0 : contents.slice(separator + 1).trim();
+    return {
+      property,
+      ...fallback !== void 0 ? { fallback } : {},
+      endIndex: index + 1
+    };
+  }
+  return void 0;
+}
+function findTopLevelComma(value) {
+  let depth = 0;
+  let quote;
+  let escaped = false;
+  for (let index = 0; index < value.length; index += 1) {
+    const character = value[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (character === "\\") {
+        escaped = true;
+      } else if (character === quote) {
+        quote = void 0;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === "(") {
+      depth += 1;
+    } else if (character === ")") {
+      depth -= 1;
+    } else if (character === "," && depth === 0) {
+      return index;
+    }
+  }
+  return -1;
+}
+function parseCssRules(css) {
+  const rules = [];
+  const stack = [];
+  let segmentStart = 0;
+  let quote;
+  let escaped = false;
+  for (let index = 0; index < css.length; index += 1) {
+    const character = css[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+      } else if (character === "\\") {
+        escaped = true;
+      } else if (character === quote) {
+        quote = void 0;
+      }
+      continue;
+    }
+    if (character === '"' || character === "'") {
+      quote = character;
+      continue;
+    }
+    if (character === "{") {
+      stack.push({
+        selector: css.slice(segmentStart, index).trim(),
+        openIndex: index
+      });
+      segmentStart = index + 1;
+      continue;
+    }
+    if (character !== "}") continue;
+    const block = stack.pop();
+    if (block) {
+      const declarations = css.slice(block.openIndex + 1, index);
+      if (!/[{}]/.test(declarations) && block.selector) {
+        rules.push({ selector: block.selector, declarations });
+      }
+    }
+    segmentStart = index + 1;
+  }
+  return rules;
+}
+function declarationValue(declarations) {
+  const matches = [...declarations.matchAll(/(?:^|;)\s*font-family\s*:\s*([^;}]+)/gi)];
+  return matches.at(-1)?.[1]?.trim();
+}
+function firstUsableFamily(stack) {
+  if (!stack) return void 0;
+  const normalizedStack = stack.replace(/\s*!important\s*$/i, "");
+  for (const item of splitFontStack(normalizedStack)) {
+    const family = stripQuotes(item.trim()).replace(/\s+/g, " ").trim();
+    if (!family || IGNORED_FAMILIES.has(family.toLowerCase())) continue;
+    return family;
+  }
+  return void 0;
+}
+function splitFontStack(value) {
+  const items = [];
+  let current = "";
+  let quote;
+  for (const character of value) {
+    if ((character === '"' || character === "'") && !quote) {
+      quote = character;
+    } else if (character === quote) {
+      quote = void 0;
+    }
+    if (character === "," && !quote) {
+      items.push(current);
+      current = "";
+    } else {
+      current += character;
+    }
+  }
+  items.push(current);
+  return items;
+}
+function stripQuotes(value) {
+  if (value.length >= 2 && (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'"))) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function slotsForSelector(selector) {
+  const slots = /* @__PURE__ */ new Set();
+  for (const item of selector.split(",")) {
+    if (/(^|[\s>+~])(?:html|body)(?=$|[\s.#:[>+~])/i.test(item) || /(^|[\s>+~]):root(?=$|[\s.#:[>+~])/i.test(item) || /(^|[\s>+~])\*(?=$|[\s.#:[>+~])/.test(item)) {
+      slots.add("body");
+    }
+    if (/(^|[\s>+~])h[123](?=$|[\s.#:[>+~])/i.test(item)) {
+      slots.add("heading");
+    }
+    if (/(^|[\s>+~])(?:code|pre|kbd|samp)(?=$|[\s.#:[>+~])/i.test(item)) {
+      slots.add("mono");
+    }
+  }
+  return [...slots];
+}
+function validateFamily(family, slot, warnings) {
+  if (FONT_FAMILY_PATTERN.test(family)) return true;
+  warnings.push(
+    `Detected ${slot} font "${family}" has characters that are not allowed in docs.json; keeping the starter font.`
+  );
+  return false;
+}
+async function probeGoogleFonts(fetcher, family) {
+  const encoded = encodeURIComponent(family).replace(/%20/g, "+");
+  try {
+    const response = await fetcher.fetchText(
+      `https://fonts.googleapis.com/css2?family=${encoded}`,
+      {
+        accept: "text/css,*/*;q=0.8",
+        maxBytes: DEFAULT_STYLESHEET_MAX_BYTES,
+        truncate: true
+      }
+    );
+    return response.status === 200 ? "available" : "inconclusive";
+  } catch (error) {
+    return /HTTP 400\b/.test(messageOf2(error)) ? "unavailable" : "inconclusive";
+  }
+}
+function googleFontForSlot(signal, assumption) {
+  return {
+    family: signal.family,
+    source: "google",
+    ...signal.weights ? { weights: signal.weights } : {},
+    provenance: `${signal.provenance} (${assumption})`
+  };
+}
+function stripCssComments(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, "");
+}
+function messageOf2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+var CONFIDENCE_FIELDS = [
+  "seeds.background.light",
+  "seeds.background.dark",
+  "seeds.text.light",
+  "seeds.text.dark",
+  "seeds.accent.light",
+  "seeds.accent.dark",
+  "fonts.heading",
+  "fonts.body",
+  "radius"
+];
+function deriveThemeCandidate(html, stylesheets) {
+  const css = [
+    ...extractInlineStyleBlocks(html),
+    ...extractStyleAttributes(html),
+    ...stylesheets
+  ].join("\n");
+  const rules = parseRules(css);
+  const customProperties = collectCustomProperties2(rules);
+  const confidence = Object.fromEntries(
+    CONFIDENCE_FIELDS.map((field) => [
+      field,
+      { level: "low", reason: `No reliable ${field} signal was found.` }
+    ])
+  );
+  const seeds = {};
+  const backgrounds = { light: [], dark: [] };
+  const texts = { light: [], dark: [] };
+  for (const rule of rules) {
+    if (!isRootOrBodySelector(rule.selector)) continue;
+    const background = declarationColor(
+      rule.declarations,
+      ["background-color", "background"],
+      customProperties
+    );
+    const text = declarationColor(rule.declarations, ["color"], customProperties);
+    const explicitMode = selectorMode(rule.selector);
+    if (background) {
+      const mode = explicitMode ?? modeFromBackground(background);
+      backgrounds[mode].push({
+        value: background,
+        weight: isBodySelector(rule.selector) ? 3 : 2,
+        reason: `${rule.selector.trim()} background declaration`
+      });
+    }
+    if (text) {
+      const mode = explicitMode ?? modeFromText(text);
+      texts[mode].push({
+        value: text,
+        weight: isBodySelector(rule.selector) ? 3 : 2,
+        reason: `${rule.selector.trim()} color declaration`
+      });
+    }
+  }
+  for (const mode of ["light", "dark"]) {
+    const background = chooseSignal(backgrounds[mode]);
+    setModeSignal(seeds, "background", mode, background, confidence);
+    const text = chooseSignal(texts[mode]);
+    setModeSignal(seeds, "text", mode, text, confidence);
+  }
+  const pageMode = backgrounds.dark.length > 0 && backgrounds.light.length === 0 ? "dark" : "light";
+  const accents = { light: [], dark: [] };
+  for (const rule of rules) {
+    const explicitMode = selectorMode(rule.selector);
+    if (isRootSelector(rule.selector)) {
+      for (const declaration of rule.declarations) {
+        if (!declaration.property.startsWith("--")) continue;
+        if (!/(?:brand|primary|accent|link|button)/i.test(declaration.property)) continue;
+        const color = resolveColor(declaration.value, customProperties);
+        if (!color || !isAccentColor(color)) continue;
+        accents[explicitMode ?? pageMode].push({
+          value: color,
+          weight: 4,
+          reason: `${declaration.property} brand custom property`
+        });
+      }
+    }
+    if (!isAccentSelector(rule.selector)) continue;
+    for (const declaration of rule.declarations) {
+      if (!/^(?:color|background|background-color|border-color)$/.test(declaration.property)) {
+        continue;
+      }
+      const color = resolveColor(declaration.value, customProperties);
+      if (!color || !isAccentColor(color)) continue;
+      accents[explicitMode ?? pageMode].push({
+        value: color,
+        weight: 1,
+        reason: `${rule.selector.trim()} ${declaration.property} declaration`
+      });
+    }
+  }
+  for (const mode of ["light", "dark"]) {
+    setModeSignal(seeds, "accent", mode, chooseSignal(accents[mode]), confidence);
+  }
+  const bodyFonts = [];
+  const headingFonts = [];
+  for (const rule of rules) {
+    const font = declarationValue2(rule.declarations, "font-family", customProperties);
+    if (!font) continue;
+    if (isHeadingSelector(rule.selector)) {
+      headingFonts.push({ value: cleanFontStack(font), weight: 2, reason: `${rule.selector.trim()} font-family` });
+    }
+    if (isRootOrBodySelector(rule.selector)) {
+      bodyFonts.push({ value: cleanFontStack(font), weight: isBodySelector(rule.selector) ? 3 : 2, reason: `${rule.selector.trim()} font-family` });
+    }
+  }
+  const heading = chooseSignal(headingFonts);
+  const body = chooseSignal(bodyFonts);
+  const fonts = {};
+  setScalarSignal(fonts, "heading", heading, confidence, "fonts.heading");
+  setScalarSignal(fonts, "body", body, confidence, "fonts.body");
+  const radii = [];
+  for (const rule of rules) {
+    for (const declaration of rule.declarations) {
+      if (declaration.property !== "border-radius") continue;
+      const resolved = resolveCustomProperty(declaration.value, customProperties);
+      const bucket = radiusBucket(resolved);
+      const weight = radiusSignalWeight(rule.selector);
+      if (!bucket || weight === 0) continue;
+      radii.push({ value: bucket, weight, reason: `${rule.selector.trim()} border-radius` });
+    }
+  }
+  const radius = chooseSignal(radii);
+  const candidate = { seeds, confidence };
+  if (Object.keys(fonts).length > 0) candidate.fonts = fonts;
+  if (radius.value) {
+    candidate.radius = radius.value;
+    confidence.radius = {
+      level: radius.level,
+      reason: radius.reason
+    };
+  } else {
+    confidence.radius = { level: "low", reason: radius.reason };
+  }
+  return candidate;
+}
+function deriveThemeRecipe(primaryColor, candidate) {
+  const fallback = rgbToHsl(
+    parseCssColor(primaryColor) ?? parseCssColor("#4F46E5")
+  );
+  const lightEvidence = confidentSeed(candidate, "background", "light");
+  const darkEvidence = confidentSeed(candidate, "background", "dark");
+  const lightAnchor = readingAnchor(lightEvidence, darkEvidence, fallback);
+  const darkAnchor = readingAnchor(darkEvidence, lightEvidence, fallback);
+  const lightBackground = canvasColor("light", lightAnchor);
+  const darkBackground = contrastSafeDarkCanvas(canvasColor("dark", darkAnchor));
+  const lightSurface = surfaceColor("light", lightBackground);
+  const darkSurface = surfaceColor("dark", darkBackground);
+  const text = confidentPair(candidate, "text");
+  const accent = confidentPair(candidate, "accent");
+  const recipe = {
+    base: "default",
+    seeds: {
+      background: {
+        light: hslToHex(lightBackground),
+        dark: hslToHex(darkBackground)
+      },
+      surface: {
+        light: hslToHex(lightSurface),
+        dark: hslToHex(darkSurface)
+      },
+      ...text ? { text } : {},
+      ...accent ? { accent } : {}
+    }
+  };
+  if (candidate?.confidence.radius?.level === "high" && candidate.radius) {
+    recipe.radius = candidate.radius === "large" ? "medium" : candidate.radius;
+  }
+  return recipe;
+}
+function confidentSeed(candidate, field, mode) {
+  const value = candidate?.seeds[field]?.[mode];
+  if (!value || candidate?.confidence[`seeds.${field}.${mode}`]?.level !== "high" || !parseCssColor(value)) {
+    return void 0;
+  }
+  return value;
+}
+function confidentPair(candidate, field) {
+  const light = confidentSeed(candidate, field, "light");
+  const dark = confidentSeed(candidate, field, "dark");
+  if (!light && !dark) return void 0;
+  return { ...light ? { light } : {}, ...dark ? { dark } : {} };
+}
+function readingAnchor(preferred, alternate, fallback) {
+  for (const value of [preferred, alternate]) {
+    const parsed = value ? parseCssColor(value) : void 0;
+    if (!parsed) continue;
+    const hsl = rgbToHsl(parsed);
+    if (hsl.s >= 0.06) {
+      return { h: hsl.h, s: hsl.s, fromBackground: true };
+    }
+  }
+  return { h: fallback.h, s: fallback.s, fromBackground: false };
+}
+function canvasColor(mode, anchor) {
+  if (mode === "light") {
+    return {
+      h: anchor.h,
+      s: anchor.fromBackground ? Math.min(anchor.s * 0.45, 0.18) : clamp(anchor.s * 0.1, 0.03, 0.12),
+      l: 0.975
+    };
+  }
+  const saturation = anchor.fromBackground ? Math.min(anchor.s, 0.5) : clamp(anchor.s * 0.28, 0.12, 0.34);
+  return {
+    h: anchor.h,
+    // Red, orange, yellow, and yellow-green accents easily turn a dark
+    // reading canvas into brown or olive. Preserve only a quiet trace of
+    // those hues; cool blue and purple canvases can carry more color without
+    // becoming visually muddy.
+    s: isCoolCanvasHue(anchor.h) ? saturation : Math.min(saturation, 0.06),
+    // Keep enough headroom for the renderer's high-contrast reading text.
+    // A 10% HSL lightness remains comfortable while allowing white to clear
+    // the default theme's 17.59:1 body-text contrast target.
+    l: 0.1
+  };
+}
+function isCoolCanvasHue(hue) {
+  const normalized = (hue % 360 + 360) % 360;
+  return normalized >= 160 && normalized <= 310;
+}
+function contrastSafeDarkCanvas(canvas) {
+  const minimumWhiteContrast = 17.6;
+  let lightness = canvas.l;
+  while (lightness > 0.06) {
+    const candidate = { ...canvas, l: lightness };
+    const rgb = parseCssColor(hslToHex(candidate));
+    const luminance = relativeLuminance(rgb.r, rgb.g, rgb.b);
+    if (1.05 / (luminance + 0.05) >= minimumWhiteContrast) return candidate;
+    lightness -= 25e-4;
+  }
+  return { ...canvas, l: lightness };
+}
+function relativeLuminance(red, green, blue) {
+  const linear = (channel) => {
+    const value = channel / 255;
+    return value <= 0.04045 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * linear(red) + 0.7152 * linear(green) + 0.0722 * linear(blue);
+}
+function surfaceColor(mode, background) {
+  return {
+    h: background.h,
+    s: background.s * (mode === "light" ? 0.65 : 0.9),
+    l: Math.min(mode === "light" ? 0.995 : 0.2, background.l + (mode === "light" ? 0.015 : 0.055))
+  };
+}
+function hslToHex(color) {
+  const hue = (color.h % 360 + 360) % 360;
+  const chroma = (1 - Math.abs(2 * color.l - 1)) * color.s;
+  const segment = hue / 60;
+  const x = chroma * (1 - Math.abs(segment % 2 - 1));
+  const [red, green, blue] = segment < 1 ? [chroma, x, 0] : segment < 2 ? [x, chroma, 0] : segment < 3 ? [0, chroma, x] : segment < 4 ? [0, x, chroma] : segment < 5 ? [x, 0, chroma] : [chroma, 0, x];
+  const match = color.l - chroma / 2;
+  return colorToHex({
+    r: (red + match) * 255,
+    g: (green + match) * 255,
+    b: (blue + match) * 255,
+    a: 1
+  });
+}
+function clamp(value, minimum, maximum) {
+  return Math.min(maximum, Math.max(minimum, value));
+}
+function extractStyleAttributes(html) {
+  const blocks = [];
+  for (const match of html.matchAll(/<([a-z][\w-]*)\b[^>]*\bstyle\s*=\s*(["'])(.*?)\2[^>]*>/gis)) {
+    blocks.push(`${match[1]} { ${match[3]} }`);
+  }
+  return blocks;
+}
+function parseRules(css) {
+  const clean = css.replace(/\/\*[\s\S]*?\*\//g, "");
+  const rules = [];
+  for (const block of clean.split("}")) {
+    const openBrace = block.lastIndexOf("{");
+    if (openBrace < 0) continue;
+    const previousOpenBrace = block.lastIndexOf("{", openBrace - 1);
+    const selector = block.slice(previousOpenBrace + 1, openBrace).trim();
+    if (selector.startsWith("@") || selector.length === 0) continue;
+    const declarations = [];
+    for (const part of block.slice(openBrace + 1).split(";")) {
+      const declaration = /^\s*([-\w]+)\s*:\s*(.*?)\s*$/.exec(part);
+      if (!declaration || declaration[2].length === 0) continue;
+      declarations.push({
+        property: declaration[1].toLowerCase(),
+        value: declaration[2].replace(/\s*!important\s*$/i, "").trim()
+      });
+    }
+    rules.push({ selector, declarations });
+  }
+  return rules;
+}
+function collectCustomProperties2(rules) {
+  const properties = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    if (!isRootSelector(rule.selector)) continue;
+    for (const declaration of rule.declarations) {
+      if (declaration.property.startsWith("--")) {
+        properties.set(declaration.property, declaration.value);
+      }
+    }
+  }
+  return properties;
+}
+function declarationValue2(declarations, property, customProperties) {
+  const declaration = [...declarations].reverse().find((entry) => entry.property === property);
+  return declaration ? resolveCustomProperty(declaration.value, customProperties) : void 0;
+}
+function declarationColor(declarations, properties, customProperties) {
+  for (const property of properties) {
+    const value = declarationValue2(declarations, property, customProperties);
+    const color = value ? resolveColor(value, customProperties) : void 0;
+    if (color) return color;
+  }
+  return void 0;
+}
+function resolveCustomProperty(value, properties) {
+  let resolved = value.trim();
+  for (let index = 0; index < 4; index++) {
+    const match = /var\(\s*(--[-\w]+)(?:\s*,\s*([^)]+))?\s*\)/.exec(resolved);
+    if (!match) break;
+    const replacement = properties.get(match[1]) ?? match[2];
+    if (!replacement) break;
+    resolved = resolved.replace(match[0], replacement.trim());
+  }
+  return resolved.trim();
+}
+function resolveColor(value, properties) {
+  const resolved = resolveCustomProperty(value, properties);
+  const literal = /#(?:[\da-f]{3}|[\da-f]{6}|[\da-f]{8})(?![\da-f])|rgba?\([^)]*\)|hsla?\([^)]*\)|oklch\([^)]*\)/i.exec(resolved)?.[0] ?? { white: "#ffffff", black: "#000000" }[resolved.toLowerCase()];
+  const parsed = literal ? parseCssColor(literal) : void 0;
+  return parsed ? colorToHex(parsed) : void 0;
+}
+function chooseSignal(signals) {
+  if (signals.length === 0) {
+    return { level: "low", reason: "No matching declaration was found." };
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const signal of signals) {
+    const current = grouped.get(signal.value) ?? { score: 0, count: 0, reasons: [] };
+    current.score += signal.weight;
+    current.count++;
+    current.reasons.push(signal.reason);
+    grouped.set(signal.value, current);
+  }
+  const ranked = [...grouped.entries()].sort(
+    (left, right) => right[1].score - left[1].score || right[1].count - left[1].count
+  );
+  const first = ranked[0];
+  const second = ranked[1];
+  if (second && first[1].score === second[1].score && first[1].count === second[1].count) {
+    return {
+      level: "low",
+      reason: `Conflicting declarations equally support ${first[0]} and ${second[0]}.`
+    };
+  }
+  return {
+    value: first[0],
+    level: first[1].count > 1 || first[1].score >= 3 ? "high" : "medium",
+    reason: `${first[1].reasons[0]}${first[1].count > 1 ? ` (${first[1].count} matching declarations)` : ""}.`
+  };
+}
+function setModeSignal(seeds, field, mode, signal, confidence) {
+  const key = `seeds.${field}.${mode}`;
+  confidence[key] = { level: signal.level, reason: signal.reason };
+  if (!signal.value) return;
+  const pair = seeds[field] ?? {};
+  pair[mode] = signal.value;
+  seeds[field] = pair;
+}
+function setScalarSignal(target, field, signal, confidence, confidenceKey) {
+  confidence[confidenceKey] = { level: signal.level, reason: signal.reason };
+  if (signal.value) target[field] = signal.value;
+}
+function selectorMode(selector) {
+  if (/(?:^|[\s.[#:_-])dark(?:$|[\s\]#.(:_-])|data-theme\s*=\s*["']?dark/i.test(selector)) {
+    return "dark";
+  }
+  if (/(?:^|[\s.[#:_-])light(?:$|[\s\]#.(:_-])|data-theme\s*=\s*["']?light/i.test(selector)) {
+    return "light";
+  }
+  return void 0;
+}
+function modeFromBackground(color) {
+  return rgbToHsl(parseCssColor(color)).l < 0.4 ? "dark" : "light";
+}
+function modeFromText(color) {
+  return rgbToHsl(parseCssColor(color)).l > 0.6 ? "dark" : "light";
+}
+function isAccentColor(color) {
+  const hsl = rgbToHsl(parseCssColor(color));
+  return hsl.s >= 0.18 && hsl.l >= 0.08 && hsl.l <= 0.92;
+}
+function isRootSelector(selector) {
+  return selectorList(selector).some(
+    (part) => /^(?::root|html)(?:(?:[.#:]|\[)\S*)?$/i.test(withoutAttributeSpaces(part))
+  );
+}
+function isBodySelector(selector) {
+  return selectorList(selector).some((part) => {
+    const compact = withoutAttributeSpaces(part);
+    const compound = String.raw`(?:(?:[.#:]|\[)\S*)?`;
+    return new RegExp(`^body${compound}$`, "i").test(compact) || new RegExp(`^html${compound}\\s+(?:>\\s*)?body${compound}$`, "i").test(compact);
+  });
+}
+function isRootOrBodySelector(selector) {
+  return isRootSelector(selector) || isBodySelector(selector);
+}
+function selectorList(selector) {
+  return selector.split(",").map((part) => part.trim()).filter(Boolean);
+}
+function withoutAttributeSpaces(selector) {
+  return selector.replace(/\[[^\]]*\]/g, (attribute) => attribute.replace(/\s+/g, ""));
+}
+function isHeadingSelector(selector) {
+  return /(^|[\s,>+~])h[1-6](?:\b|[.#:[>])|\.(?:heading|headline|title)\b/i.test(` ${selector}`);
+}
+function isAccentSelector(selector) {
+  return /(^|[\s,>+~])a(?:\b|[.#:[>])|(^|[\s,>+~])button(?:\b|[.#:[>])|\.(?:button|btn|cta)\b|\[role\s*=\s*["']?button/i.test(` ${selector}`);
+}
+function radiusSignalWeight(selector) {
+  if (/\boptgroup\b/i.test(selector)) return 0;
+  if (/(?:^|[\s.#:[>_-])(?:kbd|code|pre|badge|avatar|icon|orbit|hamburger|iframe|embed|widget|navigator|spara)(?:$|[\s.#:[>_-])/i.test(` ${selector} `)) {
+    return 0;
+  }
+  if (/(?:^|[\s,>+~])button(?:\b|[.#:[>])|\.(?:button|btn|cta)\b/i.test(` ${selector}`)) {
+    return 3;
+  }
+  if (/\.(?:card|panel|modal|dialog)\b|(?:^|[\s,>+~])(?:input|select|textarea)(?:\b|[.#:[>])/i.test(` ${selector}`)) {
+    return 2;
+  }
+  return 1;
+}
+function cleanFontStack(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function radiusBucket(value) {
+  const match = /^(-?(?:\d+|\d*\.\d+))(px|rem|em)?(?:\s|$)/i.exec(value.trim());
+  if (!match) return void 0;
+  let pixels = Number(match[1]);
+  if (!Number.isFinite(pixels) || pixels < 0) return void 0;
+  if (match[2]?.toLowerCase() === "rem" || match[2]?.toLowerCase() === "em") {
+    pixels *= 16;
+  }
+  if (pixels === 0) return "none";
+  if (pixels <= 4) return "small";
+  if (pixels <= 10) return "medium";
+  return "large";
+}
+var DEFAULT_PRIMARY_COLOR = "#4F46E5";
+async function extractBrandFromUrl(inputUrl, options = {}) {
+  const sourceUrl = normalizeHttpUrl(inputUrl).toString();
+  const fetcher = new BrandFetcher(options);
+  const warnings = [];
+  const defaultPrimaryColor = options.defaultPrimaryColor ?? DEFAULT_PRIMARY_COLOR;
+  let page;
+  try {
+    page = await fetcher.fetchText(sourceUrl, {
+      accept: "text/html,application/xhtml+xml,*/*;q=0.8",
+      maxBytes: DEFAULT_PAGE_MAX_BYTES
+    });
+  } catch (error) {
+    warnings.push(`Could not fetch page ${sourceUrl}: ${messageOf22(error)}`);
+    warnings.push(
+      `No usable brand color found; using ${defaultPrimaryColor}.`
+    );
+    return {
+      sourceUrl,
+      primaryColor: defaultPrimaryColor,
+      warnings,
+      requestCount: fetcher.requestCount
+    };
+  }
+  let pageUrl = new URL(page.url);
+  let analyzedHtml = page.text;
+  const colorCandidates = [];
+  const fontStylesheets = [];
+  for (const meta of extractThemeColorMetas(page.text)) {
+    colorCandidates.push({
+      value: meta.value,
+      weight: 3,
+      provenance: meta.media ? `meta theme-color (${meta.media})` : "meta theme-color"
+    });
+  }
+  const manifestUrl = extractManifestUrl(page.text, pageUrl);
+  if (manifestUrl) {
+    const themeColor = await fetchManifestThemeColor(
+      fetcher,
+      manifestUrl,
+      warnings
+    );
+    if (themeColor) {
+      colorCandidates.push({
+        value: themeColor,
+        weight: 3,
+        provenance: "web manifest theme_color"
+      });
+    }
+  }
+  for (const style of extractInlineStyleBlocks(page.text)) {
+    colorCandidates.push(...extractCssColorCandidates(style, "inline style"));
+  }
+  const stylesheetUrls = extractStylesheetUrls(page.text, pageUrl, 5);
+  for (const stylesheetUrl of stylesheetUrls) {
+    try {
+      const css = await fetcher.fetchText(stylesheetUrl, {
+        accept: "text/css,*/*;q=0.8",
+        maxBytes: DEFAULT_STYLESHEET_MAX_BYTES,
+        truncate: true
+      });
+      if (css.truncated) {
+        warnings.push(
+          `stylesheet ${css.url} truncated at ${DEFAULT_STYLESHEET_MAX_BYTES} bytes`
+        );
+      }
+      colorCandidates.push(
+        ...extractCssColorCandidates(css.text, `stylesheet ${stylesheetUrl}`)
+      );
+      fontStylesheets.push({
+        text: css.text,
+        provenance: `stylesheet ${stylesheetUrl}`
+      });
+    } catch (error) {
+      warnings.push(
+        `Could not fetch stylesheet ${stylesheetUrl}: ${messageOf22(error)}`
+      );
+    }
+  }
+  const staticText = extractBrandText(page.text, pageUrl);
+  const staticAssets = selectLogoAssets(page.text, pageUrl);
+  const staticThemeCandidate = deriveThemeCandidate(
+    page.text,
+    fontStylesheets.map((stylesheet) => stylesheet.text)
+  );
+  const staticBestColor = pickPrimaryColor(colorCandidates);
+  if (options.renderPage && needsRenderedFallback(
+    staticText,
+    staticAssets,
+    staticBestColor,
+    staticThemeCandidate
+  )) {
+    try {
+      const rendered = validateRenderedPage(
+        await options.renderPage(page.url, {
+          timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS
+        })
+      );
+      if (rendered.finalUrl) pageUrl = normalizeHttpUrl(rendered.finalUrl);
+      analyzedHtml = rendered.html;
+      for (const [index, stylesheet] of (rendered.stylesheets ?? []).entries()) {
+        colorCandidates.push(
+          ...extractCssColorCandidates(
+            stylesheet,
+            `rendered stylesheet ${index + 1}`
+          )
+        );
+        fontStylesheets.push({
+          text: stylesheet,
+          provenance: `rendered stylesheet ${index + 1}`
+        });
+      }
+    } catch (error) {
+      warnings.push(`Rendered brand fallback failed: ${messageOf22(error)}`);
+    }
+  }
+  const text = extractBrandText(analyzedHtml, pageUrl);
+  const themeCandidate = deriveThemeCandidate(
+    analyzedHtml,
+    fontStylesheets.map((stylesheet) => stylesheet.text)
+  );
+  const semanticAccent = highConfidenceAccent(themeCandidate);
+  const bestColor = pickPrimaryColor(colorCandidates);
+  const primaryColor = semanticAccent ?? bestColor?.hex ?? defaultPrimaryColor;
+  if (!bestColor && !semanticAccent) {
+    warnings.push(`No usable brand color found; using ${defaultPrimaryColor}.`);
+  }
+  const assets = selectLogoAssets(analyzedHtml, pageUrl);
+  const logo = assets.logo ? await maybeFetchAsset(fetcher, assets.logo, "logo", warnings) : void 0;
+  const favicon = assets.favicon ? await maybeFetchAsset(fetcher, assets.favicon, "favicon", warnings) : void 0;
+  const fonts = await detectFonts({
+    html: analyzedHtml,
+    stylesheets: fontStylesheets,
+    fetcher,
+    warnings
+  });
+  return {
+    sourceUrl,
+    finalUrl: pageUrl.toString(),
+    name: text.name,
+    description: text.description,
+    primaryColor,
+    logo,
+    favicon,
+    fonts,
+    themeCandidate,
+    warnings,
+    requestCount: fetcher.requestCount
+  };
+}
+function highConfidenceAccent(theme) {
+  for (const mode of ["light", "dark"]) {
+    if (theme.confidence[`seeds.accent.${mode}`]?.level === "high") {
+      const value = theme.seeds.accent?.[mode];
+      if (value) return value;
+    }
+  }
+  return void 0;
+}
+var MAX_RENDERED_HTML_CHARS = 2 * 1024 * 1024;
+var MAX_RENDERED_STYLESHEET_CHARS = 256 * 1024;
+var MAX_RENDERED_STYLESHEETS = 4;
+function needsRenderedFallback(text, assets, primary, theme) {
+  return !text.name || !assets.logo || !primary || !hasHighConfidence(
+    theme,
+    "seeds.background.light",
+    "seeds.background.dark"
+  ) || !hasHighConfidence(theme, "seeds.text.light", "seeds.text.dark");
+}
+function hasHighConfidence(theme, ...fields) {
+  return fields.some((field) => theme.confidence[field]?.level === "high");
+}
+function validateRenderedPage(page) {
+  if (!page || typeof page.html !== "string" || page.html.length === 0) {
+    throw new Error("provider returned no rendered HTML");
+  }
+  if (page.html.length > MAX_RENDERED_HTML_CHARS) {
+    throw new Error(
+      `rendered HTML exceeded ${MAX_RENDERED_HTML_CHARS} characters`
+    );
+  }
+  const stylesheets = page.stylesheets ?? [];
+  if (stylesheets.length > MAX_RENDERED_STYLESHEETS) {
+    throw new Error(
+      `provider returned more than ${MAX_RENDERED_STYLESHEETS} rendered stylesheets`
+    );
+  }
+  if (stylesheets.some(
+    (stylesheet) => typeof stylesheet !== "string" || stylesheet.length > MAX_RENDERED_STYLESHEET_CHARS
+  )) {
+    throw new Error(
+      `rendered stylesheet exceeded ${MAX_RENDERED_STYLESHEET_CHARS} characters`
+    );
+  }
+  if (page.finalUrl) normalizeHttpUrl(page.finalUrl);
+  return page;
+}
+function deriveDocsJson(extraction, overrides = {}) {
+  const name = cleanOption(overrides.name) ?? cleanOption(extraction.name) ?? "docs";
+  const primary = cleanOption(overrides.primary) ?? cleanOption(extraction.primaryColor) ?? DEFAULT_PRIMARY_COLOR;
+  const description = cleanOption(extraction.description) ?? `Documentation for ${name}.`;
+  const config = {
+    name,
+    description,
+    background: "linear-wash",
+    colors: {
+      primary
+    },
+    navigation: {
+      groups: [
+        {
+          group: "Getting started",
+          pages: ["index", "quickstart"]
+        }
+      ]
+    }
+  };
+  if (extraction.themeCandidate) {
+    config.theme = deriveThemeRecipe(primary, extraction.themeCandidate);
+  }
+  const logoPath = assetDocsPath(extraction.logo);
+  const faviconPath = assetDocsPath(extraction.favicon);
+  if (logoPath) config.logo = logoPath;
+  if (faviconPath) config.favicon = faviconPath;
+  const fonts = docsFonts(extraction.fonts);
+  if (fonts) config.fonts = fonts;
+  return config;
+}
+function docsFonts(extraction) {
+  if (!extraction) return void 0;
+  const fonts = {};
+  if (extraction.body) {
+    fonts.body = docsFont(extraction.body);
+    fonts.heading = docsFont(
+      extraction.heading?.family === extraction.body.family ? extraction.heading : extraction.body
+    );
+  } else if (extraction.heading) {
+    fonts.heading = docsFont(extraction.heading);
+  }
+  if (extraction.mono) fonts.mono = docsFont(extraction.mono);
+  return Object.keys(fonts).length > 0 ? fonts : void 0;
+}
+function docsFont(font) {
+  return {
+    family: font.family,
+    source: font.source,
+    ...font.weights ? { weights: font.weights } : {}
+  };
+}
+async function fetchManifestThemeColor(fetcher, manifestUrl, warnings) {
+  try {
+    const manifest = await fetcher.fetchText(manifestUrl, {
+      accept: "application/manifest+json,application/json,text/json,*/*;q=0.8",
+      maxBytes: DEFAULT_AUX_MAX_BYTES
+    });
+    const parsed = JSON.parse(manifest.text);
+    return typeof parsed.theme_color === "string" ? parsed.theme_color : void 0;
+  } catch (error) {
+    warnings.push(`Could not fetch manifest ${manifestUrl}: ${messageOf22(error)}`);
+    return void 0;
+  }
+}
+async function maybeFetchAsset(fetcher, candidate, kind, warnings) {
+  try {
+    const downloaded = await fetchBrandAsset(fetcher, candidate.url, kind);
+    return { ...downloaded, source: candidate.source };
+  } catch (error) {
+    warnings.push(
+      `Could not download ${kind} ${candidate.url}: ${messageOf22(error)}`
+    );
+    return void 0;
+  }
+}
+function assetDocsPath(asset) {
+  return asset ? `/${asset.suggestedFilename}` : void 0;
+}
+function cleanOption(value) {
+  const cleaned = value?.trim();
+  return cleaned && cleaned.length > 0 ? cleaned : void 0;
+}
+function messageOf22(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/commands/init.ts
+import pc from "picocolors";
+function registerInit(program) {
+  program.command("init").description("Scaffold a new SaturnDocs docs project").argument("[dir]", "directory to scaffold", ".").option("--name <name>", "site name").option("--primary <css-color>", "primary brand color").option("--from-url <url>", "extract brand details from a website").option("--yes", "accepted for future interactive prompts").action(async (dir, options) => {
+    try {
+      const result = await scaffoldDocsProject(dir, options);
+      if (result.extraction) printExtractionReport(result);
+      printNextSteps(result.docsDir);
+    } catch (error) {
+      console.error(pc.red(`error: ${messageOf(error)}`));
+      process.exit(1);
+    }
+  });
+}
+async function scaffoldDocsProject(dir = ".", options = {}, dependencies = {}) {
+  const docsDir = resolve(dir);
+  const docsJsonPath = join(docsDir, "docs.json");
+  if (existsSync(docsJsonPath)) {
+    throw new Error(`docs.json already exists in ${docsDir}`);
+  }
+  await mkdir(docsDir, { recursive: true });
+  const extractBrand = dependencies.extractBrand ?? extractBrandFromUrl;
+  const extraction = options.fromUrl ? await extractBrand(options.fromUrl) : void 0;
+  if (extraction) await writeExtractedAssets(docsDir, extraction);
+  const defaultName = basename(docsDir) || "docs";
+  const name = cleanOption2(options.name) ?? extraction?.name ?? defaultName;
+  const primary = cleanOption2(options.primary) ?? extraction?.primaryColor ?? DEFAULT_PRIMARY_COLOR;
+  const config = deriveDocsJson(
+    extraction ?? { primaryColor: DEFAULT_PRIMARY_COLOR },
+    {
+      name,
+      primary
+    }
+  );
+  config.fonts = extraction ? mergeExtractedFonts(extraction) : starterFonts();
+  await writeScaffoldFiles(docsDir, config);
+  return { docsDir, config: await loadDocsConfig(docsJsonPath), extraction };
+}
+function buildDocsConfig(input) {
+  const config = deriveDocsJson(
+    {
+      name: input.name,
+      description: input.description,
+      primaryColor: input.primary
+    },
+    {
+      name: input.name,
+      primary: input.primary
+    }
+  );
+  config.fonts = starterFonts();
+  if (input.logo) config.logo = input.logo;
+  if (input.favicon) config.favicon = input.favicon;
+  return config;
+}
+function starterFonts() {
+  return {
+    body: { family: "Instrument Sans", weights: [400, 500, 600] },
+    heading: { family: "Bricolage Grotesque", weights: [500, 600, 700] },
+    mono: { family: "IBM Plex Mono", weights: [400, 500] }
+  };
+}
+function mergeExtractedFonts(extraction) {
+  const fonts = starterFonts();
+  const body = extraction.fonts?.body;
+  const heading = extraction.fonts?.heading;
+  if (body) {
+    fonts.body = extractedFont(body);
+    fonts.heading = extractedFont(
+      heading?.family === body.family ? heading : body
+    );
+  } else if (heading) {
+    fonts.heading = extractedFont(heading);
+  }
+  if (extraction.fonts?.mono) fonts.mono = extractedFont(extraction.fonts.mono);
+  return fonts;
+}
+function extractedFont(detected) {
+  return {
+    family: detected.family,
+    source: detected.source,
+    ...detected.weights ? { weights: detected.weights } : {}
+  };
+}
+var THEME_SEED_FIELDS = [
+  ["background", "light"],
+  ["background", "dark"],
+  ["text", "light"],
+  ["text", "dark"],
+  ["accent", "light"],
+  ["accent", "dark"]
+];
+var THEME_CONFIDENCE_FIELDS = [
+  ...THEME_SEED_FIELDS.map(([field, mode]) => `seeds.${field}.${mode}`),
+  "radius"
+];
+function cleanOption2(value) {
+  const cleaned = value?.trim();
+  return cleaned && cleaned.length > 0 ? cleaned : void 0;
+}
+async function writeScaffoldFiles(docsDir, config) {
+  const pagesDir = join(docsDir, "pages");
+  await mkdir(pagesDir, { recursive: true });
+  await writeFile(
+    join(docsDir, "docs.json"),
+    `${JSON.stringify(config, null, 2)}
+`,
+    "utf8"
+  );
+  await writeFile(
+    join(pagesDir, "index.mdx"),
+    indexPageMdx(config.name, config.description ?? ""),
+    "utf8"
+  );
+  await writeFile(
+    join(pagesDir, "quickstart.mdx"),
+    quickstartPageMdx(config.name),
+    "utf8"
+  );
+}
+async function writeExtractedAssets(docsDir, extraction) {
+  const assets = [extraction.logo, extraction.favicon].filter(
+    (asset) => asset !== void 0
+  );
+  if (assets.length === 0) return;
+  const publicDir = join(docsDir, "public");
+  await mkdir(publicDir, { recursive: true });
+  for (const asset of assets) {
+    await writeFile(join(publicDir, asset.suggestedFilename), asset.bytes);
+  }
+}
+function indexPageMdx(name, description) {
+  return `---
+title: ${yamlString(`Welcome to ${name}`)}
+description: ${yamlString(description)}
+---
+
+<Note>
+  This site was scaffolded with SaturnDocs. Edit \`docs.json\` to update site metadata and navigation.
+</Note>
+
+## Start here
+
+<Columns cols={2}>
+  <Card title="Write pages" icon="file-text">
+    Add MDX files under \`pages/\`, then list them in \`docs.json\`.
+  </Card>
+  <Card title="Preview locally" icon="monitor">
+    Run \`saturndocs dev\` to open the docs site while you edit.
+  </Card>
+</Columns>
+`;
+}
+function quickstartPageMdx(name) {
+  return `---
+title: Quickstart
+description: ${yamlString(`Start editing ${name}.`)}
+---
+
+## Run the site
+
+\`\`\`sh
+saturndocs dev
+\`\`\`
+
+## Edit content
+
+Update \`pages/index.mdx\`, then add more files under \`pages/\`. Every page that should appear in the sidebar must be listed in \`docs.json\`.
+
+\`\`\`json title="docs.json"
+{
+  "navigation": {
+    "groups": [
+      { "group": "Getting started", "pages": ["index", "quickstart"] }
+    ]
+  }
+}
+\`\`\`
+
+## Use built-in components
+
+\`\`\`mdx
+<Note>
+  Use notes for short callouts.
+</Note>
+
+<Steps>
+  <Step title="Create a page">
+    Save a new MDX file in the pages directory.
+  </Step>
+  <Step title="Add it to navigation">
+    Add the page slug to docs.json.
+  </Step>
+</Steps>
+\`\`\`
+`;
+}
+function yamlString(value) {
+  return JSON.stringify(value);
+}
+function printExtractionReport(result) {
+  const extraction = result.extraction;
+  if (!extraction) return;
+  console.log(pc.bold("\nBrand extraction"));
+  console.log(`  Name: ${result.config.name}`);
+  console.log(
+    `  Description: ${truncate(result.config.description ?? "not found", 120)}`
+  );
+  console.log(
+    `  Primary: ${result.config.colors.primary} ${colorSwatch(
+      result.config.colors.primary
+    )}`.trimEnd()
+  );
+  console.log(`  Logo: ${result.config.logo ?? "not found"}`);
+  console.log(`  Favicon: ${result.config.favicon ?? "not found"}`);
+  const detectedFonts = extraction.fonts;
+  if (!detectedFonts || Object.keys(detectedFonts).length === 0) {
+    console.log("  Fonts: not detected");
+  } else {
+    for (const slot of ["body", "heading", "mono"]) {
+      const font = detectedFonts[slot];
+      if (!font) continue;
+      console.log(`  Fonts: ${slot}: ${font.family} (${font.source})`);
+    }
+  }
+  printThemeReport(extraction.themeCandidate, result.config.theme);
+  if (extraction.warnings.length > 0) {
+    console.log(pc.yellow("  Warnings:"));
+    for (const warning of extraction.warnings) {
+      console.log(pc.yellow(`    - ${warning}`));
+    }
+  }
+  console.log("  Review docs.json \u2014 extraction is a best guess.");
+}
+function printThemeReport(candidate, theme) {
+  if (!candidate || !theme) {
+    console.log("  Theme: not detected");
+    return;
+  }
+  console.log("  Theme:");
+  if (typeof theme !== "string") {
+    for (const field of ["background", "surface"]) {
+      for (const mode of ["light", "dark"]) {
+        const value = theme.seeds?.[field]?.[mode];
+        if (value) console.log(`    generated seeds.${field}.${mode}: ${value}`);
+      }
+    }
+  }
+  for (const [field, mode] of THEME_SEED_FIELDS) {
+    const path = `seeds.${field}.${mode}`;
+    const value = candidate.seeds[field]?.[mode];
+    const confidence = candidate.confidence[path];
+    if (!value || confidence?.level !== "high") continue;
+    console.log(`    evidence ${path}: ${value} (${confidence.level})`);
+    console.log(`      reason: ${confidence.reason}`);
+  }
+  const radiusConfidence = candidate.confidence.radius;
+  if (candidate.radius && radiusConfidence?.level === "high") {
+    console.log(`    evidence radius: ${candidate.radius} (${radiusConfidence.level})`);
+    console.log(`      reason: ${radiusConfidence.reason}`);
+  }
+  const omitted = THEME_CONFIDENCE_FIELDS.filter(
+    (field) => {
+      const level = candidate.confidence[field]?.level;
+      return level === "low" || level === "medium";
+    }
+  );
+  if (omitted.length > 0) {
+    console.log(`  omitted (not high confidence): ${omitted.join(", ")}`);
+  }
+}
+function printNextSteps(docsDir) {
+  console.log(pc.green(`
+Created SaturnDocs docs in ${docsDir}`));
+  console.log(pc.bold("Next steps"));
+  const rel = relative(process.cwd(), docsDir);
+  const cdTarget = !rel || rel === "." ? "" : rel.startsWith("..") ? docsDir : rel;
+  if (cdTarget) {
+    console.log(`  ${pc.cyan(`cd ${cdTarget}`)}`);
+  }
+  console.log(`  ${pc.cyan("saturndocs dev")}`);
+  console.log("  Edit docs.json to adjust navigation and site metadata.");
+  console.log("  Edit pages/index.mdx and pages/quickstart.mdx to start writing.");
+}
+function truncate(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  return `${value.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+function colorSwatch(value) {
+  const color = parseCssColor(value);
+  if (!color) return "";
+  return `\x1B[48;2;${color.r};${color.g};${color.b}m  \x1B[0m`;
+}
+
+export {
+  BrandFetcher,
+  normalizeHttpUrl,
+  parseCssColor,
+  colorToHex,
+  normalizeHexColor,
+  scoreColorCandidates,
+  pickPrimaryColor,
+  extractCssColorCandidates,
+  extractBrandText,
+  extractThemeColorMetas,
+  extractManifestUrl,
+  extractStylesheetUrls,
+  selectLogoAssets,
+  fetchBrandAsset,
+  extensionForContentType,
+  DEFAULT_PRIMARY_COLOR,
+  extractBrandFromUrl,
+  deriveDocsJson,
+  registerInit,
+  scaffoldDocsProject,
+  buildDocsConfig,
+  printExtractionReport
+};