blume 0.5.2 → 0.5.4

package/src/core/graph.ts

@@ -60,7 +60,7 @@ export const buildContentGraph = (
     }
 
     // Each locale gets an independent tree from its own pages and folder meta,
-    // so navigation may diverge per language (Mintlify-style).
+    // so navigation may diverge per language.
     for (const { code } of i18n.locales) {
       // Localize internal tab paths so a header tab points to its in-locale
       // route (e.g. `/docs` -> `/fr/docs`); external paths pass through.
@@ -89,9 +89,13 @@ export const buildContentGraph = (
       }
 
       navigationByLocale[code] = buildNavigation(localePages, {
-        chromeVariants: options.navigation.chromeVariants,
         folderMeta: options.folderMeta,
-        metaPrefix: code === i18n.defaultLocale ? "" : code,
+        // Meta files live in locale directories only under the `dir` parser
+        // (`fr/guides/meta.ts` -> key `fr/guides`). Under `dot`, translations
+        // sit next to the originals and `guides/meta.ts` applies to every
+        // locale — prefixing would look up keys that can never exist.
+        metaPrefix:
+          i18n.parser === "dir" && code !== i18n.defaultLocale ? code : "",
         refByLogical: true,
         selectors: options.navigation.selectors,
         sharedFolderMeta: options.sharedFolderMeta,
@@ -100,14 +104,12 @@ export const buildContentGraph = (
       });
     }
     navigation = navigationByLocale[i18n.defaultLocale] ?? {
-      chromeVariants: [],
       selectors: [],
       sidebar: [],
       tabs: [],
     };
   } else {
     navigation = buildNavigation(pages, {
-      chromeVariants: options.navigation.chromeVariants,
       folderMeta: options.folderMeta,
       selectors: options.navigation.selectors,
       sharedFolderMeta: options.sharedFolderMeta,

package/src/core/links.ts

@@ -2,7 +2,6 @@ import { existsSync } from "node:fs";
 
 import { basename, join } from "pathe";
 
-import type { AssetMount } from "./assets.ts";
 import type {
   ContentGraph,
   Diagnostic,
@@ -38,25 +37,15 @@ interface ExternalRef extends LinkSite {
 /** Lookups derived once from the content graph. */
 interface LinkContext {
   anchors: Map<string, Set<string>>;
-  /** `content.assets` mounts served alongside `public/` (checked in place). */
-  assetMounts: AssetMount[];
   publicDir: string | null;
   /** Normalized `redirect.from` paths — valid targets that resolve at runtime. */
   redirects: Set<string>;
   routes: Set<string>;
 }
 
-/** Whether a resolved asset path exists under `public/` or an asset mount. */
-const assetIsPresent = (resolved: string, ctx: LinkContext): boolean => {
-  if (ctx.publicDir && existsSync(join(ctx.publicDir, resolved))) {
-    return true;
-  }
-  return ctx.assetMounts.some(
-    (mount) =>
-      (resolved === mount.url || resolved.startsWith(`${mount.url}/`)) &&
-      existsSync(join(mount.dir, resolved.slice(mount.url.length)))
-  );
-};
+/** Whether a resolved asset path exists under `public/`. */
+const assetIsPresent = (resolved: string, ctx: LinkContext): boolean =>
+  ctx.publicDir !== null && existsSync(join(ctx.publicDir, resolved));
 
 /** Outcome of classifying one link target. */
 type LinkResult = Diagnostic | "asset-unchecked" | null;
@@ -165,8 +154,8 @@ const checkPathLink = (
     if (assetIsPresent(resolved, ctx)) {
       return null;
     }
-    // Nowhere to look: no `public/` and no asset mounts configured.
-    if (ctx.publicDir === null && ctx.assetMounts.length === 0) {
+    // Nowhere to look: no `public/` directory.
+    if (ctx.publicDir === null) {
       return "asset-unchecked";
     }
     return {
@@ -347,15 +336,12 @@ export const validateLinks = async (
   options: {
     publicDir: string | null;
     checkExternal?: boolean;
-    /** `content.assets` mounts served alongside `public/`. */
-    assetMounts?: AssetMount[];
     /** Configured redirects; their `from` paths count as valid link targets. */
     redirects?: { from: string }[];
   }
 ): Promise<Diagnostic[]> => {
   const ctx: LinkContext = {
     anchors: buildAnchorIndex(graph.pages),
-    assetMounts: options.assetMounts ?? [],
     publicDir: options.publicDir,
     redirects: new Set(
       (options.redirects ?? []).map((redirect) => toRoute(redirect.from))

package/src/core/meta.ts

@@ -39,7 +39,7 @@ export const discoverFolderMeta = async (
     absolute: true,
     cwd: contentRoot,
     // Never descend into dependencies or build output — relevant when the
-    // content root is the project root (e.g. a migrated Mintlify project).
+    // content root is the project root (e.g. a `.`-rooted or all-staged project).
     ignore: ["**/node_modules/**", "**/.blume/**", "**/dist/**"],
     onlyFiles: true,
   });

package/src/core/navigation.ts

@@ -6,7 +6,6 @@ import type {
   SidebarItemConfig,
 } from "./schema.ts";
 import type {
-  NavChromeVariant,
   NavNode,
   Navigation,
   NavSelector,
@@ -255,7 +254,11 @@ const normalizeRef = (ref: string): string => {
     return "/";
   }
   const withSlash = ref.startsWith("/") ? ref : `/${ref}`;
-  return withSlash.endsWith("/index") ? withSlash.slice(0, -6) : withSlash;
+  const trimmed = withSlash.endsWith("/index")
+    ? withSlash.slice(0, -"/index".length)
+    : withSlash;
+  // "/index" trims to "" — that's the root, not an empty route.
+  return trimmed === "" ? "/" : trimmed;
 };
 
 const routeForRef = (
@@ -342,7 +345,6 @@ const buildConfigSidebar = (
 export const buildNavigation = (
   pages: PageRecord[],
   options: {
-    chromeVariants?: NavChromeVariant[];
     folderMeta: Map<string, FolderMeta>;
     selectors?: NavSelector[];
     tabs?: NavTab[];
@@ -359,7 +361,6 @@ export const buildNavigation = (
     sharedFolderMeta?: Map<string, FolderMeta>;
   }
 ): Navigation => {
-  const chromeVariants = options.chromeVariants ?? [];
   const selectors = options.selectors ?? [];
   const tabs = options.tabs ?? [];
   const metaPrefix = options.metaPrefix ?? "";
@@ -373,7 +374,6 @@ export const buildNavigation = (
 
   if (options.sidebar) {
     return {
-      chromeVariants,
       selectors,
       sidebar: buildConfigSidebar(options.sidebar, byRoute),
       tabs,
@@ -381,7 +381,6 @@ export const buildNavigation = (
   }
 
   return {
-    chromeVariants,
     selectors,
     sidebar: buildFileSystemSidebar(
       pages,

package/src/core/project-graph.ts

@@ -1,5 +1,4 @@
 import { loadConfig } from "./config.ts";
-import type { ConfigBridge } from "./config.ts";
 import { buildContentGraph } from "./graph.ts";
 import { i18nDiagnostics } from "./i18n.ts";
 import {
@@ -69,8 +68,6 @@ export interface BlumeProject {
   diagnostics: Diagnostic[];
   /** The instantiated content sources, for lazy entry reads (search/AI/raw). */
   sources: ContentSource[];
-  /** Set when serving a foreign docs config (e.g. Mintlify) without migrating. */
-  bridge: ConfigBridge | null;
 }
 
 /**
@@ -97,7 +94,6 @@ export const scanProject = async (
   const configResult = await loadConfig(root, {
     devServerUrl: options.devServerUrl,
   });
-  const { bridge } = configResult;
   const config = applyConfigOverrides(configResult.config, options.overrides);
   const context = resolveProjectContext(root, config, {
     runtimeDir: options.runtimeDir,
@@ -179,7 +175,6 @@ export const scanProject = async (
   const i18nWarnings = config.i18n ? i18nDiagnostics(pages, config.i18n) : [];
 
   return {
-    bridge,
     config,
     context,
     diagnostics: [

package/src/core/schema.ts

@@ -99,25 +99,15 @@ const pageMetaBaseSchema = z
     deprecated: z.boolean().default(false),
     description: z.string().optional(),
     draft: z.boolean().default(false),
-    groups: z.union([z.string(), z.array(z.string())]).optional(),
     hidden: z.boolean().default(false),
-    hideApiMarker: z.boolean().default(false),
-    hideFooterPagination: z.boolean().optional(),
     icon: iconName.optional(),
-    iconType: z.string().optional(),
-    keywords: z.array(z.string()).optional(),
     /** Overrides the git-derived last-modified date when `lastModified` is on. */
     lastModified: dateSchema.optional(),
-    mode: z.string().optional(),
     noindex: z.boolean().default(false),
-    public: z.boolean().optional(),
-    rss: z.boolean().optional(),
     search: searchMetaSchema.default({}),
     seo: seoMetaSchema.default({}),
     sidebar: sidebarMetaSchema.default({}),
-    sidebarTitle: z.string().optional(),
     slug: z.string().optional(),
-    tag: z.string().optional(),
     title: z.string().optional(),
     type: z.string().default("doc"),
   })
@@ -160,45 +150,41 @@ export type FolderMeta = z.infer<typeof folderMetaSchema>;
 // Project config (blume.config.ts)
 // ---------------------------------------------------------------------------
 
-const logoConfigSchema = z.union([
+/** The logo mark: a single image path/URL, or light/dark variants with alt text. */
+const logoImageSchema = z.union([
   z.string(),
   z
     .object({
       alt: z.string().optional(),
       dark: z.string().optional(),
-      href: z.string().optional(),
       light: z.string().optional(),
     })
     .strict(),
 ]);
 
-const faviconConfigSchema = z.union([
+/**
+ * Site logo. A bare string is the image shorthand. The object form splits the
+ * brand into an optional `image` mark and optional wordmark `text` so a site can
+ * show an image-only logo (a mark with the wordmark baked in), a text-only logo,
+ * or both. Omit `text` to fall back to the site title; set `text: ""` to render
+ * the mark alone. `href` overrides the brand link (defaults to `/`).
+ */
+const logoConfigSchema = z.union([
   z.string(),
   z
     .object({
-      dark: z.string().optional(),
-      light: z.string().optional(),
+      href: z.string().optional(),
+      image: logoImageSchema.optional(),
+      text: z.string().optional(),
     })
     .strict(),
 ]);
 
-const bannerColorSchema = z
-  .object({
-    dark: z.string().optional(),
-    light: z.string().optional(),
-  })
-  .strict()
-  .refine((value) => value.dark !== undefined || value.light !== undefined, {
-    message: "Banner color requires at least one of light or dark.",
-  });
-
 /** Site-wide announcement banner: a string, or text with an optional link. */
 const bannerConfigSchema = z.union([
   z.string(),
   z
     .object({
-      /** Background color override (Mintlify compatibility). */
-      color: bannerColorSchema.optional(),
       content: z.string(),
       /** Show a dismiss button; the choice is remembered per visitor. */
       dismissible: z.boolean().default(false),
@@ -208,8 +194,6 @@ const bannerConfigSchema = z.union([
         .object({ href: z.string(), text: z.string() })
         .strict()
         .optional(),
-      /** Tone (Mintlify compatibility). */
-      type: z.enum(["info", "warning", "critical"]).optional(),
     })
     .strict(),
 ]);
@@ -329,30 +313,6 @@ const githubReleasesSourceSchema = z
   })
   .strict();
 
-/**
- * In-place Mintlify content (`docs.json` + MDX). Powers "bridge mode": Blume
- * reads an unconverted Mintlify project, transforming each page to Blume MDX at
- * scan time. Injected automatically by `loadConfig` when a `docs.json` is found
- * and no `blume.config.*` exists; can also be configured explicitly.
- */
-const mintlifySourceSchema = z
-  .object({
-    /** Absolute path of the `docs.json`/`mint.json`, watched for changes in dev. */
-    configFile: z.string().optional(),
-    /** Patterns excluded from page discovery (Mintlify defaults are merged in). */
-    exclude: z.array(z.string()).default([]),
-    /** Glob patterns for Mintlify content files. */
-    include: z.array(z.string()).default(["**/*.{md,mdx}"]),
-    /** Namespaces the source's routes under `/<prefix>/`. */
-    prefix: z.string().optional(),
-    /** Content root, absolute or relative to the project root (Mintlify: `.`). */
-    root: z.string().default("."),
-    type: z.literal("mintlify"),
-    /** `docs.json` variables, inlined into content (`{{name}}`) at scan time. */
-    variables: z.record(z.string(), z.string()).default({}),
-  })
-  .strict();
-
 /**
  * A user-provided `ContentSource` instance, passed straight through from
  * `blume.config.ts`. This is the extension point that lets adapters with custom
@@ -377,7 +337,6 @@ const contentSourceSchema = z.discriminatedUnion("type", [
   githubReleasesSourceSchema,
   sanitySourceSchema,
   notionSourceSchema,
-  mintlifySourceSchema,
   customSourceSchema,
 ]);
 
@@ -386,13 +345,6 @@ export type ContentSourceConfig = z.infer<typeof contentSourceSchema>;
 
 const contentConfigSchema = z
   .object({
-    /**
-     * Extra top-level directories (relative to the project root) served as
-     * static assets at the site root, alongside `public/`. Lets projects keep
-     * root-served asset folders in place — e.g. a Mintlify migration keeps
-     * `images/` where it is instead of relocating it under `public/`.
-     */
-    assets: z.array(z.string()).default([]),
     defaultType: z.string().default("doc"),
     exclude: z.array(z.string()).default(["**/_*", "**/.*"]),
     include: z.array(z.string()).default(["**/*.{md,mdx}"]),
@@ -483,10 +435,6 @@ const sidebarItemSchema: z.ZodType<SidebarItemConfig> = z.lazy(() =>
   ])
 );
 
-const variablesConfigSchema = z
-  .record(z.string().regex(/^[A-Za-z0-9-]+$/u), z.string())
-  .default({});
-
 /** A curated Google Font slug (see `theme/fonts.ts`). */
 const fontSlug = z.string().refine(isFontSlug, (value) => ({
   message: `Unknown font "${value}". Supported fonts: ${FONT_SLUGS.join(", ")}.`,
@@ -499,7 +447,6 @@ const themeConfigSchema = z
     action: z.string().optional(),
     background: z.string().optional(),
     backgroundDark: z.string().optional(),
-    backgroundDecoration: z.enum(["gradient", "grid", "windows"]).optional(),
     backgroundImage: z.string().optional(),
     backgroundImageDark: z.string().optional(),
     fonts: z
@@ -584,7 +531,6 @@ const searchConfigSchema = z
       .default({}),
     mixedbread: mixedbreadSearchSchema.optional(),
     oramaCloud: oramaCloudSearchSchema.optional(),
-    prompt: z.string().optional(),
     provider: z.enum(searchProviders).default("orama"),
     typesense: typesenseSearchSchema.optional(),
   })
@@ -644,16 +590,8 @@ const aiConfigSchema = z
   })
   .strict();
 
-const chromeVariantSchema = z
-  .object({
-    banner: bannerConfigSchema.optional(),
-    path: z.string(),
-  })
-  .strict();
-
 const navigationConfigSchema = z
   .object({
-    chromeVariants: z.array(chromeVariantSchema).default([]),
     /** Show a GitHub repo link in the header (requires `github` configured). */
     repo: z.boolean().default(true),
     selectors: z.array(navSelectorSchema).default([]),
@@ -824,7 +762,6 @@ const rssConfigSchema = z
 /** Discoverability features: OG images, feeds, sitemap, structured data. */
 const seoConfigSchema = z
   .object({
-    metatags: z.record(z.string(), z.string()).default({}),
     og: ogConfigSchema.default({}),
     /** Generate robots.txt (with a Sitemap reference when available). */
     robots: z.boolean().default(true),
@@ -1001,17 +938,6 @@ const tocConfigSchema = z
     };
   });
 
-/**
- * Which icon library bare `icon` names resolve against (mirrors Mintlify's
- * `icons.library`). Names can always opt into a specific set with an explicit
- * `prefix:name` (`lucide:rocket`, `fa6-brands:github`) regardless of this.
- */
-const iconsConfigSchema = z
-  .object({
-    library: z.enum(["lucide", "fontawesome", "tabler"]).default("lucide"),
-  })
-  .strict();
-
 export const blumeConfigSchema = z
   .object({
     ai: aiConfigSchema.default({}),
@@ -1036,11 +962,9 @@ export const blumeConfigSchema = z
      */
     examples: z.string().default("examples"),
     export: exportConfigSchema.default(false),
-    favicon: faviconConfigSchema.optional(),
     feedback: z.boolean().default(true),
     github: githubConfigSchema.optional(),
     i18n: i18nConfigSchema.optional(),
-    icons: iconsConfigSchema.default({}),
     lastModified: lastModifiedConfigSchema.default(false),
     logo: logoConfigSchema.optional(),
     markdown: markdownConfigSchema.default({}),
@@ -1053,7 +977,6 @@ export const blumeConfigSchema = z
     theme: themeConfigSchema.default({}),
     title: z.string().default("Documentation"),
     toc: tocConfigSchema,
-    variables: variablesConfigSchema,
   })
   .strict();
 

package/src/core/sources/filesystem.ts

@@ -7,6 +7,11 @@ import { glob } from "tinyglobby";
 import { BlumeError } from "../diagnostics.ts";
 import matter from "../frontmatter.ts";
 import type { ContentSource, SourceEntry, SourceLoadResult } from "./types.ts";
+import {
+  BLUME_WATCH_IGNORE_DIRS,
+  excludeDirSegments,
+  ignoringWatchListener,
+} from "./watch.ts";
 
 /** Options for the built-in filesystem source. */
 export interface FilesystemSourceOptions {
@@ -75,13 +80,26 @@ export const filesystemSource = (
     }
   };
 
+  // When `content.root` is the project root (a migrated `.`-rooted project),
+  // the recursive dev watcher would otherwise see Blume's own `.blume/` output
+  // and loop; skip it, VCS/dependency trees, and every excluded dir so the
+  // watcher stays in sync with what `load()` globs. See {@link ignoringWatchListener}.
+  const watchIgnoreDirs = new Set([
+    ...BLUME_WATCH_IGNORE_DIRS,
+    ...excludeDirSegments(options.exclude),
+  ]);
+
   const watch = (onChange: () => void): (() => void) => {
     if (!existsSync(contentRoot)) {
       return () => {
         // Nothing to dispose when the root doesn't exist yet.
       };
     }
-    const watcher = fsWatch(contentRoot, { recursive: true }, onChange);
+    const watcher = fsWatch(
+      contentRoot,
+      { recursive: true },
+      ignoringWatchListener(onChange, watchIgnoreDirs)
+    );
     return () => watcher.close();
   };
 

package/src/core/sources/mdx-remote.ts

@@ -91,9 +91,23 @@ interface RemoteRef {
   editUrl?: string;
 }
 
-const githubHeaders = (): Record<string, string> => {
+// Hosts the GITHUB_TOKEN may be sent to. A configured `url` base can point at
+// any server, and leaking the token there would hand a repo credential to an
+// arbitrary third party.
+const GITHUB_HOSTS = new Set(["api.github.com", "raw.githubusercontent.com"]);
+
+const githubHeaders = (url: string): Record<string, string> => {
   const token = process.env.GITHUB_TOKEN;
-  return token ? { authorization: `Bearer ${token}` } : {};
+  if (!token) {
+    return {};
+  }
+  let host = "";
+  try {
+    host = new URL(url).hostname;
+  } catch {
+    return {};
+  }
+  return GITHUB_HOSTS.has(host) ? { authorization: `Bearer ${token}` } : {};
 };
 
 interface GithubTreeEntry {
@@ -110,7 +124,7 @@ const enumerateGithub = async (
   const { owner, repo, ref } = github;
   const base = github.path.replaceAll(/^\/|\/$/gu, "");
   const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${ref}?recursive=1`;
-  const res = await doFetch(treeUrl, { headers: githubHeaders() });
+  const res = await doFetch(treeUrl, { headers: githubHeaders(treeUrl) });
   if (!res.ok) {
     throw new Error(`${treeUrl} -> ${res.status}`);
   }
@@ -172,7 +186,9 @@ export const mdxRemoteSource = (
   };
 
   const fetchEntry = async (item: RemoteRef): Promise<SourceEntry> => {
-    const res = await doFetch(item.fetchUrl, { headers: githubHeaders() });
+    const res = await doFetch(item.fetchUrl, {
+      headers: githubHeaders(item.fetchUrl),
+    });
     if (!res.ok) {
       throw new Error(`${item.fetchUrl} -> ${res.status}`);
     }

package/src/core/sources/normalize.ts

@@ -59,6 +59,11 @@ const mapRoute = (
   const groups: string[] = [];
 
   for (const part of rawParts) {
+    // A leading/trailing/double slash yields an empty part; keeping it would
+    // produce a malformed route (`//foo`, `/foo/`) that nothing can link to.
+    if (part === "") {
+      continue;
+    }
     const group = groupLabel(part);
     if (group !== null) {
       groups.push(group);
@@ -113,10 +118,11 @@ export const extractHeadings = (body: string): Heading[] => {
 };
 
 const MD_LINK = /\[[^\]]*\]\((?<target>[^)\s]+)(?:\s+"[^"]*")?\)/gu;
+const INLINE_CODE = /`[^`]*`/gu;
 
 /**
  * Extract link targets from a markdown body for later validation, recording the
- * 1-based line/column of each target. Skips fenced code blocks.
+ * 1-based line/column of each target. Skips fenced code blocks and inline code.
  */
 export const extractLinks = (body: string): PageLink[] => {
   const links: PageLink[] = [];
@@ -132,7 +138,12 @@ export const extractLinks = (body: string): PageLink[] => {
     if (inFence) {
       continue;
     }
-    for (const match of line.matchAll(MD_LINK)) {
+    // Blank out inline code spans (`[label](/x)` shown as syntax, not a link)
+    // with same-length padding so recorded columns stay accurate.
+    const masked = line.replaceAll(INLINE_CODE, (span) =>
+      " ".repeat(span.length)
+    );
+    for (const match of masked.matchAll(MD_LINK)) {
       const target = match.groups?.target;
       if (target === undefined || match.index === undefined) {
         continue;
@@ -153,7 +164,6 @@ export const extractLinks = (body: string): PageLink[] => {
   return links;
 };
 
-const INLINE_CODE = /`[^`]*`/gu;
 // Double-quoted strings hold JSX attribute values and JSON in `{...}` props; a
 // `<Tag>` written inside prose there (e.g. an "Astro <Font> integration" note)
 // isn't a real usage. Single quotes are left alone so prose apostrophes don't
@@ -207,8 +217,14 @@ const deriveTitle = (
   return titleCase(stripNumericPrefix(base.replace(extname(base), "")));
 };
 
-const withPrefix = (prefix: string | undefined, path: string): string =>
-  prefix ? `${prefix}/${path}` : path;
+/** Strip habitual leading/trailing slashes (`/getting-started`, `guides/`). */
+const trimSlashes = (value: string): string =>
+  value.replaceAll(/^\/+|\/+$/gu, "");
+
+const withPrefix = (prefix: string | undefined, path: string): string => {
+  const clean = prefix ? trimSlashes(prefix) : "";
+  return clean ? `${clean}/${path}` : path;
+};
 
 /**
  * Normalize one source entry into per-locale `PageRecord`s. This is the single
@@ -254,9 +270,15 @@ export const normalizeEntry = (
     : { locales: [""], navPath: entry.ref };
 
   const navPath = withPrefix(ctx.source.prefix, rawNavPath);
+  // Frontmatter `slug` wins, then the adapter-supplied `entry.slug` (the typed
+  // SPI's "logical route input; defaults to ref if omitted"), then the ref.
+  // The extension is re-appended so mapRoute's extname strip can't eat a
+  // dotted slug segment (`v1.2`). A slug that trims to nothing falls back.
+  const slugInput = meta.slug ?? entry.slug;
+  const slug = slugInput ? trimSlashes(slugInput) : "";
   const routeInput = withPrefix(
     ctx.source.prefix,
-    meta.slug ? `${meta.slug}${ext}` : rawNavPath
+    slug ? `${slug}${ext}` : rawNavPath
   );
 
   const { segments, groups, route: logicalRoute } = mapRoute(routeInput);

package/src/core/sources/resolve.ts

@@ -7,7 +7,6 @@ import type { ProjectContext } from "../types.ts";
 import { filesystemSource } from "./filesystem.ts";
 import { githubReleasesSource } from "./github-releases.ts";
 import { mdxRemoteSource } from "./mdx-remote.ts";
-import { mintlifySource } from "./mintlify.ts";
 import { notionSource } from "./notion.ts";
 import { sanitySource } from "./sanity.ts";
 import type { ContentSource, SourceContext } from "./types.ts";
@@ -64,18 +63,6 @@ const buildSource = (
       root: def.root,
     });
   }
-  if (def.type === "mintlify") {
-    return mintlifySource({
-      configFile: def.configFile,
-      exclude: def.exclude,
-      include: def.include,
-      name,
-      prefix: def.prefix,
-      projectRoot: context.root,
-      root: def.root,
-      variables: def.variables,
-    });
-  }
   if (def.type === "custom") {
     // A user-provided instance manages its own context/caching; we only ensure
     // its name is unique across the project for id namespacing.

package/src/core/sources/watch.ts

@@ -0,0 +1,45 @@
+import type { WatchListener } from "node:fs";
+
+/**
+ * Directory segments a recursive dev watcher must never react to. When a
+ * source's content root is the project root — a `.`-rooted layout, or an
+ * all-staged project (openapi/notion/github-releases/…) with no filesystem
+ * source — a naive recursive `fs.watch` also sees Blume's own `.blume/`
+ * output, which the dev server rewrites on every render (e.g.
+ * `.blume/.astro/data-store.json`). Left unfiltered, each such write re-triggers
+ * a rescan + runtime regeneration whose writes land back under `.blume/` and
+ * fire the watcher again: a self-sustaining loop that stalls page renders and
+ * floods the console (and, mid-render, corrupts Astro's dev module graph so
+ * `astro:server-app.js` fails to load). `.git`/`node_modules` are here for the
+ * same reason — churn that is never page content. `fs.watch` has no ignore
+ * option, so we filter by the changed path in the callback.
+ */
+export const BLUME_WATCH_IGNORE_DIRS = [".blume", ".git", "node_modules"];
+
+/** Extract single-segment ignore dirs (`foo`) from `foo/**`-style excludes. */
+export const excludeDirSegments = (patterns: readonly string[]): string[] =>
+  patterns
+    .map((pattern) => /^(?<dir>[^*/]+)\/\*\*$/u.exec(pattern)?.groups?.dir)
+    .filter((dir): dir is string => dir !== undefined);
+
+/**
+ * Build a recursive-watch listener that fires `onChange` for content changes but
+ * ignores events whose path crosses an ignored directory segment. A missing
+ * `filename` — rare; the platform couldn't name the changed path — falls through
+ * to `onChange` rather than silently dropping a real edit. Exported for testing.
+ */
+export const ignoringWatchListener = (
+  onChange: () => void,
+  ignoreDirs: Iterable<string> = BLUME_WATCH_IGNORE_DIRS
+): WatchListener<string> => {
+  const ignore = new Set(ignoreDirs);
+  return (_event, filename) => {
+    if (
+      typeof filename === "string" &&
+      filename.split(/[/\\]/u).some((segment) => ignore.has(segment))
+    ) {
+      return;
+    }
+    onChange();
+  };
+};