seemore 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,1635 @@
+#!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/node/paths.ts
+var paths_exports = {};
+__export(paths_exports, {
+  appRoot: () => appRoot,
+  cacheDir: () => cacheDir,
+  packageRoot: () => packageRoot,
+  resolveContentRoot: () => resolveContentRoot
+});
+import { existsSync as existsSync2, realpathSync } from "fs";
+import { createHash } from "crypto";
+import { tmpdir } from "os";
+import { dirname as dirname3, join as join2, resolve as resolve3 } from "path";
+import { fileURLToPath } from "url";
+function packageRoot() {
+  let dir = dirname3(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 10; depth++) {
+    if (existsSync2(join2(dir, "package.json"))) return dir;
+    const parent = dirname3(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  throw new Error("seemore: could not locate its own package root.");
+}
+function appRoot() {
+  return join2(packageRoot(), "src", "app");
+}
+function cacheDir(contentRoot) {
+  const key = createHash("sha256").update(resolve3(contentRoot)).digest("hex").slice(0, 12);
+  return join2(tmpdir(), "seemore", key);
+}
+function resolveContentRoot(cwd, explicit) {
+  if (explicit !== void 0) return canonicalise(resolve3(cwd, explicit));
+  for (const candidate of ["docs", "content"]) {
+    const dir = resolve3(cwd, candidate);
+    if (existsSync2(dir)) return canonicalise(dir);
+  }
+  return canonicalise(resolve3(cwd));
+}
+function canonicalise(dir) {
+  try {
+    return realpathSync.native(dir);
+  } catch {
+    return dir;
+  }
+}
+var init_paths = __esm({
+  "src/node/paths.ts"() {
+    "use strict";
+  }
+});
+
+// src/cli/index.ts
+import { parseArgs } from "util";
+import pc4 from "picocolors";
+
+// src/cli/build.ts
+import { mkdirSync as mkdirSync3, mkdtempSync, readFileSync as readFileSync4, rmSync, writeFileSync as writeFileSync4 } from "fs";
+import { createRequire as createRequire2 } from "module";
+import { tmpdir as tmpdir2 } from "os";
+import { isAbsolute as isAbsolute2, join as join8, relative as relative2, resolve as resolve5 } from "path";
+import pc2 from "picocolors";
+import { build as viteBuild } from "vite";
+
+// src/node/config/load.ts
+import { existsSync } from "fs";
+import { dirname, isAbsolute, resolve } from "path";
+import { createJiti } from "jiti";
+import "zod";
+
+// src/shared/base.ts
+var EXTERNAL = /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i;
+function normaliseBase(base) {
+  if (base === void 0 || base === "") return "/";
+  if (EXTERNAL.test(base)) {
+    throw new Error(
+      `Invalid \`base\`: ${JSON.stringify(base)}. \`base\` is a path on the host, not a URL \u2014 use "/${base.replace(/^.*?:\/\/[^/]*/, "").replace(/^\/+/, "")}".`
+    );
+  }
+  const trimmed = base.replace(/^\/+/, "").replace(/\/+$/, "");
+  return trimmed === "" ? "/" : `/${trimmed}/`;
+}
+function isExternalHref(href) {
+  return EXTERNAL.test(href) || href.startsWith("#") || !href.startsWith("/");
+}
+function withBase(base, href) {
+  const b = normaliseBase(base);
+  if (b === "/" || isExternalHref(href)) return href;
+  if (href === "/") return b;
+  if (href === b.slice(0, -1) || href.startsWith(b)) return href;
+  return b + href.replace(/^\/+/, "");
+}
+
+// src/shared/types.ts
+var FEATURES = [
+  "navigation.instant.prefetch",
+  "navigation.instant.preview",
+  "navigation.footer",
+  "navigation.top",
+  "navigation.path",
+  "navigation.sections",
+  "navigation.prune",
+  "toc.follow",
+  "toc.integrate",
+  "content.code.copy",
+  "content.action.edit",
+  "search.suggest",
+  "search.highlight",
+  "social.cards"
+];
+
+// src/node/config/features.ts
+var FEATURE_DEFAULTS = {
+  "navigation.instant.prefetch": true,
+  "navigation.instant.preview": false,
+  "navigation.footer": true,
+  "navigation.top": true,
+  "navigation.path": false,
+  "navigation.sections": false,
+  "navigation.prune": false,
+  "toc.follow": true,
+  "toc.integrate": false,
+  "content.code.copy": true,
+  // Implicitly on when `editLink` is configured; there is nothing to link to otherwise.
+  "content.action.edit": false,
+  "search.suggest": true,
+  "search.highlight": true,
+  "social.cards": false
+};
+var RULES = [
+  {
+    kind: "conflict",
+    a: "toc.integrate",
+    b: "toc.follow",
+    why: "`toc.integrate` merges the table of contents into the sidebar, leaving no separate TOC pane for `toc.follow` to scroll."
+  },
+  {
+    kind: "requires",
+    flag: "navigation.instant.preview",
+    needs: "navigation.instant.prefetch",
+    why: "`navigation.instant.preview` renders the target page in a popover, which is only possible once prefetch has loaded it."
+  }
+];
+function resolveFeatures(input, implicit = {}) {
+  const resolved = { ...FEATURE_DEFAULTS, ...implicit };
+  for (const flag of input) {
+    const off = flag.startsWith("!");
+    const name = off ? flag.slice(1) : flag;
+    resolved[name] = !off;
+  }
+  const problems = [];
+  for (const rule of RULES) {
+    if (rule.kind === "conflict") {
+      if (!resolved[rule.a] || !resolved[rule.b]) continue;
+      const fix = FEATURE_DEFAULTS[rule.b] ? `Add '!${rule.b}' to \`features\` to switch it off.` : `Remove '${rule.b}' from \`features\`.`;
+      problems.push(`\`${rule.a}\` cannot be combined with \`${rule.b}\`. ${rule.why} ${fix}`);
+    } else if (resolved[rule.flag] && !resolved[rule.needs]) {
+      problems.push(
+        `\`${rule.flag}\` requires \`${rule.needs}\`, which is switched off. ${rule.why}`
+      );
+    }
+  }
+  if (problems.length > 0) {
+    throw new Error(
+      `Incompatible \`features\` in seemore config:
+${problems.map((p) => `  - ${p}`).join("\n")}`
+    );
+  }
+  return resolved;
+}
+
+// src/node/config/schema.ts
+import { z } from "zod";
+var THEMES = [
+  "neutral",
+  "black",
+  "catppuccin",
+  "dusk",
+  "ocean",
+  "purple",
+  "ruby",
+  "solar",
+  "aspen",
+  "emerald",
+  "vitepress",
+  "shadcn"
+];
+var featureFlag = z.enum([...FEATURES, ...FEATURES.map((f) => `!${f}`)]);
+var navItem = z.lazy(
+  () => z.object({
+    text: z.string(),
+    link: z.string().optional(),
+    items: z.array(navItem).optional()
+  })
+);
+var searchSchema = z.union([
+  z.literal("static"),
+  z.object({ provider: z.literal("static") }),
+  z.object({
+    provider: z.literal("orama-cloud"),
+    endpoint: z.string(),
+    apiKey: z.string()
+  }),
+  z.object({
+    provider: z.literal("algolia"),
+    appId: z.string(),
+    apiKey: z.string(),
+    indexName: z.string()
+  })
+]);
+var configSchema = z.object({
+  title: z.string().default("Documentation"),
+  description: z.string().optional(),
+  favicon: z.string().optional(),
+  /** Subpath the site is served from, e.g. `/my-repo/`. Never inferred. */
+  base: z.string().optional(),
+  theme: z.enum(THEMES).default("neutral"),
+  /** A CSS file appended after everything else, so it wins. */
+  css: z.string().optional(),
+  features: z.array(featureFlag).default([]),
+  nav: z.array(navItem).optional(),
+  footer: z.object({
+    text: z.string().optional(),
+    links: z.array(z.object({ text: z.string(), link: z.string() })).optional()
+  }).optional(),
+  editLink: z.object({
+    base: z.string(),
+    text: z.string().default("Edit this page")
+  }).optional(),
+  search: searchSchema.default("static"),
+  exclude: z.array(z.string()).default([])
+});
+
+// src/node/config/load.ts
+var CONFIG_NAMES = ["seemore.config.ts", "seemore.config.mts", "seemore.config.js", "seemore.config.mjs"];
+function resolveConfig(input, options) {
+  const parsed = parseOrThrow(input, options.configFile);
+  const search = parsed.search === "static" ? { provider: "static" } : parsed.search;
+  const features = resolveFeatures(parsed.features, {
+    // Nothing to link to without an edit base, so the flag follows the option.
+    "content.action.edit": parsed.editLink !== void 0
+  });
+  return {
+    title: parsed.title,
+    description: parsed.description,
+    favicon: parsed.favicon,
+    base: normaliseBase(parsed.base),
+    theme: parsed.theme,
+    css: parsed.css === void 0 ? void 0 : resolveFrom(options.root, parsed.css),
+    features,
+    nav: parsed.nav,
+    footer: parsed.footer,
+    editLink: parsed.editLink,
+    search,
+    exclude: parsed.exclude,
+    root: options.root,
+    configFile: options.configFile
+  };
+}
+async function loadConfig(options) {
+  const file = findConfigFile(options);
+  if (file === void 0) {
+    return { config: resolveConfig({}, { root: options.root }) };
+  }
+  const jiti = createJiti(import.meta.url, { moduleCache: false, fsCache: false });
+  let loaded;
+  try {
+    loaded = await jiti.import(file, { default: true });
+  } catch (error) {
+    throw new Error(`Failed to load ${file}:
+${error instanceof Error ? error.message : String(error)}`, {
+      cause: error
+    });
+  }
+  if (loaded === null || typeof loaded !== "object") {
+    throw new Error(`${file} must export a config object as its default export, got ${typeof loaded}.`);
+  }
+  return {
+    config: resolveConfig(loaded, { root: dirname(file), configFile: file }),
+    file
+  };
+}
+function findConfigFile({ root, configPath }) {
+  if (configPath !== void 0) {
+    const absolute = resolveFrom(root, configPath);
+    if (!existsSync(absolute)) {
+      throw new Error(`Config file not found: ${absolute}`);
+    }
+    return absolute;
+  }
+  for (const name of CONFIG_NAMES) {
+    const candidate = resolve(root, name);
+    if (existsSync(candidate)) return candidate;
+  }
+  return void 0;
+}
+function resolveFrom(root, path) {
+  return isAbsolute(path) ? path : resolve(root, path);
+}
+function parseOrThrow(input, file) {
+  const result = configSchema.safeParse(input);
+  if (result.success) return result.data;
+  const where = file === void 0 ? "seemore config" : file;
+  const issues = result.error.issues.map((issue) => {
+    const field = issue.path.length === 0 ? "(root)" : issue.path.join(".");
+    return `  - ${field}: ${explain(issue)}`;
+  });
+  throw new Error(`Invalid ${where}:
+${issues.join("\n")}`);
+}
+function explain(issue) {
+  if (issue.code === "invalid_value" && issue.path.join(".") === "theme") {
+    return `unknown theme. Valid themes: ${THEMES.join(", ")}.`;
+  }
+  return issue.message;
+}
+
+// src/node/content/links.ts
+import { slug as slugify2 } from "github-slugger";
+
+// src/node/content/slug.ts
+import { slug as slugify } from "github-slugger";
+var INDEX_NAMES = /* @__PURE__ */ new Set(["index", "readme"]);
+var CONTENT_EXT = /\.mdx?$/i;
+function toPosix(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
+}
+function slugifySegment(segment) {
+  const slugged = slugify(segment);
+  if (slugged !== "") return slugged;
+  const fallback = segment.toLowerCase().replace(/[^\p{L}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "");
+  return fallback === "" ? "untitled" : fallback;
+}
+function toRoute(file) {
+  const posix = toPosix(file);
+  const segments = posix.split("/");
+  const basename2 = segments.pop() ?? "";
+  const stem = basename2.replace(CONTENT_EXT, "");
+  const isIndex = INDEX_NAMES.has(stem.toLowerCase());
+  const slugs = segments.map(slugifySegment);
+  if (!isIndex) slugs.push(slugifySegment(stem));
+  return {
+    file: posix,
+    url: slugs.length === 0 ? "/" : `/${slugs.join("/")}`,
+    slugs,
+    output: [...slugs, "index.html"].join("/"),
+    isIndex
+  };
+}
+function resolveRoutes(files) {
+  const sorted = [...files].map(toPosix).sort();
+  const byUrl = /* @__PURE__ */ new Map();
+  const warnings = [];
+  const errors = [];
+  for (const file of sorted) {
+    const route = toRoute(file);
+    const bucket = byUrl.get(route.url);
+    if (bucket) bucket.push(route);
+    else byUrl.set(route.url, [route]);
+  }
+  const routes = [];
+  for (const [url, candidates] of [...byUrl.entries()].sort(([a], [b]) => a < b ? -1 : 1)) {
+    if (candidates.length === 1) {
+      routes.push(candidates[0]);
+      continue;
+    }
+    const indexes = candidates.filter((c) => c.isIndex);
+    if (indexes.length === candidates.length) {
+      const winner = indexes.find((c) => c.file.split("/").pop()?.toLowerCase().startsWith("index")) ?? indexes[0];
+      const losers = indexes.filter((c) => c !== winner);
+      warnings.push(
+        `${url} has more than one index file: using ${winner.file}, ignoring ${losers.map((l) => l.file).join(", ")}.`
+      );
+      routes.push(winner);
+      continue;
+    }
+    errors.push(
+      `Duplicate route ${url} produced by ${candidates.length} files:
+` + candidates.map((c) => `  - ${c.file}`).join("\n") + `
+Rename one of them, or exclude it with \`exclude\` in seemore.config.ts.`
+    );
+  }
+  return { routes, errors, warnings };
+}
+
+// src/node/content/links.ts
+var CONTENT_EXT2 = /\.mdx?$/i;
+function createLinkResolver(pages, base) {
+  const byPath = /* @__PURE__ */ new Map();
+  const byName = /* @__PURE__ */ new Map();
+  const add = (map, key, page) => {
+    const bucket = map.get(key);
+    if (bucket) bucket.push(page);
+    else map.set(key, [page]);
+  };
+  for (const page of pages) {
+    const withoutExt = page.file.replace(CONTENT_EXT2, "");
+    byPath.set(withoutExt.toLowerCase(), page);
+    byPath.set(page.file.toLowerCase(), page);
+    if (page.isIndex) {
+      const dir = withoutExt.split("/").slice(0, -1).join("/");
+      if (dir !== "") byPath.set(dir.toLowerCase(), page);
+    }
+    const basename2 = withoutExt.split("/").pop() ?? "";
+    add(byName, basename2.toLowerCase(), page);
+    const slugged = slugifySegment(basename2);
+    if (slugged !== basename2.toLowerCase()) add(byName, slugged, page);
+  }
+  const pick = (candidates) => [...candidates].sort((a, b) => {
+    const depth = a.file.split("/").length - b.file.split("/").length;
+    return depth !== 0 ? depth : a.file.localeCompare(b.file);
+  })[0];
+  function lookup(target) {
+    const cleaned = toPosix(target).replace(/^\/+/, "").replace(CONTENT_EXT2, "");
+    const key = cleaned.toLowerCase();
+    const exact = byPath.get(key);
+    if (exact) return { page: exact };
+    const named = byName.get(key) ?? byName.get(slugifySegment(cleaned));
+    if (named === void 0 || named.length === 0) return {};
+    if (named.length === 1) return { page: named[0] };
+    return { page: pick(named), ambiguous: named };
+  }
+  function href(page, hash) {
+    const url = withBase(base, page.url);
+    return hash === void 0 ? url : `${url}#${slugify2(hash)}`;
+  }
+  return {
+    resolveHref(raw, fromFile) {
+      if (isExternalHref(raw) && !raw.startsWith(".") && !CONTENT_EXT2.test(raw.split("#")[0] ?? "")) {
+        return { href: raw };
+      }
+      const [pathPart = "", hashPart] = splitHash(raw);
+      if (!CONTENT_EXT2.test(pathPart)) return { href: raw };
+      const fromDir = pathPart.startsWith("/") ? [] : toPosix(fromFile).split("/").slice(0, -1);
+      const resolved = joinPosix(fromDir, pathPart);
+      const page = byPath.get(resolved.toLowerCase());
+      if (page === void 0) {
+        return {
+          href: raw,
+          warning: `Broken link ${raw} in ${toPosix(fromFile)}: no page at ${resolved}.`
+        };
+      }
+      return { href: href(page, hashPart) };
+    },
+    resolveWikilink(target, fromFile) {
+      const pipe = target.indexOf("|");
+      const linkPart = (pipe === -1 ? target : target.slice(0, pipe)).trim();
+      const label = (pipe === -1 ? target : target.slice(pipe + 1)).trim();
+      const [pathPart = "", hashPart] = splitHash(linkPart);
+      const { page, ambiguous } = lookup(pathPart);
+      if (page === void 0) {
+        return {
+          label,
+          warning: `Dead wikilink [[${target}]] in ${toPosix(fromFile)}: no page matches "${pathPart}".`
+        };
+      }
+      const warning = ambiguous === void 0 ? void 0 : `Ambiguous wikilink [[${target}]] in ${toPosix(fromFile)}: matches ${ambiguous.map((c) => c.file).sort().join(", ")}. Using ${page.file}.`;
+      return { href: href(page, hashPart), label, warning };
+    }
+  };
+}
+function splitHash(value) {
+  const index = value.indexOf("#");
+  if (index === -1) return [value, void 0];
+  return [value.slice(0, index), value.slice(index + 1)];
+}
+function joinPosix(fromDir, relative3) {
+  const segments = [...fromDir];
+  for (const part of toPosix(relative3).split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") segments.pop();
+    else segments.push(part);
+  }
+  return segments.join("/").replace(CONTENT_EXT2, "");
+}
+
+// src/node/content/source.ts
+import { dynamicLoader } from "fumadocs-core/source";
+
+// src/node/content/scan.ts
+import { readFileSync } from "fs";
+import { basename, dirname as dirname2, join, resolve as resolve2 } from "path";
+import { globSync } from "tinyglobby";
+import { z as z4 } from "zod";
+
+// src/node/content/frontmatter.ts
+import matter from "gray-matter";
+import { z as z3 } from "zod";
+var frontmatterSchema = z3.object({
+  title: z3.string().optional(),
+  description: z3.string().optional(),
+  icon: z3.string().optional(),
+  /** Sidebar ordering, second only to `meta.json`. */
+  order: z3.number().optional(),
+  /**
+   * Excluded from the build. Dev keeps drafts so they can be written, so a link to one
+   * works while you write it and warns as a dead link when you build.
+   */
+  draft: z3.boolean().optional()
+}).loose();
+function parseFrontmatter(source, file) {
+  let parsed;
+  try {
+    parsed = matter(source);
+  } catch (error) {
+    throw new Error(
+      `Invalid frontmatter in ${file}: ${error instanceof Error ? error.message.split("\n")[0] : String(error)}`,
+      { cause: error }
+    );
+  }
+  return { data: validateFrontmatter(parsed.data, file), content: parsed.content };
+}
+function validateFrontmatter(data, file) {
+  const result = frontmatterSchema.safeParse(data ?? {});
+  if (result.success) return result.data;
+  const issues = result.error.issues.map((issue) => {
+    const field = issue.path.length === 0 ? "(root)" : issue.path.join(".");
+    return `  - ${field}: ${issue.message}`;
+  });
+  throw new Error(`Invalid frontmatter in ${file}:
+${issues.join("\n")}`);
+}
+
+// src/node/content/scan.ts
+var DEFAULT_EXCLUDES = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/.seemore/**",
+  "**/.*/**",
+  "**/.*",
+  "**/CHANGELOG.md"
+];
+var metaSchema = z4.object({
+  title: z4.string().optional(),
+  icon: z4.string().optional(),
+  root: z4.boolean().optional(),
+  pages: z4.array(z4.string()).optional(),
+  pagesIndex: z4.string().optional(),
+  defaultOpen: z4.boolean().optional(),
+  collapsible: z4.boolean().optional(),
+  description: z4.string().optional()
+}).loose();
+function scan(options) {
+  const contentRoot = resolve2(options.contentRoot);
+  const ignore = [...DEFAULT_EXCLUDES, ...options.exclude ?? []];
+  const contentFiles = globSync(["**/*.md", "**/*.mdx"], {
+    cwd: contentRoot,
+    ignore,
+    dot: false,
+    absolute: false
+  }).map(toPosix);
+  const metaFiles = globSync(["**/meta.json"], { cwd: contentRoot, ignore, dot: false, absolute: false }).map(toPosix);
+  const { routes, errors, warnings } = resolveRoutes(contentFiles);
+  const pages = [];
+  for (const route of routes) {
+    const absPath = join(contentRoot, route.file);
+    let data;
+    try {
+      data = parseFrontmatter(readFileSync(absPath, "utf8"), route.file).data;
+    } catch (error) {
+      errors.push(error instanceof Error ? error.message : String(error));
+      continue;
+    }
+    if (data.draft === true && options.includeDrafts !== true) continue;
+    pages.push({ ...route, absPath, data: { ...data, title: titleFor(route, data, options.siteTitle) } });
+  }
+  const files = pages.map((page) => ({
+    type: "page",
+    path: page.file,
+    absolutePath: page.absPath,
+    // Our slugs, not fumadocs' — one algorithm decides URLs, anchors and the index.
+    slugs: page.slugs,
+    data: page.data
+  }));
+  const metaDirs = /* @__PURE__ */ new Set();
+  for (const file of metaFiles) {
+    const absPath = join(contentRoot, file);
+    try {
+      const parsed = metaSchema.safeParse(JSON.parse(readFileSync(absPath, "utf8")));
+      if (!parsed.success) {
+        errors.push(
+          `Invalid ${file}:
+${parsed.error.issues.map((i) => `  - ${i.path.join(".") || "(root)"}: ${i.message}`).join("\n")}`
+        );
+        continue;
+      }
+      metaDirs.add(dirname2(file));
+      files.push({ type: "meta", path: file, absolutePath: absPath, data: parsed.data });
+    } catch (error) {
+      errors.push(`Invalid ${file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  files.push(...synthesiseOrderMeta(pages, metaDirs));
+  return { files, pages, errors, warnings };
+}
+function synthesiseOrderMeta(pages, metaDirs) {
+  const byDir = /* @__PURE__ */ new Map();
+  for (const page of pages) {
+    const dir = dirname2(page.file);
+    const bucket = byDir.get(dir);
+    if (bucket) bucket.push(page);
+    else byDir.set(dir, [page]);
+  }
+  const out = [];
+  for (const [dir, dirPages] of byDir) {
+    if (metaDirs.has(dir)) continue;
+    if (!dirPages.some((p) => typeof p.data.order === "number" || p.isIndex)) continue;
+    const ordered = [...dirPages].sort(compareForOrder).map((p) => basename(p.file).replace(/\.mdx?$/i, ""));
+    out.push({
+      type: "meta",
+      path: dir === "." ? "meta.json" : `${dir}/meta.json`,
+      data: { pages: [...ordered, "..."] }
+    });
+  }
+  return out;
+}
+function compareForOrder(a, b) {
+  const ao = orderOf(a);
+  const bo = orderOf(b);
+  if (ao !== bo) return ao - bo;
+  return a.data.title.localeCompare(b.data.title);
+}
+function orderOf(page) {
+  if (typeof page.data.order === "number") return page.data.order;
+  return page.isIndex ? Number.NEGATIVE_INFINITY : Number.POSITIVE_INFINITY;
+}
+function titleFor(route, data, siteTitle) {
+  if (typeof data.title === "string" && data.title !== "") return data.title;
+  if (route.url === "/") return siteTitle ?? "Home";
+  return humanise(route.slugs[route.slugs.length - 1] ?? "Untitled");
+}
+function humanise(slug) {
+  return slug.split("-").filter((word) => word !== "").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
+// src/node/content/source.ts
+function createSource(options) {
+  let cached;
+  const read = () => cached ??= scan(options);
+  const loader = dynamicLoader(
+    {
+      cache: "custom",
+      files: () => read().files,
+      invalidate: () => {
+        cached = void 0;
+      }
+    },
+    { baseUrl: "/" }
+  );
+  return {
+    loader,
+    current: read,
+    pages: () => read().pages,
+    refresh() {
+      loader.invalidate();
+      return read();
+    },
+    async getPageTree() {
+      const output = await loader.get();
+      return output.getPageTree();
+    },
+    async serializeTree() {
+      const output = await loader.get();
+      return output.serializePageTree(output.getPageTree());
+    }
+  };
+}
+
+// src/node/report.ts
+import pc from "picocolors";
+function createWarningCollector() {
+  const seen = /* @__PURE__ */ new Set();
+  return {
+    add(message) {
+      seen.add(message);
+    },
+    list: () => [...seen],
+    clear: () => seen.clear(),
+    flush(log = console.warn) {
+      const messages = [...seen].sort();
+      seen.clear();
+      if (messages.length === 0) return 0;
+      log("");
+      log(pc.yellow(`${messages.length} warning${messages.length === 1 ? "" : "s"}:`));
+      for (const message of messages) log(pc.yellow(`  - ${message}`));
+      log("");
+      return messages.length;
+    }
+  };
+}
+
+// src/node/context.ts
+function createContext(options) {
+  const { config, contentRoot } = options;
+  const source = createSource({
+    contentRoot,
+    exclude: config.exclude,
+    siteTitle: config.title,
+    includeDrafts: options.includeDrafts
+  });
+  let resolver = createLinkResolver(source.pages(), config.base);
+  return {
+    config,
+    contentRoot,
+    source,
+    warnings: createWarningCollector(),
+    pages: () => source.pages(),
+    resolver: () => resolver,
+    errors: () => source.current().errors,
+    refresh() {
+      const result = source.refresh();
+      resolver = createLinkResolver(result.pages, config.base);
+      return result;
+    }
+  };
+}
+
+// src/cli/build.ts
+init_paths();
+
+// src/node/prerender/emit.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname as dirname4, join as join3 } from "path";
+function outputPathFor(url) {
+  const clean = url.replace(/^\/+|\/+$/g, "");
+  return clean === "" ? "index.html" : join3(clean, "index.html");
+}
+function writeHtml(outDir, relativePath, html) {
+  const target = join3(outDir, relativePath);
+  mkdirSync(dirname4(target), { recursive: true });
+  writeFileSync(target, html, "utf8");
+}
+function applyTemplate(template, { html, head }) {
+  return template.replace("<!--seemore-head-->", () => head).replace("<!--seemore-app-->", () => html);
+}
+
+// src/node/prerender/deploy.ts
+import { writeFileSync as writeFileSync2 } from "fs";
+import { join as join4 } from "path";
+function writeDeployArtifacts(outDir, base, shell) {
+  const prefix = base === "/" ? "" : base.replace(/\/+$/, "");
+  writeFileSync2(join4(outDir, "_redirects"), `${prefix}/*    ${prefix}/index.html    200
+`, "utf8");
+  writeFileSync2(join4(outDir, "200.html"), shell, "utf8");
+  writeFileSync2(join4(outDir, ".nojekyll"), "", "utf8");
+}
+
+// src/node/prerender/render.ts
+import { pathToFileURL } from "url";
+import { join as join6 } from "path";
+import { build } from "vite";
+
+// src/node/vite/config.ts
+init_paths();
+import { realpathSync as realpathSync2 } from "fs";
+import { join as join5 } from "path";
+import react from "@vitejs/plugin-react";
+import tailwindcss from "@tailwindcss/vite";
+import mdx from "@mdx-js/rollup";
+
+// src/node/vite/mdx.ts
+import remarkFrontmatter from "remark-frontmatter";
+import {
+  rehypeCode,
+  rehypeToc,
+  remarkAdmonition,
+  remarkDirectiveAdmonition,
+  remarkGfm,
+  remarkHeading,
+  remarkImage,
+  remarkMdxMermaid,
+  remarkSteps
+} from "fumadocs-core/mdx-plugins";
+
+// src/node/vite/remark.ts
+import { existsSync as existsSync3 } from "fs";
+import { dirname as dirname5, relative, resolve as resolve4 } from "path";
+import { visit } from "unist-util-visit";
+var WIKILINK = /\[\[([^\]\n]+)\]\]/g;
+var ALERTS = {
+  NOTE: { type: "info", title: "Note" },
+  TIP: { type: "idea", title: "Tip" },
+  IMPORTANT: { type: "info", title: "Important" },
+  WARNING: { type: "warn", title: "Warning" },
+  CAUTION: { type: "error", title: "Caution" }
+};
+var ALERT_MARKER = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]\s*/;
+function remarkSeemoreAlerts() {
+  return (tree) => {
+    visit(tree, "blockquote", (node, index, parent) => {
+      if (parent === void 0 || index === void 0) return;
+      const first = node.children[0];
+      if (first === void 0 || first.type !== "paragraph") return;
+      const marker = ALERT_MARKER.exec(textOf(first));
+      const alert = marker === null ? void 0 : ALERTS[marker[1] ?? ""];
+      if (marker === void 0 || marker === null || alert === void 0) return;
+      stripMarker(first, marker[0]);
+      parent.children[index] = {
+        type: "mdxJsxFlowElement",
+        name: "Callout",
+        attributes: [
+          { type: "mdxJsxAttribute", name: "type", value: alert.type },
+          { type: "mdxJsxAttribute", name: "title", value: alert.title }
+        ],
+        children: node.children
+      };
+    });
+  };
+}
+function textOf(paragraph) {
+  const first = paragraph.children[0];
+  return first !== void 0 && first.type === "text" ? first.value.trimStart() : "";
+}
+function stripMarker(paragraph, marker) {
+  const first = paragraph.children[0];
+  if (first === void 0 || first.type !== "text") return;
+  first.value = first.value.trimStart().slice(marker.length).replace(/^\n/, "");
+  if (first.value === "") paragraph.children.shift();
+  if (paragraph.children[0]?.type === "break") paragraph.children.shift();
+}
+function remarkSeemoreWikilinks(options) {
+  return (tree, file) => {
+    const from = virtualPath(options.contentRoot, file);
+    const resolver = options.getResolver();
+    visit(tree, "text", (node, index, parent) => {
+      if (parent === void 0 || index === void 0) return;
+      if (!node.value.includes("[[")) return;
+      const replacement = [];
+      let cursor = 0;
+      WIKILINK.lastIndex = 0;
+      for (let match = WIKILINK.exec(node.value); match !== null; match = WIKILINK.exec(node.value)) {
+        const target = match[1] ?? "";
+        if (match.index > cursor) {
+          replacement.push({ type: "text", value: node.value.slice(cursor, match.index) });
+        }
+        cursor = match.index + match[0].length;
+        const resolved = resolver.resolveWikilink(target, from);
+        if (resolved.warning !== void 0) options.onWarning(resolved.warning);
+        if (resolved.href === void 0) {
+          replacement.push({
+            type: "mdxJsxTextElement",
+            name: "span",
+            attributes: [
+              { type: "mdxJsxAttribute", name: "className", value: "seemore-broken-wikilink" },
+              { type: "mdxJsxAttribute", name: "title", value: "Unresolved link" }
+            ],
+            children: [{ type: "text", value: resolved.label }]
+          });
+        } else {
+          replacement.push({
+            type: "link",
+            url: resolved.href,
+            children: [{ type: "text", value: resolved.label }]
+          });
+        }
+      }
+      if (replacement.length === 0) return;
+      if (cursor < node.value.length) replacement.push({ type: "text", value: node.value.slice(cursor) });
+      parent.children.splice(index, 1, ...replacement);
+      return index + replacement.length;
+    });
+  };
+}
+function remarkSeemoreAssets(options) {
+  return (tree, file) => {
+    if (typeof file.path !== "string" || file.path === "") return;
+    const dir = dirname5(file.path);
+    const from = virtualPath(options.contentRoot, file);
+    visit(tree, "image", (node, index, parent) => {
+      if (parent === void 0 || index === void 0) return;
+      if (isExternal(node.url) || node.url.startsWith("/")) return;
+      const target = resolve4(dir, decodeURIComponent(node.url.split(/[?#]/)[0] ?? ""));
+      if (existsSync3(target)) return;
+      options.onWarning(`Missing asset ${node.url} referenced by ${from}.`);
+      parent.children.splice(index, 1, {
+        type: "mdxJsxTextElement",
+        name: "img",
+        attributes: [
+          { type: "mdxJsxAttribute", name: "src", value: node.url },
+          { type: "mdxJsxAttribute", name: "alt", value: node.alt ?? "" },
+          { type: "mdxJsxAttribute", name: "data-seemore-missing", value: "true" }
+        ],
+        children: []
+      });
+    });
+  };
+}
+function isExternal(url) {
+  return /^(?:[a-z][a-z0-9+.-]*:|\/\/)/i.test(url);
+}
+function remarkSeemoreLinks(options) {
+  return (tree, file) => {
+    const from = virtualPath(options.contentRoot, file);
+    const resolver = options.getResolver();
+    const rewrite = (node) => {
+      const resolved = resolver.resolveHref(node.url, from);
+      if (resolved.warning !== void 0) options.onWarning(resolved.warning);
+      node.url = resolved.href;
+    };
+    visit(tree, "link", rewrite);
+    visit(tree, "definition", rewrite);
+  };
+}
+function virtualPath(contentRoot, file) {
+  if (typeof file.path !== "string" || file.path === "") return "";
+  return toPosix(relative(contentRoot, file.path));
+}
+
+// src/node/vite/mdx.ts
+function createRemarkPlugins(options) {
+  return [
+    // Strips the `---` block so it never renders. Its data already came from the scan.
+    [remarkFrontmatter, ["yaml"]],
+    remarkGfm,
+    remarkHeading,
+    remarkAdmonition,
+    remarkDirectiveAdmonition,
+    // After the fumadocs admonition plugins, which handle `:::note`, and before anything that
+    // rewrites link or text nodes inside the quote.
+    remarkSeemoreAlerts,
+    remarkSteps,
+    // Before `remark-image`: a reference to a file that is not there becomes a warning and a
+    // visibly broken image, rather than a failed build.
+    () => remarkSeemoreAssets(options),
+    [
+      remarkImage,
+      {
+        onError: (error) => {
+          options.onWarning(error.message);
+        }
+      }
+    ],
+    // Rewrites ```mermaid fences to <Mermaid chart="…" />. We supply the component.
+    remarkMdxMermaid,
+    () => remarkSeemoreWikilinks(options),
+    () => remarkSeemoreLinks(options)
+  ];
+}
+function createRehypePlugins() {
+  return [rehypeCode, rehypeToc];
+}
+
+// src/node/vite/plugin.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { createRequire } from "module";
+import { dirname as dirname6 } from "path";
+
+// src/node/search/build.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { gzipSync } from "zlib";
+import { createFromSource } from "fumadocs-core/search/server";
+import { structure } from "fumadocs-core/mdx-plugins";
+var SIZE_WARNING_BYTES = 15e5;
+async function buildSearchIndex(ctx) {
+  const loader = await ctx.source.loader.get();
+  const bodies = /* @__PURE__ */ new Map();
+  for (const page of ctx.pages()) {
+    try {
+      bodies.set(page.url, parseFrontmatter(readFileSync2(page.absPath, "utf8"), page.file).content);
+    } catch {
+    }
+  }
+  const server = createFromSource(loader, {
+    buildIndex(page) {
+      const body = bodies.get(page.url) ?? "";
+      return {
+        id: page.url,
+        url: withBase(ctx.config.base, page.url),
+        title: typeof page.data.title === "string" ? page.data.title : page.url,
+        description: typeof page.data.description === "string" ? page.data.description : void 0,
+        structuredData: structure(body)
+      };
+    }
+  });
+  const response = await server.staticGET();
+  return await response.text();
+}
+function measureIndex(json2) {
+  const bytes = Buffer.byteLength(json2);
+  const gzipped = gzipSync(json2).byteLength;
+  if (gzipped <= SIZE_WARNING_BYTES) return { bytes, gzipped };
+  return {
+    bytes,
+    gzipped,
+    warning: `The static search index is ${formatBytes(gzipped)} gzipped, which every visitor downloads before their first search. Above ${formatBytes(SIZE_WARNING_BYTES)} consider a hosted index: set \`search: { provider: 'orama-cloud', \u2026 }\` or \`search: { provider: 'algolia', \u2026 }\` in seemore.config.ts.`
+  };
+}
+function formatBytes(bytes) {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} kB`;
+  return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+}
+
+// src/node/vite/plugin.ts
+var VIRTUAL = {
+  tree: "virtual:seemore/tree",
+  routes: "virtual:seemore/routes",
+  config: "virtual:seemore/config"
+};
+var PAGE_PREFIX = "seemore-page:";
+var resolvedId = (id) => `\0${id}`;
+var IMPORTS_MARKER = /\/\* seemore:imports[\s\S]*?\*\//;
+var USER_CSS_MARKER = /\/\* seemore:user-css[\s\S]*?\*\//;
+var require_ = createRequire(import.meta.url);
+function styleImports(ctx) {
+  const lines = [`@import 'fumadocs-ui/css/${ctx.config.theme}.css';`];
+  try {
+    lines.push(`@source '${dirname6(require_.resolve("fumadocs-ui/package.json"))}/dist';`);
+  } catch {
+  }
+  return lines.join("\n");
+}
+function userCss(ctx) {
+  if (ctx.config.css === void 0) return "";
+  const css = readIfExists(ctx.config.css);
+  if (css === void 0) {
+    ctx.warnings.add(`The stylesheet named by \`css\` was not found: ${ctx.config.css}`);
+    return "";
+  }
+  return `/* ${ctx.config.css} */
+${css}`;
+}
+function seemorePlugin({ ctx, serveSearch = false }) {
+  let server;
+  return {
+    name: "seemore",
+    enforce: "pre",
+    resolveId(id) {
+      if (id.startsWith(PAGE_PREFIX)) return id.slice(PAGE_PREFIX.length).replace(/\\/g, "/");
+      for (const virtualId of Object.values(VIRTUAL)) {
+        if (id === virtualId) return resolvedId(virtualId);
+      }
+      return void 0;
+    },
+    /**
+     * The theme preset, the paths Tailwind must scan, and the user's own stylesheet are
+     * injected into our root stylesheet rather than imported from it.
+     *
+     * Tailwind v4 only processes the file that contains `@import "tailwindcss"`, and bare
+     * specifiers in a virtual stylesheet have no directory to resolve from — injecting into
+     * the real `globals.css` keeps both working.
+     */
+    transform(code, id) {
+      const path = id.replace(/\\/g, "/").split("?")[0] ?? "";
+      if (!path.endsWith("/src/app/styles/globals.css")) return void 0;
+      const transformed = code.replace(IMPORTS_MARKER, () => styleImports(ctx)).replace(USER_CSS_MARKER, () => userCss(ctx));
+      return { code: transformed, map: null };
+    },
+    async load(id) {
+      if (id === resolvedId(VIRTUAL.tree)) {
+        return hotStoreModule("Tree", json(await ctx.source.serializeTree()));
+      }
+      if (id === resolvedId(VIRTUAL.routes)) {
+        return hotStoreModule("Routes", renderRoutesValue(ctx));
+      }
+      if (id === resolvedId(VIRTUAL.config)) return `export const config = ${json(clientConfig(ctx))};`;
+      return void 0;
+    },
+    configureServer(devServer) {
+      server = devServer;
+      if (!serveSearch) return;
+      devServer.middlewares.use(async (req, res, next) => {
+        const path = (req.url ?? "").split("?")[0] ?? "";
+        if (path !== withBase(ctx.config.base, "/api/search.json") && path !== "/api/search.json") return next();
+        try {
+          const index = await buildSearchIndex(ctx);
+          res.setHeader("Content-Type", "application/json");
+          res.end(index);
+        } catch (error) {
+          next(error);
+        }
+      });
+    },
+    /** Called by the watcher after a rescan. */
+    api: {
+      invalidate() {
+        if (server === void 0) return;
+        for (const virtualId of [VIRTUAL.tree, VIRTUAL.routes]) {
+          const mod = server.moduleGraph.getModuleById(resolvedId(virtualId));
+          if (mod) server.moduleGraph.invalidateModule(mod);
+        }
+        server.ws.send({ type: "update", updates: [] });
+      }
+    }
+  };
+}
+function hotStoreModule(suffix, value) {
+  return `const state = import.meta.hot
+  ? (import.meta.hot.data.seemore${suffix} ||= { listeners: new Set() })
+  : { listeners: new Set() };
+
+state.value = ${value};
+
+export function get${suffix}() {
+  return state.value;
+}
+
+export function subscribe${suffix}(listener) {
+  state.listeners.add(listener);
+  return () => {
+    state.listeners.delete(listener);
+  };
+}
+
+if (import.meta.hot) {
+  import.meta.hot.accept();
+  for (const listener of state.listeners) listener();
+}
+`;
+}
+function renderRoutesValue(ctx) {
+  const entries = ctx.pages().map((page) => {
+    const specifier = `${PAGE_PREFIX}${page.absPath.replace(/\\/g, "/")}`;
+    return [
+      "  {",
+      `    url: ${json(page.url)},`,
+      `    file: ${json(page.file)},`,
+      `    absPath: ${json(page.absPath)},`,
+      `    title: ${json(page.data.title)},`,
+      `    description: ${json(page.data.description ?? null)},`,
+      `    load: () => import(${json(specifier)}),`,
+      "  },"
+    ].join("\n");
+  });
+  return `[
+${entries.join("\n")}
+]`;
+}
+function clientConfig(ctx) {
+  const { config } = ctx;
+  return {
+    title: config.title,
+    description: config.description,
+    base: config.base,
+    theme: config.theme,
+    features: config.features,
+    nav: config.nav,
+    footer: config.footer,
+    editLink: config.editLink,
+    favicon: config.favicon === void 0 ? void 0 : withBase(config.base, `/${toPosix(config.favicon)}`),
+    search: config.search.provider === "static" ? { provider: "static", from: withBase(config.base, "/api/search.json") } : config.search,
+    contentRoot: config.root
+  };
+}
+function json(value) {
+  return JSON.stringify(value ?? null).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function readIfExists(path) {
+  try {
+    return readFileSync3(path, "utf8");
+  } catch {
+    return void 0;
+  }
+}
+
+// src/node/vite/watcher.ts
+import chokidar from "chokidar";
+var CONTENT_FILE = /\.(?:mdx?|json)$/i;
+function seemoreWatcherPlugin(ctx) {
+  let watcher;
+  return {
+    name: "seemore:watcher",
+    apply: "serve",
+    configureServer(server) {
+      watcher = chokidar.watch(ctx.contentRoot, {
+        ignoreInitial: true,
+        ignored: (path, stats) => {
+          if (path === ctx.config.configFile) return false;
+          const posix = path.replace(/\\/g, "/");
+          if (posix.includes("/node_modules/") || posix.includes("/.git/")) return true;
+          return stats?.isFile() === true && !CONTENT_FILE.test(posix);
+        }
+      });
+      const onEvent = (event, path) => {
+        void handleContentChange(server, ctx, event, path);
+      };
+      watcher.on("add", (p) => onEvent("add", p));
+      watcher.on("change", (p) => onEvent("change", p));
+      watcher.on("unlink", (p) => onEvent("unlink", p));
+      watcher.on("addDir", (p) => onEvent("addDir", p));
+      watcher.on("unlinkDir", (p) => onEvent("unlinkDir", p));
+      if (ctx.config.configFile !== void 0) {
+        watcher.add(ctx.config.configFile);
+        watcher.on("change", (path) => {
+          if (path !== ctx.config.configFile) return;
+          server.environments.client.hot.send({ type: "full-reload", path: "*" });
+          server.config.logger.info(
+            "seemore  config changed \u2014 reloading. Changes to `base` need a restart to take effect."
+          );
+        });
+      }
+      server.httpServer?.once("close", () => void watcher?.close());
+    },
+    async closeBundle() {
+      await watcher?.close();
+      watcher = void 0;
+    }
+  };
+}
+async function handleContentChange(server, ctx, event, path) {
+  const scan2 = ctx.refresh();
+  for (const message of [...scan2.errors, ...scan2.warnings]) ctx.warnings.add(message);
+  ctx.warnings.flush((line) => server.config.logger.warn(line));
+  await reloadVirtual(server, VIRTUAL.tree);
+  await reloadVirtual(server, VIRTUAL.routes);
+  if (event === "change" && /\.mdx?$/i.test(path)) {
+    await reloadFile(server, path);
+  }
+}
+async function reloadVirtual(server, id) {
+  await reloadById(server, `\0${id}`);
+}
+async function reloadFile(server, absolutePath) {
+  await reloadById(server, absolutePath.replace(/\\/g, "/"));
+}
+async function reloadById(server, id) {
+  const environments = Object.values(server.environments ?? {});
+  if (environments.length === 0) {
+    const legacy = server.moduleGraph.getModuleById(id);
+    if (legacy) await server.reloadModule(legacy);
+    return;
+  }
+  for (const environment of environments) {
+    const mod = environment.moduleGraph?.getModuleById(id);
+    if (mod === void 0 || mod === null) continue;
+    if (typeof environment.reloadModule === "function") await environment.reloadModule(mod);
+    else environment.moduleGraph.invalidateModule(mod);
+  }
+}
+
+// src/node/vite/config.ts
+function createViteConfig({ ctx, mode, outDir, ssrOutDir }) {
+  const root = appRoot();
+  const isSsr = ssrOutDir !== void 0;
+  const mdxOptions = {
+    // `format` is inferred per file, so a plain `.md` never needs MDX syntax.
+    remarkPlugins: createRemarkPlugins({
+      contentRoot: ctx.contentRoot,
+      getResolver: () => ctx.resolver(),
+      onWarning: (message) => ctx.warnings.add(message)
+    }),
+    rehypePlugins: createRehypePlugins(),
+    // MDX compiles its own JSX. Vite's builtin transform infers a file's language from its
+    // extension and does not know `.md`/`.mdx`, so leaving JSX in the output would fail to
+    // parse. Fast Refresh is unaffected: it is a separate transform, applied to these files
+    // through the React plugin's `include` below, which is what turns a content edit into an
+    // in-place component swap rather than a reload.
+    jsx: false
+  };
+  return {
+    root,
+    base: ctx.config.base,
+    cacheDir: cacheDir(ctx.contentRoot),
+    configFile: false,
+    envDir: false,
+    clearScreen: false,
+    logLevel: mode === "build" ? "warn" : "info",
+    plugins: [
+      // Order matters: MDX first, then React, so JSX from MDX is transformed and refreshed.
+      { ...mdx(mdxOptions), enforce: "pre" },
+      react({ include: /\.(?:mdx?|jsx?|tsx?)$/ }),
+      // Before Tailwind: our plugin injects the theme preset into the root stylesheet, and
+      // Tailwind must see the injected version.
+      seemorePlugin({ ctx, serveSearch: mode === "dev" }),
+      tailwindcss(),
+      ...mode === "dev" ? [seemoreWatcherPlugin(ctx)] : []
+    ],
+    // Vite bundles workers with the browser export condition, but a worker has no `document`.
+    // `decode-named-character-reference` — pulled in through fumadocs' search client, via
+    // remark — calls `document.createElement` at module scope in its browser build, so the
+    // search worker threw on load. The package ships a DOM-free `worker` entry; use it.
+    worker: { plugins: () => [workerConditionPlugin()] },
+    resolve: {
+      // The app is compiled from seemore's own sources, so its dependencies must resolve
+      // from seemore's directory rather than from the user's project.
+      dedupe: ["react", "react-dom", "react-router", "fumadocs-core", "fumadocs-ui"]
+    },
+    server: {
+      fs: {
+        // The content root is normally *outside* the Vite root, and files outside `allow`
+        // 404 silently — the single most likely cause of "the watcher does nothing".
+        allow: withRealPaths([root, packageRoot(), ctx.contentRoot, ctx.config.root, process.cwd()])
+      },
+      watch: {
+        // Only real exclusions here. Vite merges these into chokidar's ignore *list*, where a
+        // leading `!` is a negated matcher that matches everything it is not — so the obvious
+        // `!<contentRoot>/**` "re-include" would silently ignore the entire project instead.
+        // Content outside the Vite root is watched by seemore's own chokidar instance.
+        ignored: ["**/node_modules/**", "**/.git/**"]
+      }
+    },
+    build: isSsr ? {
+      ssr: join5(root, "entry.prerender.tsx"),
+      outDir: ssrOutDir,
+      emptyOutDir: true,
+      copyPublicDir: false,
+      minify: false,
+      rollupOptions: { output: { entryFileNames: "entry.prerender.js" } }
+    } : {
+      outDir,
+      emptyOutDir: true,
+      rollupOptions: { input: join5(root, "index.html") },
+      // The app bundle is seemore's own, not the user's; warning them about a size they
+      // cannot act on is noise.
+      chunkSizeWarningLimit: 2e3
+    },
+    // The prerender bundle is written to a scratch directory outside any `node_modules`, so
+    // it has to be self-contained: an externalised `react` there resolves against the scratch
+    // directory and is simply not found.
+    ssr: isSsr ? { noExternal: true } : void 0
+  };
+}
+function withRealPaths(paths) {
+  const out = /* @__PURE__ */ new Set();
+  for (const path of paths) {
+    out.add(path);
+    try {
+      out.add(realpathSync2.native(path));
+    } catch {
+    }
+  }
+  return [...out];
+}
+function workerConditionPlugin() {
+  return {
+    name: "seemore:worker-conditions",
+    enforce: "pre",
+    async resolveId(source, importer, options) {
+      if (!WORKER_SAFE_ENTRIES.has(source)) return void 0;
+      const resolved = await this.resolve(source, importer, options);
+      if (resolved === null) return void 0;
+      const domFree = resolved.id.replace(/index\.dom\.js$/, "index.js");
+      return domFree === resolved.id ? resolved : { ...resolved, id: domFree };
+    }
+  };
+}
+var WORKER_SAFE_ENTRIES = /* @__PURE__ */ new Set(["decode-named-character-reference"]);
+
+// src/node/prerender/render.ts
+async function loadPrerenderModule(ctx, ssrOutDir) {
+  await build(createViteConfig({ ctx, mode: "build", ssrOutDir }));
+  const entry = join6(ssrOutDir, "entry.prerender.js");
+  const loaded = await import(pathToFileURL(entry).href);
+  if (typeof loaded.render !== "function" || typeof loaded.listRoutes !== "function") {
+    throw new Error(`seemore: the prerender build at ${entry} did not export \`render\` and \`listRoutes\`.`);
+  }
+  return { render: loaded.render, listRoutes: loaded.listRoutes };
+}
+
+// src/node/social/cards.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync3 } from "fs";
+import { dirname as dirname7, join as join7 } from "path";
+
+// src/shared/og.ts
+function ogImagePath(url) {
+  const clean = url.replace(/^\/+|\/+$/g, "");
+  return clean === "" ? "/api/og/card.png" : `/api/og/${clean}/card.png`;
+}
+
+// src/node/social/cards.ts
+async function generateSocialCards(ctx, outDir) {
+  let takumi;
+  try {
+    takumi = await importOptional("takumi-js");
+  } catch {
+    ctx.warnings.add(
+      "`social.cards` is enabled but `takumi-js` is not installed. Run `npm install takumi-js`, or remove the flag."
+    );
+    return 0;
+  }
+  let written = 0;
+  for (const page of ctx.pages()) {
+    const png = await renderCard(takumi, ctx.config.title, page.data.title, page.data.description);
+    if (png === void 0) continue;
+    const target = join7(outDir, ogImagePath(page.url));
+    mkdirSync2(dirname7(target), { recursive: true });
+    writeFileSync3(target, png);
+    written++;
+  }
+  return written;
+}
+async function renderCard(takumi, site, title, description) {
+  const renderer = new takumi.Renderer({ fonts: [] });
+  const node = takumi.container(
+    {
+      style: {
+        width: 1200,
+        height: 630,
+        display: "flex",
+        flexDirection: "column",
+        justifyContent: "center",
+        padding: 80,
+        backgroundColor: "#0b0b0b",
+        color: "#ffffff",
+        gap: 24
+      }
+    },
+    [
+      takumi.text(site, { style: { fontSize: 28, opacity: 0.6 } }),
+      takumi.text(title, { style: { fontSize: 64, fontWeight: 700 } }),
+      ...typeof description === "string" ? [takumi.text(description, { style: { fontSize: 30, opacity: 0.8 } })] : []
+    ]
+  );
+  return await renderer.renderAsync(node, { width: 1200, height: 630, format: "png" });
+}
+async function importOptional(specifier) {
+  return await import(specifier);
+}
+
+// src/cli/build.ts
+async function runBuild(options) {
+  const contentRoot = resolveContentRoot(options.cwd, options.dir);
+  const loaded = await loadConfig({ root: options.cwd, configPath: options.configPath });
+  const config = { ...loaded.config, base: options.base === void 0 ? loaded.config.base : normaliseBase(options.base) };
+  warnAboutMissingBase(config.base, loaded.file);
+  const ctx = createContext({ config, contentRoot });
+  const outDir = resolve5(options.cwd, options.outDir ?? "dist");
+  assertSafeOutDir(outDir, options.cwd, contentRoot);
+  const scan2 = ctx.source.current();
+  failOnErrors(ctx.errors(), contentRoot);
+  if (scan2.pages.length === 0) {
+    throw new Error(`No Markdown files found under ${contentRoot}. Point seemore at a folder that has some, or check \`exclude\`.`);
+  }
+  for (const warning of scan2.warnings) ctx.warnings.add(warning);
+  console.log(pc2.dim(`seemore  ${scan2.pages.length} pages from ${relative2(options.cwd, contentRoot) || "."}`));
+  await viteBuild(createViteConfig({ ctx, mode: "build", outDir }));
+  const template = readFileSync4(join8(outDir, "index.html"), "utf8");
+  const ssrOutDir = mkdtempSync(join8(tmpdir2(), "seemore-ssr-"));
+  try {
+    const prerender = await loadPrerenderModule(ctx, ssrOutDir);
+    const urls = prerender.listRoutes();
+    for (const url of urls) {
+      writeHtml(outDir, outputPathFor(url), applyTemplate(template, await prerender.render(url)));
+    }
+    const notFound = applyTemplate(template, await prerender.render("/__seemore_not_found"));
+    writeHtml(outDir, "404.html", notFound);
+    writeDeployArtifacts(outDir, config.base, notFound);
+    if (config.search.provider === "static") {
+      const index = await buildSearchIndex(ctx);
+      mkdirSync3(join8(outDir, "api"), { recursive: true });
+      writeFileSync4(join8(outDir, "api", "search.json"), index, "utf8");
+      const size = measureIndex(index);
+      console.log(pc2.dim(`seemore  search index ${formatBytes(size.gzipped)} gzipped`));
+      if (size.warning !== void 0) ctx.warnings.add(size.warning);
+    }
+    if (config.search.provider !== "static") await warnIfSearchSdkMissing(ctx, config.search.provider);
+    if (config.features["social.cards"]) await generateSocialCards(ctx, outDir);
+    ctx.warnings.flush();
+    console.log(pc2.green(`seemore  ${urls.length} pages written to ${relative2(options.cwd, outDir) || outDir}`));
+    return { outDir, routes: urls.length };
+  } finally {
+    rmSync(ssrOutDir, { recursive: true, force: true });
+  }
+}
+function assertSafeOutDir(outDir, cwd, contentRoot) {
+  const contains = (parent, child) => {
+    const rel = relative2(parent, child);
+    return rel === "" || !rel.startsWith("..") && !isAbsolute2(rel);
+  };
+  for (const [name, dir] of [
+    ["the current directory", cwd],
+    ["the content directory", contentRoot]
+  ]) {
+    if (contains(outDir, dir)) {
+      throw new Error(
+        `Refusing to build into ${outDir}: it is, or contains, ${name}, and the build empties its output directory first. Pass --out with a directory of its own.`
+      );
+    }
+  }
+}
+async function warnIfSearchSdkMissing(ctx, provider) {
+  const packageName = provider === "algolia" ? "algoliasearch" : "@orama/core";
+  try {
+    createRequire2(join8(ctx.config.root, "noop.js")).resolve(packageName);
+  } catch {
+    ctx.warnings.add(
+      `\`search.provider\` is '${provider}', which needs ${packageName}. Run \`npm install ${packageName}\` or search will find nothing.`
+    );
+  }
+}
+function failOnErrors(errors, contentRoot) {
+  if (errors.length === 0) return;
+  throw new Error(`seemore found ${errors.length} problem(s) in ${contentRoot}:
+
+${errors.join("\n\n")}`);
+}
+function warnAboutMissingBase(base, configFile) {
+  if (base !== "/" || process.env.GITHUB_ACTIONS !== "true") return;
+  const repo = process.env.GITHUB_REPOSITORY?.split("/")[1];
+  console.warn(
+    pc2.yellow(
+      `seemore  \`base\` is not set, and GitHub Pages serves project sites from a subpath.
+        Add this to ${configFile ?? "seemore.config.ts"}:
+
+          base: '/${repo ?? "your-repo"}/',
+
+        Or pass --base '/${repo ?? "your-repo"}/'. Ignore this if you deploy to a domain root.`
+    )
+  );
+}
+
+// src/cli/dev.ts
+import { createServer } from "vite";
+import pc3 from "picocolors";
+init_paths();
+var DEFAULT_PORT = 4040;
+async function runDev(options) {
+  const contentRoot = resolveContentRoot(options.cwd, options.dir);
+  const loaded = await loadConfig({ root: options.cwd, configPath: options.configPath });
+  const config = {
+    ...loaded.config,
+    base: options.base === void 0 ? loaded.config.base : normaliseBase(options.base)
+  };
+  const ctx = createContext({ config, contentRoot, includeDrafts: true });
+  const scan2 = ctx.source.current();
+  for (const message of [...scan2.errors, ...scan2.warnings]) ctx.warnings.add(message);
+  if (scan2.pages.length === 0) {
+    ctx.warnings.add(`No Markdown files found under ${contentRoot}. seemore will serve an empty site until there are.`);
+  }
+  const base = createViteConfig({ ctx, mode: "dev" });
+  const server = await createServer({
+    ...base,
+    server: {
+      ...base.server,
+      port: options.port ?? DEFAULT_PORT,
+      host: options.host,
+      open: options.open === true ? config.base : false
+    }
+  });
+  await server.listen();
+  const resolvedPort = server.config.server.port ?? DEFAULT_PORT;
+  const url = `http://localhost:${resolvedPort}${config.base}`;
+  ctx.warnings.flush();
+  console.log(`
+  ${pc3.green("seemore")}  ${pc3.bold(url)}`);
+  console.log(`  ${pc3.dim(`${scan2.pages.length} pages from ${contentRoot}`)}
+`);
+  return {
+    server,
+    ctx,
+    url,
+    close: async () => {
+      await server.close();
+    }
+  };
+}
+
+// src/cli/index.ts
+var USAGE = `
+${pc4.bold("seemore")} \u2014 turn a folder of Markdown into a docs site
+
+  seemore [dir]           start the dev server
+  seemore build [dir]     build a static site into dist/
+
+Options
+  --port <number>        dev server port (default 4040)
+  --host [host]          expose the dev server on the network
+  --open / --no-open     open a browser on start (default: no)
+  --config <path>        path to seemore.config.ts
+  --out <dir>            build output directory (default: dist)
+  --base <path>          subpath the site is served from, e.g. /my-repo/
+  -h, --help             show this message
+  -v, --version          show the version
+`;
+function normaliseHostFlag(argv) {
+  const index = argv.indexOf("--host");
+  if (index === -1) return argv;
+  const next = argv[index + 1];
+  if (next !== void 0 && !next.startsWith("-")) return argv;
+  return [...argv.slice(0, index), "--host=", ...argv.slice(index + 1)];
+}
+async function main(argv = process.argv.slice(2)) {
+  const { values, positionals } = parseArgs({
+    args: normaliseHostFlag(argv),
+    allowPositionals: true,
+    options: {
+      port: { type: "string" },
+      host: { type: "string" },
+      open: { type: "boolean" },
+      "no-open": { type: "boolean" },
+      config: { type: "string" },
+      out: { type: "string" },
+      base: { type: "string" },
+      help: { type: "boolean", short: "h" },
+      version: { type: "boolean", short: "v" }
+    }
+  });
+  if (values.help === true) {
+    console.log(USAGE);
+    return;
+  }
+  if (values.version === true) {
+    const { readFileSync: readFileSync5 } = await import("fs");
+    const { join: join9 } = await import("path");
+    const { packageRoot: packageRoot2 } = await Promise.resolve().then(() => (init_paths(), paths_exports));
+    const pkg = JSON.parse(readFileSync5(join9(packageRoot2(), "package.json"), "utf8"));
+    console.log(pkg.version);
+    return;
+  }
+  const [command, ...rest] = positionals;
+  const isBuild = command === "build";
+  const dir = isBuild ? rest[0] : command;
+  const shared = { cwd: process.cwd(), dir, configPath: values.config, base: values.base };
+  if (isBuild) {
+    await runBuild({ ...shared, outDir: values.out });
+    return;
+  }
+  await runDev({
+    ...shared,
+    port: values.port === void 0 ? void 0 : Number(values.port),
+    host: values.host === void 0 ? void 0 : values.host === "" ? true : values.host,
+    open: values.open === true && values["no-open"] !== true
+  });
+}
+main().catch((error) => {
+  console.error(`
+${pc4.red("seemore")} ${error instanceof Error ? error.message : String(error)}
+`);
+  process.exitCode = 1;
+});
+export {
+  main
+};
+//# sourceMappingURL=index.js.map