@kenjura/ursa 0.96.0 → 0.98.0

package/src/helper/__test__/contentHash.test.js

@@ -2,12 +2,22 @@ import { join } from "path";
 import { mkdtemp, rm, mkdir, writeFile, readFile } from "fs/promises";
 import { existsSync } from "fs";
 import { tmpdir } from "os";
-import {
-  enforceCacheVersion,
-  getUrsaDir,
-  loadHashCache,
-  saveHashCache,
-} from "../contentHash.js";
+import { enforceCacheVersion, getUrsaDir } from "../contentHash.js";
+
+// The cache `.ursa/` holds is the build graph. These tests only need a file
+// that must survive a matching stamp and vanish on a mismatch.
+const CACHE_FILE = "graph.json";
+async function saveHashCache(dir, map) {
+  await mkdir(getUrsaDir(dir), { recursive: true });
+  await writeFile(join(getUrsaDir(dir), CACHE_FILE), JSON.stringify([...map]));
+}
+async function loadHashCache(dir) {
+  try {
+    return new Map(JSON.parse(await readFile(join(getUrsaDir(dir), CACHE_FILE), "utf8")));
+  } catch {
+    return new Map();
+  }
+}
 
 let sourceDir;
 beforeEach(async () => {

package/src/helper/__test__/inlineMenu.test.js

@@ -0,0 +1,142 @@
+import { join } from "path";
+import { mkdtemp, mkdir, writeFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import {
+  namedMenuOptions,
+  findNamedMenu,
+  collectMenuAnchorIds,
+  prepareMdxMenuAnchors,
+  resolveMenuAnchors,
+  renderInlineMenuHtml,
+  menuNotFoundComment,
+  leadingMenusEnd,
+} from "../inlineMenu.js";
+import { isMenuFile, findCustomMenu } from "../customMenu.js";
+
+describe("isMenuFile", () => {
+  it("matches the folder menu and named menus, not documents", () => {
+    for (const name of ["menu.md", "_menu.md", "menu.txt", "menu-2.md", "menu-classes.md", "_menu-x.txt", "Menu-Classes.md"]) {
+      expect(isMenuFile(name)).toBe(true);
+    }
+    for (const name of ["menus.md", "menu.mdx", "my-menu.md", "menu-.md", "menu_x.md", "index.md", "menu"]) {
+      expect(isMenuFile(name)).toBe(false);
+    }
+  });
+});
+
+describe("namedMenuOptions", () => {
+  it("defaults appearance to horizontal and reports an invalid value", () => {
+    expect(namedMenuOptions({ id: "classes" })).toEqual({ id: "classes", appearance: "horizontal", appearanceInvalid: null });
+    expect(namedMenuOptions({ id: "x", appearance: "Vertical" }).appearance).toBe("vertical");
+    expect(namedMenuOptions({ id: "x", appearance: "sideways" })).toMatchObject({ appearance: "horizontal", appearanceInvalid: "sideways" });
+    expect(namedMenuOptions({}).id).toBeNull();
+    expect(namedMenuOptions({ id: "" }).id).toBeNull();
+  });
+});
+
+describe("anchors", () => {
+  it("collects ids in both forms, once each", () => {
+    const html = '<p>{menu:a}</p><div data-ursa-menu="b"></div><p>x {menu:a} y</p>';
+    expect(collectMenuAnchorIds(html)).toEqual(["b", "a"]);
+  });
+
+  it("rewrites MDX anchors alone on a line into the element form", () => {
+    const src = "---\nx: 1\n---\n\n{menu:classes}\n\nText with {menu:inline} stays.\n  {menu:indented}  \n";
+    const out = prepareMdxMenuAnchors(src);
+    expect(out).toContain('<div data-ursa-menu="classes"></div>');
+    expect(out).toContain('<div data-ursa-menu="indented"></div>');
+    expect(out).toContain("Text with {menu:inline} stays.");
+  });
+
+  it("replaces a paragraph that is only the anchor", () => {
+    const out = resolveMenuAnchors("<h1>T</h1>\n<p>{menu:classes}</p>\n<p>Body.</p>", (id) => `<nav>${id}</nav>`);
+    expect(out).toBe("<h1>T</h1>\n<nav>classes</nav>\n<p>Body.</p>");
+  });
+
+  it("splits a paragraph with text around the anchor so the nav is not inside a <p>", () => {
+    const out = resolveMenuAnchors("<p>Before {menu:x} after</p>", (id) => `<nav>${id}</nav>`);
+    expect(out).toBe("<p>Before</p>\n<nav>x</nav><p>after</p>\n");
+  });
+
+  it("leaves anchors quoted in code alone", () => {
+    const html = "<p>Write <code>{menu:x}</code> on its own line.</p>\n<pre><code>{menu:y}</code></pre>";
+    expect(resolveMenuAnchors(html, () => "NO")).toBe(html);
+  });
+
+  it("replaces the element form anywhere", () => {
+    const out = resolveMenuAnchors('<div data-ursa-menu="c"></div><div data-ursa-menu="d"/>', (id) => `[${id}]`);
+    expect(out).toBe("[c][d]");
+  });
+
+  it("is a no-op for bodies without anchors", () => {
+    const html = "<p>Nothing here { menu } either</p>";
+    expect(resolveMenuAnchors(html, () => "X")).toBe(html);
+  });
+
+  it("finds where leading menus end", () => {
+    const nav = '<nav class="ursa-menu ursa-menu-horizontal" data-menu-id="a"><ul></ul></nav>';
+    expect(leadingMenusEnd(`${nav}\n<p>x</p>`)).toBe(nav.length);
+    expect(leadingMenusEnd(`\n${nav}${menuNotFoundComment("b")}<h1>T</h1>`)).toBe(1 + nav.length + menuNotFoundComment("b").length);
+    expect(leadingMenusEnd("<h1>T</h1>")).toBe(0);
+  });
+});
+
+describe("renderInlineMenuHtml", () => {
+  const data = [
+    { label: "Arcanist", href: "/character/classes/arcanist.html", children: [] },
+    { label: "Fighter & Co", href: "/character/classes/fighter.html", children: [] },
+    {
+      label: "More",
+      href: null,
+      children: [{ label: "Witch", href: "/character/classes/witch.html", children: [] }],
+    },
+  ];
+
+  it("renders a horizontal nav by default, escaping labels", () => {
+    const html = renderInlineMenuHtml(data, { id: "classes" });
+    expect(html).toMatch(/^<nav class="ursa-menu ursa-menu-horizontal" data-menu-id="classes"/);
+    expect(html).toContain("Fighter &amp; Co");
+    expect(html).toContain('<ul class="ursa-menu-level" data-depth="1">');
+    expect(html).toContain('<li class="ursa-menu-item ursa-menu-has-children"><span>More</span>');
+  });
+
+  it("marks the current page and its ancestors", () => {
+    const html = renderInlineMenuHtml(data, { id: "classes", appearance: "vertical", currentUrl: "/character/classes/witch.html" });
+    expect(html).toContain("ursa-menu-vertical");
+    expect(html).toContain('<li class="ursa-menu-item ursa-menu-current"><a href="/character/classes/witch.html" aria-current="page">Witch</a>');
+    expect(html).toContain('<li class="ursa-menu-item ursa-menu-has-children ursa-menu-active"><span>More</span>');
+    expect(html).not.toContain('ursa-menu-current"><a href="/character/classes/arcanist.html"');
+  });
+
+  it("treats index.html, a trailing slash and no extension as the same page", () => {
+    const items = [{ label: "Classes", href: "/character/classes/index.html", children: [] }];
+    for (const url of ["/character/classes/", "/character/classes", "/character/classes/index.html"]) {
+      expect(renderInlineMenuHtml(items, { id: "x", currentUrl: url })).toContain("ursa-menu-current");
+    }
+  });
+});
+
+describe("findNamedMenu / findCustomMenu", () => {
+  let root;
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), "ursa-inline-menu-"));
+    await mkdir(join(root, "a/b"), { recursive: true });
+    await writeFile(join(root, "menu.md"), "---\nauto-generate-menu: true\n---\n");
+    await writeFile(join(root, "menu-classes.md"), "---\nid: classes\n---\n- [Root](./index.md)\n");
+    await writeFile(join(root, "a/menu-classes.md"), "---\nid: classes\nappearance: vertical\n---\n- [Deep](./x.md)\n");
+    await writeFile(join(root, "a/b/menu.md"), "---\nid: named-main\n---\n- [Hidden](./y.md)\n");
+  });
+  afterEach(() => rm(root, { recursive: true, force: true }));
+
+  it("nearest file with the id wins", () => {
+    expect(findNamedMenu(join(root, "a/b"), root, "classes").menuDir).toBe(join(root, "a"));
+    expect(findNamedMenu(root, root, "classes").menuDir).toBe(root);
+    expect(findNamedMenu(join(root, "a/b"), root, "named-main").path).toBe(join(root, "a/b/menu.md"));
+    expect(findNamedMenu(join(root, "a/b"), root, "nope")).toBeNull();
+  });
+
+  it("a menu.md with an id is not the folder's nav menu", () => {
+    const info = findCustomMenu(join(root, "a/b"), root);
+    expect(info.menuDir).toBe(root);
+  });
+});

