blume 0.1.0 → 0.1.2

package/src/migrate/fumadocs/index.ts

@@ -1,11 +1,17 @@
 import { existsSync } from "node:fs";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 
-import matter from "gray-matter";
 import { dirname, join, relative } from "pathe";
 import { glob } from "tinyglobby";
 
-import { writeBlumeConfig } from "../shared.ts";
+import matter from "../../core/frontmatter.ts";
+import type { FolderMeta } from "../../core/schema.ts";
+import {
+  ensureGitignore,
+  leftoverFiles,
+  rewriteFrameworkScripts,
+  writeBlumeConfig,
+} from "../shared.ts";
 import { loadFumadocsConfig } from "./config.ts";
 import {
   inlineFumadocsIncludes,
@@ -16,7 +22,13 @@ import {
   unsupportedFumadocsComponents,
 } from "./content.ts";
 import { normalizeFumadocsPageMeta } from "./frontmatter.ts";
-import { translateFumadocsMeta } from "./meta.ts";
+import { reshapeFumadocsGroups } from "./groups.ts";
+import {
+  parseFumadocsPages,
+  renderMetaModule,
+  translateFumadocsMeta,
+  translateFumadocsSelfMeta,
+} from "./meta.ts";
 
 export interface FumadocsMigrationResult {
   moved: number;
@@ -29,6 +41,23 @@ const PAGE_GLOB = "**/*.{md,mdx}";
 const META_GLOB = "**/meta.json";
 const IGNORE = ["**/node_modules/**"];
 
+/**
+ * Old Next/Fumadocs scaffolding a migration leaves behind. Blume can't safely
+ * auto-delete these (they may hold custom code), so the ones that exist are
+ * surfaced as a "safe to delete" checklist once the migration is verified.
+ */
+const FUMADOCS_LEFTOVERS = [
+  "next.config.ts",
+  "next.config.mjs",
+  "next.config.js",
+  "source.config.ts",
+  "source.config.mjs",
+  "source.config.js",
+  "mdx-components.tsx",
+  "next-env.d.ts",
+  "app",
+];
+
 interface PageResult {
   includeWarnings: string[];
   moved: number;
@@ -82,6 +111,24 @@ const movePage = async (
   };
 };
 
+/** Write a `FolderMeta` to `dest` unless it already exists. */
+const writeMeta = async (
+  dest: string,
+  meta: FolderMeta,
+  rel: string,
+  warnings: string[]
+): Promise<string[]> => {
+  if (Object.keys(meta).length === 0) {
+    return warnings;
+  }
+  if (existsSync(dest)) {
+    return [...warnings, `Skipped ${rel} (target already exists)`];
+  }
+  await mkdir(dirname(dest), { recursive: true });
+  await writeFile(dest, renderMetaModule(meta), "utf-8");
+  return warnings;
+};
+
 /** Convert one `meta.json` into a typed `meta.ts`, or relocate it if unparseable. */
 const convertMeta = async (
   abs: string,
@@ -105,23 +152,32 @@ const convertMeta = async (
     ];
   }
 
-  const { meta, warnings } = translateFumadocsMeta(parsed);
   const dir = dirname(rel) === "." ? "" : dirname(rel);
-  if (Object.keys(meta).length > 0) {
-    const dest = join(root, "docs", dir, "meta.ts");
-    if (existsSync(dest)) {
-      await rm(abs, { force: true });
-      return [...warnings, `Skipped ${rel} (target already exists)`];
+  const docsDir = join(root, "docs", dir);
+  const dest = join(docsDir, "meta.ts");
+
+  // A `pages` array with `---Section---` separators can't round-trip through a
+  // flat `meta.ts` ordering, so rebuild its sections as group folders instead.
+  const structure = parseFumadocsPages((parsed as { pages?: unknown }).pages);
+  if (structure.hasSections && !existsSync(dest)) {
+    const self = translateFumadocsSelfMeta(parsed);
+    const reshape = await reshapeFumadocsGroups(structure, docsDir);
+    const meta: FolderMeta = { ...self.meta };
+    if (reshape.order.length > 0) {
+      meta.pages = reshape.order;
     }
-    await mkdir(dirname(dest), { recursive: true });
-    await writeFile(
-      dest,
-      `import { defineMeta } from "blume";\n\nexport default defineMeta(${JSON.stringify(meta, null, 2)});\n`,
-      "utf-8"
-    );
+    const result = await writeMeta(dest, meta, rel, [
+      ...self.warnings,
+      ...reshape.warnings,
+    ]);
+    await rm(abs, { force: true });
+    return result;
   }
+
+  const { meta, warnings } = translateFumadocsMeta(parsed);
+  const result = await writeMeta(dest, meta, rel, warnings);
   await rm(abs, { force: true });
-  return warnings;
+  return result;
 };
 
 interface PageSummary {
@@ -221,14 +277,32 @@ export const migrateFumadocsProject = async (
     pageFiles.map((abs) => movePage(abs, base, root))
   );
   const pages = summarizePages(pageResults);
-  const metaResults = await Promise.all(
-    metaFiles.map((abs) => convertMeta(abs, base, root))
+  // Convert metas deepest-first and sequentially: a parent's group-folder
+  // reshape can move a child folder, so the child's own reshape must finish
+  // first (and the two can't race over the same `docs/` paths).
+  const orderedMetas = metaFiles.toSorted(
+    (a, b) => b.split("/").length - a.split("/").length
   );
-  const metaWarnings = metaResults.flat();
+  const metaWarnings: string[] = [];
+  for (const abs of orderedMetas) {
+    // oxlint-disable-next-line no-await-in-loop -- sequential to avoid move races
+    metaWarnings.push(...(await convertMeta(abs, base, root)));
+  }
 
   await writeBlumeConfig(root, config);
   const cleanupWarnings = await cleanupSourceDirs(root);
 
+  // Tear down the old Next/Fumadocs scaffolding so the project builds as Blume:
+  // repoint the npm scripts, ignore Blume's outputs, and list the leftover
+  // framework files to delete by hand.
+  const scriptsRewritten = await rewriteFrameworkScripts(
+    root,
+    /\bnext\b/u,
+    /fumadocs/u
+  );
+  const gitignoreAdded = await ensureGitignore(root, [".blume/", "dist/"]);
+  const leftovers = leftoverFiles(root, FUMADOCS_LEFTOVERS);
+
   const warnings = [
     ...configWarnings,
     ...metaWarnings,
@@ -246,6 +320,17 @@ export const migrateFumadocsProject = async (
       `Components without a drop-in Blume equivalent need manual review: ${pages.unsupported.join(", ")}.`
     );
   }
+  if (scriptsRewritten) {
+    warnings.push("Repointed the dev/build/start scripts at the Blume CLI.");
+  }
+  if (gitignoreAdded.length > 0) {
+    warnings.push(`Added ${gitignoreAdded.join(", ")} to .gitignore.`);
+  }
+  if (leftovers.length > 0) {
+    warnings.push(
+      `Safe to delete once the migration looks right: ${leftovers.join(", ")}. Also drop the \`next\` plugin from tsconfig.json and the \`.next\`/\`.source\` lines from .gitignore.`
+    );
+  }
   warnings.push("Review blume.config.ts and the generated meta.ts files.");
 
   return { moved: pages.moved, warnings };

package/src/migrate/fumadocs/meta.ts

@@ -10,9 +10,16 @@ import type { FolderMeta } from "../../core/schema.ts";
  * - `root: true` -> `display: "page"` (the closest analogue to a page-tree root).
  * - `description` -> dropped (folders carry no description in Blume).
  * - `pages` entries: plain slugs are kept as ordering; `"..."` (the rest marker,
- *   already Blume's default) is dropped silently; `"---Section---"` separators
- *   and `"[Text](url)"` links have no folder-meta home and are dropped with a
- *   warning.
+ *   already Blume's default) is dropped silently; `"...folder"` (the *extract*
+ *   operator, which inlines a folder's children) keeps the folder's place in the
+ *   ordering as a plain `"folder"` key and warns that it renders as a normal
+ *   group rather than flattened; `"---Section---"` separators and `"[Text](url)"`
+ *   links have no folder-meta home and are dropped with a warning.
+ *
+ * When a `pages` array carries `---Section---` separators, the migrator instead
+ * takes the *structural* path ({@link parseFumadocsPages} + the group-folder
+ * reshape in `index.ts`), which rebuilds each section as a Blume group folder
+ * rather than flattening it through `filterPages`.
  */
 
 interface FumadocsMeta {
@@ -27,6 +34,8 @@ interface FumadocsMeta {
 const SEPARATOR = /^---(?<label>.*)---$/u;
 const LINK = /^(?:\[[^\]]*\])?\[(?<text>[^\]]*)\]\((?<href>[^)]*)\)$/u;
 const REST = "...";
+/** Fumadocs *extract* operator: `...folder` inlines that folder's children. */
+const EXTRACT = /^\.\.\.(?<folder>.+)$/u;
 
 interface PagesResult {
   pages: string[];
@@ -48,6 +57,20 @@ const filterPages = (raw: unknown): PagesResult => {
     if (value === REST || value === "") {
       continue;
     }
+    const extract = EXTRACT.exec(value);
+    if (extract) {
+      // Blume has no "flatten a folder's children inline" sidebar primitive, but
+      // the folder is a sibling here, so keep its position in the ordering and
+      // let it render as a normal group.
+      const folder = extract.groups?.folder?.trim() ?? "";
+      if (folder) {
+        pages.push(folder);
+        warnings.push(
+          `Sidebar extract "...${folder}" became a normal "${folder}" group (its pages are not flattened into the parent).`
+        );
+      }
+      continue;
+    }
     const separator = SEPARATOR.exec(value);
     if (separator) {
       const label = separator.groups?.label?.trim();
@@ -74,8 +97,17 @@ export interface FumadocsMetaConversion {
   warnings: string[];
 }
 
-/** Map a parsed Fumadocs `meta.json` object onto a Blume `FolderMeta`. */
-export const translateFumadocsMeta = (
+/** Render a Blume `meta.ts` module source for a `FolderMeta`. */
+export const renderMetaModule = (meta: FolderMeta): string =>
+  `import { defineMeta } from "blume";\n\nexport default defineMeta(${JSON.stringify(meta, null, 2)});\n`;
+
+/**
+ * Translate a folder's own title/icon/display fields — everything in a Fumadocs
+ * `meta.json` *except* the `pages` ordering. Split out from
+ * {@link translateFumadocsMeta} so the structural path (which reshapes `pages`
+ * into group folders) can reuse the self fields without the flat `pages` array.
+ */
+export const translateFumadocsSelfMeta = (
   value: unknown
 ): FumadocsMetaConversion => {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -104,11 +136,109 @@ export const translateFumadocsMeta = (
     );
   }
 
-  const { pages, warnings: pageWarnings } = filterPages(source.pages);
-  if (pages.length > 0) {
-    meta.pages = pages;
-  }
-  warnings.push(...pageWarnings);
+  return { meta, warnings };
+};
 
+/** Map a parsed Fumadocs `meta.json` object onto a Blume `FolderMeta`. */
+export const translateFumadocsMeta = (
+  value: unknown
+): FumadocsMetaConversion => {
+  const { meta, warnings } = translateFumadocsSelfMeta(value);
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    const { pages, warnings: pageWarnings } = filterPages(
+      (value as FumadocsMeta).pages
+    );
+    if (pages.length > 0) {
+      meta.pages = pages;
+    }
+    warnings.push(...pageWarnings);
+  }
   return { meta, warnings };
 };
+
+// ---------------------------------------------------------------------------
+// Structural pages (separators -> sections)
+// ---------------------------------------------------------------------------
+
+/**
+ * One entry in a Fumadocs `pages` array, after classification: a `ref` (a plain
+ * page or folder name), an `extract` (`...folder`, whose children Fumadocs
+ * inlines), or a `link` (`[Text](url)`).
+ */
+export type FumadocsPageItem =
+  | { kind: "extract"; name: string }
+  | { kind: "link"; href: string; text: string }
+  | { kind: "ref"; name: string };
+
+/** A run of items under one `---Label---` separator. */
+export interface FumadocsSection {
+  items: FumadocsPageItem[];
+  label: string;
+}
+
+export interface FumadocsPagesStructure {
+  /** Whether any `---Section---` separator was present. */
+  hasSections: boolean;
+  /** Items before the first separator; they stay at the folder's top level. */
+  lead: FumadocsPageItem[];
+  sections: FumadocsSection[];
+}
+
+/**
+ * Parse a Fumadocs `pages` array into its structural shape: the lead items
+ * (before any separator) and the sections each `---Label---` introduces. Unlike
+ * {@link filterPages}, separators are preserved (as section boundaries) so the
+ * migrator can rebuild them as Blume group folders. The rest marker (`"..."`) is
+ * dropped — Blume appends unlisted pages by default.
+ */
+export const parseFumadocsPages = (raw: unknown): FumadocsPagesStructure => {
+  const lead: FumadocsPageItem[] = [];
+  const sections: FumadocsSection[] = [];
+  if (!Array.isArray(raw)) {
+    return { hasSections: false, lead, sections };
+  }
+
+  let current: FumadocsSection | null = null;
+  const push = (item: FumadocsPageItem): void => {
+    (current ? current.items : lead).push(item);
+  };
+
+  for (const entry of raw) {
+    if (typeof entry !== "string") {
+      continue;
+    }
+    const value = entry.trim();
+    if (value === REST || value === "") {
+      continue;
+    }
+    const separator = SEPARATOR.exec(value);
+    if (separator) {
+      current = {
+        items: [],
+        label: separator.groups?.label?.trim() || "Section",
+      };
+      sections.push(current);
+      continue;
+    }
+    const extract = EXTRACT.exec(value);
+    if (extract) {
+      const name = extract.groups?.folder?.trim();
+      if (name) {
+        push({ kind: "extract", name });
+      }
+      continue;
+    }
+    const link = LINK.exec(value);
+    if (link) {
+      push({
+        href: link.groups?.href ?? "",
+        kind: "link",
+        text: link.groups?.text ?? "",
+      });
+      continue;
+    }
+    push({ kind: "ref", name: value });
+  }
+
+  return { hasSections: sections.length > 0, lead, sections };
+};

package/src/migrate/mintlify/snippets.ts

@@ -1,8 +1,9 @@
 import { readFile as readFileFromDisk } from "node:fs/promises";
 
-import matter from "gray-matter";
 import { dirname, relative, resolve } from "pathe";
 
+import matter from "../../core/frontmatter.ts";
+
 const MARKDOWN_SNIPPET_IMPORT =
   /^import\s+(?<name>[$A-Z_a-z][$\w]*)\s+from\s+["'](?<source>[^"']+\.mdx?)["'];?\s*$/gmu;
 const NAMED_SNIPPET_IMPORT =

package/src/migrate/mintlify/transform.ts

@@ -1,5 +1,4 @@
-import matter from "gray-matter";
-
+import matter from "../../core/frontmatter.ts";
 import { stripUnknownPageMeta } from "../shared.ts";
 import {
   rewriteMintlifyCallouts,

package/src/migrate/nextra/index.ts

@@ -1,10 +1,10 @@
 import { existsSync } from "node:fs";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 
-import matter from "gray-matter";
 import { basename, dirname, extname, join, relative } from "pathe";
 import { glob } from "tinyglobby";
 
+import matter from "../../core/frontmatter.ts";
 import type { BlumeConfig, FolderMeta } from "../../core/schema.ts";
 import { writeBlumeConfig } from "../shared.ts";
 import {

package/src/migrate/shared.ts

@@ -1,4 +1,5 @@
-import { writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { readFile, writeFile } from "node:fs/promises";
 
 import { join } from "pathe";
 
@@ -20,6 +21,102 @@ export const writeBlumeConfig = async (
   await writeFile(join(root, "blume.config.ts"), body, "utf-8");
 };
 
+// ---------------------------------------------------------------------------
+// Old-framework teardown
+// ---------------------------------------------------------------------------
+
+/** The Blume command each standard npm script maps to after a migration. */
+const BLUME_SCRIPTS: Record<string, string> = {
+  build: "blume build",
+  dev: "blume dev",
+  start: "blume preview",
+};
+
+/**
+ * Rewrite a migrated project's npm scripts off the old framework's CLI. A
+ * `dev`/`build`/`start` script whose command invokes `cli` (e.g. `/\bnext\b/`)
+ * is repointed at the matching Blume command (`start` -> `blume preview`); a
+ * script whose command matches `remove` (e.g. a `fumadocs-mdx` postinstall) is
+ * dropped. Scripts that don't match either are left untouched, so custom tasks
+ * survive. Returns true when `package.json` changed.
+ */
+export const rewriteFrameworkScripts = async (
+  root: string,
+  cli: RegExp,
+  remove?: RegExp
+): Promise<boolean> => {
+  const pkgPath = join(root, "package.json");
+  if (!existsSync(pkgPath)) {
+    return false;
+  }
+  let pkg: { scripts?: Record<string, unknown> };
+  try {
+    pkg = JSON.parse(await readFile(pkgPath, "utf-8"));
+  } catch {
+    return false;
+  }
+  const { scripts } = pkg;
+  if (!scripts || typeof scripts !== "object") {
+    return false;
+  }
+
+  const next: Record<string, unknown> = {};
+  let changed = false;
+  for (const [name, command] of Object.entries(scripts)) {
+    const blume = BLUME_SCRIPTS[name];
+    if (typeof command === "string" && remove?.test(command)) {
+      changed = true;
+    } else if (
+      typeof command === "string" &&
+      blume &&
+      cli.test(command) &&
+      command !== blume
+    ) {
+      next[name] = blume;
+      changed = true;
+    } else {
+      next[name] = command;
+    }
+  }
+
+  if (changed) {
+    pkg.scripts = next;
+    await writeFile(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf-8");
+  }
+  return changed;
+};
+
+/** A `.gitignore` line, normalized for comparison (trailing slashes dropped). */
+const gitignoreKey = (line: string): string => line.trim().replace(/\/+$/u, "");
+
+/**
+ * Ensure `.gitignore` ignores each of `entries`, appending any that are missing
+ * (creating the file when absent). Trailing-slash differences (`dist` vs
+ * `dist/`) count as already present. Returns the entries actually added.
+ */
+export const ensureGitignore = async (
+  root: string,
+  entries: string[]
+): Promise<string[]> => {
+  const path = join(root, ".gitignore");
+  const existing = existsSync(path) ? await readFile(path, "utf-8") : "";
+  const present = new Set(
+    existing.split("\n").map(gitignoreKey).filter(Boolean)
+  );
+  const added = entries.filter((entry) => !present.has(gitignoreKey(entry)));
+  if (added.length === 0) {
+    return [];
+  }
+  const gap = existing.length > 0 && !existing.endsWith("\n") ? "\n" : "";
+  await writeFile(path, `${existing}${gap}${added.join("\n")}\n`, "utf-8");
+  return added;
+};
+
+/** Of the candidate project-relative paths, the ones that still exist — the old
+ * framework files a migration leaves behind for the user to remove by hand. */
+export const leftoverFiles = (root: string, candidates: string[]): string[] =>
+  candidates.filter((candidate) => existsSync(join(root, candidate)));
+
 // ---------------------------------------------------------------------------
 // Callout components -> Blume `:::` directives
 // ---------------------------------------------------------------------------

package/src/migrate/starlight/index.ts

@@ -1,10 +1,10 @@
 import { existsSync } from "node:fs";
 import { readFile, writeFile } from "node:fs/promises";
 
-import matter from "gray-matter";
 import { join } from "pathe";
 import { glob } from "tinyglobby";
 
+import matter from "../../core/frontmatter.ts";
 import { writeBlumeConfig } from "../shared.ts";
 import { loadStarlightConfig, mapStarlightConfig } from "./config.ts";
 import {

package/src/registry/eject.ts

@@ -5,18 +5,25 @@ import { join, relative } from "pathe";
 
 import { resolveAskBackend } from "../ai/ask.ts";
 import { buildRawMarkdown } from "../ai/markdown.ts";
+import { discoverExamples } from "../astro/examples.ts";
 import {
   buildRuntimeData,
   collectStaged,
   detectNeedsReact,
 } from "../astro/generate.ts";
-import { discoverPages } from "../astro/pages.ts";
+import { discoverIslands } from "../astro/islands.ts";
+import { customOgRoutes, discoverPages } from "../astro/pages.ts";
 import {
   askEndpointTemplate,
   astroConfigTemplate,
   catchAllPageTemplate,
   contentConfigTemplate,
   envTemplate,
+  exampleMapTemplate,
+  exampleWrapperTemplate,
+  exampleSlug,
+  islandMapTemplate,
+  islandWrapperTemplate,
   mixedbreadSearchEndpointTemplate,
   ogEndpointTemplate,
   rawMarkdownEndpointTemplate,
@@ -55,15 +62,28 @@ export const eject = async (root: string): Promise<string[]> => {
   const exportPdf = config.export.pdf;
   const exportEpub = config.export.epub;
 
-  const [pages, needsReactRaw, userTheme, rawMarkdown] = await Promise.all([
-    context.pagesRoot ? discoverPages(context.pagesRoot) : Promise.resolve([]),
-    detectNeedsReact(root),
-    context.themeFile
-      ? readFile(context.themeFile, "utf-8")
-      : Promise.resolve(""),
-    buildRawMarkdown(project),
+  const [pages, needsReactRaw, userTheme, rawMarkdown, islands, examples] =
+    await Promise.all([
+      context.pagesRoot
+        ? discoverPages(context.pagesRoot)
+        : Promise.resolve([]),
+      detectNeedsReact(root),
+      context.themeFile
+        ? readFile(context.themeFile, "utf-8")
+        : Promise.resolve(""),
+      buildRawMarkdown(project),
+      discoverIslands(root),
+      discoverExamples(root),
+    ]);
+  // Island/example frameworks drive which Astro renderers the ejected config
+  // wires in; React also switches on for project `.tsx`/`.jsx` and Ask AI.
+  const frameworks = new Set<string>([
+    ...islands.islands.map((island) => island.framework),
+    ...examples.examples.map((example) => example.framework),
   ]);
-  const needsReact = needsReactRaw || askEnabled;
+  const needsReact = needsReactRaw || askEnabled || frameworks.has("react");
+  const needsVue = frameworks.has("vue");
+  const needsSvelte = frameworks.has("svelte");
 
   // A project-relative context so generated files use portable paths.
   const relContext: ProjectContext = {
@@ -95,7 +115,10 @@ export const eject = async (root: string): Promise<string[]> => {
         contentRoutes: project.manifest.routes.map((route) => route.path),
         context: relContext,
         dataPath: "./src/generated/data.json",
+        examplesPath: "./src/generated/examples.ts",
         needsReact,
+        needsSvelte,
+        needsVue,
         pages: relPages,
         searchClientPath: "./src/generated/search-client.ts",
         themePath: "./src/generated/app.css",
@@ -129,6 +152,16 @@ export const eject = async (root: string): Promise<string[]> => {
       content: userComponentsTemplate(componentsImport),
       path: join(genDir, "components.ts"),
     },
+    // Island/example maps the catch-all imports; written even when empty so the
+    // relative import and the `blume:examples` alias always resolve.
+    {
+      content: islandMapTemplate(islands.islands),
+      path: join(genDir, "islands.ts"),
+    },
+    {
+      content: exampleMapTemplate(examples.examples),
+      path: join(genDir, "examples.ts"),
+    },
     {
       content: tailwindEntryTemplate({
         configTokens: buildThemeCss(config.theme),
@@ -166,7 +199,9 @@ export const eject = async (root: string): Promise<string[]> => {
 
   if (config.seo.og.enabled) {
     files.push({
-      content: ogEndpointTemplate(),
+      content: ogEndpointTemplate(
+        customOgRoutes(pages, config.title, config.description)
+      ),
       path: join(srcDir, "pages", "og", "[...slug].png.ts"),
     });
   }
@@ -233,6 +268,18 @@ export const eject = async (root: string): Promise<string[]> => {
     }
   }
 
+  // Per-island and per-example live wrappers referenced by the maps above.
+  files.push(
+    ...islands.islands.map((island) => ({
+      content: islandWrapperTemplate(island),
+      path: join(genDir, "islands", `${island.name}.astro`),
+    })),
+    ...examples.examples.map((example) => ({
+      content: exampleWrapperTemplate(example),
+      path: join(genDir, "examples", `${exampleSlug(example.path)}.astro`),
+    }))
+  );
+
   // Materialize staged source bodies under `<root>/blume-staged/<source>/<ref>`,
   // matching the relative `staged` collection base in the ejected config.
   for (const [entryId, content] of staged) {

package/src/search/documents.ts

@@ -1,5 +1,4 @@
-import matter from "gray-matter";
-
+import matter from "../core/frontmatter.ts";
 import { contentIndexable } from "../core/manifest.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
 import { readEntryText } from "../core/sources/read.ts";