blume 1.1.3 → 1.2.0

package/src/audit/checks/duplicates.ts

@@ -1,17 +1,24 @@
+import { normalizeBasePath, stripBasePath } from "../../core/base-path.ts";
 import type { Diagnostic } from "../../core/types.ts";
 import { finding } from "../catalog.ts";
 import type { CheckId } from "../catalog.ts";
 import { pageSite } from "../locate.ts";
 import type { AuditContext, CheckModule, PageSnapshot } from "../types.ts";
+import { decodePath } from "../url.ts";
 
-const isNonCanonical = (page: PageSnapshot): boolean => {
+const isNonCanonical = (page: PageSnapshot, deployBase: string): boolean => {
   if (!page.canonical) {
     return false;
   }
   try {
+    // Canonicals are emitted as `site + base + route`; page URLs carry no
+    // deployment base — without stripping it, every page of a subpath
+    // deployment would look non-canonical and escape these checks entirely.
     return (
-      new URL(page.canonical).pathname.replace(/\/$/u, "") !==
-      page.url.replace(/\/$/u, "")
+      stripBasePath(
+        deployBase,
+        decodePath(new URL(page.canonical).pathname)
+      ).replace(/\/$/u, "") !== page.url.replace(/\/$/u, "")
     );
   } catch {
     return false;
@@ -19,8 +26,9 @@ const isNonCanonical = (page: PageSnapshot): boolean => {
 };
 
 /** Pages that can meaningfully be compared against each other for duplication. */
-const comparable = (context: AuditContext): PageSnapshot[] =>
-  context.pages.filter(
+const comparable = (context: AuditContext): PageSnapshot[] => {
+  const deployBase = normalizeBasePath(context.project.config.deployment.base);
+  return context.pages.filter(
     (page) =>
       page.indexable &&
       // A fallback page renders the default locale's content at a localized URL.
@@ -29,8 +37,9 @@ const comparable = (context: AuditContext): PageSnapshot[] =>
       !page.route?.fallback &&
       // A page that points its canonical elsewhere has already declared itself a
       // duplicate; that's the mechanism working, not a finding.
-      !isNonCanonical(page)
+      !isNonCanonical(page, deployBase)
   );
+};
 
 /**
  * Group pages by a value and report every group with more than one member.

package/src/audit/checks/indexability.ts

@@ -1,10 +1,11 @@
+import { normalizeBasePath, stripBasePath } from "../../core/base-path.ts";
 import { SITE_INFERRING_ADAPTERS } from "../../core/deployment-env.ts";
 import type { Diagnostic } from "../../core/types.ts";
 import { finding } from "../catalog.ts";
 import { pageSite } from "../locate.ts";
 import { ERROR_ROUTES } from "../types.ts";
 import type { AuditContext, CheckModule, PageSnapshot } from "../types.ts";
-import { normalizePath, siteOrigin } from "../url.ts";
+import { decodePath, normalizePath, siteOrigin } from "../url.ts";
 
 /** The canonical URL parsed, or null when it isn't a usable absolute URL. */
 const parseCanonical = (page: PageSnapshot): URL | null => {
@@ -76,7 +77,15 @@ const canonicalChecks = (
     return found;
   }
 
-  const target = normalizePath(canonical.pathname);
+  // Canonicals are emitted as `site + base + route`; page URLs and `byUrl`
+  // keys carry no deployment base, so strip it (and percent-encoding) before
+  // comparing.
+  const target = normalizePath(
+    stripBasePath(
+      normalizeBasePath(context.project.config.deployment.base),
+      decodePath(canonical.pathname)
+    )
+  );
   if (target === normalizePath(page.url)) {
     return found;
   }

package/src/audit/checks/network.ts

@@ -12,9 +12,17 @@ const SERVER_ERROR = 500;
 /** Past this, a page is slow enough that it costs you crawl budget and readers. */
 const SLOW_MS = 1500;
 
-/** The live URL a built page is served at, under the `--url` origin. */
-const liveUrl = (origin: string, page: PageSnapshot): string =>
-  new URL(page.url, origin).toString();
+/**
+ * The live URL a built page is served at, under the `--url` origin. Page URLs
+ * come from the built file tree and carry no `deployment.base`, but the live
+ * site serves everything under it — probing without the base would 4xx every
+ * page of a healthy subpath deployment.
+ */
+const liveUrl = (
+  origin: string,
+  page: PageSnapshot,
+  deployBase: string
+): string => new URL(`${deployBase}${page.url}`, origin).toString();
 
 /**
  * Whether the response failed outright, and how. Null when the page is served.
@@ -144,17 +152,23 @@ export const networkChecks: CheckModule = {
     }
 
     const found: Diagnostic[] = [];
-    const targets = context.pages.map((page) => liveUrl(origin, page));
+    const deployBase = normalizeBasePath(
+      context.project.config.deployment.base
+    );
+    const targets = context.pages.map((page) =>
+      liveUrl(origin, page, deployBase)
+    );
     // robots.txt and sitemap.xml are fetched alongside the pages: they're the
     // two files a crawler asks for first, and a deploy that hides them silently
-    // undoes everything else the audit checks.
-    const robotsUrl = new URL("/robots.txt", origin).toString();
-    const sitemapUrl = new URL("/sitemap.xml", origin).toString();
+    // undoes everything else the audit checks. They sit at the root of the
+    // build output, which the host serves under the deployment base.
+    const robotsUrl = new URL(`${deployBase}/robots.txt`, origin).toString();
+    const sitemapUrl = new URL(`${deployBase}/sitemap.xml`, origin).toString();
 
     const results = await probeAll([...targets, robotsUrl, sitemapUrl]);
 
     for (const page of context.pages) {
-      const result = results.get(liveUrl(origin, page));
+      const result = results.get(liveUrl(origin, page, deployBase));
       if (!result) {
         continue;
       }

package/src/audit/checks/sitemap.ts

@@ -3,7 +3,7 @@ import type { Diagnostic } from "../../core/types.ts";
 import { finding } from "../catalog.ts";
 import { pageSite } from "../locate.ts";
 import type { AuditContext, CheckModule } from "../types.ts";
-import { normalizePath, siteOrigin } from "../url.ts";
+import { decodePath, normalizePath, siteOrigin } from "../url.ts";
 
 const MAX_SITEMAP_BYTES = 50 * 1024 * 1024;
 const MAX_SITEMAP_URLS = 50_000;
@@ -18,12 +18,24 @@ const LASTMOD_SLACK_MS = 24 * 60 * 60 * 1000;
 /** Error routes are never crawlable destinations, so they belong out of the sitemap. */
 const ERROR_ROUTES = new Set(["/404", "/500"]);
 
-/** Site paths listed in the sitemap, normalized for comparison against page URLs. */
-const sitemapPaths = (context: AuditContext): Map<string, string> => {
+/**
+ * Site paths listed in the sitemap, normalized for comparison against page
+ * URLs. `<loc>`s carry the deployment base and are `encodeURI`'d; page URLs
+ * (from the file tree) carry neither, so both are undone here.
+ */
+const sitemapPaths = (
+  context: AuditContext,
+  deployBase: string
+): Map<string, string> => {
   const paths = new Map<string, string>();
   for (const loc of context.sitemap?.urls ?? []) {
     try {
-      paths.set(normalizePath(new URL(loc).pathname), loc);
+      paths.set(
+        normalizePath(
+          stripBasePath(deployBase, decodePath(new URL(loc).pathname))
+        ),
+        loc
+      );
     } catch {
       // A malformed <loc> is reported by SITEMAP_INVALID, not here.
     }
@@ -31,10 +43,20 @@ const sitemapPaths = (context: AuditContext): Map<string, string> => {
   return paths;
 };
 
-/** The path of a canonical URL, or null when it isn't parseable (CANONICAL_BAD_TARGET reports that). */
-const canonicalPath = (canonical: string): string | null => {
+/**
+ * The path of a canonical URL, or null when it isn't parseable
+ * (CANONICAL_BAD_TARGET reports that). Canonicals are emitted as
+ * `site + base + route`, so the deployment base is stripped to keep the result
+ * comparable against base-less page URLs.
+ */
+const canonicalPath = (
+  canonical: string,
+  deployBase: string
+): string | null => {
   try {
-    return normalizePath(new URL(canonical).pathname);
+    return normalizePath(
+      stripBasePath(deployBase, decodePath(new URL(canonical).pathname))
+    );
   } catch {
     return null;
   }
@@ -45,7 +67,8 @@ const checkListedUrl = (
   context: AuditContext,
   loc: string,
   origin: string | null,
-  file: string
+  file: string,
+  deployBase: string
 ): Diagnostic[] => {
   let parsed: URL;
   try {
@@ -70,12 +93,10 @@ const checkListedUrl = (
     ];
   }
 
-  // `<loc>`s carry the deployment base; page URLs (from the file tree) don't.
+  // `<loc>`s carry the deployment base and are `encodeURI`'d; page URLs (from
+  // the file tree) are neither.
   const path = normalizePath(
-    stripBasePath(
-      normalizeBasePath(context.project.config.deployment.base),
-      parsed.pathname
-    )
+    stripBasePath(deployBase, decodePath(parsed.pathname))
   );
   const page = context.byUrl.get(path);
   if (!page) {
@@ -104,7 +125,7 @@ const checkListedUrl = (
     );
   }
 
-  const canonical = page.canonical && canonicalPath(page.canonical);
+  const canonical = page.canonical && canonicalPath(page.canonical, deployBase);
   if (canonical && canonical !== path) {
     found.push(
       finding(
@@ -198,10 +219,15 @@ export const sitemapChecks: CheckModule = {
     }
 
     const origin = siteOrigin(site);
-    const listed = sitemapPaths(context);
+    const deployBase = normalizeBasePath(
+      context.project.config.deployment.base
+    );
+    const listed = sitemapPaths(context, deployBase);
 
     for (const loc of sitemap.urls) {
-      found.push(...checkListedUrl(context, loc, origin, sitemap.file));
+      found.push(
+        ...checkListedUrl(context, loc, origin, sitemap.file, deployBase)
+      );
     }
 
     // The other direction: a page that was built, is indexable, and should be

package/src/audit/redirects.ts

@@ -19,6 +19,17 @@ interface ConfiguredRedirect {
  * An external destination (`https://…`) is always `ok`: it's outside the site,
  * so there's no local page to check it against.
  */
+/**
+ * A destination's page path: the part before any query string or fragment. A
+ * redirect to `/guide#setup` or `/search?q=x` lands on the `/guide` / `/search`
+ * page — the suffix belongs to the browser, not the file tree, so keeping it
+ * would report a working redirect as broken.
+ */
+const pathOnly = (value: string): string => {
+  const cut = value.search(/[?#]/u);
+  return cut === -1 ? value : value.slice(0, cut);
+};
+
 export const resolveRedirects = (
   redirects: readonly ConfiguredRedirect[],
   pageUrls: ReadonlySet<string>
@@ -40,7 +51,7 @@ export const resolveRedirects = (
         chain.push(current);
         break;
       }
-      const next = normalizePath(current);
+      const next = normalizePath(pathOnly(current));
       if (seen.has(next)) {
         chain.push(next);
         return {

package/src/audit/run.ts

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 
-import { normalizeBasePath } from "../core/base-path.ts";
+import { normalizeBasePath, withBasePath } from "../core/base-path.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
 import type { Diagnostic } from "../core/types.ts";
 import { deployStaticDir } from "../deploy/adapter-output.ts";
@@ -123,9 +123,10 @@ const matches = (id: CheckId, terms: string[]): boolean => {
 export const runAudit = async (options: AuditOptions): Promise<AuditResult> => {
   const { project } = options;
   const staticDir = deployStaticDir(project.config, project.context);
+  const basePath = normalizeBasePath(project.config.basePath);
 
   const crawl = await crawlStaticDir({
-    basePath: normalizeBasePath(project.config.basePath),
+    basePath,
     manifest: project.manifest,
     staticDir,
   });
@@ -148,7 +149,16 @@ export const runAudit = async (options: AuditOptions): Promise<AuditResult> => {
     pages: crawl.pages,
     project,
     redirects: resolveRedirects(
-      project.config.redirects,
+      // Redirects are authored as if mounted at root; the built page URLs they
+      // are checked against carry `basePath` (it's a real directory in the
+      // build), so both sides gain it here — mirroring what
+      // `applyBaseToAstroRedirects` does at build time. `withBasePath` is
+      // idempotent and leaves external `to` URLs untouched.
+      project.config.redirects.map((redirect) => ({
+        ...redirect,
+        from: withBasePath(basePath, redirect.from),
+        to: withBasePath(basePath, redirect.to),
+      })),
       // Pages and static files both: a redirect may legitimately land on a
       // served asset (`/old-whitepaper` -> `/files/whitepaper.pdf`).
       new Set(

package/src/audit/url.ts

@@ -22,6 +22,21 @@ export const normalizePath = (path: string): string => {
   return trimmed === "" ? "/" : trimmed;
 };
 
+/**
+ * Percent-decode a pathname for comparison against the built file tree. Page
+ * URLs and file-index keys come from raw on-disk names, while `URL#pathname`
+ * (and the `encodeURI`'d sitemap `<loc>`s) are percent-encoded — a Japanese
+ * route would never match its own page without this. Malformed sequences are
+ * kept as-is: they can't have come from our own encoder.
+ */
+export const decodePath = (path: string): string => {
+  try {
+    return decodeURI(path);
+  } catch {
+    return path;
+  }
+};
+
 /** The origin of `deployment.site`, or null when no site is configured. */
 export const siteOrigin = (site?: string): string | null => {
   if (!site) {
@@ -73,7 +88,9 @@ export const resolveHref = (
       return {
         hash: parsed.hash.slice(1),
         kind: "self-origin",
-        path: normalizePath(stripBasePath(deployBase, parsed.pathname)),
+        path: normalizePath(
+          stripBasePath(deployBase, decodePath(parsed.pathname))
+        ),
       };
     }
     return { kind: "external", url: parsed.toString() };
@@ -98,6 +115,8 @@ export const resolveHref = (
   return {
     hash: resolved.hash.slice(1),
     kind: "internal",
-    path: normalizePath(stripBasePath(deployBase, resolved.pathname)),
+    path: normalizePath(
+      stripBasePath(deployBase, decodePath(resolved.pathname))
+    ),
   };
 };

package/src/cli/commands/audit.ts

@@ -40,6 +40,26 @@ export const shouldFail = (
   return result.diagnostics.some((d) => failing.has(d.severity));
 };
 
+/**
+ * Launch the agent CLI, translating a missing executable into the Windows
+ * not-found sentinel. Only `ENOENT` means "not installed" — any other spawn
+ * failure (`EACCES`, `EMFILE`, …) must surface as itself, not be masked by an
+ * irrelevant install hint.
+ */
+const launchAgentCode = async (
+  bin: string,
+  prompt: string
+): Promise<number> => {
+  try {
+    return await launchAgent(bin, prompt);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException)?.code !== "ENOENT") {
+      throw error;
+    }
+    return WINDOWS_COMMAND_NOT_FOUND;
+  }
+};
+
 export const auditCommand = defineCommand({
   args: {
     claude: {
@@ -163,12 +183,7 @@ export const auditCommand = defineCommand({
       process.stderr.write(
         `  Handing ${count} finding${count === 1 ? "" : "s"} to ${cli.name}…\n\n`
       );
-      let code: number;
-      try {
-        code = await launchAgent(cli.bin, fixPrompt(report));
-      } catch {
-        code = WINDOWS_COMMAND_NOT_FOUND;
-      }
+      const code = await launchAgentCode(cli.bin, fixPrompt(report));
       // A POSIX spawn rejects on a missing executable; the Windows shell
       // launch reports it through cmd.exe's 9009 instead. Same diagnosis.
       if (code === WINDOWS_COMMAND_NOT_FOUND) {

package/src/cli/commands/dev.ts

@@ -2,6 +2,7 @@ import { watch } from "node:fs";
 
 import { dev } from "astro";
 import { defineCommand } from "citty";
+import { basename, dirname } from "pathe";
 
 import { generateRuntime } from "../../astro/generate.ts";
 import { showBlumeErrorOverlay } from "../../astro/integration.ts";
@@ -202,8 +203,10 @@ export const devCommand = defineCommand({
     // Content is watched per source (filesystem uses fs.watch; remote sources
     // are frozen for the session). The remaining project inputs — user pages,
     // config, theme, and component overrides — are watched directly.
+    const dirTargets = [project.context.pagesRoot].filter(
+      (target) => target !== null
+    );
     const fileTargets = [
-      project.context.pagesRoot,
       project.context.configFile,
       project.context.themeFile,
       project.context.componentsFile,
@@ -211,10 +214,24 @@ export const devCommand = defineCommand({
 
     const disposers = [
       ...project.sources.map((source) => source.watch?.(regenerate)),
-      ...fileTargets.map((target) => {
+      ...dirTargets.map((target) => {
         const watcher = watch(target, { recursive: true }, regenerate);
         return () => watcher.close();
       }),
+      // Single files are watched via their parent directory: fs.watch on the
+      // file itself tracks the inode, so a rename-replace save (vim and most
+      // "atomic save" editors) orphans the watcher after the first write and
+      // every later edit is silently ignored.
+      ...fileTargets.map((target) => {
+        const name = basename(target);
+        const watcher = watch(dirname(target), (_event, filename) => {
+          // A null filename (some platforms) can't be filtered — regenerate.
+          if (!filename || filename === name) {
+            regenerate();
+          }
+        });
+        return () => watcher.close();
+      }),
     ].filter((dispose) => dispose !== undefined);
 
     const shutdown = async () => {