package/src/helper/assetBundler.js

@@ -13,8 +13,8 @@
 
 import * as esbuild from "esbuild";
 import { join, dirname, basename, relative, resolve } from "path";
-import { readFile, writeFile, mkdir } from "fs/promises";
-import { existsSync } from "fs";
+import { writeFile, mkdir } from "fs/promises";
+import { readFile, existsSync } from "./build/tracedFs.js";
 import { outputFile } from "fs-extra";
 
 // Cache for meta bundles so we don't rebuild them per-document
@@ -68,10 +68,13 @@ export function parseTemplateAssets(templateHtml) {
  * @param {string} templateHtml - Original template HTML
  * @param {string} templateName - Template name (used for bundle filename)
  * @param {{ cssFiles: string[], jsFiles: string[], cdnCss: string[], cdnJs: string[] }} assets - Parsed assets
+ * @param {{cssUrl?: string, jsUrl?: string}} [urls] - Bundle URLs to emit (default: /public/<name>.bundle.*)
  * @returns {string} Rewritten template HTML
  */
-export function rewriteTemplateWithBundles(templateHtml, templateName, assets) {
+export function rewriteTemplateWithBundles(templateHtml, templateName, assets, urls = {}) {
   let html = templateHtml;
+  const cssUrl = urls.cssUrl ?? `/public/${templateName}.bundle.css`;
+  const jsUrl = urls.jsUrl ?? `/public/${templateName}.bundle.js`;
 
   // Replace individual CSS <link> tags with a single bundle reference
   if (assets.cssFiles.length > 0) {
@@ -86,7 +89,7 @@ export function rewriteTemplateWithBundles(templateHtml, templateName, assets) {
       html = html.replace(pattern, "\n");
     }
     // Insert single bundle link where the first CSS link was (in <head>)
-    const bundleCssTag = `    <link rel="stylesheet" href="/public/${templateName}.bundle.css" />`;
+    const bundleCssTag = `    <link rel="stylesheet" href="${cssUrl}" />`;
     // Insert after the last CDN CSS or at the position of the first removed tag
     // Best heuristic: insert right before ${styleLink} or before </head>
     if (html.includes("${styleLink}")) {
@@ -107,7 +110,7 @@ export function rewriteTemplateWithBundles(templateHtml, templateName, assets) {
       html = html.replace(pattern, "\n");
     }
     // Insert single bundle script before ${customScript} or before </body>
-    const bundleJsTag = `    <script src="/public/${templateName}.bundle.js"></script>`;
+    const bundleJsTag = `    <script src="${jsUrl}"></script>`;
     if (html.includes("${customScript}")) {
       html = html.replace("${customScript}", bundleJsTag + "\n    ${customScript}");
     } else {
@@ -192,6 +195,19 @@ function rebaseCssUrls(css, cssFileDir, sourceDir) {
  */
 export async function bundleCss(filePaths, outputPath, { minify = true, rebaseUrls = false, sourceDir = "" } = {}) {
   if (filePaths.length === 0) return;
+  const code = await bundleCssContent(filePaths, { minify, rebaseUrls, sourceDir });
+  await mkdir(dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, code);
+}
+
+/**
+ * Bundle CSS files and return the result instead of writing it.
+ * @param {string[]} filePaths - Absolute paths to CSS files to bundle
+ * @param {{ minify?: boolean, rebaseUrls?: boolean, sourceDir?: string }} options
+ * @returns {Promise<string>} Bundled (and, when possible, minified) CSS
+ */
+export async function bundleCssContent(filePaths, { minify = true, rebaseUrls = false, sourceDir = "" } = {}) {
+  if (filePaths.length === 0) return "";
 
   const allImports = [];
   const allRules = [];
@@ -224,17 +240,14 @@ export async function bundleCss(filePaths, outputPath, { minify = true, rebaseUr
         loader: "css",
         minify: true,
       });
-      await mkdir(dirname(outputPath), { recursive: true });
-      await writeFile(outputPath, result.code);
-      return;
+      return result.code;
     } catch (e) {
       console.warn(`⚠️  CSS minification failed, using unminified bundle: ${e.message}`);
     }
   }
 
-  // Fallback: write raw concatenated CSS
-  await mkdir(dirname(outputPath), { recursive: true });
-  await writeFile(outputPath, combined);
+  // Fallback: raw concatenated CSS
+  return combined;
 }
 
 /**
@@ -251,6 +264,22 @@ export async function bundleCss(filePaths, outputPath, { minify = true, rebaseUr
  */
 export async function bundleJs(filePaths, outputPath, { minify = true, minifySyntax = true } = {}) {
   if (filePaths.length === 0) return { success: false };
+  const { success, code } = await bundleJsContent(filePaths, { minify, minifySyntax });
+  if (!success) return { success: false };
+  await mkdir(dirname(outputPath), { recursive: true });
+  await writeFile(outputPath, code);
+  return { success: true };
+}
+
+/**
+ * Bundle JS files and return the result instead of writing it.
+ * @param {string[]} filePaths - Absolute paths to JS files to bundle
+ * @param {{ minify?: boolean, minifySyntax?: boolean }} options
+ * @returns {Promise<{ success: boolean, code: string }>} success is false when the
+ *   concatenation has a syntax error (callers keep individual tags)
+ */
+export async function bundleJsContent(filePaths, { minify = true, minifySyntax = true } = {}) {
+  if (filePaths.length === 0) return { success: false, code: "" };
 
   // Concatenate all JS files with separators
   const contents = [];
@@ -268,9 +297,7 @@ export async function bundleJs(filePaths, outputPath, { minify = true, minifySyn
         minify: true,
         minifySyntax,
       });
-      await mkdir(dirname(outputPath), { recursive: true });
-      await writeFile(outputPath, result.code);
-      return { success: true };
+      return { success: true, code: result.code };
     } catch (e) {
       // If minification fails (e.g., non-standard syntax), fall back to raw concatenation
       console.warn(`⚠️  JS minification failed, trying unminified bundle: ${e.message}`);
@@ -284,13 +311,60 @@ export async function bundleJs(filePaths, outputPath, { minify = true, minifySyn
     await esbuild.transform(combined, { loader: "js" });
   } catch (e) {
     console.warn(`⚠️  JS bundle has syntax errors, keeping individual script tags: ${e.message}`);
-    return { success: false };
+    return { success: false, code: "" };
   }
 
-  // Write raw concatenated code (syntax-valid but unminified)
-  await mkdir(dirname(outputPath), { recursive: true });
-  await writeFile(outputPath, combined);
-  return { success: true };
+  // Raw concatenated code (syntax-valid but unminified)
+  return { success: true, code: combined };
+}
+
+/**
+ * Where a template's `/public/<rel>` reference lives in the meta directory:
+ * the template's own folder first, then `meta/shared`, then (legacy) the meta
+ * root. Every probe is a recorded lookup, so moving an asset between the two
+ * folders is observed. Returns null when nothing exists.
+ */
+export function resolveMetaAssetPath(publicPath, templateDir, metaDir) {
+  const relativePath = publicPath.replace(/^\/public\//, "");
+  for (const candidate of [
+    resolve(templateDir, relativePath),
+    resolve(metaDir, "shared", relativePath),
+    resolve(metaDir, relativePath),
+  ]) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+/**
+ * Append `?v=<hash>` to every `url()` in a stylesheet whose target `lookup`
+ * knows. URLs with a query string, data: URIs, fragments and anything the
+ * lookup does not recognise are left alone. Cache-busting by content hash
+ * keeps an unchanged asset's URL stable, so pages are not rewritten for it.
+ * @param {string} css
+ * @param {(url: string) => string|null} lookup - site-absolute URL → content hash
+ */
+export function versionCssUrls(css, lookup) {
+  return css.replace(/url\(\s*(['"]?)(?!data:)([^'"\)]+?)\1\s*\)/gi, (match, quote, url) => {
+    if (url.includes("?") || url.startsWith("#")) return match;
+    const hash = lookup(url);
+    if (!hash) return match;
+    return `url(${quote}${url}?v=${hash}${quote})`;
+  });
+}
+
+/**
+ * Rewrite literal `fetch('/public/x.json')` calls in template JavaScript so
+ * the request carries the page's build id: `data-build` on <body>, set once
+ * per serve session and once per generate run. The bundle itself stays a pure
+ * function of the meta files — baking a JSON file's content hash into it
+ * would rewrite the bundle, and so every page, whenever the menu changed.
+ */
+export function rewriteJsonFetches(js) {
+  return js.replace(
+    /fetch\((['"])([^'"\)]+\.json)\1(?!\s*\+)/g,
+    (m, q, url) => `fetch(${q}${url}?v=${q}+(document.body&&document.body.dataset.build||'')`
+  );
 }
 
 /**

package/src/helper/automenu.js

@@ -1,9 +1,8 @@
-import dirTree from "directory-tree";
 import { isHiddenOrSystemPath } from "./hiddenPaths.js";
 import { extname, basename, join, dirname } from "path";
-import { existsSync, readFileSync } from "fs";
+import { existsSync, readFileSync, readdirSync, isIgnoredDirEntry } from "./build/tracedFs.js";
 import { getFolderConfig, isFolderHidden, getRootConfig } from "./folderConfig.js";
-import { isMetadataOnly } from "./metadataExtractor.js";
+import { isMenuFile } from "./customMenu.js";
 import {
   INDEX_EXTENSIONS,
   toDisplayName,
@@ -11,6 +10,7 @@ import {
   getMenuSortAsFromFile,
   getFolderLabel,
   getFolderSortKey,
+  readFrontmatterInfo,
 } from "./menuLabels.js";
 
 // Icon extensions to check for custom icons
@@ -201,20 +201,15 @@ function buildMenuData(tree, source, validPaths, parentPath = '', includeDebug =
     const relativePath = item.path.replace(source, '');
     const folderPath = parentPath ? `${parentPath}/${baseName}` : baseName;
     
-    // Skip hidden files (config.json, style.css, etc.)
-    if (!hasChildren && hiddenFiles.includes(fileName)) {
+    // Skip hidden files (config.json, style.css, etc.) and menu files
+    if (!hasChildren && (hiddenFiles.includes(fileName) || isMenuFile(fileName))) {
       continue;
     }
     
     // Skip metadata-only index files (they only provide folder metadata, not actual pages)
     if (!hasChildren && isIndexFile(baseName)) {
-      try {
-        const content = readFileSync(item.path, 'utf8');
-        if (isMetadataOnly(content)) {
-          continue; // Skip - this file doesn't produce a page
-        }
-      } catch (e) {
-        // If we can't read it, include it in the menu
+      if (readFrontmatterInfo(item.path)?.isMetadataOnly) {
+        continue; // Skip - this file doesn't produce a page
       }
     }
     
@@ -390,6 +385,37 @@ export function pruneHiddenNodes(node, source) {
   };
 }
 
+/**
+ * Build a directory tree in the shape `directory-tree` produced
+ * ({name, path, children?}), reading through the traced filesystem so the
+ * build graph records every listing the menu depends on. Entries are sorted
+ * by name; readdir order never reaches the menu.
+ * @param {string} dir - Absolute directory path
+ * @returns {object|null} Tree node, or null if `dir` cannot be listed
+ */
+function walkTree(dir) {
+  let entries;
+  try {
+    entries = readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+  const children = [];
+  for (const entry of [...entries].sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0))) {
+    // Never inputs (see tracedFs.isIgnoredDirEntry); skipping them here also
+    // keeps the walk out of a .git or node_modules sitting inside the docroot.
+    if (isIgnoredDirEntry(entry.name)) continue;
+    const path = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const child = walkTree(path);
+      if (child) children.push(child);
+    } else if (entry.isFile()) {
+      children.push({ name: entry.name, path });
+    }
+  }
+  return { name: basename(dir), path: dir, children };
+}
+
 export async function getAutomenu(source, validPaths) {
   /*
    * Walk first, prune second.
@@ -406,7 +432,7 @@ export async function getAutomenu(source, validPaths) {
    * discarded; docroots do not normally contain one, and correctness on every
    * ordinary path is worth more than speed on a pathological one.
    */
-  const fullTree = dirTree(source);
+  const fullTree = walkTree(source.replace(/\/$/, ''));
   if (!fullTree) {
     throw new Error(
       `Cannot read docroot for menu generation: ${source} (does it exist and is it a directory?)`

package/src/helper/build/__test__/autoIndex.test.js

@@ -1,9 +1,7 @@
 import { join } from "path";
-import { mkdtemp, mkdir, writeFile, rm, readFile } from "fs/promises";
-import { existsSync } from "fs";
+import { mkdtemp, mkdir, writeFile, rm } from "fs/promises";
 import { tmpdir } from "os";
-import { generateAutoIndices, generateAutoIndexHtmlFromSource } from "../autoIndex.js";
-import { clearConfigCache } from "../../folderConfig.js";
+import { generateAutoIndexHtmlFromSource } from "../autoIndex.js";
 
 let tempDir;
 let source;
@@ -19,82 +17,6 @@ afterEach(async () => {
   await rm(tempDir, { recursive: true, force: true });
 });
 
-const TEMPLATE =
-  "<html><head>${styleLink}</head><body>${menu}${body}${footer}${customScript}</body></html>";
-
-function makeProgress() {
-  const logs = [];
-  return {
-    logs,
-    log: (msg) => logs.push(msg),
-    status: () => {},
-    done: () => {},
-  };
-}
-
-function runAutoIndices(directories, generatedArticles, progress) {
-  return generateAutoIndices(
-    output,
-    directories,
-    source,
-    { "default-template": TEMPLATE },
-    "",
-    "",
-    generatedArticles,
-    new Set(),
-    new Set(),
-    "20260101000000",
-    progress,
-    null
-  );
-}
-
-describe("generateAutoIndices with empty source folders", () => {
-  it("skips output directories that were never created instead of logging an error", async () => {
-    // Source has an empty folder (guides) and a folder with a document (docs).
-    // Only docs produced output files, so output/guides does not exist.
-    await mkdir(join(source, "guides"));
-    await mkdir(join(source, "docs"));
-    await writeFile(join(source, "docs", "hello.md"), "# Hello\n\nWorld\n");
-    await mkdir(join(output, "docs"));
-    await writeFile(join(output, "docs", "hello.html"), "<html><body>Hello</body></html>");
-
-    const progress = makeProgress();
-    await runAutoIndices(
-      [join(source, "guides"), join(source, "docs")],
-      [join(source, "docs", "hello.md")],
-      progress
-    );
-
-    const errors = progress.logs.filter((m) => /Error generating auto-index/i.test(m));
-    expect(errors).toEqual([]);
-    // The missing output directory is skipped, not created
-    expect(existsSync(join(output, "guides"))).toBe(false);
-    expect(existsSync(join(output, "guides", "index.html"))).toBe(false);
-  });
-
-  it("still generates auto-indices for folders that produced output", async () => {
-    await mkdir(join(source, "guides"));
-    await mkdir(join(source, "docs"));
-    await writeFile(join(source, "docs", "hello.md"), "# Hello\n\nWorld\n");
-    await mkdir(join(output, "docs"));
-    await writeFile(join(output, "docs", "hello.html"), "<html><body>Hello</body></html>");
-
-    const progress = makeProgress();
-    await runAutoIndices(
-      [join(source, "guides"), join(source, "docs")],
-      [join(source, "docs", "hello.md")],
-      progress
-    );
-
-    // Root and docs both exist in output, so both get an index.html
-    const docsIndex = await readFile(join(output, "docs", "index.html"), "utf8");
-    expect(docsIndex).toContain('<a href="hello.html">');
-    const rootIndex = await readFile(join(output, "index.html"), "utf8");
-    expect(rootIndex).toContain('<a href="docs/index.html">');
-  });
-});
-
 describe("auto-index naming matches the automenu", () => {
   it("uses menu-label from a folder's index frontmatter, and config.json when there is no index", async () => {
     // bnw has a real index.md carrying the label; hfr has no index at all, so
@@ -140,35 +62,9 @@ describe("auto-index naming matches the automenu", () => {
 
     expect(html).toContain('<a href="SoL/index.html">SoL</a>');
   });
-
-  it("labels generated index pages with the folder's menu-label", async () => {
-    // No index.md content, so this folder gets an auto-generated index.html;
-    // its <h1> should use the label rather than the raw folder name.
-    await mkdir(join(source, "bnw"));
-    await writeFile(
-      join(source, "bnw", "config.json"),
-      JSON.stringify({ label: "BNW - Brave New World" })
-    );
-    await writeFile(join(source, "bnw", "quests.md"), "# Quests\n");
-    await mkdir(join(output, "bnw"));
-    await writeFile(join(output, "bnw", "quests.html"), "<html><body>Quests</body></html>");
-
-    await runAutoIndices([join(source, "bnw")], [join(source, "bnw", "quests.md")], makeProgress());
-
-    const bnwIndex = await readFile(join(output, "bnw", "index.html"), "utf8");
-    expect(bnwIndex).toContain("<h1>BNW - Brave New World</h1>");
-    const rootIndex = await readFile(join(output, "index.html"), "utf8");
-    expect(rootIndex).toContain('<a href="bnw/index.html">BNW - Brave New World</a>');
-  });
 });
 
 describe("folders ignored via config.json { hidden: true }", () => {
-  beforeEach(() => {
-    // getFolderConfig memoizes per absolute path; temp dirs are unique per
-    // test, but clearing keeps the cache from growing across the suite.
-    clearConfigCache();
-  });
-
   it("omits a hidden folder from an auto-index built from source", async () => {
     await mkdir(join(source, "_art"), { recursive: true });
     await writeFile(join(source, "_art", "config.json"), JSON.stringify({ hidden: true }));
@@ -183,32 +79,6 @@ describe("folders ignored via config.json { hidden: true }", () => {
     expect(html).not.toContain("prompts");
   });
 
-  it("omits a hidden folder even when stale output for it still exists", async () => {
-    // A folder generated before it was hidden leaves files behind in output.
-    // The listing is built from output, so without a source-side check the
-    // hidden folder would reappear in the index.
-    await mkdir(join(source, "_art"), { recursive: true });
-    await writeFile(join(source, "_art", "config.json"), JSON.stringify({ hidden: true }));
-    await mkdir(join(source, "people"), { recursive: true });
-    await writeFile(join(source, "people", "alice.md"), "# Alice\n");
-
-    await mkdir(join(output, "_art"), { recursive: true });
-    await writeFile(join(output, "_art", "prompts.html"), "<html><body>stale</body></html>");
-    await mkdir(join(output, "people"), { recursive: true });
-    await writeFile(join(output, "people", "alice.html"), "<html><body>Alice</body></html>");
-
-    const progress = makeProgress();
-    await runAutoIndices(
-      [source, join(source, "people")],
-      [join(source, "people", "alice.md")],
-      progress
-    );
-
-    const index = await readFile(join(output, "index.html"), "utf8");
-    expect(index).toContain("people");
-    expect(index).not.toContain("_art");
-  });
-
   it("does not count documents inside a hidden subfolder when deciding a folder has content", async () => {
     // `notes` holds nothing but a hidden subfolder, so it produces no pages
     // and must not be linked as though it did.