@blaaiz/docs-core 0.1.0

package/dist/chunk-3ZX4WIE3.js

@@ -0,0 +1,2984 @@
+// src/core/ai/models.ts
+var AI_PROVIDER_NAMES = Object.freeze([
+  "anthropic",
+  "openai"
+]);
+var AI_PROVIDER_MODELS = Object.freeze(
+  {
+    anthropic: Object.freeze({
+      defaultModel: "claude-sonnet-5",
+      models: Object.freeze([
+        "claude-sonnet-5",
+        "claude-haiku-4-5",
+        "claude-opus-5",
+        "claude-opus-4-8",
+        "claude-sonnet-4-6"
+      ]),
+      defaultApiKeyEnv: "ANTHROPIC_API_KEY"
+    }),
+    openai: Object.freeze({
+      defaultModel: "gpt-5-mini",
+      models: Object.freeze([
+        "gpt-5-mini",
+        "gpt-5",
+        "gpt-5.2",
+        "gpt-5-nano",
+        "gpt-4.1",
+        "gpt-4.1-mini",
+        "gpt-4o",
+        "gpt-4o-mini"
+      ]),
+      defaultApiKeyEnv: "OPENAI_API_KEY"
+    })
+  }
+);
+function isAiProviderName(value) {
+  return typeof value === "string" && AI_PROVIDER_NAMES.includes(value);
+}
+function isAllowedAiModel(provider, model) {
+  return AI_PROVIDER_MODELS[provider].models.includes(model);
+}
+
+// src/core/ai/config.ts
+var DEFAULT_RATE_LIMIT_PER_MINUTE = 10;
+var DEFAULT_MAX_CONTEXT_PAGES = 6;
+var MIN_RATE_LIMIT_PER_MINUTE = 1;
+var MAX_RATE_LIMIT_PER_MINUTE = 600;
+var MIN_MAX_CONTEXT_PAGES = 1;
+var MAX_MAX_CONTEXT_PAGES = 20;
+var MAX_SYSTEM_PROMPT_CHARS = 4e3;
+var AiConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AiConfigError";
+  }
+};
+function describe(value) {
+  if (typeof value === "string") {
+    return `'${value}'`;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || value === null) {
+    return String(value);
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  return Array.isArray(value) ? "an array" : `a ${typeof value}`;
+}
+function quoteList(values) {
+  return values.map((value) => `'${value}'`).join(", ");
+}
+function requireOptionalString(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new AiConfigError(
+      `${field} must be a non-empty string, got ${describe(value)}. Remove the field to use the default.`
+    );
+  }
+  return value.trim();
+}
+function requireOptionalIntegerInRange(value, field, min, max, fallback) {
+  if (value === void 0) {
+    return fallback;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value < min || value > max) {
+    throw new AiConfigError(
+      `${field} must be an integer between ${String(min)} and ${String(max)}, got ${describe(value)}.`
+    );
+  }
+  return value;
+}
+function resolveAiConfig(config) {
+  const candidate = config;
+  if (typeof candidate !== "object" || candidate === null || Array.isArray(candidate)) {
+    throw new AiConfigError(
+      `ai must be an object, got ${describe(candidate)}. Example: ai: { provider: 'anthropic' }.`
+    );
+  }
+  const raw = candidate;
+  const provider = raw["provider"];
+  if (!isAiProviderName(provider)) {
+    throw new AiConfigError(
+      `ai.provider must be one of ${quoteList(AI_PROVIDER_NAMES)}, got ${describe(provider)}.`
+    );
+  }
+  const registry = AI_PROVIDER_MODELS[provider];
+  const model = requireOptionalString(raw["model"], "ai.model") ?? registry.defaultModel;
+  if (!isAllowedAiModel(provider, model)) {
+    throw new AiConfigError(
+      `ai.model must be one of ${quoteList(registry.models)} for provider '${provider}', got ${describe(model)}.`
+    );
+  }
+  const apiKeyEnv = requireOptionalString(raw["apiKeyEnv"], "ai.apiKeyEnv") ?? registry.defaultApiKeyEnv;
+  const rateLimitPerMinute = requireOptionalIntegerInRange(
+    raw["rateLimitPerMinute"],
+    "ai.rateLimitPerMinute",
+    MIN_RATE_LIMIT_PER_MINUTE,
+    MAX_RATE_LIMIT_PER_MINUTE,
+    DEFAULT_RATE_LIMIT_PER_MINUTE
+  );
+  const maxContextPages = requireOptionalIntegerInRange(
+    raw["maxContextPages"],
+    "ai.maxContextPages",
+    MIN_MAX_CONTEXT_PAGES,
+    MAX_MAX_CONTEXT_PAGES,
+    DEFAULT_MAX_CONTEXT_PAGES
+  );
+  const systemPrompt = raw["systemPrompt"];
+  if (systemPrompt !== void 0) {
+    if (typeof systemPrompt !== "string") {
+      throw new AiConfigError(`ai.systemPrompt must be a string, got ${describe(systemPrompt)}.`);
+    }
+    if (systemPrompt.length > MAX_SYSTEM_PROMPT_CHARS) {
+      throw new AiConfigError(
+        `ai.systemPrompt must be ${String(MAX_SYSTEM_PROMPT_CHARS)} characters or fewer, got ${String(systemPrompt.length)}.`
+      );
+    }
+  }
+  const trimmedPrompt = typeof systemPrompt === "string" ? systemPrompt.trim() : "";
+  return Object.freeze({
+    provider,
+    model,
+    apiKeyEnv,
+    defaultApiKeyEnv: registry.defaultApiKeyEnv,
+    rateLimitPerMinute,
+    maxContextPages,
+    ...trimmedPrompt === "" ? {} : { systemPrompt: trimmedPrompt }
+  });
+}
+
+// src/core/search.ts
+var K1 = 1.2;
+var B = 0.75;
+var TITLE_BONUS = 1;
+var SECTION_BONUS = 0.5;
+var PREFIX_WEIGHT = 0.4;
+var STOPWORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "but",
+  "by",
+  "can",
+  "do",
+  "does",
+  "for",
+  "from",
+  "get",
+  "has",
+  "have",
+  "how",
+  "i",
+  "if",
+  "in",
+  "is",
+  "it",
+  "its",
+  "me",
+  "my",
+  "need",
+  "no",
+  "not",
+  "of",
+  "on",
+  "or",
+  "our",
+  "should",
+  "so",
+  "that",
+  "the",
+  "their",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "to",
+  "up",
+  "us",
+  "want",
+  "was",
+  "we",
+  "what",
+  "when",
+  "where",
+  "which",
+  "who",
+  "why",
+  "will",
+  "with",
+  "would",
+  "you",
+  "your"
+]);
+var DOUBLED_CONSONANT = /([bcdfghjklmnpqrstvz])\1$/;
+function stem(token) {
+  let word = token;
+  if (word.length >= 5 && word.endsWith("ies")) {
+    word = `${word.slice(0, -3)}y`;
+  } else if (word.length >= 5 && /(?:ss|sh|ch|x|z)es$/.test(word)) {
+    word = word.slice(0, -2);
+  } else if (word.length >= 4 && word.endsWith("s") && !word.endsWith("ss") && !word.endsWith("us") && // Protect -is singulars (analysis, basis), but only long ones: a short
+  // word ending in -is is far more likely a plural like `apis` or `uris`.
+  !(word.endsWith("is") && word.length >= 6)) {
+    word = word.slice(0, -1);
+  }
+  if (word.length >= 6 && word.endsWith("ing")) {
+    word = word.slice(0, -3).replace(DOUBLED_CONSONANT, "$1");
+  } else if (word.length >= 5 && word.endsWith("ed")) {
+    word = word.slice(0, -2).replace(DOUBLED_CONSONANT, "$1");
+  }
+  if (word.length >= 7 && word.endsWith("ation")) {
+    word = `${word.slice(0, -5)}ate`;
+  }
+  if (word.length >= 7 && word.endsWith("ate")) {
+    word = word.slice(0, -3);
+  }
+  if (word.length >= 5 && word.endsWith("e")) {
+    word = word.slice(0, -1);
+  }
+  return word;
+}
+function tokenize(text) {
+  return text.toLowerCase().match(/[a-z0-9]+/g) ?? [];
+}
+function stemmedTokens(text) {
+  return tokenize(text).map(stem);
+}
+function buildSearchIndex(documents) {
+  const documentFrequency = {};
+  let totalLength = 0;
+  const indexed = documents.map((doc) => {
+    const tokens = stemmedTokens(`${doc.title} ${doc.section ?? ""} ${doc.body ?? ""}`);
+    const terms = {};
+    for (const token of tokens) {
+      terms[token] = (terms[token] ?? 0) + 1;
+    }
+    for (const term of Object.keys(terms)) {
+      documentFrequency[term] = (documentFrequency[term] ?? 0) + 1;
+    }
+    totalLength += tokens.length;
+    return {
+      id: doc.id,
+      title: doc.title,
+      path: doc.path,
+      terms,
+      length: tokens.length,
+      titleTerms: [...new Set(stemmedTokens(doc.title))],
+      ...doc.section !== void 0 ? { section: doc.section, sectionTerms: [...new Set(stemmedTokens(doc.section))] } : {}
+    };
+  });
+  return {
+    documents: indexed,
+    documentFrequency,
+    vocabulary: Object.keys(documentFrequency).sort(),
+    averageLength: indexed.length > 0 ? totalLength / indexed.length : 0
+  };
+}
+function inverseDocumentFrequency(documentCount, withTerm) {
+  return Math.max(0.05, Math.log(1 + (documentCount - withTerm + 0.5) / (withTerm + 0.5)));
+}
+function queryTerms(query) {
+  const tokens = tokenize(query);
+  const meaningful = tokens.filter((token) => !STOPWORDS.has(token) && token.length > 1);
+  return (meaningful.length > 0 ? meaningful : tokens).map(stem);
+}
+function lowerBound(vocabulary, prefix) {
+  let low = 0;
+  let high = vocabulary.length;
+  while (low < high) {
+    const mid = low + high >> 1;
+    if ((vocabulary[mid] ?? "") < prefix) {
+      low = mid + 1;
+    } else {
+      high = mid;
+    }
+  }
+  return low;
+}
+function termsWithPrefix(vocabulary, prefix) {
+  const matches = [];
+  for (let at = lowerBound(vocabulary, prefix); at < vocabulary.length; at++) {
+    const term = vocabulary[at] ?? "";
+    if (!term.startsWith(prefix)) {
+      break;
+    }
+    matches.push(term);
+  }
+  return matches;
+}
+function collectPrefixStats(index, unmatchedTerms) {
+  const stats = /* @__PURE__ */ new Map();
+  for (const term of unmatchedTerms) {
+    const matching = termsWithPrefix(index.vocabulary, term);
+    const frequencyByDocument = /* @__PURE__ */ new Map();
+    if (matching.length > 0) {
+      index.documents.forEach((doc, position) => {
+        let frequency = 0;
+        for (const match of matching) {
+          frequency += doc.terms[match] ?? 0;
+        }
+        if (frequency > 0) {
+          frequencyByDocument.set(position, frequency);
+        }
+      });
+    }
+    stats.set(term, { frequencyByDocument, documentsWithPrefix: frequencyByDocument.size });
+  }
+  return stats;
+}
+function compareStrings(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function searchIndex(index, query, limit = 8) {
+  const terms = queryTerms(query);
+  if (terms.length === 0 || index.documents.length === 0) {
+    return [];
+  }
+  const documentCount = index.documents.length;
+  const unmatched = terms.filter(
+    (term) => term.length >= 2 && (index.documentFrequency[term] ?? 0) === 0
+  );
+  const prefixStats = unmatched.length > 0 ? collectPrefixStats(index, unmatched) : void 0;
+  const results = [];
+  index.documents.forEach((doc, position) => {
+    const lengthNorm = 1 - B + B * (index.averageLength > 0 ? doc.length / index.averageLength : 1);
+    let score = 0;
+    for (const term of terms) {
+      const exactDocuments = index.documentFrequency[term] ?? 0;
+      let frequency;
+      let idf;
+      let weight;
+      let inTitle;
+      let inSection;
+      if (exactDocuments > 0) {
+        frequency = doc.terms[term] ?? 0;
+        idf = inverseDocumentFrequency(documentCount, exactDocuments);
+        weight = 1;
+        inTitle = doc.titleTerms.includes(term);
+        inSection = doc.sectionTerms?.includes(term) ?? false;
+      } else {
+        const stats = prefixStats?.get(term);
+        if (stats === void 0 || stats.documentsWithPrefix === 0) {
+          continue;
+        }
+        frequency = stats.frequencyByDocument.get(position) ?? 0;
+        idf = inverseDocumentFrequency(documentCount, stats.documentsWithPrefix);
+        weight = PREFIX_WEIGHT;
+        inTitle = doc.titleTerms.some((titleTerm) => titleTerm.startsWith(term));
+        inSection = doc.sectionTerms?.some((sectionTerm) => sectionTerm.startsWith(term)) ?? false;
+      }
+      if (frequency > 0) {
+        score += weight * idf * (frequency * (K1 + 1) / (frequency + K1 * lengthNorm));
+      }
+      if (inTitle) {
+        score += weight * idf * TITLE_BONUS;
+      }
+      if (inSection) {
+        score += weight * idf * SECTION_BONUS;
+      }
+    }
+    if (score > 0) {
+      results.push({
+        id: doc.id,
+        title: doc.title,
+        path: doc.path,
+        score,
+        ...doc.section !== void 0 ? { section: doc.section } : {}
+      });
+    }
+  });
+  results.sort(
+    (a, b) => b.score - a.score || compareStrings(a.title, b.title) || compareStrings(a.path, b.path)
+  );
+  return results.slice(0, limit);
+}
+
+// src/core/rate-limit.ts
+var SWEEP_THRESHOLD = 5e3;
+var RATE_LIMIT_WINDOW_MS = 6e4;
+function clientRateLimitKey(request) {
+  const forwarded = request.headers.get("x-forwarded-for");
+  const first = forwarded?.split(",")[0]?.trim() ?? "";
+  if (first !== "") {
+    return first;
+  }
+  const realIp = request.headers.get("x-real-ip")?.trim() ?? "";
+  return realIp === "" ? "unknown" : realIp;
+}
+function createRateLimiter(options) {
+  const now = options.now ?? (() => Date.now());
+  const hits = /* @__PURE__ */ new Map();
+  function prune(timestamps, cutoff) {
+    return timestamps.filter((at) => at > cutoff);
+  }
+  function sweep(cutoff) {
+    for (const [key, timestamps] of hits) {
+      const fresh = prune(timestamps, cutoff);
+      if (fresh.length === 0) {
+        hits.delete(key);
+      } else {
+        hits.set(key, fresh);
+      }
+    }
+  }
+  return {
+    allow(key) {
+      const at = now();
+      const cutoff = at - options.windowMs;
+      if (hits.size > SWEEP_THRESHOLD) {
+        sweep(cutoff);
+      }
+      const timestamps = prune(hits.get(key) ?? [], cutoff);
+      if (timestamps.length >= options.limit) {
+        hits.set(key, timestamps);
+        const oldest = timestamps[0] ?? at;
+        const waitMs = oldest + options.windowMs - at;
+        return { allowed: false, retryAfterSeconds: Math.max(1, Math.ceil(waitMs / 1e3)) };
+      }
+      timestamps.push(at);
+      hits.set(key, timestamps);
+      return { allowed: true };
+    }
+  };
+}
+
+// src/core/ai/prompt.ts
+var RULES = [
+  "Answer only from the documentation below. Never use outside knowledge, and never guess.",
+  "When the documentation does not answer the question, say so plainly and name what is missing. Do not invent an answer.",
+  "Never invent a URL, an endpoint, a parameter, a field name, or a value. Copy them exactly from the documentation.",
+  "The pages are ordered best-match first. Prefer the most relevant page, but combine pages when the answer spans them \u2014 for example an endpoint page and its related guide.",
+  "The pages are re-retrieved for every question, so earlier turns in this conversation may have used pages that are not shown now. Never call an earlier answer wrong just because its page is absent here.",
+  "A page ending in [content truncated] has more on the site. If the answer may sit in the missing part, say so and point the reader to that page.",
+  "Be concise. Answer the question first, then add only the detail that matters.",
+  "Use Markdown: short paragraphs, lists where they help, and fenced code blocks for code.",
+  "Refer to a page by its title, in the sentence, where it helps the reader go deeper.",
+  "Reply in the language the reader used."
+];
+function renderPage(page, position) {
+  return [
+    `=== PAGE ${String(position)}: ${page.title} (${page.url}) ===`,
+    page.markdown,
+    `=== END PAGE ${String(position)} ===`
+  ].join("\n");
+}
+function buildSystemPrompt(options) {
+  const sections = [
+    `You are the documentation assistant for ${options.siteName}. You answer questions about ${options.siteName} using its documentation.`,
+    RULES.map((rule) => `- ${rule}`).join("\n")
+  ];
+  if (options.pages.length === 0) {
+    sections.push(
+      "DOCUMENTATION\n\nNo documentation page matched this question. Tell the reader you cannot find it in the documentation, and suggest they rephrase the question or use the search box."
+    );
+  } else {
+    sections.push(
+      [
+        "DOCUMENTATION",
+        `The following ${String(options.pages.length)} ${options.pages.length === 1 ? "page is" : "pages are"} the only source you may use.`,
+        options.pages.map((page, position) => renderPage(page, position + 1)).join("\n\n")
+      ].join("\n\n")
+    );
+  }
+  const extra = options.extraInstructions?.trim() ?? "";
+  if (extra !== "") {
+    sections.push(`ADDITIONAL INSTRUCTIONS FROM THIS SITE
+
+${extra}`);
+  }
+  return sections.join("\n\n");
+}
+
+// src/core/ai/providers/error.ts
+var MAX_MESSAGE_CHARS = 300;
+var SECRET_PATTERNS = [
+  /sk-[A-Za-z0-9_*-]{6,}/g,
+  /\bBearer\s+[A-Za-z0-9._-]{8,}/gi
+];
+function redactSecrets(text) {
+  return SECRET_PATTERNS.reduce((masked, pattern) => masked.replace(pattern, "[redacted]"), text);
+}
+function messageFromJson(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return void 0;
+  }
+  const record = payload;
+  const error = record["error"];
+  if (typeof error === "string" && error.trim() !== "") {
+    return error;
+  }
+  if (typeof error === "object" && error !== null) {
+    const errorRecord = error;
+    for (const key of ["message", "type", "code"]) {
+      const value = errorRecord[key];
+      if (typeof value === "string" && value.trim() !== "") {
+        return value;
+      }
+    }
+  }
+  const message = record["message"];
+  return typeof message === "string" && message.trim() !== "" ? message : void 0;
+}
+function shorten(text) {
+  return text.length > MAX_MESSAGE_CHARS ? `${text.slice(0, MAX_MESSAGE_CHARS - 1)}\u2026` : text;
+}
+async function readProviderError(response, providerLabel) {
+  const statusLine = `${providerLabel} refused the request: ${String(response.status)} ${response.statusText === "" ? "error" : response.statusText}.`;
+  let raw;
+  try {
+    raw = (await response.text()).trim();
+  } catch {
+    return statusLine;
+  }
+  if (raw === "" || raw.startsWith("<") || raw.length > 4e3) {
+    return statusLine;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    parsed = void 0;
+  }
+  const message = messageFromJson(parsed);
+  if (message === void 0) {
+    return raw.length > MAX_MESSAGE_CHARS ? statusLine : `${providerLabel} refused the request: ${redactSecrets(shorten(raw.replace(/\s+/g, " ")))}`;
+  }
+  return `${providerLabel} refused the request: ${redactSecrets(shorten(message.replace(/\s+/g, " ")))}`;
+}
+
+// src/core/ai/providers/sse.ts
+function takeLine(buffer) {
+  const match = /\r\n|\n|\r/.exec(buffer);
+  if (match === null) {
+    return null;
+  }
+  if (match[0] === "\r" && match.index + 1 === buffer.length) {
+    return null;
+  }
+  return {
+    line: buffer.slice(0, match.index),
+    rest: buffer.slice(match.index + match[0].length)
+  };
+}
+var FrameBuilder = class {
+  event;
+  data = [];
+  /** Apply one non-blank line. */
+  add(line) {
+    if (line.startsWith(":")) {
+      return;
+    }
+    const colon = line.indexOf(":");
+    const field = colon === -1 ? line : line.slice(0, colon);
+    const rawValue = colon === -1 ? "" : line.slice(colon + 1);
+    const value = rawValue.startsWith(" ") ? rawValue.slice(1) : rawValue;
+    if (field === "event") {
+      this.event = value;
+    } else if (field === "data") {
+      this.data.push(value);
+    }
+  }
+  /** Take the pending frame, or `null` when nothing has accumulated. */
+  take() {
+    if (this.event === void 0 && this.data.length === 0) {
+      return null;
+    }
+    const frame = { event: this.event, data: this.data.join("\n") };
+    this.event = void 0;
+    this.data = [];
+    return frame;
+  }
+};
+async function* readSseFrames(body) {
+  if (body === null) {
+    return;
+  }
+  const reader = body.getReader();
+  const decoder2 = new TextDecoder();
+  const builder = new FrameBuilder();
+  let buffer = "";
+  try {
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) {
+        break;
+      }
+      buffer += decoder2.decode(value, { stream: true });
+      for (; ; ) {
+        const taken = takeLine(buffer);
+        if (taken === null) {
+          break;
+        }
+        buffer = taken.rest;
+        if (taken.line === "") {
+          const frame = builder.take();
+          if (frame !== null) {
+            yield frame;
+          }
+        } else {
+          builder.add(taken.line);
+        }
+      }
+    }
+    buffer += decoder2.decode();
+    if (buffer !== "") {
+      builder.add(buffer);
+    }
+    const last = builder.take();
+    if (last !== null) {
+      yield last;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+function parseFrameData(data) {
+  if (data === "") {
+    return void 0;
+  }
+  try {
+    return JSON.parse(data);
+  } catch {
+    return void 0;
+  }
+}
+function frameEventType(frame, payload) {
+  if (frame.event !== void 0 && frame.event !== "") {
+    return frame.event;
+  }
+  if (typeof payload === "object" && payload !== null) {
+    const type = payload["type"];
+    if (typeof type === "string" && type !== "") {
+      return type;
+    }
+  }
+  return void 0;
+}
+
+// src/core/ai/providers/anthropic.ts
+var MESSAGES_URL = "https://api.anthropic.com/v1/messages";
+var API_VERSION = "2023-06-01";
+var PROVIDER_LABEL = "Anthropic";
+function requestBody(request, model) {
+  return JSON.stringify({
+    model,
+    max_tokens: request.maxOutputTokens,
+    system: request.system,
+    messages: request.messages.map((message) => ({
+      role: message.role,
+      content: message.content
+    })),
+    stream: true
+  });
+}
+function textDelta(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return void 0;
+  }
+  const delta = payload["delta"];
+  if (typeof delta !== "object" || delta === null) {
+    return void 0;
+  }
+  const record = delta;
+  if (record["type"] !== "text_delta") {
+    return void 0;
+  }
+  const text = record["text"];
+  return typeof text === "string" ? text : void 0;
+}
+function errorMessage(payload) {
+  if (typeof payload === "object" && payload !== null) {
+    const error = payload["error"];
+    if (typeof error === "object" && error !== null) {
+      const message = error["message"];
+      if (typeof message === "string" && message.trim() !== "") {
+        return message;
+      }
+    }
+  }
+  return "The Anthropic stream failed.";
+}
+function createAnthropicProvider(options) {
+  const doFetch = options.fetch ?? ((url, init) => fetch(url, init));
+  return {
+    async *stream(request) {
+      let response;
+      try {
+        response = await doFetch(MESSAGES_URL, {
+          method: "POST",
+          headers: {
+            "x-api-key": options.apiKey,
+            "anthropic-version": API_VERSION,
+            "content-type": "application/json"
+          },
+          body: requestBody(request, options.model),
+          ...request.signal ? { signal: request.signal } : {}
+        });
+      } catch {
+        yield { type: "error", message: `Could not reach ${PROVIDER_LABEL}.` };
+        return;
+      }
+      if (!response.ok) {
+        yield { type: "error", message: await readProviderError(response, PROVIDER_LABEL) };
+        return;
+      }
+      for await (const frame of readSseFrames(response.body)) {
+        const payload = parseFrameData(frame.data);
+        const type = frameEventType(frame, payload);
+        if (type === "error") {
+          yield { type: "error", message: errorMessage(payload) };
+          return;
+        }
+        if (type === "message_stop") {
+          yield { type: "done" };
+          return;
+        }
+        if (type === "content_block_delta") {
+          const text = textDelta(payload);
+          if (text !== void 0 && text !== "") {
+            yield { type: "text", text };
+          }
+        }
+      }
+      yield { type: "done" };
+    }
+  };
+}
+
+// src/core/ai/providers/openai.ts
+var RESPONSES_URL = "https://api.openai.com/v1/responses";
+var PROVIDER_LABEL2 = "OpenAI";
+function requestBody2(request, model) {
+  return JSON.stringify({
+    model,
+    instructions: request.system,
+    input: request.messages.map((message) => ({
+      role: message.role,
+      content: message.content
+    })),
+    stream: true,
+    max_output_tokens: request.maxOutputTokens
+  });
+}
+function textDelta2(payload) {
+  if (typeof payload !== "object" || payload === null) {
+    return void 0;
+  }
+  const delta = payload["delta"];
+  return typeof delta === "string" ? delta : void 0;
+}
+function errorMessage2(payload) {
+  if (typeof payload === "object" && payload !== null) {
+    const record = payload;
+    const response = record["response"];
+    if (typeof response === "object" && response !== null) {
+      const error = response["error"];
+      if (typeof error === "object" && error !== null) {
+        const message = error["message"];
+        if (typeof message === "string" && message.trim() !== "") {
+          return message;
+        }
+      }
+    }
+    for (const key of ["message", "code"]) {
+      const value = record[key];
+      if (typeof value === "string" && value.trim() !== "") {
+        return value;
+      }
+    }
+  }
+  return "The OpenAI stream failed.";
+}
+function createOpenAiProvider(options) {
+  const doFetch = options.fetch ?? ((url, init) => fetch(url, init));
+  return {
+    async *stream(request) {
+      let response;
+      try {
+        response = await doFetch(RESPONSES_URL, {
+          method: "POST",
+          headers: {
+            authorization: `Bearer ${options.apiKey}`,
+            "content-type": "application/json"
+          },
+          body: requestBody2(request, options.model),
+          ...request.signal ? { signal: request.signal } : {}
+        });
+      } catch {
+        yield { type: "error", message: `Could not reach ${PROVIDER_LABEL2}.` };
+        return;
+      }
+      if (!response.ok) {
+        yield { type: "error", message: await readProviderError(response, PROVIDER_LABEL2) };
+        return;
+      }
+      for await (const frame of readSseFrames(response.body)) {
+        const payload = parseFrameData(frame.data);
+        const type = frameEventType(frame, payload);
+        if (type === "error" || type === "response.failed") {
+          yield { type: "error", message: errorMessage2(payload) };
+          return;
+        }
+        if (type === "response.completed" || type === "response.incomplete") {
+          yield { type: "done" };
+          return;
+        }
+        if (type === "response.output_text.delta") {
+          const text = textDelta2(payload);
+          if (text !== void 0 && text !== "") {
+            yield { type: "text", text };
+          }
+        }
+      }
+      yield { type: "done" };
+    }
+  };
+}
+
+// src/core/ai/retrieval.ts
+var PAGE_CHAR_BUDGET = 8e3;
+var MIN_USEFUL_CHARS = 400;
+var TRUNCATION_MARKER = "\n\n[content truncated]";
+var PRIOR_TURN_CHAR_CAP = 300;
+function buildRetrievalQuery(messages) {
+  const userTurns = messages.filter((message) => message.role === "user");
+  const newest = userTurns.at(-1)?.content ?? "";
+  const prior = userTurns.slice(0, -1).slice(-2).map((turn) => turn.content.slice(0, PRIOR_TURN_CHAR_CAP));
+  return [...prior, newest].join("\n").trim();
+}
+function truncate(text, budget) {
+  if (text.length <= budget) {
+    return text;
+  }
+  const room = budget - TRUNCATION_MARKER.length;
+  const slice = text.slice(0, room);
+  const lastBreak = slice.lastIndexOf("\n");
+  const cut = lastBreak >= Math.floor(room / 2) ? slice.slice(0, lastBreak) : slice;
+  return `${cut}${TRUNCATION_MARKER}`;
+}
+async function selectContext(options) {
+  const hits = searchIndex(options.index, options.query, options.maxPages);
+  if (hits.length === 0) {
+    return [];
+  }
+  const bodyByPath = /* @__PURE__ */ new Map();
+  for (const document of options.documents) {
+    if (document.body !== void 0 && document.body !== "") {
+      bodyByPath.set(document.path, document.body);
+    }
+  }
+  const pages = [];
+  const seen = /* @__PURE__ */ new Set();
+  let used = 0;
+  const totalBudget = options.maxPages * PAGE_CHAR_BUDGET;
+  for (const hit of hits) {
+    if (seen.has(hit.path)) {
+      continue;
+    }
+    seen.add(hit.path);
+    const remaining = totalBudget - used;
+    if (remaining < MIN_USEFUL_CHARS) {
+      break;
+    }
+    const loaded = await options.loadMarkdown(hit.path);
+    const source = loaded !== null && loaded.trim() !== "" ? loaded : bodyByPath.get(hit.path);
+    if (source === void 0 || source.trim() === "") {
+      continue;
+    }
+    const markdown = truncate(source.trim(), Math.min(PAGE_CHAR_BUDGET, remaining));
+    used += markdown.length;
+    pages.push({ url: hit.path, title: hit.title, markdown });
+  }
+  return pages;
+}
+
+// src/core/ai/route.ts
+var DEFAULT_MAX_OUTPUT_TOKENS = 2048;
+var MAX_MESSAGES = 20;
+var MAX_CONTENT_CHARS = 4e3;
+function readProcessEnv(name) {
+  const runtime = globalThis;
+  return runtime.process?.env?.[name];
+}
+function jsonResponse(status, payload, headers = {}) {
+  return new Response(JSON.stringify(payload), {
+    status,
+    headers: { "content-type": "application/json", "cache-control": "no-store", ...headers }
+  });
+}
+function parseMessages(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    return { error: "Request body must be a JSON object." };
+  }
+  const raw = value["messages"];
+  if (!Array.isArray(raw)) {
+    return { error: 'Request body must include a "messages" array.' };
+  }
+  if (raw.length === 0) {
+    return { error: "messages must contain at least one message." };
+  }
+  if (raw.length > MAX_MESSAGES) {
+    return {
+      error: `messages must contain ${String(MAX_MESSAGES)} messages or fewer, got ${String(raw.length)}.`
+    };
+  }
+  const messages = [];
+  for (const [position, entry] of raw.entries()) {
+    const at = `messages[${String(position)}]`;
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      return { error: `${at} must be an object with "role" and "content".` };
+    }
+    const record = entry;
+    const role = record["role"];
+    if (role !== "user" && role !== "assistant") {
+      return { error: `${at}.role must be 'user' or 'assistant'.` };
+    }
+    const content = record["content"];
+    if (typeof content !== "string") {
+      return { error: `${at}.content must be a string.` };
+    }
+    if (content.trim() === "") {
+      return { error: `${at}.content must not be empty.` };
+    }
+    if (content.length > MAX_CONTENT_CHARS) {
+      return {
+        error: `${at}.content must be ${String(MAX_CONTENT_CHARS)} characters or fewer, got ${String(content.length)}.`
+      };
+    }
+    messages.push({ role, content });
+  }
+  if (messages.at(-1)?.role !== "user") {
+    return { error: `The last message must have role 'user'.` };
+  }
+  return { messages };
+}
+function createProvider(resolved, apiKey, doFetch) {
+  const providerOptions = {
+    apiKey,
+    model: resolved.model,
+    ...doFetch ? { fetch: doFetch } : {}
+  };
+  return resolved.provider === "anthropic" ? createAnthropicProvider(providerOptions) : createOpenAiProvider(providerOptions);
+}
+function createAskAiRoute(options) {
+  const resolved = resolveAiConfig(options.config);
+  if (typeof options.siteName !== "string" || options.siteName.trim() === "") {
+    throw new AiConfigError("siteName must be a non-empty string, e.g. theme.name.");
+  }
+  if (typeof options.loadPageMarkdown !== "function") {
+    throw new AiConfigError(
+      "loadPageMarkdown must be a function that returns a page's Markdown, or null."
+    );
+  }
+  const documentsSource = options.documents;
+  if (!Array.isArray(documentsSource) && typeof documentsSource !== "function") {
+    throw new AiConfigError(
+      "documents must be an array of SearchDocument, or a function returning one."
+    );
+  }
+  const readEnv = options.env ?? readProcessEnv;
+  const maxOutputTokens = options.maxOutputTokens ?? DEFAULT_MAX_OUTPUT_TOKENS;
+  const limiter = createRateLimiter({
+    limit: resolved.rateLimitPerMinute,
+    windowMs: RATE_LIMIT_WINDOW_MS,
+    ...options.now ? { now: options.now } : {}
+  });
+  let corpus;
+  function loadCorpus() {
+    if (corpus === void 0) {
+      const pending = (async () => {
+        const documents = typeof documentsSource === "function" ? await documentsSource() : documentsSource;
+        return { documents, index: buildSearchIndex(documents) };
+      })();
+      void pending.catch(() => {
+        if (corpus === pending) {
+          corpus = void 0;
+        }
+      });
+      corpus = pending;
+    }
+    return corpus;
+  }
+  const encoder2 = new TextEncoder();
+  function streamAnswer(provider, system, messages, sources, upstream) {
+    return new ReadableStream({
+      async start(controller) {
+        let open = true;
+        const send = (event, data) => {
+          if (!open) {
+            return;
+          }
+          try {
+            controller.enqueue(
+              encoder2.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`)
+            );
+          } catch {
+            open = false;
+          }
+        };
+        send("sources", sources);
+        let closed = false;
+        try {
+          for await (const event of provider.stream({
+            system,
+            messages,
+            maxOutputTokens,
+            signal: upstream.signal
+          })) {
+            if (event.type === "text") {
+              send("text", { text: event.text });
+              continue;
+            }
+            if (event.type === "error") {
+              send("error", { message: event.message });
+            } else {
+              send("done", {});
+            }
+            closed = true;
+            break;
+          }
+          if (!closed) {
+            send("done", {});
+          }
+        } catch {
+          send("error", { message: "The answer stream stopped unexpectedly." });
+        }
+        open = false;
+        try {
+          controller.close();
+        } catch {
+        }
+      },
+      cancel() {
+        upstream.abort();
+      }
+    });
+  }
+  return {
+    async POST(request) {
+      let body;
+      try {
+        body = await request.json();
+      } catch {
+        return jsonResponse(400, { error: "Request body must be JSON." });
+      }
+      const parsed = parseMessages(body);
+      if ("error" in parsed) {
+        return jsonResponse(400, { error: parsed.error });
+      }
+      const decision = limiter.allow(clientRateLimitKey(request));
+      if (!decision.allowed) {
+        const retryAfter = decision.retryAfterSeconds ?? 60;
+        return jsonResponse(
+          429,
+          {
+            error: `Too many questions. Try again in ${String(retryAfter)} seconds.`,
+            retryAfterSeconds: retryAfter
+          },
+          { "retry-after": String(retryAfter) }
+        );
+      }
+      const apiKey = (options.apiKey ?? readEnv(resolved.apiKeyEnv) ?? "").trim();
+      if (apiKey === "") {
+        return jsonResponse(500, {
+          error: `Ask AI is not configured: set the ${resolved.apiKeyEnv} environment variable on the server.`
+        });
+      }
+      let pages;
+      try {
+        const { documents, index } = await loadCorpus();
+        pages = await selectContext({
+          index,
+          documents,
+          query: buildRetrievalQuery(parsed.messages),
+          maxPages: resolved.maxContextPages,
+          loadMarkdown: options.loadPageMarkdown
+        });
+      } catch {
+        return jsonResponse(500, {
+          error: "Ask AI could not read the documentation for this site."
+        });
+      }
+      const system = buildSystemPrompt({
+        siteName: options.siteName,
+        pages,
+        ...resolved.systemPrompt === void 0 ? {} : { extraInstructions: resolved.systemPrompt }
+      });
+      const sources = pages.map((page) => ({ url: page.url, title: page.title }));
+      const upstream = new AbortController();
+      const clientSignal = request.signal;
+      if (clientSignal !== void 0) {
+        if (clientSignal.aborted) {
+          upstream.abort();
+        } else {
+          clientSignal.addEventListener(
+            "abort",
+            () => {
+              upstream.abort();
+            },
+            { once: true }
+          );
+        }
+      }
+      const provider = createProvider(resolved, apiKey, options.fetch);
+      return new Response(streamAnswer(provider, system, parsed.messages, sources, upstream), {
+        headers: {
+          "content-type": "text/event-stream; charset=utf-8",
+          "cache-control": "no-store",
+          connection: "keep-alive",
+          // Tell a buffering reverse proxy to pass the stream straight through.
+          "x-accel-buffering": "no"
+        }
+      });
+    }
+  };
+}
+
+// src/core/config.ts
+var DocsConfigError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DocsConfigError";
+  }
+};
+var MIN_PROXY_RATE_LIMIT = 1;
+var MAX_PROXY_RATE_LIMIT = 6e3;
+var MIN_SESSION_TTL_SECONDS = 60;
+var MAX_SESSION_TTL_SECONDS = 2592e3;
+var PALETTE_KEYS = [
+  "primary",
+  "background",
+  "foreground",
+  "card",
+  "border",
+  "muted"
+];
+function describe2(value) {
+  if (typeof value === "string") {
+    return `'${value}'`;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || value === null) {
+    return String(value);
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  return Array.isArray(value) ? "an array" : `a ${typeof value}`;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireObject(value, field, example) {
+  if (!isPlainObject(value)) {
+    throw new DocsConfigError(`${field} must be an object, got ${describe2(value)}. ${example}`);
+  }
+  return value;
+}
+function optionalObject(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isPlainObject(value)) {
+    throw new DocsConfigError(
+      `${field} must be an object, got ${describe2(value)}. Remove the field to leave it unset.`
+    );
+  }
+  return value;
+}
+function requireString(value, field, example) {
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new DocsConfigError(
+      `${field} must be a non-empty string, got ${describe2(value)}. ${example}`
+    );
+  }
+  return value;
+}
+function optionalString(value, field) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new DocsConfigError(
+      `${field} must be a non-empty string, got ${describe2(value)}. Remove the field to use the default.`
+    );
+  }
+  return value;
+}
+function optionalBoolean(value, field) {
+  if (value !== void 0 && typeof value !== "boolean") {
+    throw new DocsConfigError(`${field} must be true or false, got ${describe2(value)}.`);
+  }
+}
+function optionalIntegerInRange(value, field, min, max) {
+  if (value === void 0) {
+    return;
+  }
+  if (typeof value !== "number" || !Number.isInteger(value) || value < min || value > max) {
+    throw new DocsConfigError(
+      `${field} must be an integer between ${String(min)} and ${String(max)}, got ${describe2(value)}.`
+    );
+  }
+}
+function optionalPath(value, field) {
+  const path = optionalString(value, field);
+  if (path !== void 0 && !path.startsWith("/")) {
+    throw new DocsConfigError(
+      `${field} must start with '/', got ${describe2(path)}. Example: '/signin'.`
+    );
+  }
+}
+function requireStringArray(value, field, options) {
+  if (!Array.isArray(value)) {
+    throw new DocsConfigError(
+      `${field} must be an array, got ${describe2(value)}. ${options.example}`
+    );
+  }
+  if (value.length < options.minLength) {
+    throw new DocsConfigError(
+      `${field} must contain at least ${String(options.minLength)} entry, got an empty array. ${options.example}`
+    );
+  }
+  return value.map(
+    (entry, index) => requireString(entry, `${field}[${String(index)}]`, options.example)
+  );
+}
+function validatePalette(value, field) {
+  const palette = optionalObject(value, field);
+  if (palette === void 0) {
+    return;
+  }
+  for (const key of PALETTE_KEYS) {
+    optionalString(palette[key], `${field}.${key}`);
+  }
+}
+function validateTheme(value) {
+  const theme = requireObject(value, "theme", "Example: theme: { name: 'Example Docs' }.");
+  requireString(theme["name"], "theme.name", "Example: theme: { name: 'Example Docs' }.");
+  const logo = optionalObject(theme["logo"], "theme.logo");
+  if (logo !== void 0) {
+    requireString(logo["light"], "theme.logo.light", "Example: '/logo-light.png'.");
+    requireString(logo["dark"], "theme.logo.dark", "Example: '/logo-dark.png'.");
+  }
+  optionalString(theme["favicon"], "theme.favicon");
+  validatePalette(theme["colors"], "theme.colors");
+  validatePalette(theme["darkColors"], "theme.darkColors");
+}
+function validateWorkspaceProviders(value) {
+  const providers = requireObject(value, "auth.providers", "Example: providers: { email: true }.");
+  optionalBoolean(providers["email"], "auth.providers.email");
+  const secret = optionalObject(providers["secret"], "auth.providers.secret");
+  if (secret !== void 0) {
+    optionalString(secret["secretEnv"], "auth.providers.secret.secretEnv");
+  }
+  const google = optionalObject(providers["google"], "auth.providers.google");
+  if (google !== void 0) {
+    optionalString(google["clientIdEnv"], "auth.providers.google.clientIdEnv");
+    optionalString(google["clientSecretEnv"], "auth.providers.google.clientSecretEnv");
+    optionalPath(google["redirectPath"], "auth.providers.google.redirectPath");
+  }
+  if (providers["email"] !== true && secret === void 0 && google === void 0) {
+    throw new DocsConfigError(
+      "auth.providers must enable at least one provider: 'email', 'secret', or 'google'. Example: providers: { email: true }."
+    );
+  }
+}
+function validateAuth(value) {
+  if (value === "public") {
+    return;
+  }
+  if (!isPlainObject(value)) {
+    throw new DocsConfigError(
+      `auth must be 'public' or a workspace configuration object, got ${describe2(value)}. Example: auth: 'public'.`
+    );
+  }
+  const mode = value["mode"];
+  if (mode !== "workspace") {
+    throw new DocsConfigError(`auth.mode must be 'workspace', got ${describe2(mode)}.`);
+  }
+  const domains = requireStringArray(value["allowedDomains"], "auth.allowedDomains", {
+    minLength: 1,
+    example: "Example: allowedDomains: ['example.com']."
+  });
+  for (const [index, domain] of domains.entries()) {
+    if (domain.includes("@") || !domain.includes(".") || /\s/.test(domain)) {
+      throw new DocsConfigError(
+        `auth.allowedDomains[${String(index)}] must be a bare domain like 'example.com', got ${describe2(domain)}.`
+      );
+    }
+  }
+  validateWorkspaceProviders(value["providers"]);
+  optionalPath(value["signInPath"], "auth.signInPath");
+  optionalString(value["sessionSecretEnv"], "auth.sessionSecretEnv");
+  optionalIntegerInRange(
+    value["sessionTtlSeconds"],
+    "auth.sessionTtlSeconds",
+    MIN_SESSION_TTL_SECONDS,
+    MAX_SESSION_TTL_SECONDS
+  );
+  optionalBoolean(value["secureCookies"], "auth.secureCookies");
+}
+function validateProxy(value) {
+  const proxy = requireObject(value, "proxy", "Example: proxy: { allowedOrigins: [] }.");
+  const origins = requireStringArray(proxy["allowedOrigins"], "proxy.allowedOrigins", {
+    minLength: 0,
+    example: "Example: allowedOrigins: ['https://api.example.com']."
+  });
+  for (const [index, origin] of origins.entries()) {
+    const field = `proxy.allowedOrigins[${String(index)}]`;
+    let parsed;
+    try {
+      parsed = new URL(origin);
+    } catch {
+      throw new DocsConfigError(
+        `${field} must be an absolute origin like 'https://api.example.com', got ${describe2(origin)}.`
+      );
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new DocsConfigError(`${field} must use http or https, got ${describe2(origin)}.`);
+    }
+  }
+  optionalIntegerInRange(
+    proxy["rateLimitPerMinute"],
+    "proxy.rateLimitPerMinute",
+    MIN_PROXY_RATE_LIMIT,
+    MAX_PROXY_RATE_LIMIT
+  );
+}
+function validateFeatures(value) {
+  const features = optionalObject(value, "features");
+  if (features === void 0) {
+    return;
+  }
+  optionalBoolean(features["copyPage"], "features.copyPage");
+}
+function validateSeo(value) {
+  const seo = optionalObject(value, "seo");
+  if (seo === void 0) {
+    return;
+  }
+  const siteUrl = optionalString(seo["siteUrl"], "seo.siteUrl");
+  if (siteUrl !== void 0) {
+    let parsed;
+    try {
+      parsed = new URL(siteUrl);
+    } catch {
+      throw new DocsConfigError(
+        `seo.siteUrl must be an absolute URL like 'https://docs.example.com', got ${describe2(siteUrl)}.`
+      );
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new DocsConfigError(`seo.siteUrl must use http or https, got ${describe2(siteUrl)}.`);
+    }
+  }
+  const template = optionalString(seo["titleTemplate"], "seo.titleTemplate");
+  if (template !== void 0 && !template.includes("%s")) {
+    throw new DocsConfigError(
+      `seo.titleTemplate must contain '%s' for the page title, got ${describe2(template)}. Example: '%s | Example Docs'.`
+    );
+  }
+  optionalString(seo["description"], "seo.description");
+  optionalString(seo["ogImage"], "seo.ogImage");
+  const twitter = optionalString(seo["twitter"], "seo.twitter");
+  if (twitter !== void 0 && !twitter.startsWith("@")) {
+    throw new DocsConfigError(
+      `seo.twitter must start with '@', got ${describe2(twitter)}. Example: '@example'.`
+    );
+  }
+  if (seo["keywords"] !== void 0) {
+    requireStringArray(seo["keywords"], "seo.keywords", {
+      minLength: 0,
+      example: "Example: keywords: ['payments', 'api']."
+    });
+  }
+  optionalBoolean(seo["noindex"], "seo.noindex");
+}
+function validateDocsConfig(config) {
+  if (!isPlainObject(config)) {
+    throw new DocsConfigError(
+      `The docs configuration must be an object, got ${describe2(config)}. Export one object from docs.config.ts.`
+    );
+  }
+  validateTheme(config["theme"]);
+  validateAuth(config["auth"]);
+  validateProxy(config["proxy"]);
+  validateFeatures(config["features"]);
+  validateSeo(config["seo"]);
+  if (config["ai"] !== void 0) {
+    resolveAiConfig(config["ai"]);
+  }
+  return config;
+}
+function defineDocsConfig(config) {
+  return validateDocsConfig(config);
+}
+
+// src/core/theme.ts
+var TOKEN_TO_VAR = {
+  primary: "--color-fd-primary",
+  background: "--color-fd-background",
+  foreground: "--color-fd-foreground",
+  card: "--color-fd-card",
+  border: "--color-fd-border",
+  muted: "--color-fd-muted-foreground"
+};
+function paletteToDeclarations(palette) {
+  const parts = [];
+  for (const key of Object.keys(TOKEN_TO_VAR)) {
+    const value = palette[key];
+    if (typeof value === "string" && value.length > 0) {
+      parts.push(`${TOKEN_TO_VAR[key]}: ${value};`);
+    }
+  }
+  return parts.join(" ");
+}
+function buildThemeCss(theme) {
+  const blocks = [];
+  if (theme.colors) {
+    const light = paletteToDeclarations(theme.colors);
+    if (light.length > 0) {
+      blocks.push(`:root { ${light} }`);
+    }
+  }
+  if (theme.darkColors) {
+    const dark = paletteToDeclarations(theme.darkColors);
+    if (dark.length > 0) {
+      blocks.push(`:root.dark, .dark { ${dark} }`);
+    }
+  }
+  return blocks.join("\n");
+}
+
+// src/core/seo.ts
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function buildMetadata(config, page = {}) {
+  const name = config.theme.name;
+  const seo = config.seo ?? {};
+  const template = seo.titleTemplate ?? `%s \xB7 ${name}`;
+  const siteUrl = seo.siteUrl ? trimTrailingSlash(seo.siteUrl) : void 0;
+  const isDefault = page.title === void 0;
+  const displayTitle = isDefault ? name : template.replace("%s", page.title);
+  const description = page.description ?? seo.description;
+  const path = page.path ?? "/";
+  const ogImage = page.ogImage ?? seo.ogImage;
+  const favicon = config.theme.favicon;
+  const indexable = !(page.noindex ?? seo.noindex ?? false);
+  const keywords = [...seo.keywords ?? [], ...page.keywords ?? []];
+  return {
+    ...siteUrl ? { metadataBase: new URL(siteUrl) } : {},
+    title: isDefault ? { default: name, template } : page.title,
+    ...description ? { description } : {},
+    ...keywords.length ? { keywords } : {},
+    alternates: { canonical: path },
+    ...favicon ? { icons: { icon: favicon } } : {},
+    robots: { index: indexable, follow: indexable },
+    openGraph: {
+      type: "website",
+      siteName: name,
+      title: displayTitle,
+      ...description ? { description } : {},
+      url: path,
+      ...ogImage ? { images: [{ url: ogImage }] } : {}
+    },
+    twitter: {
+      card: ogImage ? "summary_large_image" : "summary",
+      title: displayTitle,
+      ...description ? { description } : {},
+      ...seo.twitter ? { site: seo.twitter } : {},
+      ...ogImage ? { images: [ogImage] } : {}
+    }
+  };
+}
+function buildRobots(config) {
+  const seo = config.seo ?? {};
+  const siteUrl = seo.siteUrl ? trimTrailingSlash(seo.siteUrl) : void 0;
+  const blocked = seo.noindex ?? false;
+  return {
+    rules: blocked ? { userAgent: "*", disallow: "/" } : { userAgent: "*", allow: "/", disallow: ["/signin", "/api/"] },
+    ...siteUrl && !blocked ? { sitemap: `${siteUrl}/sitemap.xml`, host: siteUrl } : {}
+  };
+}
+function buildSitemap(entries, config, options = {}) {
+  const seo = config.seo ?? {};
+  const siteUrl = seo.siteUrl ? trimTrailingSlash(seo.siteUrl) : "";
+  const changeFrequency = options.changeFrequency ?? "weekly";
+  const pagePriority = options.priority ?? 0.7;
+  const homePriority = options.homePriority ?? 1;
+  return entries.map((entry) => {
+    const path = entry.path.startsWith("/") ? entry.path : `/${entry.path}`;
+    return {
+      url: `${siteUrl}${path}`,
+      ...entry.lastModified ? { lastModified: entry.lastModified } : {},
+      changeFrequency,
+      priority: path === "/" ? homePriority : pagePriority
+    };
+  });
+}
+
+// src/core/docs-tree.ts
+function slugify(title) {
+  return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function isOpenApi(item) {
+  return item.kind === "openapi";
+}
+function hasOpenApi(items) {
+  return items.some((item) => item.kind === "group" ? hasOpenApi(item.items) : isOpenApi(item));
+}
+function basename(file) {
+  const i = file.lastIndexOf("/");
+  return i === -1 ? file : file.slice(i + 1);
+}
+function dirname(file) {
+  const i = file.lastIndexOf("/");
+  return i === -1 ? "" : file.slice(0, i);
+}
+function planDocsTree(navigation, options = {}) {
+  const apiDir = options.apiDir ?? "api";
+  const specs = [];
+  const apiPages = [];
+  const apiGroups = [];
+  const metas = [];
+  const rootPages = [];
+  for (const tab of navigation) {
+    if (hasOpenApi(tab.items)) {
+      planApiTab(tab);
+      continue;
+    }
+    planDocTab(tab);
+  }
+  metas.unshift({ path: "meta.json", content: { pages: rootPages } });
+  return { specs, apiPages, apiGroups, metas };
+  function planApiTab(tab) {
+    rootPages.push(apiDir);
+    const groupDirs = [];
+    for (const item of tab.items) {
+      if (item.kind !== "group") {
+        continue;
+      }
+      const dir = `${apiDir}/${slugify(item.title)}`;
+      groupDirs.push(slugify(item.title));
+      apiGroups.push({ dir, title: item.title });
+      let order = 0;
+      for (const page of item.items) {
+        if (page.kind !== "openapi") {
+          continue;
+        }
+        if (!specs.includes(page.file)) {
+          specs.push(page.file);
+        }
+        apiPages.push({ file: page.file, method: page.method, apiPath: page.apiPath, dir, order });
+        order += 1;
+      }
+    }
+    metas.push({
+      path: `${apiDir}/meta.json`,
+      content: {
+        title: tab.title,
+        root: true,
+        ...tab.icon ? { icon: tab.icon } : {},
+        pages: groupDirs
+      }
+    });
+  }
+  function planDocTab(tab) {
+    const directPages = tab.items.filter((item) => item.kind === "doc");
+    const groups = tab.items.filter((item) => item.kind === "group");
+    if (groups.length === 0 && directPages.every((page) => !page.file.includes("/"))) {
+      for (const page of directPages) {
+        rootPages.push(page.file);
+      }
+      return;
+    }
+    const firstFile = directPages[0]?.file ?? groups.flatMap((g) => g.items).find((item) => item.kind === "doc")?.file;
+    if (firstFile === void 0) {
+      return;
+    }
+    const tabDir = firstFile.split("/")[0] ?? "";
+    rootPages.push(tabDir);
+    const tabPages = directPages.map((page) => basename(page.file));
+    for (const group of groups) {
+      const pages = group.items.filter((item) => item.kind === "doc");
+      const groupDir = dirname(pages[0]?.file ?? "");
+      const folder = groupDir.split("/").slice(1).join("/");
+      if (folder === "") {
+        tabPages.push(...pages.map((page) => basename(page.file)));
+        continue;
+      }
+      tabPages.push(folder);
+      metas.push({
+        path: `${groupDir}/meta.json`,
+        content: { title: group.title, pages: pages.map((page) => basename(page.file)) }
+      });
+    }
+    metas.push({
+      path: `${tabDir}/meta.json`,
+      content: {
+        title: tab.title,
+        root: true,
+        ...tab.icon ? { icon: tab.icon } : {},
+        pages: tabPages
+      }
+    });
+  }
+}
+
+// src/core/openapi-markdown.ts
+var MAX_FIELD_DEPTH = 3;
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function resolvePointer(document, pointer) {
+  if (!pointer.startsWith("#/")) {
+    return void 0;
+  }
+  let node = document;
+  for (const rawSegment of pointer.slice(2).split("/")) {
+    const segment = rawSegment.replaceAll("~1", "/").replaceAll("~0", "~");
+    if (!isObject(node)) {
+      return void 0;
+    }
+    node = node[segment];
+  }
+  return node;
+}
+function withRef(schema, seen) {
+  const ref = isObject(schema) ? asString(schema["$ref"]) : void 0;
+  return ref === void 0 || seen.has(ref) ? seen : /* @__PURE__ */ new Set([...seen, ref]);
+}
+function derefNode(document, schema, seen) {
+  if (!isObject(schema)) {
+    return void 0;
+  }
+  const ref = asString(schema["$ref"]);
+  if (ref !== void 0) {
+    if (seen.has(ref)) {
+      return void 0;
+    }
+    return derefNode(document, resolvePointer(document, ref), /* @__PURE__ */ new Set([...seen, ref]));
+  }
+  const allOf = schema["allOf"];
+  if (Array.isArray(allOf)) {
+    const merged = { ...schema };
+    delete merged["allOf"];
+    const properties = {};
+    const required = [];
+    for (const member of allOf) {
+      const resolved = derefNode(document, member, seen);
+      if (resolved === void 0) {
+        continue;
+      }
+      for (const [key, value] of Object.entries(resolved)) {
+        if (key === "properties" && isObject(value)) {
+          Object.assign(properties, value);
+        } else if (key === "required" && Array.isArray(value)) {
+          required.push(...value.filter((entry) => typeof entry === "string"));
+        } else if (!(key in merged)) {
+          merged[key] = value;
+        }
+      }
+    }
+    if (Object.keys(properties).length > 0) {
+      merged["properties"] = {
+        ...properties,
+        ...isObject(merged["properties"]) ? merged["properties"] : {}
+      };
+    }
+    if (required.length > 0) {
+      const own = Array.isArray(merged["required"]) ? merged["required"].filter((entry) => typeof entry === "string") : [];
+      merged["required"] = [.../* @__PURE__ */ new Set([...required, ...own])];
+    }
+    if (merged["type"] === void 0 && isObject(merged["properties"])) {
+      merged["type"] = "object";
+    }
+    return merged;
+  }
+  return schema;
+}
+function typeLabel(document, schema, seen) {
+  if (!isObject(schema)) {
+    return "unknown";
+  }
+  const ref = asString(schema["$ref"]);
+  const refName = ref?.split("/").at(-1);
+  const resolved = derefNode(document, schema, seen);
+  if (resolved === void 0) {
+    return refName ?? "unknown";
+  }
+  const type = asString(resolved["type"]);
+  if (refName !== void 0 && (type === "object" || isObject(resolved["properties"]))) {
+    return refName;
+  }
+  if (type === "array") {
+    return `array of ${typeLabel(document, resolved["items"], seen)}`;
+  }
+  if (Array.isArray(resolved["oneOf"]) || Array.isArray(resolved["anyOf"])) {
+    const variants = resolved["oneOf"] ?? resolved["anyOf"];
+    return `one of ${String(variants.length)} shapes`;
+  }
+  if (type === void 0) {
+    return isObject(resolved["properties"]) ? "object" : ref?.split("/").at(-1) ?? "unknown";
+  }
+  const format = asString(resolved["format"]);
+  return format === void 0 ? type : `${type} (${format})`;
+}
+function fieldLine(document, name, schema, required, indent, seen, location) {
+  const label = typeLabel(document, schema, seen);
+  const resolved = derefNode(document, schema, seen) ?? schema;
+  const notes = [];
+  const description = asString(resolved["description"]);
+  if (description !== void 0 && description !== "") {
+    notes.push(description.replaceAll(/\s*\n\s*/g, " ").trim());
+  }
+  const enumValues = resolved["enum"];
+  if (Array.isArray(enumValues) && enumValues.length > 0) {
+    notes.push(`One of: ${enumValues.map((value) => `\`${String(value)}\``).join(", ")}.`);
+  }
+  const defaultValue = resolved["default"];
+  if (typeof defaultValue === "string" || typeof defaultValue === "number" || typeof defaultValue === "boolean") {
+    notes.push(`Default: \`${String(defaultValue)}\`.`);
+  }
+  const example = resolved["example"];
+  if ((typeof example === "string" || typeof example === "number" || typeof example === "boolean") && String(example).length <= 60) {
+    notes.push(`Example: \`${String(example)}\`.`);
+  }
+  if (resolved["deprecated"] === true) {
+    notes.push("Deprecated.");
+  }
+  const detail = notes.length > 0 ? ` \u2014 ${notes.join(" ")}` : "";
+  const parenthetical = [
+    ...location === void 0 ? [] : [`in: ${location}`],
+    label,
+    ...required ? ["required"] : []
+  ].join(", ");
+  return `${indent}- \`${name}\` (${parenthetical})${detail}`;
+}
+function schemaFieldLines(document, schema, depth, seen) {
+  if (depth >= MAX_FIELD_DEPTH) {
+    return [`${"  ".repeat(depth)}- (nested fields omitted at this depth)`];
+  }
+  const scope = withRef(schema, seen);
+  const resolved = derefNode(document, schema, seen);
+  if (resolved === void 0) {
+    return [];
+  }
+  if (asString(resolved["type"]) === "array") {
+    return schemaFieldLines(document, resolved["items"], depth, withRef(resolved["items"], scope));
+  }
+  const properties = resolved["properties"];
+  const variants = resolved["oneOf"] ?? resolved["anyOf"];
+  const variantLines = Array.isArray(variants) ? variants.flatMap((variant, index) => {
+    const inner = schemaFieldLines(document, variant, depth + 1, scope);
+    const title = asString(derefNode(document, variant, scope)?.["title"]);
+    if (inner.length === 0 && title === void 0) {
+      return [];
+    }
+    const label = title ?? typeLabel(document, variant, scope);
+    const head = `${"  ".repeat(depth)}- Shape ${String(index + 1)} (${label})${inner.length > 0 ? ":" : ""}`;
+    return [head, ...inner];
+  }) : [];
+  if (!isObject(properties)) {
+    return variantLines;
+  }
+  const required = new Set(
+    Array.isArray(resolved["required"]) ? resolved["required"].filter((entry) => typeof entry === "string") : []
+  );
+  const indent = "  ".repeat(depth);
+  const lines = [];
+  for (const [name, property] of Object.entries(properties)) {
+    if (!isObject(property)) {
+      continue;
+    }
+    lines.push(fieldLine(document, name, property, required.has(name), indent, scope));
+    const propertyScope = withRef(property, scope);
+    const child = derefNode(document, property, scope);
+    if (child === void 0) {
+      continue;
+    }
+    const items = asString(child["type"]) === "array" ? child["items"] : void 0;
+    const nestedScope = items === void 0 ? propertyScope : withRef(items, propertyScope);
+    const nested = items === void 0 ? child : derefNode(document, items, propertyScope);
+    const hasNestedFields = nested !== void 0 && (isObject(nested["properties"]) || Array.isArray(nested["oneOf"]) || Array.isArray(nested["anyOf"]));
+    if (!hasNestedFields) {
+      continue;
+    }
+    lines.push(...schemaFieldLines(document, nested, depth + 1, nestedScope));
+  }
+  return lines;
+}
+function securityLine(document, operation) {
+  const security = operation["security"] ?? document.security;
+  if (!Array.isArray(security) || security.length === 0) {
+    return void 0;
+  }
+  const requirements = security.filter(isObject).map(
+    (entry) => Object.entries(entry).map(([scheme, scopes]) => {
+      const scopeList = Array.isArray(scopes) ? scopes.filter((scope) => typeof scope === "string") : [];
+      return scopeList.length > 0 ? `${scheme} (scopes: ${scopeList.join(", ")})` : scheme;
+    }).join(" + ")
+  ).filter((entry) => entry !== "");
+  return requirements.length > 0 ? `Auth: ${requirements.join(" or ")}` : void 0;
+}
+function bodySchema(content) {
+  if (!isObject(content)) {
+    return void 0;
+  }
+  const mediaType = "application/json" in content ? "application/json" : Object.keys(content)[0];
+  if (mediaType === void 0) {
+    return void 0;
+  }
+  const media = content[mediaType];
+  return isObject(media) ? { mediaType, schema: media["schema"] } : void 0;
+}
+function openApiOperationToMarkdown(document, ref) {
+  const pathItem = isObject(document.paths) ? document.paths[ref.path] : void 0;
+  if (!isObject(pathItem)) {
+    return null;
+  }
+  const operation = pathItem[ref.method.toLowerCase()];
+  if (!isObject(operation)) {
+    return null;
+  }
+  const seen = /* @__PURE__ */ new Set();
+  const sections = [];
+  if (operation["deprecated"] === true) {
+    sections.push("**Deprecated.**");
+  }
+  const auth = securityLine(document, operation);
+  if (auth !== void 0) {
+    sections.push(auth);
+  }
+  const parameters = operation["parameters"];
+  if (Array.isArray(parameters)) {
+    const lines = parameters.map((parameter) => derefNode(document, parameter, seen) ?? parameter).filter(isObject).flatMap((parameter) => {
+      const name = asString(parameter["name"]);
+      if (name === void 0) {
+        return [];
+      }
+      const where = asString(parameter["in"]) ?? "query";
+      const schema = isObject(parameter["schema"]) ? parameter["schema"] : {};
+      return [fieldLine(document, name, schema, parameter["required"] === true, "", seen, where)];
+    });
+    if (lines.length > 0) {
+      sections.push(`## Parameters
+
+${lines.join("\n")}`);
+    }
+  }
+  const requestBody3 = derefNode(document, operation["requestBody"], seen);
+  if (requestBody3 !== void 0) {
+    const body = bodySchema(requestBody3["content"]);
+    if (body !== void 0) {
+      const lines = schemaFieldLines(document, body.schema, 0, seen);
+      const requiredNote = requestBody3["required"] === true ? ", required" : "";
+      const heading = `## Request body (${body.mediaType}${requiredNote})`;
+      sections.push(lines.length > 0 ? `${heading}
+
+${lines.join("\n")}` : heading);
+    }
+  }
+  const responses = operation["responses"];
+  if (isObject(responses)) {
+    const lines = [];
+    for (const [status, rawResponse] of Object.entries(responses)) {
+      const response = derefNode(document, rawResponse, seen) ?? rawResponse;
+      if (!isObject(response)) {
+        continue;
+      }
+      const description = asString(response["description"])?.replaceAll(/\s*\n\s*/g, " ").trim();
+      lines.push(
+        `- \`${status}\`${description !== void 0 && description !== "" ? ` \u2014 ${description}` : ""}`
+      );
+      const body = bodySchema(response["content"]);
+      if (body !== void 0) {
+        lines.push(...schemaFieldLines(document, body.schema, 1, seen));
+      }
+    }
+    if (lines.length > 0) {
+      sections.push(`## Responses
+
+${lines.join("\n")}`);
+    }
+  }
+  return sections.length > 0 ? sections.join("\n\n") : null;
+}
+
+// src/core/markdown.ts
+function splitFrontmatter(raw) {
+  const lines = raw.split("\n");
+  if (!/^---\s*$/.test(lines[0] ?? "")) {
+    return { frontmatter: "", body: raw };
+  }
+  for (let i = 1; i < lines.length; i++) {
+    if (/^---\s*$/.test(lines[i] ?? "")) {
+      return { frontmatter: lines.slice(1, i).join("\n"), body: lines.slice(i + 1).join("\n") };
+    }
+  }
+  return { frontmatter: "", body: raw };
+}
+function stripQuotes(value) {
+  const quote = value[0];
+  if ((quote === '"' || quote === "'") && value.length >= 2 && value.endsWith(quote)) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function foldLines(lines) {
+  let out = "";
+  let previous = "start";
+  for (const line of lines) {
+    if (line === "") {
+      out += "\n";
+      previous = "blank";
+      continue;
+    }
+    const literal = /^[ \t]/.test(line);
+    if (previous === "text") {
+      out += literal ? "\n" : " ";
+    } else if (previous === "literal") {
+      out += "\n";
+    }
+    out += line;
+    previous = literal ? "literal" : "text";
+  }
+  return out;
+}
+function readBlockScalar(lines, start, style) {
+  const collected = [];
+  for (let i = start; i < lines.length; i++) {
+    const line = lines[i] ?? "";
+    if (line.trim() !== "" && !/^[ \t]/.test(line)) {
+      break;
+    }
+    collected.push(line);
+  }
+  const firstText = collected.find((line) => line.trim() !== "");
+  if (firstText === void 0) {
+    return void 0;
+  }
+  const indent = firstText.length - firstText.trimStart().length;
+  const content = collected.map((line) => line.trim() === "" ? "" : line.slice(indent));
+  return (style === "|" ? content.join("\n") : foldLines(content)).trim();
+}
+function stripLineComment(value) {
+  return value.replace(/\s+#.*$/, "");
+}
+function frontmatterValue(frontmatter, key) {
+  const lines = frontmatter.split("\n");
+  const keyPattern = new RegExp(`^${key}:(.*)$`);
+  for (let i = 0; i < lines.length; i++) {
+    const match = keyPattern.exec(lines[i] ?? "");
+    if (!match) {
+      continue;
+    }
+    const inline = (match[1] ?? "").trim();
+    const blockHeader = /^([>|])[0-9+-]*$/.exec(inline);
+    if (blockHeader) {
+      return readBlockScalar(lines, i + 1, blockHeader[1]);
+    }
+    if (inline === "") {
+      return void 0;
+    }
+    const quoted = inline.startsWith('"') || inline.startsWith("'");
+    const parts = [quoted ? inline : stripLineComment(inline)];
+    for (let j = i + 1; j < lines.length; j++) {
+      const continuation = lines[j] ?? "";
+      if (continuation.trim() === "" || !/^[ \t]/.test(continuation)) {
+        break;
+      }
+      parts.push(quoted ? continuation.trim() : stripLineComment(continuation.trim()));
+    }
+    return stripQuotes(parts.join(" ")).trim();
+  }
+  return void 0;
+}
+function isGeneratedApiPage(frontmatter) {
+  return /^_openapi\s*:/m.test(frontmatter);
+}
+function cleanBody(body) {
+  const segments = body.split(/(```[\s\S]*?```)/g);
+  const cleaned = segments.map(
+    (segment) => segment.startsWith("```") ? segment : segment.replace(/^\s*(import|export)\s.*$/gm, "").replace(/\{\/\*[\s\S]*?\*\/\}/g, "").replace(/<\/?[A-Za-z][^>]*>/g, "")
+  );
+  return cleaned.join("").replace(/\n{3,}/g, "\n\n").trim();
+}
+function summariseApiPage(title, description, body, documents) {
+  const opMatch = /operations=\{(\[[\s\S]*?\])\}/.exec(body);
+  let ops = [];
+  if (opMatch?.[1]) {
+    try {
+      const parsed = JSON.parse(opMatch[1]);
+      ops = (Array.isArray(parsed) ? parsed : []).filter(
+        (op) => typeof op === "object" && op !== null && typeof op.path === "string" && typeof op.method === "string"
+      );
+    } catch {
+      ops = [];
+    }
+  }
+  const documentName = /document="([^"]+)"/.exec(body)?.[1];
+  const onlyName = Object.keys(documents ?? {}).length === 1 ? Object.keys(documents ?? {})[0] : void 0;
+  const lookupName = documentName ?? onlyName;
+  const document = lookupName === void 0 ? void 0 : documents?.[lookupName];
+  const operationSections = ops.map((op) => {
+    const endpoint = `\`${op.method.toUpperCase()} ${op.path}\``;
+    const detail = document === void 0 ? null : openApiOperationToMarkdown(document, op);
+    return detail === null ? endpoint : `${endpoint}
+
+${detail}`;
+  });
+  return `${[`# ${title}`, description ?? "", ...operationSections].filter(Boolean).join("\n\n")}
+`;
+}
+function mdxToMarkdown(raw, options = {}) {
+  if (raw.trim() === "") {
+    return null;
+  }
+  const { frontmatter, body } = splitFrontmatter(raw);
+  const title = frontmatterValue(frontmatter, "title") ?? options.fallbackTitle ?? "Untitled";
+  const description = frontmatterValue(frontmatter, "description");
+  const trimmedBody = body.trim();
+  if (isGeneratedApiPage(frontmatter)) {
+    return summariseApiPage(title, description, trimmedBody, options.openApiDocuments);
+  }
+  return `# ${title}
+
+${description ? `${description}
+
+` : ""}${cleanBody(trimmedBody)}
+`;
+}
+function createMarkdownRoute(options) {
+  return {
+    async GET(_request, context) {
+      const { slug } = await context.params;
+      const raw = await options.read(slug);
+      if (raw === null) {
+        return new Response("Not found", { status: 404 });
+      }
+      const fallbackTitle = slug?.at(-1);
+      const openApiDocuments = await options.loadOpenApiDocuments?.();
+      const markdown = mdxToMarkdown(raw, {
+        ...fallbackTitle === void 0 ? {} : { fallbackTitle },
+        ...openApiDocuments === void 0 ? {} : { openApiDocuments }
+      });
+      if (markdown === null) {
+        return new Response("Not found", { status: 404 });
+      }
+      return new Response(markdown, {
+        headers: { "content-type": "text/plain; charset=utf-8" }
+      });
+    }
+  };
+}
+
+// src/core/auth/domains.ts
+function isAllowedEmail(email, allowedDomains) {
+  const at = email.lastIndexOf("@");
+  if (at < 1 || at === email.length - 1) {
+    return false;
+  }
+  const domain = email.slice(at + 1).toLowerCase();
+  return allowedDomains.some((allowed) => allowed.toLowerCase() === domain);
+}
+
+// src/core/auth/session.ts
+var SESSION_COOKIE = "docs_session";
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function base64UrlEncode(bytes) {
+  let binary = "";
+  for (const byte of bytes) {
+    binary += String.fromCharCode(byte);
+  }
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function base64UrlDecode(value) {
+  const normalized = value.replace(/-/g, "+").replace(/_/g, "/");
+  const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+  const binary = atob(padded);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i += 1) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+async function hmacKey(secret) {
+  return crypto.subtle.importKey(
+    "raw",
+    encoder.encode(secret),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign", "verify"]
+  );
+}
+async function signSession(payload, secret) {
+  const data = base64UrlEncode(encoder.encode(JSON.stringify(payload)));
+  const key = await hmacKey(secret);
+  const signature = new Uint8Array(await crypto.subtle.sign("HMAC", key, encoder.encode(data)));
+  return `${data}.${base64UrlEncode(signature)}`;
+}
+async function verifySession(token, secret, nowSeconds = Math.floor(Date.now() / 1e3)) {
+  const dot = token.indexOf(".");
+  if (dot <= 0) {
+    return null;
+  }
+  const data = token.slice(0, dot);
+  const signature = token.slice(dot + 1);
+  const key = await hmacKey(secret);
+  let valid;
+  try {
+    valid = await crypto.subtle.verify(
+      "HMAC",
+      key,
+      base64UrlDecode(signature),
+      encoder.encode(data)
+    );
+  } catch {
+    return null;
+  }
+  if (!valid) {
+    return null;
+  }
+  let payload;
+  try {
+    payload = JSON.parse(decoder.decode(base64UrlDecode(data)));
+  } catch {
+    return null;
+  }
+  if (typeof payload.email !== "string" || typeof payload.exp !== "number") {
+    return null;
+  }
+  if (payload.exp < nowSeconds) {
+    return null;
+  }
+  return payload;
+}
+function readCookie(cookieHeader, name) {
+  if (cookieHeader === null) {
+    return null;
+  }
+  for (const part of cookieHeader.split(";")) {
+    const [key, ...rest] = part.trim().split("=");
+    if (key === name) {
+      return rest.join("=");
+    }
+  }
+  return null;
+}
+function buildSessionCookie(token, options) {
+  const flags = ["Path=/", "HttpOnly", "SameSite=Lax", `Max-Age=${String(options.maxAgeSeconds)}`];
+  if (options.secure !== false) {
+    flags.push("Secure");
+  }
+  return `${SESSION_COOKIE}=${token}; ${flags.join("; ")}`;
+}
+function clearSessionCookie(options = {}) {
+  const flags = ["Path=/", "HttpOnly", "SameSite=Lax", "Max-Age=0"];
+  if (options.secure !== false) {
+    flags.push("Secure");
+  }
+  return `${SESSION_COOKIE}=; ${flags.join("; ")}`;
+}
+
+// src/core/auth/email-provider.ts
+var DEFAULT_TTL_SECONDS = 8 * 60 * 60;
+async function readEmailAndFrom(request) {
+  const contentType = request.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    const body = await request.json();
+    return {
+      email: typeof body["email"] === "string" ? body["email"] : "",
+      from: typeof body["from"] === "string" ? body["from"] : null
+    };
+  }
+  const form = await request.formData();
+  const email = form.get("email");
+  const from = form.get("from");
+  return {
+    email: typeof email === "string" ? email : "",
+    from: typeof from === "string" ? from : null
+  };
+}
+function safeRedirectPath(from, fallback) {
+  if (from !== null && from.startsWith("/") && !from.startsWith("//")) {
+    return from;
+  }
+  return fallback;
+}
+function createEmailSignIn(options) {
+  const ttl = options.ttlSeconds ?? DEFAULT_TTL_SECONDS;
+  const fallback = options.defaultRedirect ?? "/";
+  const signInPath = options.signInPath ?? "/signin";
+  return async function handle(request) {
+    const isJson = (request.headers.get("content-type") ?? "").includes("application/json");
+    const { email, from } = await readEmailAndFrom(request);
+    if (!isAllowedEmail(email, options.allowedDomains)) {
+      if (isJson) {
+        return new Response(JSON.stringify({ error: "This email domain is not allowed." }), {
+          status: 403,
+          headers: { "content-type": "application/json" }
+        });
+      }
+      const params = new URLSearchParams({ error: "forbidden" });
+      const safeFrom = safeRedirectPath(from, "");
+      if (safeFrom) {
+        params.set("from", safeFrom);
+      }
+      return new Response(null, {
+        status: 303,
+        headers: { location: `${signInPath}?${params.toString()}` }
+      });
+    }
+    const exp = Math.floor(Date.now() / 1e3) + ttl;
+    const token = await signSession({ email, exp }, options.secret);
+    const cookie2 = buildSessionCookie(token, {
+      maxAgeSeconds: ttl,
+      ...options.secureCookies !== void 0 ? { secure: options.secureCookies } : {}
+    });
+    const target = safeRedirectPath(from, fallback);
+    return new Response(null, {
+      status: 303,
+      headers: { location: target, "set-cookie": cookie2 }
+    });
+  };
+}
+
+// src/core/auth/google-provider.ts
+var AUTHORIZE_URL = "https://accounts.google.com/o/oauth2/v2/auth";
+var TOKEN_URL = "https://oauth2.googleapis.com/token";
+var STATE_COOKIE = "docs_oauth_state";
+var FROM_COOKIE = "docs_oauth_from";
+var DEFAULT_TTL_SECONDS2 = 8 * 60 * 60;
+function cookie(name, value, secure, maxAge) {
+  const flags = ["Path=/", "HttpOnly", "SameSite=Lax", `Max-Age=${String(maxAge)}`];
+  if (secure) {
+    flags.push("Secure");
+  }
+  return `${name}=${value}; ${flags.join("; ")}`;
+}
+function readCookie2(header, name) {
+  if (header === null) {
+    return null;
+  }
+  for (const part of header.split(";")) {
+    const [key, ...rest] = part.trim().split("=");
+    if (key === name) {
+      return rest.join("=");
+    }
+  }
+  return null;
+}
+function safeRedirectPath2(from, fallback) {
+  if (from !== null && from.startsWith("/") && !from.startsWith("//")) {
+    return from;
+  }
+  return fallback;
+}
+function decodeIdTokenEmail(idToken) {
+  const parts = idToken.split(".");
+  if (parts.length < 2 || parts[1] === void 0) {
+    return null;
+  }
+  try {
+    const normalized = parts[1].replace(/-/g, "+").replace(/_/g, "/");
+    const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+    const claims = JSON.parse(atob(padded));
+    return typeof claims.email === "string" ? claims.email : null;
+  } catch {
+    return null;
+  }
+}
+function createGoogleAuth(options) {
+  const ttl = options.ttlSeconds ?? DEFAULT_TTL_SECONDS2;
+  const secure = options.secureCookies !== false;
+  const fallback = options.defaultRedirect ?? "/";
+  const signInPath = options.signInPath ?? "/signin";
+  const doFetch = options.fetch ?? ((url, init) => fetch(url, init));
+  function bounce(code, from) {
+    const params = new URLSearchParams({ error: code });
+    const safeFrom = safeRedirectPath2(from, "");
+    if (safeFrom) {
+      params.set("from", safeFrom);
+    }
+    const headers = new Headers({ location: `${signInPath}?${params.toString()}` });
+    headers.append("set-cookie", cookie(STATE_COOKIE, "", secure, 0));
+    headers.append("set-cookie", cookie(FROM_COOKIE, "", secure, 0));
+    return new Response(null, { status: 303, headers });
+  }
+  function start(request) {
+    const url = new URL(request.url);
+    const from = url.searchParams.get("from");
+    const state = crypto.randomUUID();
+    const authorize = new URL(AUTHORIZE_URL);
+    authorize.searchParams.set("client_id", options.clientId);
+    authorize.searchParams.set("redirect_uri", options.redirectUri);
+    authorize.searchParams.set("response_type", "code");
+    authorize.searchParams.set("scope", "openid email");
+    authorize.searchParams.set("state", state);
+    if (options.allowedDomains.length === 1 && options.allowedDomains[0] !== void 0) {
+      authorize.searchParams.set("hd", options.allowedDomains[0]);
+    }
+    const headers = new Headers({ location: authorize.toString() });
+    headers.append("set-cookie", cookie(STATE_COOKIE, state, secure, 600));
+    headers.append("set-cookie", cookie(FROM_COOKIE, from ?? fallback, secure, 600));
+    return new Response(null, { status: 302, headers });
+  }
+  async function callback(request) {
+    const url = new URL(request.url);
+    const code = url.searchParams.get("code");
+    const returnedState = url.searchParams.get("state");
+    const cookieHeader = request.headers.get("cookie");
+    const expectedState = readCookie2(cookieHeader, STATE_COOKIE);
+    if (code === null || returnedState === null || expectedState === null || returnedState !== expectedState) {
+      return bounce("state", readCookie2(cookieHeader, FROM_COOKIE));
+    }
+    const tokenResponse = await doFetch(TOKEN_URL, {
+      method: "POST",
+      headers: { "content-type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams({
+        client_id: options.clientId,
+        client_secret: options.clientSecret,
+        code,
+        grant_type: "authorization_code",
+        redirect_uri: options.redirectUri
+      }).toString()
+    });
+    if (!tokenResponse.ok) {
+      return bounce("oauth", readCookie2(cookieHeader, FROM_COOKIE));
+    }
+    const tokens = await tokenResponse.json();
+    const email = typeof tokens.id_token === "string" ? decodeIdTokenEmail(tokens.id_token) : null;
+    if (email === null || !isAllowedEmail(email, options.allowedDomains)) {
+      return bounce("forbidden", readCookie2(cookieHeader, FROM_COOKIE));
+    }
+    const exp = Math.floor(Date.now() / 1e3) + ttl;
+    const token = await signSession({ email, exp }, options.secret);
+    const target = safeRedirectPath2(readCookie2(cookieHeader, FROM_COOKIE), fallback);
+    const headers = new Headers({ location: target });
+    headers.append("set-cookie", buildSessionCookie(token, { maxAgeSeconds: ttl, secure }));
+    headers.append("set-cookie", cookie(STATE_COOKIE, "", secure, 0));
+    headers.append("set-cookie", cookie(FROM_COOKIE, "", secure, 0));
+    return new Response(null, { status: 303, headers });
+  }
+  return { start, callback };
+}
+
+// src/core/auth/gate.ts
+var ALWAYS_PUBLIC = ["/_next/", "/favicon", "/api/auth/"];
+function createAuthGate(options) {
+  const signInPath = options.signInPath ?? "/signin";
+  const publicPaths = [...ALWAYS_PUBLIC, ...options.publicPaths ?? []];
+  return async function gate(request) {
+    const url = new URL(request.url);
+    const path = url.pathname;
+    if (path === signInPath || publicPaths.some((prefix) => path.startsWith(prefix))) {
+      return null;
+    }
+    const token = readCookie(request.headers.get("cookie"), SESSION_COOKIE);
+    if (token !== null) {
+      const session = await verifySession(token, options.secret);
+      if (session !== null && isAllowedEmail(session.email, options.allowedDomains)) {
+        return null;
+      }
+    }
+    const redirectUrl = new URL(signInPath, url.origin);
+    redirectUrl.searchParams.set("from", path);
+    return Response.redirect(redirectUrl.toString(), 302);
+  };
+}
+
+// src/core/auth/secret-provider.ts
+var DEFAULT_TTL_SECONDS3 = 8 * 60 * 60;
+var DEFAULT_PENDING_TTL_SECONDS = 15 * 60;
+var PENDING_COOKIE = "docs_secret_email";
+function timingSafeEqual(a, b) {
+  const encoder2 = new TextEncoder();
+  const ea = encoder2.encode(a);
+  const eb = encoder2.encode(b);
+  let diff = ea.length ^ eb.length;
+  const len = Math.max(ea.length, eb.length);
+  for (let i = 0; i < len; i += 1) {
+    diff |= (ea[i] ?? 0) ^ (eb[i] ?? 0);
+  }
+  return diff === 0;
+}
+function safeRedirectPath3(from, fallback) {
+  if (from !== null && from.startsWith("/") && !from.startsWith("//")) {
+    return from;
+  }
+  return fallback;
+}
+async function readForm(request) {
+  const contentType = request.headers.get("content-type") ?? "";
+  if (contentType.includes("application/json")) {
+    const body = await request.json();
+    return {
+      email: typeof body["email"] === "string" ? body["email"] : "",
+      secret: typeof body["secret"] === "string" ? body["secret"] : null,
+      from: typeof body["from"] === "string" ? body["from"] : null
+    };
+  }
+  const form = await request.formData();
+  const email = form.get("email");
+  const secret = form.get("secret");
+  const from = form.get("from");
+  return {
+    email: typeof email === "string" ? email : "",
+    secret: typeof secret === "string" ? secret : null,
+    from: typeof from === "string" ? from : null
+  };
+}
+function signInQuery(parts) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(parts)) {
+    if (value) {
+      params.set(key, value);
+    }
+  }
+  const query = params.toString();
+  return query ? `?${query}` : "";
+}
+function pendingCookie(email, secure, maxAge) {
+  const flags = ["Path=/", "HttpOnly", "SameSite=Lax", `Max-Age=${String(maxAge)}`];
+  if (secure) {
+    flags.push("Secure");
+  }
+  return `${PENDING_COOKIE}=${encodeURIComponent(email)}; ${flags.join("; ")}`;
+}
+function clearPendingCookie(secure) {
+  return pendingCookie("", secure, 0);
+}
+function createSecretSignIn(options) {
+  const ttl = options.ttlSeconds ?? DEFAULT_TTL_SECONDS3;
+  const pendingTtl = options.pendingTtlSeconds ?? DEFAULT_PENDING_TTL_SECONDS;
+  const secure = options.secureCookies !== false;
+  const fallback = options.defaultRedirect ?? "/";
+  const signInPath = options.signInPath ?? "/signin";
+  return async function handle(request) {
+    const { email, secret, from } = await readForm(request);
+    const safeFrom = safeRedirectPath3(from, "") || void 0;
+    if (secret === null) {
+      if (!isAllowedEmail(email, options.allowedDomains)) {
+        return new Response(null, {
+          status: 303,
+          headers: {
+            location: `${signInPath}${signInQuery({ error: "forbidden", from: safeFrom })}`
+          }
+        });
+      }
+      const headers2 = new Headers({
+        location: `${signInPath}${signInQuery({ step: "secret", from: safeFrom })}`
+      });
+      headers2.append("set-cookie", pendingCookie(email, secure, pendingTtl));
+      return new Response(null, { status: 303, headers: headers2 });
+    }
+    const pending = readCookie(request.headers.get("cookie"), PENDING_COOKIE);
+    const pendingEmail = pending ? decodeURIComponent(pending) : "";
+    if (!isAllowedEmail(pendingEmail, options.allowedDomains)) {
+      return new Response(null, {
+        status: 303,
+        headers: { location: `${signInPath}${signInQuery({ from: safeFrom })}` }
+      });
+    }
+    if (options.accessSecret === "" || !timingSafeEqual(secret, options.accessSecret)) {
+      return new Response(null, {
+        status: 303,
+        headers: {
+          location: `${signInPath}${signInQuery({ step: "secret", error: "badsecret", from: safeFrom })}`
+        }
+      });
+    }
+    const exp = Math.floor(Date.now() / 1e3) + ttl;
+    const token = await signSession({ email: pendingEmail, exp }, options.secret);
+    const headers = new Headers({ location: safeRedirectPath3(from, fallback) });
+    headers.append("set-cookie", buildSessionCookie(token, { maxAgeSeconds: ttl, secure }));
+    headers.append("set-cookie", clearPendingCookie(secure));
+    return new Response(null, { status: 303, headers });
+  };
+}
+
+// src/core/auth/signout.ts
+function createSignOut(options = {}) {
+  return function handle() {
+    return new Response(null, {
+      status: 303,
+      headers: {
+        location: options.redirectTo ?? "/signin",
+        "set-cookie": clearSessionCookie(
+          options.secureCookies !== void 0 ? { secure: options.secureCookies } : {}
+        )
+      }
+    });
+  };
+}
+
+// src/core/proxy.ts
+var DEFAULT_RATE_LIMIT_PER_MINUTE2 = 60;
+var ProxyTargetError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ProxyTargetError";
+  }
+};
+var BLOCKED_HOST_PATTERNS = [
+  /^localhost$/i,
+  /\.localhost$/i,
+  /^0\.0\.0\.0$/,
+  /^127\./,
+  /^10\./,
+  /^192\.168\./,
+  /^169\.254\./,
+  /^172\.(1[6-9]|2\d|3[01])\./,
+  /^\[?::1\]?$/,
+  /^\[?fe80:/i,
+  /^\[?fc00:/i,
+  /^\[?fd[0-9a-f]{2}:/i
+];
+function isBlockedHost(hostname) {
+  return BLOCKED_HOST_PATTERNS.some((pattern) => pattern.test(hostname));
+}
+function normalizeOrigins(origins) {
+  const set = /* @__PURE__ */ new Set();
+  for (const origin of origins) {
+    let parsed;
+    try {
+      parsed = new URL(origin);
+    } catch {
+      throw new ProxyTargetError(`Invalid allow-listed origin: ${origin}`);
+    }
+    set.add(parsed.origin);
+  }
+  return set;
+}
+function assertAllowedTarget(target, allowedOrigins) {
+  const allowed = normalizeOrigins(allowedOrigins);
+  let url;
+  try {
+    url = new URL(target);
+  } catch {
+    throw new ProxyTargetError(`Invalid target URL: ${target}`);
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new ProxyTargetError(`Unsupported protocol: ${url.protocol}`);
+  }
+  if (isBlockedHost(url.hostname)) {
+    throw new ProxyTargetError(`Blocked host: ${url.hostname}`);
+  }
+  if (!allowed.has(url.origin)) {
+    throw new ProxyTargetError(`Target origin is not allow-listed: ${url.origin}`);
+  }
+  return url;
+}
+var STRIPPED_REQUEST_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "connection",
+  "content-length"
+]);
+function jsonResponse2(status, payload, headers = {}) {
+  return new Response(JSON.stringify(payload), {
+    status,
+    headers: { "content-type": "application/json", ...headers }
+  });
+}
+function proxyLimiter(options) {
+  const limit = options.rateLimitPerMinute ?? DEFAULT_RATE_LIMIT_PER_MINUTE2;
+  if (!Number.isInteger(limit) || limit < 1) {
+    throw new ProxyTargetError(
+      `proxy.rateLimitPerMinute must be an integer of 1 or more, got ${String(limit)}.`
+    );
+  }
+  return createRateLimiter({
+    limit,
+    windowMs: RATE_LIMIT_WINDOW_MS,
+    ...options.now ? { now: options.now } : {}
+  });
+}
+function tooManyRequests(retryAfterSeconds) {
+  const retryAfter = retryAfterSeconds ?? 60;
+  return jsonResponse2(
+    429,
+    {
+      error: `Too many requests. Try again in ${String(retryAfter)} seconds.`,
+      retryAfterSeconds: retryAfter
+    },
+    { "retry-after": String(retryAfter) }
+  );
+}
+function parseEnvelope(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new ProxyTargetError("Request body must be a JSON object.");
+  }
+  const record = value;
+  if (typeof record["url"] !== "string") {
+    throw new ProxyTargetError('Request body must include a string "url".');
+  }
+  const headers = {};
+  if (typeof record["headers"] === "object" && record["headers"] !== null) {
+    for (const [key, header] of Object.entries(record["headers"])) {
+      if (typeof header === "string" && !STRIPPED_REQUEST_HEADERS.has(key.toLowerCase())) {
+        headers[key] = header;
+      }
+    }
+  }
+  return {
+    url: record["url"],
+    method: typeof record["method"] === "string" ? record["method"] : "GET",
+    headers,
+    body: typeof record["body"] === "string" ? record["body"] : null
+  };
+}
+function createTryItProxy(options) {
+  normalizeOrigins(options.allowedOrigins);
+  const doFetch = options.fetch ?? ((url, init) => fetch(url, init));
+  const limiter = proxyLimiter(options);
+  return async function handle(request) {
+    const decision = limiter.allow(clientRateLimitKey(request));
+    if (!decision.allowed) {
+      return tooManyRequests(decision.retryAfterSeconds);
+    }
+    let envelope;
+    try {
+      const parsed = await request.json();
+      envelope = parseEnvelope(parsed);
+    } catch (error) {
+      const message = error instanceof ProxyTargetError ? error.message : "Invalid JSON body.";
+      return jsonResponse2(400, { error: message });
+    }
+    let target;
+    try {
+      target = assertAllowedTarget(envelope.url, options.allowedOrigins);
+    } catch (error) {
+      const message = error instanceof ProxyTargetError ? error.message : "Blocked target.";
+      return jsonResponse2(403, { error: message });
+    }
+    const init = {
+      method: envelope.method ?? "GET",
+      headers: envelope.headers ?? {}
+    };
+    if (envelope.body !== null && envelope.body !== void 0) {
+      init.body = envelope.body;
+    }
+    const upstream = await doFetch(target.toString(), init);
+    return new Response(upstream.body, {
+      status: upstream.status,
+      headers: upstream.headers
+    });
+  };
+}
+var STRIPPED_FORWARD_HEADERS = [
+  "host",
+  "connection",
+  "content-length",
+  "origin",
+  "referer",
+  "x-forwarded-for",
+  "x-forwarded-host",
+  "x-forwarded-proto",
+  "x-forwarded-port",
+  "x-real-ip"
+];
+var TARGET_PARAMS = ["url", "scalar_url"];
+function createTryItProxyRoute(options) {
+  normalizeOrigins(options.allowedOrigins);
+  const doFetch = options.fetch ?? ((url, init) => fetch(url, init));
+  const limiter = proxyLimiter(options);
+  async function handle(request) {
+    const decision = limiter.allow(clientRateLimitKey(request));
+    if (!decision.allowed) {
+      return tooManyRequests(decision.retryAfterSeconds);
+    }
+    const requestUrl = new URL(request.url);
+    const rawTarget = TARGET_PARAMS.map((name) => requestUrl.searchParams.get(name) ?? "").find(
+      (value) => value !== ""
+    );
+    if (rawTarget === void 0) {
+      return jsonResponse2(400, {
+        error: 'Missing target. Pass the upstream URL in the "url" query parameter.'
+      });
+    }
+    let target;
+    try {
+      target = assertAllowedTarget(rawTarget, options.allowedOrigins);
+    } catch (error) {
+      const message = error instanceof ProxyTargetError ? error.message : "Blocked target.";
+      return jsonResponse2(403, { error: message });
+    }
+    const headers = new Headers(request.headers);
+    for (const name of STRIPPED_FORWARD_HEADERS) {
+      headers.delete(name);
+    }
+    const init = { method: request.method, headers, redirect: "manual" };
+    if (request.method !== "GET" && request.method !== "HEAD") {
+      init.body = await request.arrayBuffer();
+    }
+    const upstream = await doFetch(target.toString(), init);
+    const responseHeaders = new Headers(upstream.headers);
+    responseHeaders.set("access-control-allow-origin", "*");
+    return new Response(upstream.body, { status: upstream.status, headers: responseHeaders });
+  }
+  return {
+    GET: handle,
+    POST: handle,
+    PUT: handle,
+    PATCH: handle,
+    DELETE: handle,
+    OPTIONS: () => new Response(null, {
+      status: 204,
+      headers: {
+        "access-control-allow-origin": "*",
+        "access-control-allow-methods": "GET,POST,PUT,PATCH,DELETE,OPTIONS",
+        "access-control-allow-headers": "*"
+      }
+    })
+  };
+}
+function unwrapProxyTarget(url) {
+  try {
+    const parsed = new URL(url, "http://localhost");
+    if (!/\/proxy\/?$/.test(parsed.pathname)) {
+      return url;
+    }
+    for (const name of TARGET_PARAMS) {
+      const target = parsed.searchParams.get(name);
+      if (target !== null && target !== "") {
+        return target;
+      }
+    }
+    return url;
+  } catch {
+    return url;
+  }
+}
+
+// src/adapters/docs-json/parse-navigation.ts
+var HTTP_METHODS = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "HEAD",
+  "OPTIONS",
+  "TRACE"
+]);
+var InvalidNavigationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidNavigationError";
+  }
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parsePageString(entry) {
+  const parts = entry.trim().split(/\s+/);
+  const [file, maybeMethod, ...rest] = parts;
+  if (file === void 0 || file === "") {
+    throw new InvalidNavigationError("Encountered an empty navigation page entry.");
+  }
+  if (maybeMethod !== void 0 && rest.length > 0 && HTTP_METHODS.has(maybeMethod.toUpperCase())) {
+    return {
+      kind: "openapi",
+      file,
+      method: maybeMethod.toUpperCase(),
+      apiPath: rest.join(" ")
+    };
+  }
+  return { kind: "doc", file: entry.trim() };
+}
+function parseItem(entry, path) {
+  if (typeof entry === "string") {
+    return parsePageString(entry);
+  }
+  if (isRecord(entry) && typeof entry["group"] === "string") {
+    return parseGroup(entry, path);
+  }
+  throw new InvalidNavigationError(
+    `Navigation entry at ${path} must be a page string or a group object.`
+  );
+}
+function parseItems(pages, path) {
+  if (!Array.isArray(pages)) {
+    throw new InvalidNavigationError(`Expected an array of pages at ${path}.`);
+  }
+  return pages.map((entry, index) => parseItem(entry, `${path}[${String(index)}]`));
+}
+function parseGroup(group, path) {
+  const title = group["group"];
+  if (typeof title !== "string") {
+    throw new InvalidNavigationError(`Group at ${path} is missing a string "group" title.`);
+  }
+  return {
+    kind: "group",
+    title,
+    items: parseItems(group["pages"], `${path}.pages`)
+  };
+}
+function parseTab(tab, path) {
+  if (!isRecord(tab) || typeof tab["tab"] !== "string") {
+    throw new InvalidNavigationError(`Tab at ${path} is missing a string "tab" title.`);
+  }
+  const items = tab["groups"] !== void 0 ? parseGroups(tab["groups"], `${path}.groups`) : parseItems(tab["pages"], `${path}.pages`);
+  const icon = tab["icon"];
+  return {
+    kind: "tab",
+    title: tab["tab"],
+    items,
+    ...typeof icon === "string" ? { icon } : {}
+  };
+}
+function parseGroups(groups, path) {
+  if (!Array.isArray(groups)) {
+    throw new InvalidNavigationError(`Expected an array of groups at ${path}.`);
+  }
+  return groups.map((group, index) => {
+    const groupPath = `${path}[${String(index)}]`;
+    if (!isRecord(group)) {
+      throw new InvalidNavigationError(`Group at ${groupPath} must be an object.`);
+    }
+    return parseGroup(group, groupPath);
+  });
+}
+function parseNavigation(docsJson) {
+  if (!isRecord(docsJson)) {
+    throw new InvalidNavigationError("docs.json must be an object.");
+  }
+  const navigation = docsJson["navigation"];
+  if (!isRecord(navigation)) {
+    throw new InvalidNavigationError('docs.json must have a "navigation" object.');
+  }
+  const tabs = navigation["tabs"];
+  if (!Array.isArray(tabs)) {
+    throw new InvalidNavigationError('docs.json navigation must have a "tabs" array.');
+  }
+  return tabs.map((tab, index) => parseTab(tab, `navigation.tabs[${String(index)}]`));
+}
+
+// src/adapters/openapi/merge-documents.ts
+var OpenApiMergeError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "OpenApiMergeError";
+  }
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function collectServers(inputs, override) {
+  if (override !== void 0) {
+    return [...override];
+  }
+  const byUrl = /* @__PURE__ */ new Map();
+  for (const doc of inputs) {
+    const servers = doc["servers"];
+    if (!Array.isArray(servers)) {
+      continue;
+    }
+    for (const server of servers) {
+      if (isRecord2(server) && typeof server["url"] === "string" && !byUrl.has(server["url"])) {
+        byUrl.set(server["url"], server);
+      }
+    }
+  }
+  return [...byUrl.values()];
+}
+function collectTags(inputs) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const doc of inputs) {
+    const tags = doc["tags"];
+    if (!Array.isArray(tags)) {
+      continue;
+    }
+    for (const tag of tags) {
+      if (isRecord2(tag) && typeof tag["name"] === "string" && !byName.has(tag["name"])) {
+        byName.set(tag["name"], tag);
+      }
+    }
+  }
+  return [...byName.values()];
+}
+function mergeComponents(inputs) {
+  const merged = {};
+  for (const doc of inputs) {
+    const components = doc["components"];
+    if (!isRecord2(components)) {
+      continue;
+    }
+    for (const [section, value] of Object.entries(components)) {
+      if (!isRecord2(value)) {
+        continue;
+      }
+      const target = merged[section] ?? (merged[section] = {});
+      for (const [key, definition] of Object.entries(value)) {
+        if (!(key in target)) {
+          target[key] = definition;
+        }
+      }
+    }
+  }
+  return merged;
+}
+var HTTP_METHODS2 = /* @__PURE__ */ new Set(["get", "put", "post", "delete", "patch", "options", "head", "trace"]);
+function assemblePaths(inputs) {
+  const paths = {};
+  for (const doc of inputs) {
+    const docPaths = doc["paths"];
+    if (!isRecord2(docPaths)) {
+      throw new OpenApiMergeError('Each OpenAPI input must have a "paths" object.');
+    }
+    const docSecurity = doc["security"];
+    for (const [route, pathItem] of Object.entries(docPaths)) {
+      if (!isRecord2(pathItem)) {
+        throw new OpenApiMergeError(`Path item for "${route}" must be an object.`);
+      }
+      const target = paths[route] ?? (paths[route] = {});
+      for (const [method, operation] of Object.entries(pathItem)) {
+        if (method in target) {
+          throw new OpenApiMergeError(
+            `Duplicate operation ${method.toUpperCase()} ${route} across inputs.`
+          );
+        }
+        let resolved = operation;
+        if (HTTP_METHODS2.has(method.toLowerCase()) && isRecord2(operation) && !("security" in operation) && Array.isArray(docSecurity)) {
+          resolved = { ...operation, security: docSecurity };
+        }
+        target[method] = resolved;
+      }
+    }
+  }
+  return paths;
+}
+function mergeOpenApiDocuments(inputs, options) {
+  const records = inputs.map((input, index) => {
+    if (!isRecord2(input)) {
+      throw new OpenApiMergeError(`OpenAPI input at index ${String(index)} must be an object.`);
+    }
+    return input;
+  });
+  return {
+    openapi: options.openapi ?? "3.1.0",
+    info: options.info,
+    servers: collectServers(records, options.servers),
+    tags: collectTags(records),
+    paths: assemblePaths(records),
+    components: mergeComponents(records)
+  };
+}
+
+export { AI_PROVIDER_MODELS, AI_PROVIDER_NAMES, AiConfigError, DocsConfigError, InvalidNavigationError, OpenApiMergeError, ProxyTargetError, SESSION_COOKIE, assertAllowedTarget, buildMetadata, buildRobots, buildSearchIndex, buildSessionCookie, buildSitemap, buildThemeCss, clearSessionCookie, createAskAiRoute, createAuthGate, createEmailSignIn, createGoogleAuth, createMarkdownRoute, createSecretSignIn, createSignOut, createTryItProxy, createTryItProxyRoute, defineDocsConfig, isAllowedEmail, mdxToMarkdown, mergeOpenApiDocuments, openApiOperationToMarkdown, parseNavigation, planDocsTree, readCookie, resolveAiConfig, searchIndex, signSession, unwrapProxyTarget, validateDocsConfig, verifySession };
+//# sourceMappingURL=chunk-3ZX4WIE3.js.map
+//# sourceMappingURL=chunk-3ZX4WIE3.js.map