docula 0.50.0 → 1.0.0

package/dist/docula.js

@@ -1,7 +1,7 @@
 // src/docula.ts
-import fs3 from "fs";
+import fs4 from "fs";
 import http from "http";
-import path5 from "path";
+import path6 from "path";
 import process4 from "process";
 import { pathToFileURL } from "url";
 import { createJiti } from "jiti";
@@ -9,62 +9,581 @@ import handler from "serve-handler";
 import updateNotifier from "update-notifier";
 
 // src/builder.ts
-import fs2 from "fs";
-import path4 from "path";
+import fs3 from "fs";
+import path5 from "path";
 import { Ecto } from "ecto";
 import { Writr } from "writr";
 
+// src/api-parser.ts
+function parseOpenApiSpec(specJson) {
+  const spec = JSON.parse(specJson);
+  const info = {
+    title: spec.info?.title ?? "",
+    description: spec.info?.description ?? "",
+    version: spec.info?.version ?? ""
+  };
+  const servers = [];
+  if (Array.isArray(spec.servers)) {
+    for (const server of spec.servers) {
+      servers.push({
+        url: server.url ?? "",
+        description: server.description ?? ""
+      });
+    }
+  }
+  const tagDescriptions = /* @__PURE__ */ new Map();
+  if (Array.isArray(spec.tags)) {
+    for (const tag of spec.tags) {
+      if (tag.name) {
+        tagDescriptions.set(tag.name, tag.description ?? "");
+      }
+    }
+  }
+  const groupedOperations = /* @__PURE__ */ new Map();
+  const paths = spec.paths ?? {};
+  for (const [pathStr, pathItem] of Object.entries(paths)) {
+    if (!pathItem || typeof pathItem !== "object") {
+      continue;
+    }
+    const methods = [
+      "get",
+      "post",
+      "put",
+      "delete",
+      "patch",
+      "head",
+      "options"
+    ];
+    for (const method of methods) {
+      const operation = pathItem[method];
+      if (!operation) {
+        continue;
+      }
+      const tags = Array.isArray(operation.tags) && operation.tags.length > 0 ? operation.tags : ["Default"];
+      const parameters = extractParameters(operation, pathItem, spec);
+      const requestBody = extractRequestBody(operation, spec);
+      const responses = extractResponses(operation, spec);
+      const baseUrl = servers.length > 0 ? servers[0].url : "";
+      const codeExamples = generateCodeExamples(
+        method,
+        pathStr,
+        baseUrl,
+        parameters,
+        requestBody
+      );
+      const operationId = operation.operationId ?? `${method}-${pathStr.replaceAll(/[^a-zA-Z0-9]/g, "-")}`;
+      const apiOperation = {
+        id: slugify(operationId),
+        method,
+        methodUpper: method.toUpperCase(),
+        path: pathStr,
+        summary: operation.summary ?? "",
+        description: operation.description ?? "",
+        parameters,
+        requestBody,
+        responses,
+        codeExamples
+      };
+      for (const tag of tags) {
+        const existing = groupedOperations.get(tag) ?? [];
+        existing.push(apiOperation);
+        groupedOperations.set(tag, existing);
+      }
+    }
+  }
+  const groups = [];
+  for (const [name, operations] of groupedOperations) {
+    groups.push({
+      name,
+      description: tagDescriptions.get(name) ?? "",
+      id: slugify(name),
+      operations
+    });
+  }
+  return { info, servers, groups };
+}
+function getStatusClass(statusCode) {
+  if (statusCode.startsWith("2")) {
+    return "2xx";
+  }
+  if (statusCode.startsWith("3")) {
+    return "3xx";
+  }
+  if (statusCode.startsWith("4")) {
+    return "4xx";
+  }
+  if (statusCode.startsWith("5")) {
+    return "5xx";
+  }
+  return "default";
+}
+function slugify(text) {
+  return text.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function resolveRef(ref, spec) {
+  if (!ref.startsWith("#/")) {
+    return void 0;
+  }
+  const parts = ref.slice(2).split("/");
+  let current = spec;
+  for (const part of parts) {
+    if (current && typeof current === "object" && part in current) {
+      current = current[part];
+    } else {
+      return void 0;
+    }
+  }
+  return current;
+}
+function resolveSchema(schema, spec, visited = /* @__PURE__ */ new Set()) {
+  if (!schema) {
+    return void 0;
+  }
+  if (schema.$ref) {
+    if (visited.has(schema.$ref)) {
+      return { type: "object", description: "(circular reference)" };
+    }
+    visited.add(schema.$ref);
+    const resolved = resolveRef(schema.$ref, spec);
+    return resolved ? resolveSchema(resolved, spec, visited) : void 0;
+  }
+  return schema;
+}
+function extractSchemaProperties(schema, spec, visited = /* @__PURE__ */ new Set()) {
+  const resolved = resolveSchema(schema, spec, new Set(visited));
+  if (!resolved) {
+    return [];
+  }
+  const properties = [];
+  const requiredFields = Array.isArray(resolved.required) ? resolved.required : [];
+  if (resolved.properties && typeof resolved.properties === "object") {
+    for (const [name, propSchema] of Object.entries(resolved.properties)) {
+      const prop = resolveSchema(
+        propSchema,
+        spec,
+        new Set(visited)
+      );
+      properties.push({
+        name,
+        type: getSchemaType(prop),
+        required: requiredFields.includes(name),
+        description: prop?.description ?? "",
+        enumValues: Array.isArray(prop?.enum) ? prop.enum : void 0
+      });
+    }
+  } else if (resolved.type === "array" && resolved.items) {
+    const itemSchema = resolveSchema(
+      resolved.items,
+      spec,
+      new Set(visited)
+    );
+    properties.push({
+      name: "(items)",
+      type: getSchemaType(itemSchema),
+      required: false,
+      description: itemSchema?.description ?? ""
+    });
+  } else if (resolved.type && resolved.type !== "object") {
+    properties.push({
+      name: "(value)",
+      type: resolved.type,
+      required: false,
+      description: resolved.description ?? ""
+    });
+  }
+  return properties;
+}
+function getSchemaType(schema) {
+  if (!schema) {
+    return "unknown";
+  }
+  if (schema.type === "array") {
+    const items = schema.items;
+    const itemType = items?.type ?? "any";
+    return `array<${itemType}>`;
+  }
+  if (schema.type) {
+    if (schema.format) {
+      return `${schema.type} (${schema.format})`;
+    }
+    return schema.type;
+  }
+  if (schema.oneOf || schema.anyOf) {
+    return "oneOf";
+  }
+  if (schema.allOf) {
+    return "allOf";
+  }
+  return "object";
+}
+function extractParameters(operation, pathItem, spec) {
+  const parameters = [];
+  const allParams = [
+    ...Array.isArray(pathItem.parameters) ? pathItem.parameters : [],
+    ...Array.isArray(operation.parameters) ? operation.parameters : []
+  ];
+  for (const param of allParams) {
+    const resolved = param.$ref ? resolveRef(param.$ref, spec) : param;
+    if (!resolved) {
+      continue;
+    }
+    const paramSchema = resolveSchema(
+      resolved.schema,
+      spec
+    );
+    parameters.push({
+      name: resolved.name ?? "",
+      in: resolved.in ?? "",
+      required: Boolean(resolved.required),
+      type: getSchemaType(paramSchema),
+      description: resolved.description ?? ""
+    });
+  }
+  return parameters;
+}
+function extractRequestBody(operation, spec) {
+  let requestBody = operation.requestBody;
+  if (!requestBody) {
+    return void 0;
+  }
+  if (requestBody.$ref) {
+    requestBody = resolveRef(requestBody.$ref, spec);
+    if (!requestBody) {
+      return void 0;
+    }
+  }
+  const content = requestBody.content;
+  if (!content) {
+    return void 0;
+  }
+  const contentType = Object.keys(content)[0] ?? "application/json";
+  const mediaType = content[contentType];
+  if (!mediaType) {
+    return void 0;
+  }
+  const schema = mediaType.schema;
+  const schemaProperties = extractSchemaProperties(schema, spec);
+  let example = "";
+  if (mediaType.example) {
+    example = JSON.stringify(mediaType.example, null, 2);
+  } else if (schema) {
+    const generated = generateExampleFromSchema(schema, spec);
+    if (generated !== void 0) {
+      example = JSON.stringify(generated, null, 2);
+    }
+  }
+  return { contentType, schemaProperties, example };
+}
+function extractResponses(operation, spec) {
+  const responses = [];
+  const responsesObj = operation.responses;
+  if (!responsesObj) {
+    return responses;
+  }
+  for (const [statusCode, responseObj] of Object.entries(responsesObj)) {
+    let response = responseObj;
+    if (response.$ref) {
+      const resolved = resolveRef(response.$ref, spec);
+      if (!resolved) {
+        continue;
+      }
+      response = resolved;
+    }
+    const content = response.content;
+    let contentType = "";
+    let schemaProperties = [];
+    let example = "";
+    if (content) {
+      contentType = Object.keys(content)[0] ?? "";
+      const mediaType = content[contentType];
+      if (mediaType?.schema) {
+        schemaProperties = extractSchemaProperties(
+          mediaType.schema,
+          spec
+        );
+        if (mediaType.example) {
+          example = JSON.stringify(mediaType.example, null, 2);
+        } else {
+          const generated = generateExampleFromSchema(
+            mediaType.schema,
+            spec
+          );
+          if (generated !== void 0) {
+            example = JSON.stringify(generated, null, 2);
+          }
+        }
+      }
+    }
+    responses.push({
+      statusCode,
+      statusClass: getStatusClass(statusCode),
+      /* v8 ignore next */
+      description: response.description ?? "",
+      contentType,
+      schemaProperties,
+      example
+    });
+  }
+  return responses;
+}
+function generateExampleFromSchema(schema, spec, visited = /* @__PURE__ */ new Set()) {
+  if (!schema) {
+    return void 0;
+  }
+  if (schema.$ref) {
+    if (visited.has(schema.$ref)) {
+      return {};
+    }
+    visited.add(schema.$ref);
+    const resolved = resolveRef(schema.$ref, spec);
+    return resolved ? generateExampleFromSchema(resolved, spec, visited) : void 0;
+  }
+  if (schema.example !== void 0) {
+    return schema.example;
+  }
+  if (schema.type === "object" || schema.properties) {
+    const result = {};
+    if (schema.properties) {
+      for (const [name, propSchema] of Object.entries(schema.properties)) {
+        result[name] = generateExampleFromSchema(
+          propSchema,
+          spec,
+          new Set(visited)
+        );
+      }
+    }
+    if (schema.additionalProperties === true) {
+      result.key = "value";
+    }
+    return result;
+  }
+  if (schema.type === "array") {
+    const itemExample = generateExampleFromSchema(
+      schema.items,
+      spec,
+      new Set(visited)
+    );
+    return itemExample !== void 0 ? [itemExample] : [];
+  }
+  if (schema.enum && Array.isArray(schema.enum) && schema.enum.length > 0) {
+    return schema.enum[0];
+  }
+  const defaults = {
+    string: "string",
+    number: 0,
+    integer: 0,
+    boolean: true
+  };
+  return defaults[schema.type] ?? null;
+}
+function generateCodeExamples(method, pathStr, baseUrl, parameters, requestBody) {
+  const url = `${baseUrl}${pathStr}`;
+  const queryParams = parameters.filter((p) => p.in === "query");
+  const headerParams = parameters.filter((p) => p.in === "header");
+  const queryString = queryParams.length > 0 ? `?${queryParams.map((p) => `${p.name}={${p.name}}`).join("&")}` : "";
+  const fullUrl = `${url}${queryString}`;
+  const curlParts = [`curl -X ${method.toUpperCase()} "${fullUrl}"`];
+  for (const header of headerParams) {
+    curlParts.push(`  -H "${header.name}: {${header.name}}"`);
+  }
+  if (requestBody) {
+    curlParts.push(`  -H "Content-Type: ${requestBody.contentType}"`);
+    if (requestBody.example) {
+      curlParts.push(`  -d '${requestBody.example.replaceAll("\n", "")}'`);
+    }
+  }
+  const curl = curlParts.join(" \\\n");
+  const jsParts = [];
+  const fetchOptions = [];
+  fetchOptions.push(`  method: '${method.toUpperCase()}'`);
+  const jsHeaders = [];
+  for (const header of headerParams) {
+    jsHeaders.push(`    '${header.name}': '{${header.name}}'`);
+  }
+  if (requestBody) {
+    jsHeaders.push(`    'Content-Type': '${requestBody.contentType}'`);
+  }
+  if (jsHeaders.length > 0) {
+    fetchOptions.push(`  headers: {
+${jsHeaders.join(",\n")}
+  }`);
+  }
+  if (requestBody?.example) {
+    fetchOptions.push(
+      `  body: JSON.stringify(${requestBody.example.replaceAll("\n", "")})`
+    );
+  }
+  jsParts.push(`const response = await fetch('${fullUrl}', {`);
+  jsParts.push(fetchOptions.join(",\n"));
+  jsParts.push("});");
+  jsParts.push("const data = await response.json();");
+  const javascript = jsParts.join("\n");
+  const pyParts = [];
+  pyParts.push("import requests");
+  pyParts.push("");
+  const pyArgs = [];
+  if (queryParams.length > 0) {
+    const paramsObj = queryParams.map((p) => `    '${p.name}': '{${p.name}}'`).join(",\n");
+    pyArgs.push(`    params={
+${paramsObj}
+    }`);
+  }
+  const pyHeaders = [];
+  for (const header of headerParams) {
+    pyHeaders.push(`        '${header.name}': '{${header.name}}'`);
+  }
+  if (requestBody) {
+    pyHeaders.push(`        'Content-Type': '${requestBody.contentType}'`);
+  }
+  if (pyHeaders.length > 0) {
+    pyArgs.push(`    headers={
+${pyHeaders.join(",\n")}
+    }`);
+  }
+  if (requestBody?.example) {
+    pyArgs.push(`    json=${requestBody.example.replaceAll("\n", "")}`);
+  }
+  const pyUrl = queryParams.length > 0 ? url : fullUrl;
+  if (pyArgs.length > 0) {
+    pyParts.push(`response = requests.${method}(`);
+    pyParts.push(`    '${pyUrl}',`);
+    pyParts.push(`${pyArgs.join(",\n")}`);
+    pyParts.push(")");
+  } else {
+    pyParts.push(`response = requests.${method}('${pyUrl}')`);
+  }
+  pyParts.push("data = response.json()");
+  const python = pyParts.join("\n");
+  return { curl, javascript, python };
+}
+
 // src/console.ts
 import path from "path";
 import process from "process";
+import {
+  blue,
+  bold,
+  cyan,
+  dim,
+  gray,
+  green,
+  magenta,
+  red,
+  yellow
+} from "colorette";
+var ansiRegex = /\u001B\[[0-9;]*m/g;
 var DoculaConsole = class {
   log(message) {
     console.log(message);
   }
   error(message) {
-    console.error(message);
+    console.error(red(bold(`\u2718 [error] ${message}`)));
   }
   warn(message) {
-    console.warn(message);
+    console.warn(yellow(`\u26A0 [warn] ${message}`));
+  }
+  success(message) {
+    console.log(green(bold(`\u2714 ${message}`)));
+  }
+  info(message) {
+    console.log(cyan(`\u2139 ${message}`));
+  }
+  step(message) {
+    console.log(bold(blue(`\u25B6 ${message}`)));
+  }
+  fileBuilt(filePath) {
+    console.log(dim(`  \u2192 ${filePath}`));
+  }
+  fileCopied(filePath) {
+    this.fileBuilt(filePath);
+  }
+  serverLog(method, url, statusCode, durationMs) {
+    let statusColor = green;
+    if (statusCode >= 400) {
+      statusColor = red;
+    } else if (statusCode >= 300) {
+      statusColor = yellow;
+    }
+    const sanitizedMethod = method.replace(ansiRegex, "");
+    const sanitizedUrl = url.replace(ansiRegex, "");
+    const parts = [
+      `  ${bold(sanitizedMethod)}`,
+      sanitizedUrl,
+      statusColor(String(statusCode))
+    ];
+    if (durationMs !== void 0) {
+      parts.push(gray(`${durationMs}ms`));
+    }
+    console.log(parts.join(" "));
+  }
+  banner(message) {
+    console.log(bold(magenta(message)));
   }
   printHelp() {
-    console.log("   Usage: docula [command] [arguments]");
+    console.log(
+      bold(
+        magenta(
+          "\n  Docula \u{1F987} \u2014 Beautiful Website for Your Projects\n"
+        )
+      )
+    );
+    console.log(bold(cyan("  Usage:")));
+    console.log("    docula [command] [arguments]");
     console.log();
-    console.log("   Commands:");
-    console.log("     init           Initialize a new project");
+    console.log(bold(cyan("  Commands:")));
+    console.log(`    ${green("init")}           Initialize a new project`);
+    console.log(
+      `    ${green("build")}          Build the project. By default just npx docula will build the project if it finds a ./site folder`
+    );
     console.log(
-      "     build          Build the project. By default just npx docula will build the project if it finds a ./site folder"
+      `    ${green("serve")}          Serve the project as a local website`
     );
-    console.log("     serve          Serve the project as a local website");
-    console.log("     help           Print this help");
-    console.log("     version        Print the version");
+    console.log(`    ${green("help")}           Print this help`);
+    console.log(`    ${green("version")}        Print the version`);
     console.log();
-    console.log("   Arguments init:");
+    console.log(bold(cyan("  Arguments init:")));
     console.log(
-      "     --typescript       Generate TypeScript config file (docula.config.ts)"
+      `    ${yellow("--typescript")}       Generate TypeScript config file (docula.config.ts)`
     );
     console.log(
-      "     -s, --site         Set the path where site files are located"
+      `    ${yellow("-s, --site")}         Set the path where site files are located`
     );
     console.log();
-    console.log("   Arguments build:");
-    console.log("     -w, --watch            watch for changes and rebuild");
+    console.log(bold(cyan("  Arguments build:")));
+    console.log(
+      `    ${yellow("-w, --watch")}            watch for changes and rebuild`
+    );
     console.log(
-      "     -s, --site             Set the path where site files are located"
+      `    ${yellow("-c, --clean")}            Clean the output directory before building`
     );
     console.log(
-      "     -o, --outputPath       Set the output directory. Default is ./site/dist"
+      `    ${yellow("-s, --site")}             Set the path where site files are located`
     );
-    console.log("     -t, --templatePath     Set the custom template to use");
     console.log(
-      "     -T, --template         Set the built-in template name (e.g., modern, classic)"
+      `    ${yellow("-o, --output")}           Set the output directory. Default is ./site/dist`
+    );
+    console.log(
+      `    ${yellow("-t, --templatePath")}     Set the custom template to use`
+    );
+    console.log(
+      `    ${yellow("-T, --template")}         Set the built-in template name (e.g., modern, classic)`
     );
     console.log();
-    console.log("   Arguments serve:");
-    console.log("     -p, --port         Set the port number used with serve");
-    console.log("     -w, --watch        watch for changes and rebuild");
+    console.log(bold(cyan("  Arguments serve:")));
+    console.log(
+      `    ${yellow("-p, --port")}         Set the port number used with serve`
+    );
+    console.log(
+      `    ${yellow("-b, --build")}        Build the site before serving`
+    );
     console.log(
-      "     -s, --site         Set the path where site files are located"
+      `    ${yellow("-w, --watch")}        watch for changes and rebuild`
+    );
+    console.log(
+      `    ${yellow("-c, --clean")}        Clean the output directory before building`
+    );
+    console.log(
+      `    ${yellow("-s, --site")}         Set the path where site files are located`
     );
   }
   parseProcessArgv(argv) {
@@ -104,7 +623,9 @@ var DoculaConsole = class {
       template: "",
       output: "",
       watch: false,
-      port: 3e3,
+      clean: false,
+      build: false,
+      port: void 0,
       typescript: false
     };
     for (let i = 0; i < argv.length; i++) {
@@ -129,6 +650,16 @@ var DoculaConsole = class {
           arguments_.watch = true;
           break;
         }
+        case "-c":
+        case "--clean": {
+          arguments_.clean = true;
+          break;
+        }
+        case "-b":
+        case "--build": {
+          arguments_.build = true;
+          break;
+        }
         case "-s":
         case "--site": {
           arguments_.sitePath = argv[i + 1];
@@ -160,6 +691,8 @@ var DoculaConsole = class {
 };
 
 // src/github.ts
+import fs from "fs";
+import path2 from "path";
 import process2 from "process";
 import { CacheableNet } from "@cacheable/net";
 var Github = class {
@@ -169,18 +702,32 @@ var Github = class {
     repo: ""
   };
   net;
-  constructor(options) {
+  cacheConfig;
+  constructor(options, cacheConfig) {
     this.parseOptions(options);
     this.net = new CacheableNet();
+    if (cacheConfig) {
+      this.cacheConfig = cacheConfig;
+    }
   }
   async getData() {
+    if (this.cacheConfig && this.cacheConfig.ttl > 0) {
+      const cached = this.loadCache();
+      if (cached) {
+        return cached;
+      }
+    }
     const data = {
       releases: {},
       contributors: {}
     };
     data.releases = await this.getReleases();
     data.contributors = await this.getContributors();
-    return data;
+    const result = data;
+    if (this.cacheConfig && this.cacheConfig.ttl > 0) {
+      this.saveCache(result);
+    }
+    return result;
   }
   // biome-ignore lint/suspicious/noExplicitAny: need to fix
   async getReleases() {
@@ -244,6 +791,41 @@ var Github = class {
     this.options.author = options.author;
     this.options.repo = options.repo;
   }
+  getCacheFilePath() {
+    if (!this.cacheConfig) {
+      throw new Error("Cache config is not set");
+    }
+    const cacheDir = path2.join(this.cacheConfig.cachePath, "github");
+    return path2.join(cacheDir, "github-data.json");
+  }
+  loadCache() {
+    try {
+      const cacheFile = this.getCacheFilePath();
+      if (!fs.existsSync(cacheFile)) {
+        return void 0;
+      }
+      const stat = fs.statSync(cacheFile);
+      const ageInSeconds = (Date.now() - stat.mtimeMs) / 1e3;
+      if (ageInSeconds > (this.cacheConfig?.ttl ?? 0)) {
+        return void 0;
+      }
+      const raw = fs.readFileSync(cacheFile, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+  }
+  saveCache(data) {
+    try {
+      const cacheFile = this.getCacheFilePath();
+      const cacheDir = path2.dirname(cacheFile);
+      if (!fs.existsSync(cacheDir)) {
+        fs.mkdirSync(cacheDir, { recursive: true });
+      }
+      fs.writeFileSync(cacheFile, JSON.stringify(data, null, 2));
+    } catch {
+    }
+  }
   // biome-ignore lint/suspicious/noExplicitAny: need to fix
   addAnchorLink(data) {
     return data.map((release) => {
@@ -255,7 +837,7 @@ var Github = class {
 };
 
 // src/options.ts
-import path2 from "path";
+import path3 from "path";
 import process3 from "process";
 var DoculaOptions = class {
   /**
@@ -269,15 +851,15 @@ var DoculaOptions = class {
   /**
    * Path to the output directory
    */
-  outputPath = path2.join(process3.cwd(), "./dist");
+  output = path3.join(process3.cwd(), "./dist");
   /**
    * Path to the site directory
    */
-  sitePath = path2.join(process3.cwd(), "./site");
+  sitePath = path3.join(process3.cwd(), "./site");
   /**
    * Path to the github repository
    */
-  githubPath = "jaredwray/docula";
+  githubPath = "";
   /**
    * Site title
    */
@@ -294,10 +876,6 @@ var DoculaOptions = class {
    * Port to run the server
    */
   port = 3e3;
-  /**
-   * Single page website
-   */
-  singlePage = true;
   /**
    * Sections
    */
@@ -322,6 +900,66 @@ var DoculaOptions = class {
    * When true, generates llms.txt and llms-full.txt files for the built site.
    */
   enableLlmsTxt = true;
+  /**
+   * Override the default theme toggle. By default the site follows the system
+   * preference. Set to "light" or "dark" to use that theme when no user
+   * preference is stored in localStorage.
+   */
+  themeMode;
+  /**
+   * When true, automatically adds generated paths (e.g., .cache) to the
+   * site directory's .gitignore file if not already present.
+   */
+  autoUpdateIgnores = true;
+  /**
+   * File extensions to copy as assets from docs/ and changelog/ directories.
+   * Override in docula.config to customize.
+   */
+  /**
+   * Cookie-based authentication. When set, shows a Login/Logout button
+   * in the header based on whether a JWT cookie is present.
+   */
+  cookieAuth;
+  /**
+   * File extensions to copy as assets from docs/ and changelog/ directories.
+   * Override in docula.config to customize.
+   */
+  /**
+   * Cache settings. Controls caching of external data (e.g., GitHub API responses)
+   * in the .cache directory within the site path.
+   */
+  cache = {
+    github: {
+      ttl: 3600
+    }
+  };
+  /**
+   * File extensions to copy as assets from docs/ and changelog/ directories.
+   * Override in docula.config to customize.
+   */
+  allowedAssets = [
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".svg",
+    ".webp",
+    ".avif",
+    ".ico",
+    ".pdf",
+    ".zip",
+    ".tar",
+    ".gz",
+    ".mp4",
+    ".webm",
+    ".ogg",
+    ".mp3",
+    ".wav",
+    ".json",
+    ".xml",
+    ".csv",
+    ".txt"
+  ];
   constructor(options) {
     if (options) {
       this.parseOptions(options);
@@ -334,15 +972,15 @@ var DoculaOptions = class {
     }
     if (options.templatePath) {
       this.templatePath = options.templatePath;
-      this.templatePath = path2.join(process3.cwd(), this.templatePath);
+      this.templatePath = path3.join(process3.cwd(), this.templatePath);
     }
-    if (options.outputPath) {
-      this.outputPath = options.outputPath;
-      this.outputPath = path2.join(process3.cwd(), this.outputPath);
+    if (options.output) {
+      this.output = options.output;
+      this.output = path3.join(process3.cwd(), this.output);
     }
     if (options.sitePath) {
       this.sitePath = options.sitePath;
-      this.sitePath = path2.join(process3.cwd(), this.sitePath);
+      this.sitePath = path3.join(process3.cwd(), this.sitePath);
     }
     if (options.githubPath) {
       this.githubPath = options.githubPath;
@@ -362,9 +1000,6 @@ var DoculaOptions = class {
     if (options.port) {
       this.port = options.port;
     }
-    if (options.singlePage !== void 0 && typeof options.singlePage === "boolean") {
-      this.singlePage = options.singlePage;
-    }
     if (options.openApiUrl) {
       this.openApiUrl = options.openApiUrl;
     }
@@ -377,30 +1012,45 @@ var DoculaOptions = class {
     if (options.enableLlmsTxt !== void 0 && typeof options.enableLlmsTxt === "boolean") {
       this.enableLlmsTxt = options.enableLlmsTxt;
     }
+    if (options.themeMode !== void 0 && (options.themeMode === "light" || options.themeMode === "dark")) {
+      this.themeMode = options.themeMode;
+    }
+    if (options.autoUpdateIgnores !== void 0 && typeof options.autoUpdateIgnores === "boolean") {
+      this.autoUpdateIgnores = options.autoUpdateIgnores;
+    }
+    if (options.cache && typeof options.cache === "object" && options.cache.github !== null && typeof options.cache.github === "object" && typeof options.cache.github.ttl === "number") {
+      this.cache = options.cache;
+    }
+    if (options.allowedAssets && Array.isArray(options.allowedAssets)) {
+      this.allowedAssets = options.allowedAssets;
+    }
+    if (options.cookieAuth && typeof options.cookieAuth === "object" && typeof options.cookieAuth.loginUrl === "string") {
+      this.cookieAuth = options.cookieAuth;
+    }
   }
 };
 
 // src/template-resolver.ts
-import fs from "fs";
-import path3 from "path";
+import fs2 from "fs";
+import path4 from "path";
 function getBuiltInTemplatesDir() {
-  return path3.join(import.meta.url, "../../templates").replace("file:", "");
+  return path4.join(import.meta.url, "../../templates").replace("file:", "");
 }
 function listBuiltInTemplates() {
   const templatesDir = getBuiltInTemplatesDir();
-  if (!fs.existsSync(templatesDir)) {
+  if (!fs2.existsSync(templatesDir)) {
     return [];
   }
-  return fs.readdirSync(templatesDir).filter(
-    (entry) => fs.statSync(path3.join(templatesDir, entry)).isDirectory()
+  return fs2.readdirSync(templatesDir).filter(
+    (entry) => fs2.statSync(path4.join(templatesDir, entry)).isDirectory()
   );
 }
 function resolveTemplatePath(templatePath, templateName) {
   if (templatePath) {
     return templatePath;
   }
-  const resolvedPath = path3.join(getBuiltInTemplatesDir(), templateName);
-  if (!fs.existsSync(resolvedPath)) {
+  const resolvedPath = path4.join(getBuiltInTemplatesDir(), templateName);
+  if (!fs2.existsSync(resolvedPath)) {
     const available = listBuiltInTemplates();
     throw new Error(
       `Built-in template "${templateName}" not found. Available templates: ${available.join(", ")}`
@@ -427,8 +1077,9 @@ var DoculaBuilder = class {
   async build() {
     const startTime = Date.now();
     this.validateOptions(this.options);
-    const resolvedTemplatePath = resolveTemplatePath(
-      this.options.templatePath,
+    const resolvedTemplatePath = this.mergeTemplateOverrides(
+      resolveTemplatePath(this.options.templatePath, this.options.template),
+      this.options.sitePath,
       this.options.template
     );
     const doculaData = {
@@ -437,16 +1088,20 @@ var DoculaBuilder = class {
       siteDescription: this.options.siteDescription,
       sitePath: this.options.sitePath,
       templatePath: resolvedTemplatePath,
-      outputPath: this.options.outputPath,
+      output: this.options.output,
       githubPath: this.options.githubPath,
       sections: this.options.sections,
       openApiUrl: this.options.openApiUrl,
-      homePage: this.options.homePage
+      homePage: this.options.homePage,
+      themeMode: this.options.themeMode,
+      cookieAuth: this.options.cookieAuth
     };
-    if (!doculaData.openApiUrl && fs2.existsSync(`${doculaData.sitePath}/api/swagger.json`)) {
+    if (!doculaData.openApiUrl && fs3.existsSync(`${doculaData.sitePath}/api/swagger.json`)) {
       doculaData.openApiUrl = "/api/swagger.json";
     }
-    doculaData.github = await this.getGithubData(this.options.githubPath);
+    if (this.options.githubPath) {
+      doculaData.github = await this.getGithubData(this.options.githubPath);
+    }
     doculaData.documents = this.getDocuments(
       `${doculaData.sitePath}/docs`,
       doculaData
@@ -491,63 +1146,106 @@ var DoculaBuilder = class {
     doculaData.hasApi = Boolean(
       doculaData.openApiUrl && doculaData.templates?.api
     );
+    this._console.step("Building pages...");
     if (!this.options.homePage && doculaData.hasDocuments) {
       await this.buildDocsHomePage(doculaData);
+      this._console.fileBuilt("index.html");
+    } else if (!this.options.homePage && !doculaData.hasDocuments) {
+      this._console.error(
+        "homePage is set to false but no documents were found in the docs directory. Add documents to the docs/ folder or set homePage to true."
+      );
     } else {
       await this.buildIndexPage(doculaData);
+      this._console.fileBuilt("index.html");
     }
     await this.buildSiteMapPage(doculaData);
+    this._console.fileBuilt("sitemap.xml");
     await this.buildRobotsPage(this.options);
+    this._console.fileBuilt("robots.txt");
     if (doculaData.hasDocuments) {
+      this._console.step("Building documentation pages...");
       await this.buildDocsPages(doculaData);
+      for (const document of doculaData.documents ?? []) {
+        this._console.fileBuilt(document.urlPath);
+      }
     }
     if (doculaData.hasApi) {
+      this._console.step("Building API page...");
       await this.buildApiPage(doculaData);
+      this._console.fileBuilt("api/index.html");
     }
     if (doculaData.hasChangelog) {
+      this._console.step("Building changelog...");
       await this.buildChangelogPage(doculaData);
+      this._console.fileBuilt("changelog/index.html");
       await this.buildChangelogEntryPages(doculaData);
+      for (const entry of doculaData.changelogEntries ?? []) {
+        this._console.fileBuilt(`changelog/${entry.slug}/index.html`);
+      }
     }
     const siteRelativePath = this.options.sitePath;
-    if (fs2.existsSync(`${siteRelativePath}/favicon.ico`)) {
-      await fs2.promises.copyFile(
+    this._console.step("Copying assets...");
+    if (fs3.existsSync(`${siteRelativePath}/favicon.ico`)) {
+      await fs3.promises.copyFile(
         `${siteRelativePath}/favicon.ico`,
-        `${this.options.outputPath}/favicon.ico`
+        `${this.options.output}/favicon.ico`
       );
+      this._console.fileCopied("favicon.ico");
     }
-    if (fs2.existsSync(`${siteRelativePath}/logo.svg`)) {
-      await fs2.promises.copyFile(
+    if (fs3.existsSync(`${siteRelativePath}/logo.svg`)) {
+      await fs3.promises.copyFile(
         `${siteRelativePath}/logo.svg`,
-        `${this.options.outputPath}/logo.svg`
+        `${this.options.output}/logo.svg`
       );
+      this._console.fileCopied("logo.svg");
     }
-    if (fs2.existsSync(`${siteRelativePath}/logo_horizontal.png`)) {
-      await fs2.promises.copyFile(
+    if (fs3.existsSync(`${siteRelativePath}/logo_horizontal.png`)) {
+      await fs3.promises.copyFile(
         `${siteRelativePath}/logo_horizontal.png`,
-        `${this.options.outputPath}/logo_horizontal.png`
+        `${this.options.output}/logo_horizontal.png`
       );
+      this._console.fileCopied("logo_horizontal.png");
     }
-    if (fs2.existsSync(`${resolvedTemplatePath}/css`)) {
+    if (fs3.existsSync(`${resolvedTemplatePath}/css`)) {
       this.copyDirectory(
         `${resolvedTemplatePath}/css`,
-        `${this.options.outputPath}/css`
+        `${this.options.output}/css`
       );
+      this._console.fileCopied("css/");
     }
-    if (fs2.existsSync(`${siteRelativePath}/variables.css`)) {
-      await fs2.promises.copyFile(
+    if (fs3.existsSync(`${resolvedTemplatePath}/js`)) {
+      this.copyDirectory(
+        `${resolvedTemplatePath}/js`,
+        `${this.options.output}/js`
+      );
+      this._console.fileCopied("js/");
+    }
+    if (fs3.existsSync(`${siteRelativePath}/variables.css`)) {
+      await fs3.promises.copyFile(
         `${siteRelativePath}/variables.css`,
-        `${this.options.outputPath}/css/variables.css`
+        `${this.options.output}/css/variables.css`
       );
+      this._console.fileCopied("css/variables.css");
+    }
+    this.copyPublicFolder(siteRelativePath, this.options.output);
+    this.copyContentAssets(
+      `${doculaData.sitePath}/changelog`,
+      `${this.options.output}/changelog`
+    );
+    if (doculaData.documents?.length) {
+      this.copyDocumentSiblingAssets(doculaData);
+    }
+    if (this.options.enableLlmsTxt) {
+      this._console.step("Building LLM files...");
     }
-    this.copyPublicFolder(siteRelativePath, this.options.outputPath);
     await this.buildLlmsFiles(doculaData);
     const endTime = Date.now();
     const executionTime = endTime - startTime;
-    this._console.log(`Build completed in ${executionTime}ms`);
+    this._console.success(`Build completed in ${executionTime}ms`);
   }
   validateOptions(options) {
-    if (options.githubPath.length < 3) {
-      throw new Error("No github options provided");
+    if (options.githubPath && !options.githubPath.includes("/")) {
+      throw new Error("githubPath must be in 'owner/repo' format");
     }
     if (options.siteDescription.length < 3) {
       throw new Error("No site description options provided");
@@ -565,14 +1263,21 @@ var DoculaBuilder = class {
       author: paths[0],
       repo: paths[1]
     };
-    const github = new Github(options);
+    let cacheConfig;
+    if (this._options.cache.github.ttl > 0) {
+      cacheConfig = {
+        cachePath: path5.join(this._options.sitePath, ".cache"),
+        ttl: this._options.cache.github.ttl
+      };
+    }
+    const github = new Github(options, cacheConfig);
     return github.getData();
   }
   async getTemplates(templatePath, hasDocuments, hasChangelog = false) {
     const templates = {
       home: ""
     };
-    if (fs2.existsSync(templatePath)) {
+    if (fs3.existsSync(templatePath)) {
       const home = await this.getTemplateFile(templatePath, "home");
       if (home) {
         templates.home = home;
@@ -598,9 +1303,9 @@ var DoculaBuilder = class {
     }
     return templates;
   }
-  async getTemplateFile(path6, name) {
+  async getTemplateFile(path7, name) {
     let result;
-    const files = await fs2.promises.readdir(path6);
+    const files = await fs3.promises.readdir(path7);
     for (const file of files) {
       const fileName = file.split(".");
       if (fileName[0].toString().toLowerCase() === name.toLowerCase()) {
@@ -612,13 +1317,13 @@ var DoculaBuilder = class {
   }
   async buildRobotsPage(options) {
     const { sitePath } = options;
-    const { outputPath } = options;
-    const robotsPath = `${outputPath}/robots.txt`;
-    await fs2.promises.mkdir(outputPath, { recursive: true });
-    await (fs2.existsSync(`${sitePath}/robots.txt`) ? fs2.promises.copyFile(`${sitePath}/robots.txt`, robotsPath) : fs2.promises.writeFile(robotsPath, "User-agent: *\nDisallow:"));
+    const { output } = options;
+    const robotsPath = `${output}/robots.txt`;
+    await fs3.promises.mkdir(output, { recursive: true });
+    await (fs3.existsSync(`${sitePath}/robots.txt`) ? fs3.promises.copyFile(`${sitePath}/robots.txt`, robotsPath) : fs3.promises.writeFile(robotsPath, "User-agent: *\nDisallow:"));
   }
   async buildSiteMapPage(data) {
-    const sitemapPath = `${data.outputPath}/sitemap.xml`;
+    const sitemapPath = `${data.output}/sitemap.xml`;
     const urls = [{ url: data.siteUrl }];
     if (data.openApiUrl && data.templates?.api) {
       urls.push({ url: `${data.siteUrl}/api` });
@@ -646,16 +1351,16 @@ var DoculaBuilder = class {
       xml += "</url>";
     }
     xml += "</urlset>";
-    await fs2.promises.mkdir(data.outputPath, { recursive: true });
-    await fs2.promises.writeFile(sitemapPath, xml, "utf8");
+    await fs3.promises.mkdir(data.output, { recursive: true });
+    await fs3.promises.writeFile(sitemapPath, xml, "utf8");
   }
   async buildLlmsFiles(data) {
     if (!this.options.enableLlmsTxt) {
       return;
     }
-    await fs2.promises.mkdir(data.outputPath, { recursive: true });
-    const llmsOutputPath = `${data.outputPath}/llms.txt`;
-    const llmsFullOutputPath = `${data.outputPath}/llms-full.txt`;
+    await fs3.promises.mkdir(data.output, { recursive: true });
+    const llmsOutputPath = `${data.output}/llms.txt`;
+    const llmsFullOutputPath = `${data.output}/llms-full.txt`;
     const llmsOverrideContent = await this.getSafeSiteOverrideFileContent(
       data.sitePath,
       "llms.txt"
@@ -665,21 +1370,23 @@ var DoculaBuilder = class {
       "llms-full.txt"
     );
     if (llmsOverrideContent !== void 0) {
-      await fs2.promises.writeFile(llmsOutputPath, llmsOverrideContent, "utf8");
+      await fs3.promises.writeFile(llmsOutputPath, llmsOverrideContent, "utf8");
     } else {
       const llmsContent = this.generateLlmsIndexContent(data);
-      await fs2.promises.writeFile(llmsOutputPath, llmsContent, "utf8");
+      await fs3.promises.writeFile(llmsOutputPath, llmsContent, "utf8");
     }
+    this._console.fileBuilt("llms.txt");
     if (llmsFullOverrideContent !== void 0) {
-      await fs2.promises.writeFile(
+      await fs3.promises.writeFile(
         llmsFullOutputPath,
         llmsFullOverrideContent,
         "utf8"
       );
     } else {
       const llmsFullContent = await this.generateLlmsFullContent(data);
-      await fs2.promises.writeFile(llmsFullOutputPath, llmsFullContent, "utf8");
+      await fs3.promises.writeFile(llmsFullOutputPath, llmsFullContent, "utf8");
     }
+    this._console.fileBuilt("llms-full.txt");
   }
   generateLlmsIndexContent(data) {
     const lines = [];
@@ -846,17 +1553,17 @@ var DoculaBuilder = class {
       return void 0;
     }
     const normalizedPath = openApiPathWithoutQuery.startsWith("/") ? openApiPathWithoutQuery.slice(1) : openApiPathWithoutQuery;
-    return path4.join(data.sitePath, normalizedPath);
+    return path5.join(data.sitePath, normalizedPath);
   }
   async getSafeSiteOverrideFileContent(sitePath, fileName) {
-    const resolvedSitePath = path4.resolve(sitePath);
-    const candidatePath = path4.resolve(sitePath, fileName);
+    const resolvedSitePath = path5.resolve(sitePath);
+    const candidatePath = path5.resolve(sitePath, fileName);
     if (!this.isPathWithinBasePath(candidatePath, resolvedSitePath)) {
       return void 0;
     }
     let candidateStats;
     try {
-      candidateStats = await fs2.promises.lstat(candidatePath);
+      candidateStats = await fs3.promises.lstat(candidatePath);
     } catch {
       return void 0;
     }
@@ -866,29 +1573,29 @@ var DoculaBuilder = class {
     let realSitePath;
     let realCandidatePath;
     try {
-      realSitePath = await fs2.promises.realpath(resolvedSitePath);
-      realCandidatePath = await fs2.promises.realpath(candidatePath);
+      realSitePath = await fs3.promises.realpath(resolvedSitePath);
+      realCandidatePath = await fs3.promises.realpath(candidatePath);
     } catch {
       return void 0;
     }
     if (!this.isPathWithinBasePath(realCandidatePath, realSitePath)) {
       return void 0;
     }
-    return fs2.promises.readFile(realCandidatePath, "utf8");
+    return fs3.promises.readFile(realCandidatePath, "utf8");
   }
   async getSafeLocalOpenApiSpec(data) {
     const localOpenApiPath = this.resolveLocalOpenApiPath(data);
     if (!localOpenApiPath) {
       return void 0;
     }
-    const resolvedSitePath = path4.resolve(data.sitePath);
-    const resolvedLocalOpenApiPath = path4.resolve(localOpenApiPath);
+    const resolvedSitePath = path5.resolve(data.sitePath);
+    const resolvedLocalOpenApiPath = path5.resolve(localOpenApiPath);
     if (!this.isPathWithinBasePath(resolvedLocalOpenApiPath, resolvedSitePath)) {
       return void 0;
     }
     let localOpenApiStats;
     try {
-      localOpenApiStats = await fs2.promises.lstat(resolvedLocalOpenApiPath);
+      localOpenApiStats = await fs3.promises.lstat(resolvedLocalOpenApiPath);
     } catch {
       return void 0;
     }
@@ -898,8 +1605,8 @@ var DoculaBuilder = class {
     let realSitePath;
     let realLocalOpenApiPath;
     try {
-      realSitePath = await fs2.promises.realpath(resolvedSitePath);
-      realLocalOpenApiPath = await fs2.promises.realpath(
+      realSitePath = await fs3.promises.realpath(resolvedSitePath);
+      realLocalOpenApiPath = await fs3.promises.realpath(
         resolvedLocalOpenApiPath
       );
     } catch {
@@ -908,26 +1615,26 @@ var DoculaBuilder = class {
     if (!this.isPathWithinBasePath(realLocalOpenApiPath, realSitePath)) {
       return void 0;
     }
-    const localOpenApiContent = (await fs2.promises.readFile(realLocalOpenApiPath, "utf8")).trim();
+    const localOpenApiContent = (await fs3.promises.readFile(realLocalOpenApiPath, "utf8")).trim();
     return {
       sourcePath: realLocalOpenApiPath,
       content: localOpenApiContent
     };
   }
   isPathWithinBasePath(candidatePath, basePath) {
-    const relativePath = path4.relative(
-      path4.resolve(basePath),
-      path4.resolve(candidatePath)
+    const relativePath = path5.relative(
+      path5.resolve(basePath),
+      path5.resolve(candidatePath)
     );
-    return relativePath === "" || !relativePath.startsWith("..") && !path4.isAbsolute(relativePath);
+    return relativePath === "" || !relativePath.startsWith("..") && !path5.isAbsolute(relativePath);
   }
   toPosixPath(filePath) {
-    return filePath.replaceAll(path4.sep, path4.posix.sep);
+    return filePath.replaceAll(path5.sep, path5.posix.sep);
   }
   async buildIndexPage(data) {
     if (data.templates) {
-      const indexPath = `${data.outputPath}/index.html`;
-      await fs2.promises.mkdir(data.outputPath, { recursive: true });
+      const indexPath = `${data.output}/index.html`;
+      await fs3.promises.mkdir(data.output, { recursive: true });
       const indexTemplate = `${data.templatePath}/${data.templates.home}`;
       let content;
       if (!data.hasDocuments) {
@@ -939,7 +1646,7 @@ var DoculaBuilder = class {
         { ...data, content, announcement },
         data.templatePath
       );
-      await fs2.promises.writeFile(indexPath, indexContent, "utf8");
+      await fs3.promises.writeFile(indexPath, indexContent, "utf8");
     } else {
       throw new Error("No templates found");
     }
@@ -951,8 +1658,8 @@ var DoculaBuilder = class {
     if (!data.documents?.length) {
       throw new Error("No documents found for homePage");
     }
-    const indexPath = `${data.outputPath}/index.html`;
-    await fs2.promises.mkdir(data.outputPath, { recursive: true });
+    const indexPath = `${data.output}/index.html`;
+    await fs3.promises.mkdir(data.output, { recursive: true });
     const documentsTemplate = `${data.templatePath}/${data.templates.docPage}`;
     const firstDocument = data.documents[0];
     if (!data.sidebarItems) {
@@ -963,12 +1670,12 @@ var DoculaBuilder = class {
       { ...data, ...firstDocument },
       data.templatePath
     );
-    await fs2.promises.writeFile(indexPath, documentContent, "utf8");
+    await fs3.promises.writeFile(indexPath, documentContent, "utf8");
   }
   async buildReadmeSection(data) {
     let htmlReadme = "";
-    if (fs2.existsSync(`${data.sitePath}/README.md`)) {
-      const readmeContent = fs2.readFileSync(
+    if (fs3.existsSync(`${data.sitePath}/README.md`)) {
+      const readmeContent = fs3.readFileSync(
         `${data.sitePath}/README.md`,
         "utf8"
       );
@@ -978,8 +1685,8 @@ var DoculaBuilder = class {
   }
   async buildAnnouncementSection(data) {
     const announcementPath = `${data.sitePath}/announcement.md`;
-    if (fs2.existsSync(announcementPath)) {
-      const announcementContent = fs2.readFileSync(announcementPath, "utf8");
+    if (fs3.existsSync(announcementPath)) {
+      const announcementContent = fs3.readFileSync(announcementPath, "utf8");
       return new Writr(announcementContent).render();
     }
     return void 0;
@@ -987,20 +1694,20 @@ var DoculaBuilder = class {
   async buildDocsPages(data) {
     if (data.templates && data.documents?.length) {
       const documentsTemplate = `${data.templatePath}/${data.templates.docPage}`;
-      await fs2.promises.mkdir(`${data.outputPath}/docs`, { recursive: true });
+      await fs3.promises.mkdir(`${data.output}/docs`, { recursive: true });
       data.sidebarItems = this.generateSidebarItems(data);
       const promises = data.documents.map(async (document) => {
         const folder = document.urlPath.split("/").slice(0, -1).join("/");
-        await fs2.promises.mkdir(`${data.outputPath}/${folder}`, {
+        await fs3.promises.mkdir(`${data.output}/${folder}`, {
           recursive: true
         });
-        const slug = `${data.outputPath}${document.urlPath}`;
+        const slug = `${data.output}${document.urlPath}`;
         const documentContent = await this._ecto.renderFromFile(
           documentsTemplate,
           { ...data, ...document },
           data.templatePath
         );
-        return fs2.promises.writeFile(slug, documentContent, "utf8");
+        return fs3.promises.writeFile(slug, documentContent, "utf8");
       });
       await Promise.all(promises);
     } else {
@@ -1011,33 +1718,56 @@ var DoculaBuilder = class {
     if (!data.openApiUrl || !data.templates?.api) {
       return;
     }
-    const apiPath = `${data.outputPath}/api/index.html`;
-    const apiOutputPath = `${data.outputPath}/api`;
-    await fs2.promises.mkdir(apiOutputPath, { recursive: true });
+    const apiPath = `${data.output}/api/index.html`;
+    const apiOutputPath = `${data.output}/api`;
+    await fs3.promises.mkdir(apiOutputPath, { recursive: true });
     const swaggerSource = `${data.sitePath}/api/swagger.json`;
-    if (fs2.existsSync(swaggerSource)) {
-      await fs2.promises.copyFile(
+    if (fs3.existsSync(swaggerSource)) {
+      await fs3.promises.copyFile(
         swaggerSource,
         `${apiOutputPath}/swagger.json`
       );
     }
+    let apiSpec;
+    const localSpec = await this.getSafeLocalOpenApiSpec(data);
+    if (localSpec) {
+      apiSpec = parseOpenApiSpec(localSpec.content);
+    } else if (data.openApiUrl && this.isRemoteUrl(data.openApiUrl)) {
+      try {
+        const response = await fetch(data.openApiUrl);
+        const specContent = await response.text();
+        apiSpec = parseOpenApiSpec(specContent);
+      } catch {
+      }
+    }
+    if (apiSpec) {
+      apiSpec.info.description = new Writr(
+        apiSpec.info.description
+      ).renderSync();
+      for (const group of apiSpec.groups) {
+        group.description = new Writr(group.description).renderSync();
+        for (const op of group.operations) {
+          op.description = new Writr(op.description).renderSync();
+        }
+      }
+    }
     const apiTemplate = `${data.templatePath}/${data.templates.api}`;
     const apiContent = await this._ecto.renderFromFile(
       apiTemplate,
-      { ...data, specUrl: data.openApiUrl },
+      { ...data, specUrl: data.openApiUrl, apiSpec },
       data.templatePath
     );
-    await fs2.promises.writeFile(apiPath, apiContent, "utf8");
+    await fs3.promises.writeFile(apiPath, apiContent, "utf8");
   }
   getChangelogEntries(changelogPath) {
     const entries = [];
-    if (!fs2.existsSync(changelogPath)) {
+    if (!fs3.existsSync(changelogPath)) {
       return entries;
     }
-    const files = fs2.readdirSync(changelogPath);
+    const files = fs3.readdirSync(changelogPath);
     for (const file of files) {
       const filePath = `${changelogPath}/${file}`;
-      const stats = fs2.statSync(filePath);
+      const stats = fs3.statSync(filePath);
       if (stats.isFile() && (file.endsWith(".md") || file.endsWith(".mdx"))) {
         const entry = this.parseChangelogEntry(filePath);
         entries.push(entry);
@@ -1060,11 +1790,11 @@ var DoculaBuilder = class {
     return entries;
   }
   parseChangelogEntry(filePath) {
-    const fileContent = fs2.readFileSync(filePath, "utf8");
+    const fileContent = fs3.readFileSync(filePath, "utf8");
     const writr = new Writr(fileContent);
     const matterData = writr.frontMatter;
     const markdownContent = writr.body;
-    const fileName = path4.basename(filePath, path4.extname(filePath));
+    const fileName = path5.basename(filePath, path5.extname(filePath));
     const slug = fileName.replace(/^\d{4}-\d{2}-\d{2}-/, "");
     const isMdx = filePath.endsWith(".mdx");
     const tag = matterData.tag;
@@ -1144,16 +1874,16 @@ var DoculaBuilder = class {
     if (!data.hasChangelog || !data.templates?.changelog) {
       return;
     }
-    const changelogOutputPath = `${data.outputPath}/changelog`;
+    const changelogOutputPath = `${data.output}/changelog`;
     const changelogIndexPath = `${changelogOutputPath}/index.html`;
-    await fs2.promises.mkdir(changelogOutputPath, { recursive: true });
+    await fs3.promises.mkdir(changelogOutputPath, { recursive: true });
     const changelogTemplate = `${data.templatePath}/${data.templates.changelog}`;
     const changelogContent = await this._ecto.renderFromFile(
       changelogTemplate,
       { ...data, entries: data.changelogEntries },
       data.templatePath
     );
-    await fs2.promises.writeFile(changelogIndexPath, changelogContent, "utf8");
+    await fs3.promises.writeFile(changelogIndexPath, changelogContent, "utf8");
   }
   async buildChangelogEntryPages(data) {
     if (!data.hasChangelog || !data.templates?.changelogEntry || !data.changelogEntries?.length) {
@@ -1161,15 +1891,15 @@ var DoculaBuilder = class {
     }
     const entryTemplate = `${data.templatePath}/${data.templates.changelogEntry}`;
     const promises = data.changelogEntries.map(async (entry) => {
-      const entryOutputPath = `${data.outputPath}/changelog/${entry.slug}`;
-      await fs2.promises.mkdir(entryOutputPath, { recursive: true });
+      const entryOutputPath = `${data.output}/changelog/${entry.slug}`;
+      await fs3.promises.mkdir(entryOutputPath, { recursive: true });
       const entryContent = await this._ecto.renderFromFile(
         entryTemplate,
         { ...data, ...entry, entries: data.changelogEntries },
         data.templatePath
       );
       const entryFilePath = `${entryOutputPath}/index.html`;
-      return fs2.promises.writeFile(entryFilePath, entryContent, "utf8");
+      return fs3.promises.writeFile(entryFilePath, entryContent, "utf8");
     });
     await Promise.all(promises);
   }
@@ -1225,7 +1955,7 @@ var DoculaBuilder = class {
   }
   getDocuments(sitePath, doculaData) {
     let documents = [];
-    if (fs2.existsSync(sitePath)) {
+    if (fs3.existsSync(sitePath)) {
       documents = this.getDocumentInDirectory(sitePath);
       doculaData.sections = this.getSections(sitePath, this.options);
       for (const section of doculaData.sections) {
@@ -1238,12 +1968,12 @@ var DoculaBuilder = class {
   }
   getDocumentInDirectory(sitePath) {
     const documents = [];
-    const documentList = fs2.readdirSync(sitePath);
+    const documentList = fs3.readdirSync(sitePath);
     if (documentList.length > 0) {
       for (const document of documentList) {
         const documentPath = `${sitePath}/${document}`;
-        const stats = fs2.statSync(documentPath);
-        if (stats.isFile()) {
+        const stats = fs3.statSync(documentPath);
+        if (stats.isFile() && (document.endsWith(".md") || document.endsWith(".mdx"))) {
           const documentData = this.parseDocumentData(documentPath);
           documents.push(documentData);
         }
@@ -1256,13 +1986,13 @@ var DoculaBuilder = class {
   }
   getSections(sitePath, doculaOptions) {
     const sections = [];
-    if (fs2.existsSync(sitePath)) {
-      const documentList = fs2.readdirSync(sitePath);
+    if (fs3.existsSync(sitePath)) {
+      const documentList = fs3.readdirSync(sitePath);
       if (documentList.length > 0) {
         for (const document of documentList) {
           const documentPath = `${sitePath}/${document}`;
-          const stats = fs2.statSync(documentPath);
-          if (stats.isDirectory()) {
+          const stats = fs3.statSync(documentPath);
+          if (stats.isDirectory() && this.directoryContainsMarkdown(documentPath)) {
             const section = {
               name: document.replaceAll("-", " ").replaceAll(/\b\w/g, (l) => l.toUpperCase()),
               path: document
@@ -1292,7 +2022,7 @@ var DoculaBuilder = class {
     return section;
   }
   parseDocumentData(documentPath) {
-    const documentContent = fs2.readFileSync(documentPath, "utf8");
+    const documentContent = fs3.readFileSync(documentPath, "utf8");
     const writr = new Writr(documentContent);
     const matterData = writr.frontMatter;
     let markdownContent = writr.body;
@@ -1310,9 +2040,13 @@ var DoculaBuilder = class {
       }
     }
     if (!this.hasTableOfContents(markdownContent)) {
-      markdownContent = `## Table of Contents
+      const h2Matches = markdownContent.match(/^## /gm);
+      if (h2Matches && h2Matches.length >= 2) {
+        const firstH2 = markdownContent.search(/^## /m);
+        markdownContent = `${markdownContent.slice(0, firstH2)}## Table of Contents
 
-${markdownContent}`;
+${markdownContent.slice(firstH2)}`;
+      }
     }
     return {
       title: matterData.title,
@@ -1339,67 +2073,260 @@ ${markdownContent}`;
     const htmlHeading = /<h[1-6][^>]*>\s*(table of contents|toc)\s*<\/h[1-6]>/i;
     return atxHeading.test(normalized) || setextHeading.test(normalized) || htmlHeading.test(normalized);
   }
+  directoryContainsMarkdown(dirPath) {
+    const entries = fs3.readdirSync(dirPath);
+    for (const entry of entries) {
+      const fullPath = `${dirPath}/${entry}`;
+      const stat = fs3.statSync(fullPath);
+      if (stat.isFile() && (entry.endsWith(".md") || entry.endsWith(".mdx"))) {
+        return true;
+      }
+    }
+    return false;
+  }
+  mergeTemplateOverrides(resolvedTemplatePath, sitePath, templateName) {
+    if (this.options.templatePath) {
+      return resolvedTemplatePath;
+    }
+    const overrideDir = path5.join(sitePath, "templates", templateName);
+    const cacheDir = path5.join(sitePath, ".cache", "templates", templateName);
+    if (!this.isPathWithinBasePath(overrideDir, sitePath) || !this.isPathWithinBasePath(cacheDir, sitePath)) {
+      return resolvedTemplatePath;
+    }
+    if (!fs3.existsSync(overrideDir)) {
+      return resolvedTemplatePath;
+    }
+    const overrideFiles = this.listFilesRecursive(overrideDir);
+    if (fs3.existsSync(cacheDir) && this.isCacheFresh(overrideDir, cacheDir, overrideFiles)) {
+      this._console.step("Using cached template overrides...");
+      return cacheDir;
+    }
+    if (overrideFiles.length > 0) {
+      this._console.step("Applying template overrides...");
+      for (const file of overrideFiles) {
+        this._console.info(`Template override: ${file}`);
+      }
+    }
+    this.ensureCacheInGitignore(sitePath);
+    if (fs3.existsSync(cacheDir)) {
+      fs3.rmSync(cacheDir, { recursive: true, force: true });
+    }
+    fs3.mkdirSync(cacheDir, { recursive: true });
+    this.copyDirectory(resolvedTemplatePath, cacheDir);
+    this.copyDirectory(overrideDir, cacheDir);
+    const manifestPath = path5.join(cacheDir, ".manifest.json");
+    fs3.writeFileSync(manifestPath, JSON.stringify(overrideFiles));
+    return cacheDir;
+  }
+  ensureCacheInGitignore(sitePath) {
+    if (!this.options.autoUpdateIgnores) {
+      return;
+    }
+    const cacheDir = path5.join(sitePath, ".cache");
+    if (fs3.existsSync(cacheDir)) {
+      return;
+    }
+    const gitignorePath = path5.join(sitePath, ".gitignore");
+    const entry = ".cache";
+    if (fs3.existsSync(gitignorePath)) {
+      const content = fs3.readFileSync(gitignorePath, "utf8");
+      if (!content.split("\n").some((line) => line.trim() === entry)) {
+        fs3.appendFileSync(gitignorePath, `
+${entry}
+`);
+        this._console.info(`Added ${entry} to .gitignore`);
+      }
+    } else {
+      fs3.writeFileSync(gitignorePath, `${entry}
+`);
+      this._console.info("Created .gitignore with .cache");
+    }
+  }
+  isCacheFresh(overrideDir, cacheDir, overrideFiles) {
+    const manifestPath = path5.join(cacheDir, ".manifest.json");
+    if (!fs3.existsSync(manifestPath)) {
+      return false;
+    }
+    try {
+      const previousFiles = JSON.parse(
+        fs3.readFileSync(manifestPath, "utf8")
+      );
+      if (previousFiles.length !== overrideFiles.length || !previousFiles.every((f, i) => f === overrideFiles[i])) {
+        return false;
+      }
+    } catch {
+      return false;
+    }
+    for (const file of overrideFiles) {
+      const overridePath = path5.join(overrideDir, file);
+      const cachedPath = path5.join(cacheDir, file);
+      if (!fs3.existsSync(cachedPath)) {
+        return false;
+      }
+      const overrideMtime = fs3.statSync(overridePath).mtimeMs;
+      const cachedMtime = fs3.statSync(cachedPath).mtimeMs;
+      if (overrideMtime > cachedMtime) {
+        return false;
+      }
+    }
+    return true;
+  }
+  listFilesRecursive(dir, prefix = "") {
+    const results = [];
+    const entries = fs3.readdirSync(dir);
+    for (const entry of entries) {
+      if (entry.startsWith(".")) {
+        continue;
+      }
+      const fullPath = path5.join(dir, entry);
+      const relativePath = prefix ? `${prefix}/${entry}` : entry;
+      const stat = fs3.lstatSync(fullPath);
+      if (stat.isSymbolicLink()) {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        results.push(...this.listFilesRecursive(fullPath, relativePath));
+      } else {
+        results.push(relativePath);
+      }
+    }
+    return results;
+  }
   copyDirectory(source, target) {
-    const files = fs2.readdirSync(source);
+    const files = fs3.readdirSync(source);
     for (const file of files) {
       if (file.startsWith(".")) {
         continue;
       }
       const sourcePath = `${source}/${file}`;
       const targetPath = `${target}/${file}`;
-      const stat = fs2.lstatSync(sourcePath);
+      const stat = fs3.lstatSync(sourcePath);
+      if (stat.isSymbolicLink()) {
+        continue;
+      }
       if (stat.isDirectory()) {
-        fs2.mkdirSync(targetPath, { recursive: true });
+        fs3.mkdirSync(targetPath, { recursive: true });
         this.copyDirectory(sourcePath, targetPath);
       } else {
-        fs2.mkdirSync(target, { recursive: true });
-        fs2.copyFileSync(sourcePath, targetPath);
+        fs3.mkdirSync(target, { recursive: true });
+        fs3.copyFileSync(sourcePath, targetPath);
       }
     }
   }
-  copyPublicFolder(sitePath, outputPath) {
+  copyPublicFolder(sitePath, output) {
     const publicPath = `${sitePath}/public`;
-    if (!fs2.existsSync(publicPath)) {
+    if (!fs3.existsSync(publicPath)) {
       return;
     }
-    this._console.log("Public folder found, copying contents to dist...");
-    const resolvedOutputPath = path4.resolve(outputPath);
-    this.copyPublicDirectory(
-      publicPath,
-      outputPath,
-      publicPath,
-      resolvedOutputPath
-    );
+    this._console.step("Copying public folder...");
+    const resolvedOutput = path5.resolve(output);
+    this.copyPublicDirectory(publicPath, output, publicPath, resolvedOutput);
   }
-  copyPublicDirectory(source, target, basePath, outputPath) {
-    const files = fs2.readdirSync(source);
+  copyPublicDirectory(source, target, basePath, output) {
+    const files = fs3.readdirSync(source);
     for (const file of files) {
       const sourcePath = `${source}/${file}`;
       const targetPath = `${target}/${file}`;
       const relativePath = sourcePath.replace(`${basePath}/`, "");
-      const resolvedSourcePath = path4.resolve(sourcePath);
-      if (resolvedSourcePath === outputPath || resolvedSourcePath.startsWith(`${outputPath}${path4.sep}`)) {
+      const resolvedSourcePath = path5.resolve(sourcePath);
+      if (resolvedSourcePath === output || resolvedSourcePath.startsWith(`${output}${path5.sep}`)) {
+        continue;
+      }
+      const stat = fs3.lstatSync(sourcePath);
+      if (stat.isSymbolicLink()) {
         continue;
       }
-      const stat = fs2.lstatSync(sourcePath);
       if (stat.isDirectory()) {
-        fs2.mkdirSync(targetPath, { recursive: true });
-        this.copyPublicDirectory(sourcePath, targetPath, basePath, outputPath);
+        fs3.mkdirSync(targetPath, { recursive: true });
+        this.copyPublicDirectory(sourcePath, targetPath, basePath, output);
       } else {
-        fs2.mkdirSync(target, { recursive: true });
-        fs2.copyFileSync(sourcePath, targetPath);
-        this._console.log(`  Copied: ${relativePath}`);
+        fs3.mkdirSync(target, { recursive: true });
+        fs3.copyFileSync(sourcePath, targetPath);
+        this._console.fileCopied(relativePath);
+      }
+    }
+  }
+  copyDocumentSiblingAssets(data) {
+    if (!data.documents) {
+      return;
+    }
+    for (const document of data.documents) {
+      const sourceDir = path5.dirname(document.documentPath);
+      const outputDir = `${data.output}${path5.dirname(document.urlPath)}`;
+      const availableAssets = this.listContentAssets(sourceDir);
+      for (const assetRelPath of availableAssets) {
+        if (document.markdown.includes(assetRelPath)) {
+          const source = path5.join(sourceDir, assetRelPath);
+          if (fs3.lstatSync(source).isSymbolicLink()) {
+            continue;
+          }
+          const target = path5.join(outputDir, assetRelPath);
+          fs3.mkdirSync(path5.dirname(target), { recursive: true });
+          fs3.copyFileSync(source, target);
+        }
+      }
+    }
+  }
+  listContentAssets(sourcePath, basePath) {
+    const root = basePath ?? sourcePath;
+    const results = [];
+    if (!fs3.existsSync(sourcePath)) {
+      return results;
+    }
+    const files = fs3.readdirSync(sourcePath);
+    for (const file of files) {
+      if (file.startsWith(".")) {
+        continue;
+      }
+      const fullPath = `${sourcePath}/${file}`;
+      const stat = fs3.lstatSync(fullPath);
+      if (stat.isSymbolicLink()) {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        results.push(...this.listContentAssets(fullPath, root));
+      } else {
+        const ext = path5.extname(file).toLowerCase();
+        if (this.options.allowedAssets.includes(ext)) {
+          results.push(path5.relative(root, fullPath));
+        }
+      }
+    }
+    return results;
+  }
+  copyContentAssets(sourcePath, targetPath) {
+    if (!fs3.existsSync(sourcePath)) {
+      return;
+    }
+    const files = fs3.readdirSync(sourcePath);
+    for (const file of files) {
+      if (file.startsWith(".")) {
+        continue;
+      }
+      const source = `${sourcePath}/${file}`;
+      const target = `${targetPath}/${file}`;
+      const stat = fs3.lstatSync(source);
+      if (stat.isSymbolicLink()) {
+        continue;
+      }
+      if (stat.isDirectory()) {
+        this.copyContentAssets(source, target);
+      } else {
+        const ext = path5.extname(file).toLowerCase();
+        if (this.options.allowedAssets.includes(ext)) {
+          fs3.mkdirSync(targetPath, { recursive: true });
+          fs3.copyFileSync(source, target);
+        }
       }
     }
   }
 };
 
 // src/init.ts
-var doculaconfigmjs = "ZXhwb3J0IGNvbnN0IG9wdGlvbnMgPSB7Cgl0ZW1wbGF0ZTogJ21vZGVybicsCglvdXRwdXRQYXRoOiAnLi9kaXN0JywKCXNpdGVQYXRoOiAnLi9zaXRlJywKCWdpdGh1YlBhdGg6ICdqYXJlZHdyYXkvZG9jdWxhJywKCXNpdGVUaXRsZTogJ0RvY3VsYScsCglzaXRlRGVzY3JpcHRpb246ICdCZWF1dGlmdWwgV2Vic2l0ZSBmb3IgWW91ciBQcm9qZWN0cycsCglzaXRlVXJsOiAnaHR0cHM6Ly9kb2N1bGEub3JnJywKfTsKCg==";
-var doculaconfigts = "aW1wb3J0IHR5cGUgeyBEb2N1bGFPcHRpb25zIH0gZnJvbSAnZG9jdWxhJzsKCmV4cG9ydCBjb25zdCBvcHRpb25zOiBQYXJ0aWFsPERvY3VsYU9wdGlvbnM+ID0gewoJdGVtcGxhdGU6ICdtb2Rlcm4nLAoJb3V0cHV0UGF0aDogJy4vZGlzdCcsCglzaXRlUGF0aDogJy4vc2l0ZScsCglnaXRodWJQYXRoOiAnamFyZWR3cmF5L2RvY3VsYScsCglzaXRlVGl0bGU6ICdEb2N1bGEnLAoJc2l0ZURlc2NyaXB0aW9uOiAnQmVhdXRpZnVsIFdlYnNpdGUgZm9yIFlvdXIgUHJvamVjdHMnLAoJc2l0ZVVybDogJ2h0dHBzOi8vZG9jdWxhLm9yZycsCn07Cg==";
+var doculaconfigmjs = "ZXhwb3J0IGNvbnN0IG9wdGlvbnMgPSB7CglvdXRwdXQ6ICcuL2Rpc3QnLAoJc2l0ZVBhdGg6ICcuL3NpdGUnLAoJZ2l0aHViUGF0aDogJ2phcmVkd3JheS9kb2N1bGEnLAoJc2l0ZVRpdGxlOiAnRG9jdWxhJywKCXNpdGVEZXNjcmlwdGlvbjogJ0JlYXV0aWZ1bCBXZWJzaXRlIGZvciBZb3VyIFByb2plY3RzJywKCXNpdGVVcmw6ICdodHRwczovL2RvY3VsYS5vcmcnLAoJLy8gb3BlbkFwaVVybDogJy9hcGkvc3dhZ2dlci5qc29uJywKCS8vIGVuYWJsZVJlbGVhc2VDaGFuZ2Vsb2c6IHRydWUsCgkvLyBlbmFibGVMbG1zVHh0OiB0cnVlLAoJLy8gaG9tZVBhZ2U6IHRydWUsCgkvLyB0aGVtZU1vZGU6ICdsaWdodCcsCn07Cg==";
+var doculaconfigts = "aW1wb3J0IHR5cGUgeyBEb2N1bGFPcHRpb25zIH0gZnJvbSAnZG9jdWxhJzsKCmV4cG9ydCBjb25zdCBvcHRpb25zOiBQYXJ0aWFsPERvY3VsYU9wdGlvbnM+ID0gewoJb3V0cHV0OiAnLi9kaXN0JywKCXNpdGVQYXRoOiAnLi9zaXRlJywKCWdpdGh1YlBhdGg6ICdqYXJlZHdyYXkvZG9jdWxhJywKCXNpdGVUaXRsZTogJ0RvY3VsYScsCglzaXRlRGVzY3JpcHRpb246ICdCZWF1dGlmdWwgV2Vic2l0ZSBmb3IgWW91ciBQcm9qZWN0cycsCglzaXRlVXJsOiAnaHR0cHM6Ly9kb2N1bGEub3JnJywKCS8vIG9wZW5BcGlVcmw6ICcvYXBpL3N3YWdnZXIuanNvbicsCgkvLyBlbmFibGVSZWxlYXNlQ2hhbmdlbG9nOiB0cnVlLAoJLy8gZW5hYmxlTGxtc1R4dDogdHJ1ZSwKCS8vIGhvbWVQYWdlOiB0cnVlLAoJLy8gdGhlbWVNb2RlOiAnbGlnaHQnLAp9Owo=";
 var faviconico = "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";
 var logopng = "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";
-var variablescss = "OnJvb3QgewogICAgLS1mb250LWZhbWlseTogJ09wZW4gU2FucycsIHNhbnMtc2VyaWY7CiAgCiAgICAtLWNvbG9yLXByaW1hcnk6ICAjMzIyZDNjOwogICAgLS1jb2xvci1zZWNvbmRhcnk6ICM4Y2RjMDA7CiAgICAtLWNvbG9yLXNlY29uZGFyeS1kYXJrOiAjOGNkYzAwOwogICAgLS1jb2xvci10ZXh0OiAjMzIyZDNjOwogIAogICAgLS1iYWNrZ3JvdW5kOiAjZmZmZmZmOwogICAgLS1ob21lLWJhY2tncm91bmQ6ICNmZmZmZmY7CiAgICAtLWhlYWRlci1iYWNrZ3JvdW5kOiAjZmZmZmZmOwogIAogICAgLS1zaWRlYmFyLWJhY2tncm91bmQ6ICNmZmZmZmY7CiAgICAtLXNpZGViYXItdGV4dDogIzMyMmQzYzsKICAgIC0tc2lkZWJhci10ZXh0LWFjdGl2ZTogIzdkNzg4NzsKICAKICAgIC0tYm9yZGVyOiByZ2JhKDIzOCwyMzgsMjQ1LDEpOwogIAogICAgLS1iYWNrZ3JvdW5kLXNlYXJjaC1oaWdobGlnaHQ6IHZhcigtLWNvbG9yLXNlY29uZGFyeS1kYXJrKTsKICAgIC0tY29sb3Itc2VhcmNoLWhpZ2hsaWdodDogI2ZmZmZmZjsKICAgIC0tc2VhcmNoLWlucHV0LWJhY2tncm91bmQ6IHZhcigtLWhlYWRlci1iYWNrZ3JvdW5kKTsKICAKICAgIC0tY29kZTogcmdiYSgyMzgsMjM4LDI0NSwxKTsKICAKICAgIC0tcGFnZWZpbmQtdWktdGV4dDogdmFyKC0tY29sb3ItdGV4dCkgIWltcG9ydGFudDsKICAgIC0tcGFnZWZpbmQtdWktZm9udDogdmFyKC0tZm9udC1mYW1pbHkpICFpbXBvcnRhbnQ7CiAgICAtLXBhZ2VmaW5kLXVpLWJhY2tncm91bmQ6IHZhcigtLWJhY2tncm91bmQpICFpbXBvcnRhbnQ7CiAgICAtLXBhZ2VmaW5kLXVpLWJvcmRlcjogdmFyKC0tYm9yZGVyKSAhaW1wb3J0YW50OwogICAgLS1wYWdlZmluZC11aS1zY2FsZTogLjkgIWltcG9ydGFudDsKICB9";
 
 // src/docula.ts
 import { Writr as Writr2 } from "writr";
@@ -1409,6 +2336,7 @@ var Docula = class {
   // biome-ignore lint/suspicious/noExplicitAny: need to fix
   _configFileModule = {};
   _server;
+  _watcher;
   /**
    * Initialize the Docula class
    * @param {DoculaOptions} options
@@ -1441,6 +2369,13 @@ var Docula = class {
   get server() {
     return this._server;
   }
+  /**
+   * The file watcher used in watch mode
+   * @returns {fs.FSWatcher | undefined}
+   */
+  get watcher() {
+    return this._watcher;
+  }
   /**
    * The config file module. This is the module that is loaded from the docula.config.ts or docula.config.mjs file
    * @returns {any}
@@ -1449,14 +2384,30 @@ var Docula = class {
   get configFileModule() {
     return this._configFileModule;
   }
+  /**
+   * Remove the .cache directory inside the site path.
+   * Resolves the path and verifies it stays within sitePath to prevent
+   * path-traversal attacks.
+   * @param {string} sitePath
+   */
+  cleanCache(sitePath) {
+    const resolvedSitePath = path6.resolve(sitePath);
+    const cachePath = path6.resolve(resolvedSitePath, ".cache");
+    if (!cachePath.startsWith(resolvedSitePath + path6.sep) && cachePath !== resolvedSitePath) {
+      return;
+    }
+    if (fs4.existsSync(cachePath)) {
+      fs4.rmSync(cachePath, { recursive: true, force: true });
+    }
+  }
   /**
    * Check for updates
    * @returns {void}
    */
   checkForUpdates() {
-    const packageJsonPath = path5.join(process4.cwd(), "package.json");
-    if (fs3.existsSync(packageJsonPath)) {
-      const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf8"));
+    const packageJsonPath = path6.join(process4.cwd(), "package.json");
+    if (fs4.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs4.readFileSync(packageJsonPath, "utf8"));
       updateNotifier({ pkg: packageJson }).notify();
     }
   }
@@ -1468,7 +2419,6 @@ var Docula = class {
   async execute(process5) {
     this.checkForUpdates();
     const consoleProcess = this._console.parseProcessArgv(process5.argv);
-    this.options.singlePage = this.isSinglePageWebsite(this.options.sitePath);
     if (consoleProcess.args.sitePath) {
       this.options.sitePath = consoleProcess.args.sitePath;
     }
@@ -1490,7 +2440,10 @@ var Docula = class {
       this.options.template = consoleProcess.args.template;
     }
     if (consoleProcess.args.output) {
-      this.options.outputPath = consoleProcess.args.output;
+      this.options.output = consoleProcess.args.output;
+    }
+    if (consoleProcess.args.port !== void 0 && !Number.isNaN(consoleProcess.args.port)) {
+      this.options.port = consoleProcess.args.port;
     }
     switch (consoleProcess.command) {
       case "init": {
@@ -1509,31 +2462,35 @@ var Docula = class {
         break;
       }
       case "serve": {
-        const builder = new DoculaBuilder(this.options);
-        await builder.build();
+        if (consoleProcess.args.build || consoleProcess.args.watch) {
+          if (consoleProcess.args.clean && fs4.existsSync(this.options.output)) {
+            fs4.rmSync(this.options.output, { recursive: true, force: true });
+          }
+          if (consoleProcess.args.clean) {
+            this.cleanCache(this.options.sitePath);
+          }
+          const builder = new DoculaBuilder(this.options);
+          await builder.build();
+          if (consoleProcess.args.watch) {
+            this.watch(this.options, builder);
+          }
+        }
         await this.serve(this.options);
         break;
       }
       default: {
+        if (consoleProcess.args.clean && fs4.existsSync(this.options.output)) {
+          fs4.rmSync(this.options.output, { recursive: true, force: true });
+        }
+        if (consoleProcess.args.clean) {
+          this.cleanCache(this.options.sitePath);
+        }
         const builder = new DoculaBuilder(this.options);
         await builder.build();
         break;
       }
     }
   }
-  /**
-   * Checks if the site is a single page website
-   * @param {string} sitePath
-   * @returns {boolean}
-   */
-  isSinglePageWebsite(sitePath) {
-    const documentationPath = `${sitePath}/docs`;
-    if (!fs3.existsSync(documentationPath)) {
-      return true;
-    }
-    const files = fs3.readdirSync(documentationPath);
-    return files.length === 0;
-  }
   /**
    * Generate the init files
    * @param {string} sitePath
@@ -1541,8 +2498,8 @@ var Docula = class {
    * @returns {void}
    */
   generateInit(sitePath, typescript = false) {
-    if (!fs3.existsSync(sitePath)) {
-      fs3.mkdirSync(sitePath);
+    if (!fs4.existsSync(sitePath)) {
+      fs4.mkdirSync(sitePath);
     }
     const configExtension = typescript ? "ts" : "mjs";
     const doculaConfigFile = `${sitePath}/docula.config.${configExtension}`;
@@ -1550,15 +2507,13 @@ var Docula = class {
       typescript ? doculaconfigts : doculaconfigmjs,
       "base64"
     );
-    fs3.writeFileSync(doculaConfigFile, doculaConfigFileBuffer);
+    fs4.writeFileSync(doculaConfigFile, doculaConfigFileBuffer);
     const logoBuffer = Buffer.from(logopng, "base64");
-    fs3.writeFileSync(`${sitePath}/logo.png`, logoBuffer);
+    fs4.writeFileSync(`${sitePath}/logo.png`, logoBuffer);
     const faviconBuffer = Buffer.from(faviconico, "base64");
-    fs3.writeFileSync(`${sitePath}/favicon.ico`, faviconBuffer);
-    const variablesBuffer = Buffer.from(variablescss, "base64");
-    fs3.writeFileSync(`${sitePath}/variables.css`, variablesBuffer);
+    fs4.writeFileSync(`${sitePath}/favicon.ico`, faviconBuffer);
     this._console.log(
-      `docula initialized. Please update the ${doculaConfigFile} file with your site information. In addition, you can replace the image, favicon, and style the site with site.css file.`
+      `docula initialized. Please update the ${doculaConfigFile} file with your site information. In addition, you can replace the image and favicon.`
     );
   }
   /**
@@ -1566,7 +2521,7 @@ var Docula = class {
    * @returns {string}
    */
   getVersion() {
-    const packageJson = fs3.readFileSync("./package.json", "utf8");
+    const packageJson = fs4.readFileSync("./package.json", "utf8");
     const packageObject = JSON.parse(packageJson);
     return packageObject.version;
   }
@@ -1577,24 +2532,76 @@ var Docula = class {
    * @returns {Promise<void>}
    */
   async loadConfigFile(sitePath) {
-    if (!fs3.existsSync(sitePath)) {
+    if (!fs4.existsSync(sitePath)) {
       return;
     }
     const tsConfigFile = `${sitePath}/docula.config.ts`;
     const mjsConfigFile = `${sitePath}/docula.config.mjs`;
-    if (fs3.existsSync(tsConfigFile)) {
-      const absolutePath = path5.resolve(tsConfigFile);
+    if (fs4.existsSync(tsConfigFile)) {
+      const absolutePath = path6.resolve(tsConfigFile);
       const jiti = createJiti(import.meta.url, {
         interopDefault: true
       });
       this._configFileModule = await jiti.import(absolutePath);
       return;
     }
-    if (fs3.existsSync(mjsConfigFile)) {
-      const absolutePath = path5.resolve(mjsConfigFile);
+    if (fs4.existsSync(mjsConfigFile)) {
+      const absolutePath = path6.resolve(mjsConfigFile);
       this._configFileModule = await import(pathToFileURL(absolutePath).href);
     }
   }
+  /**
+   * Watch the site path for file changes and rebuild on change
+   * @param {DoculaOptions} options
+   * @param {DoculaBuilder} builder
+   * @returns {fs.FSWatcher}
+   */
+  watch(options, builder) {
+    if (this._watcher) {
+      this._watcher.close();
+    }
+    let debounceTimer;
+    let isBuilding = false;
+    let pendingRebuild = false;
+    const outputRelative = path6.relative(options.sitePath, options.output);
+    const runBuild = async (filename) => {
+      isBuilding = true;
+      this._console.info(`File changed: ${filename}, rebuilding...`);
+      try {
+        await builder.build();
+        this._console.success("Rebuild complete");
+      } catch (error) {
+        this._console.error(`Rebuild failed: ${error.message}`);
+      } finally {
+        isBuilding = false;
+        if (pendingRebuild) {
+          pendingRebuild = false;
+          await runBuild("queued changes");
+        }
+      }
+    };
+    this._watcher = fs4.watch(
+      options.sitePath,
+      { recursive: true },
+      (_eventType, filename) => {
+        if (filename && outputRelative && !outputRelative.startsWith("..") && (String(filename) === outputRelative || String(filename).startsWith(`${outputRelative}${path6.sep}`))) {
+          return;
+        }
+        if (isBuilding) {
+          pendingRebuild = true;
+          return;
+        }
+        if (debounceTimer) {
+          clearTimeout(debounceTimer);
+        }
+        debounceTimer = setTimeout(async () => {
+          await runBuild(String(filename));
+        }, 300);
+      }
+    );
+    this._console.info("Watching for file changes...");
+    return this._watcher;
+  }
   /**
    * Serve the site based on the options (port and output path)
    * @param {DoculaOptions} options
@@ -1605,24 +2612,45 @@ var Docula = class {
       this._server.close();
     }
     const { port } = options;
-    const { outputPath } = options;
+    const { output } = options;
+    if (!fs4.existsSync(output)) {
+      fs4.mkdirSync(output, { recursive: true });
+    }
     const config = {
-      public: outputPath
+      public: output
     };
-    this._server = http.createServer(
-      async (request, response) => (
-        /* v8 ignore next -- @preserve */
-        handler(request, response, config)
-      )
-    );
+    this._server = http.createServer(async (request, response) => {
+      const start = Date.now();
+      response.on("finish", () => {
+        const duration = Date.now() - start;
+        this._console.serverLog(
+          request.method ?? "GET",
+          request.url ?? "/",
+          response.statusCode,
+          duration
+        );
+      });
+      handler(request, response, config);
+    });
     this._server.listen(port, () => {
-      this._console.log(`Docula \u{1F987} at http://localhost:${port}`);
+      this._console.banner(
+        `
+  Docula \u{1F987} at http://localhost:${port}
+`
+      );
     });
     return this._server;
   }
 };
 export {
+  DoculaOptions,
   Writr2 as Writr,
   Docula as default
 };
 /* v8 ignore next -- @preserve */
+/* v8 ignore next 3 -- @preserve */
+/* v8 ignore next 2 -- @preserve */
+/* v8 ignore next 9 -- @preserve */
+/* v8 ignore next 4 -- @preserve */
+/* v8 ignore start -- @preserve */
+/* v8 ignore stop -- @preserve */