@at-flux/astro-feature-flags 1.0.2 → 1.0.4

package/docs/how-to/hide-from-sitemaps.md

@@ -1,20 +1,62 @@
 # Hide Flagged Routes From Sitemaps
 
-Use `getResolvedFeatures()` plus `featureRouteIncluded()` in your sitemap filter so routes disabled by feature flags are excluded.
+A route disabled by a flag is deleted from the build. If the sitemap still lists it,
+every crawler that reads the sitemap is handed a 404.
+
+## Automatic (the default)
+
+Put `astroFeatureFlags()` **after** `sitemap()` in `integrations` and there is nothing
+else to do. Astro runs `astro:build:done` in array order, so by the time the flags
+integration prunes the routes the sitemap is already on disk, and it takes the dead
+`<url>` entries out of it. A sitemap left with no URLs is deleted, along with its entry
+in `sitemap-index.xml`.
 
 ```js
 // astro.config.mjs
 
 import sitemap from "@astrojs/sitemap";
+import astroFeatureFlags from "@at-flux/astro-feature-flags";
+
+export default defineConfig({
+  integrations: [
+    sitemap(),
+    // after sitemap(), so the sitemap exists when the prune runs
+    astroFeatureFlags({
+      flags: {
+        wip: { colour: "rgb(220 38 38)", routes: ["/blog/*"] },
+      },
+      environments: {
+        prod: {
+          when: process.env.NODE_ENV === "production",
+          flags: { wip: false },
+        },
+      },
+    }),
+  ],
+});
+```
+
+Get the order wrong and the build warns: the sitemap is written after the prune, so
+nothing is found to prune. Pass `pruneSitemap: false` to opt out, and
+`staticMinify: false` to turn off route pruning and the HTML cull with it.
+
+Matching is by route prefix, the same decision that deletes the files, so `/blog/*`
+takes out `/blog/post/` and leaves `/blogroll/` alone.
+
+## By hand
+
+Filter in `@astrojs/sitemap` instead when the URL list needs to differ from what is
+built — a route that ships but should not be advertised, say. `getResolvedFeatures()`
+resolves the flags once and `featureRouteIncluded()` answers per URL:
+
+```js
 import astroFeatureFlags, {
   featureRouteIncluded,
   getResolvedFeatures,
 } from "@at-flux/astro-feature-flags";
 
 const featureFlagOptions = {
-  flags: {
-    wip: { colour: "rgb(220 38 38)", routes: ["/blog/*"] },
-  },
+  flags: { wip: { routes: ["/blog/*"] } },
   environments: {
     prod: {
       when: process.env.NODE_ENV === "production",
@@ -27,23 +69,27 @@ const featureRuntime = getResolvedFeatures(featureFlagOptions);
 
 export default defineConfig({
   integrations: [
-    astroFeatureFlags(featureFlagOptions),
     sitemap({
       filter: (page) => {
         try {
-          const pathname = new URL(page).pathname;
-          return featureRouteIncluded(pathname, featureRuntime);
+          return featureRouteIncluded(new URL(page).pathname, featureRuntime);
         } catch {
           return true;
         }
       },
     }),
+    astroFeatureFlags(featureFlagOptions),
   ],
 });
 ```
 
-`featureRuntime` only needs to be declared before the `sitemap` filter uses it.
+`featureRuntime` only needs to be declared before the `sitemap` filter uses it. Both
+mechanisms can run together: the filter never emits the URL, and the prune then finds
+nothing to remove.
 
-You can still place `astroFeatureFlags(featureFlagOptions)` anywhere in `integrations`; the key is that `featureRouteIncluded(pathname, featureRuntime)` has access to the resolved runtime object.
+If the sitemap runs under a `mode` whose active layer is not the one you want for URL
+filtering, pass **`forceEnvironment`** (it wins over **`AFF_ENVIRONMENT`** when both are
+set), for example
+`getResolvedFeatures({ ...featureFlagOptions, mode: "development", forceEnvironment: "prod" })`.
 
-If the sitemap plugin runs with a `mode` where the active layer is not the one you want for URL filtering, pass **`forceEnvironment`** (it wins over **`AFF_ENVIRONMENT`** when both are set), for example `getResolvedFeatures({ ...featureFlagOptions, mode: "development", forceEnvironment: "prod" })`. Behaviour is covered by **`test/sitemap-route-filter.test.ts`** in this package.
+Covered by **`test/sitemap-prune.test.ts`** and **`test/sitemap-route-filter.test.ts`**.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@at-flux/astro-feature-flags",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "type": "module",
   "description": "Typed Astro feature flags from JSON config. Includes environment specific rendering and pruning from elements to entire routes",
   "author": "atflux <dev@atflux.uk>",
@@ -35,14 +35,14 @@
     }
   },
   "peerDependencies": {
-    "astro": "4.7.0 || 5.0.0"
+    "astro": ">=5.0.0"
   },
   "devDependencies": {
     "@types/node": "24.7.0",
-    "astro": "5.18.1",
-    "tsdown": "0.21.8",
-    "typescript": "5.9.3",
-    "vitest": "3.2.4"
+    "astro": "7.1.3",
+    "tsdown": "0.22.13",
+    "typescript": "7.0.2",
+    "vitest": "4.1.10"
   },
   "repository": {
     "type": "git",
@@ -57,7 +57,7 @@
     "access": "public"
   },
   "dependencies": {
-    "node-html-parser": "7.1.0"
+    "node-html-parser": "9.0.0"
   },
   "scripts": {
     "build": "tsdown",

package/src/dev-head-inject.ts

@@ -2,6 +2,7 @@ import type { ResolvedFeatureRuntime } from "./runtime";
 import { toToken } from "./runtime";
 import { inlineInvoke } from "./inline-script";
 import { affHeadInlineRuntime } from "./dev-inline-runtimes";
+import { DEV_LAYER } from "./dev-outline-css";
 
 /**
  * Single `injectScript('head-inline', …)` payload for `astro dev`: dev-only outline CSS,
@@ -21,6 +22,7 @@ export function buildAffDevHeadInline(args: {
     featureFlagStyles,
     routeFlags: runtime.routeFlags,
     flagNameToToken,
+    devLayer: DEV_LAYER,
   });
   return `${setup}\n${affDevBootstrap}`;
 }

package/src/dev-inline-runtimes.ts

@@ -2,6 +2,7 @@ type HeadInlinePayload = {
   featureFlagStyles: string;
   routeFlags: Record<string, string[]>;
   flagNameToToken: Record<string, string>;
+  devLayer: string;
 };
 
 type BootstrapPayload = {
@@ -23,7 +24,33 @@ export function affHeadInlineRuntime(payload: HeadInlinePayload): void {
     return p.endsWith("/") ? p : `${p}/`;
   };
   try {
-    const { featureFlagStyles, routeFlags: RF, flagNameToToken: M } = payload;
+    const {
+      featureFlagStyles,
+      routeFlags: RF,
+      flagNameToToken: M,
+      devLayer: L,
+    } = payload;
+
+    // Layer priority is fixed by the order layers are first declared, in
+    // document order. The dev sheet is appended, so it lands after the app's
+    // own stylesheets and its layer would sort last — above Tailwind's
+    // `utilities` — which is the opposite of what the layer is for. A style
+    // element holding nothing but the order statement, inserted as the first
+    // child of <head>, declares the layer before any app sheet and so pins it
+    // below everything the app writes.
+    const ensureLayerOrder = () => {
+      if (document.querySelector("style[data-astro-feature-flags-layer]"))
+        return;
+      const head = document.head || document.documentElement;
+      const s = document.createElement("style");
+      s.setAttribute("data-astro-feature-flags-layer", "");
+      s.setAttribute(
+        "data-astro-transition-persist",
+        "astro-feature-flags-layer",
+      );
+      s.textContent = `@layer ${L};`;
+      head.insertBefore(s, head.firstChild);
+    };
 
     // Inject the dev-chrome stylesheet. Astro's ClientRouter swaps <head> on a
     // view-transition navigation, and a runtime-injected <style> is dropped on
@@ -33,6 +60,7 @@ export function affHeadInlineRuntime(payload: HeadInlinePayload): void {
     // keep the injector idempotent + re-run it on every nav so the styles stay
     // constant across pages even where a swap removes them.
     const ensureFeatureFlagStyles = () => {
+      ensureLayerOrder();
       if (document.querySelector("style[data-astro-feature-flags]")) return;
       const s = document.createElement("style");
       s.setAttribute("data-astro-feature-flags", "");
@@ -43,7 +71,10 @@ export function affHeadInlineRuntime(payload: HeadInlinePayload): void {
     ensureFeatureFlagStyles();
 
     const affPath = () => {
-      let p = typeof location !== "undefined" && location.pathname ? location.pathname : "/";
+      let p =
+        typeof location !== "undefined" && location.pathname
+          ? location.pathname
+          : "/";
       if (!p.endsWith("/")) p += "/";
       return p;
     };
@@ -82,7 +113,8 @@ export function affHeadInlineRuntime(payload: HeadInlinePayload): void {
       for (let i = 0; i < names.length; i++) {
         const tk = M[names[i]];
         if (!tk) continue;
-        if (root.getAttribute(`data-ff-enabled-${tk}`) === "off") disabled.push(tk);
+        if (root.getAttribute(`data-ff-enabled-${tk}`) === "off")
+          disabled.push(tk);
       }
       const id = "aff-route-disabled-overlay";
       let el = document.getElementById(id);
@@ -113,7 +145,10 @@ export function affHeadInlineRuntime(payload: HeadInlinePayload): void {
 
     const affApply = () => {
       ensureFeatureFlagStyles();
-      document.documentElement.setAttribute("data-ff-route", affTokens(affPath()).join(" "));
+      document.documentElement.setAttribute(
+        "data-ff-route",
+        affTokens(affPath()).join(" "),
+      );
       affSyncDisabledOverlay();
     };
 
@@ -122,7 +157,10 @@ export function affHeadInlineRuntime(payload: HeadInlinePayload): void {
       const obs = new MutationObserver((muts) => {
         for (let i = 0; i < muts.length; i++) {
           const a = muts[i] && muts[i].attributeName;
-          if (a === "data-ff-route" || (a && a.indexOf("data-ff-enabled-") === 0)) {
+          if (
+            a === "data-ff-route" ||
+            (a && a.indexOf("data-ff-enabled-") === 0)
+          ) {
             affSyncDisabledOverlay();
             break;
           }
@@ -155,7 +193,8 @@ export function affDevBootstrapRuntime(payload: BootstrapPayload): void {
   const K = `${N}.dev.v1`;
 
   const root = document.documentElement;
-  const isEnabled = (tk: string) => root.getAttribute(`data-ff-enabled-${tk}`) !== "off";
+  const isEnabled = (tk: string) =>
+    root.getAttribute(`data-ff-enabled-${tk}`) !== "off";
   const currentTokenColor = (
     tk: string,
     cols: Record<string, string>,
@@ -194,7 +233,8 @@ export function affDevBootstrapRuntime(payload: BootstrapPayload): void {
   const applyCombo = (el: HTMLElement, cols: Record<string, string>) => {
     const allTokens = comboTokens(el);
     const hasCombo = allTokens.length >= 2;
-    const hasDisabledInCombo = hasCombo && allTokens.some((tk) => !isEnabled(tk));
+    const hasDisabledInCombo =
+      hasCombo && allTokens.some((tk) => !isEnabled(tk));
     const visual = allTokens.filter((tk) => isEnabled(tk));
     if (hasDisabledInCombo) {
       // Fail-closed for combos: if any member token is disabled, hide the whole element.
@@ -225,15 +265,24 @@ export function affDevBootstrapRuntime(payload: BootstrapPayload): void {
     el.setAttribute("data-ff-label", visual.join(" | "));
     const strong = visual.map((tk) => currentTokenColor(tk, cols));
     const soft = strong.map((c) => `color-mix(in oklab, white 86%, ${c} 14%)`);
-    el.style.setProperty("--ff-combo-gradient", `linear-gradient(90deg, ${strong.join(", ")})`);
-    el.style.setProperty("--ff-combo-gradient-soft", `linear-gradient(90deg, ${soft.join(", ")})`);
+    el.style.setProperty(
+      "--ff-combo-gradient",
+      `linear-gradient(90deg, ${strong.join(", ")})`,
+    );
+    el.style.setProperty(
+      "--ff-combo-gradient-soft",
+      `linear-gradient(90deg, ${soft.join(", ")})`,
+    );
     el.style.setProperty("--ff-combo-outline", strong[0] || "#64748b");
     el.style.setProperty("--ff-combo-text", strong[0] || "#111827");
     el.style.setProperty(
       "--ff-combo-badge-border",
       `color-mix(in oklab, ${strong[0] || "#64748b"} 35%, transparent)`,
     );
-    el.style.setProperty("--ff-combo-badge-gradient", `linear-gradient(90deg, ${soft.join(", ")})`);
+    el.style.setProperty(
+      "--ff-combo-badge-gradient",
+      `linear-gradient(90deg, ${soft.join(", ")})`,
+    );
   };
 
   const routeTokensForPath = (path: string): string[] => {
@@ -359,10 +408,21 @@ export function affDevBootstrapRuntime(payload: BootstrapPayload): void {
       const toks = routeTokensForPath(p).filter((tk) => isEnabled(tk));
       if (toks.length) {
         const strong = toks.map((tk) => currentTokenColor(tk, cols));
-        const soft = strong.map((c) => `color-mix(in oklab, white 86%, ${c} 14%)`);
-        root.style.setProperty(`--${N}-route-gradient`, `linear-gradient(90deg, ${soft.join(", ")})`);
-        root.style.setProperty("--ff-route-outline-gradient", `linear-gradient(90deg, ${strong.join(", ")})`);
-        root.style.setProperty("--ff-route-badge-gradient", `linear-gradient(90deg, ${soft.join(", ")})`);
+        const soft = strong.map(
+          (c) => `color-mix(in oklab, white 86%, ${c} 14%)`,
+        );
+        root.style.setProperty(
+          `--${N}-route-gradient`,
+          `linear-gradient(90deg, ${soft.join(", ")})`,
+        );
+        root.style.setProperty(
+          "--ff-route-outline-gradient",
+          `linear-gradient(90deg, ${strong.join(", ")})`,
+        );
+        root.style.setProperty(
+          "--ff-route-badge-gradient",
+          `linear-gradient(90deg, ${soft.join(", ")})`,
+        );
         root.style.setProperty(
           "--ff-route-badge-border",
           `color-mix(in oklab, ${strong[0] || "#64748b"} 35%, transparent)`,
@@ -383,7 +443,9 @@ export function affDevBootstrapRuntime(payload: BootstrapPayload): void {
 
     affAfterNav();
     if (document.readyState === "loading") {
-      document.addEventListener("DOMContentLoaded", affAfterNav, { once: true });
+      document.addEventListener("DOMContentLoaded", affAfterNav, {
+        once: true,
+      });
     }
     document.addEventListener("astro:page-load", affAfterNav);
     document.addEventListener("astro:after-swap", affAfterNav);

package/src/dev-outline-css.ts

@@ -8,6 +8,13 @@ import { affDevBootstrapRuntime } from "./dev-inline-runtimes";
 import type { ResolvedFeatureRuntime } from "./runtime";
 import { toToken } from "./runtime";
 
+/**
+ * Cascade layer for the declarations the app must be able to override without
+ * writing `!important`. Named rather than anonymous so the order statement in
+ * {@link affHeadInlineRuntime} can name it too.
+ */
+export const DEV_LAYER = "aff-dev";
+
 export type DevOutlineHiddenStrategy = "visibility" | "display";
 
 export interface DevOutlineCssOptions extends ElementBadgeLayoutOptions {
@@ -67,7 +74,9 @@ function normalizeCssOptions(
     ...(css?.outlineColorByToken ?? {}),
   };
   const badgeLabelWip =
-    css?.badgeLabelWip ?? css?.badgeLabelDev ?? defaultDevOutlineCssOptions.badgeLabelWip;
+    css?.badgeLabelWip ??
+    css?.badgeLabelDev ??
+    defaultDevOutlineCssOptions.badgeLabelWip;
   return {
     ...defaultDevOutlineCssOptions,
     ...(css ?? {}),
@@ -97,6 +106,28 @@ function featureColorVar(token: string, namespace: string): string {
  * Dev-only styles: `data-ff="token"` (or space-separated tokens) gates outlines/badges.
  * `html[data-ff-route="<token>"]` (dev) adds a fixed top-right route badge (label only).
  * Toolbar toggles: `data-ff-enabled-*`, `data-ff-outline-*`, `data-ff-badge-*`, `--<namespace>-c-*`.
+ *
+ * The badge is an absolutely positioned `::before`, so its host has to be a
+ * containing block, and the host also wants rounding for the outline to follow.
+ * Both of those are the app's business, not ours: a flagged element that the app
+ * positions itself, or rounds itself, must keep doing so. Marking a flagged
+ * element must not move it.
+ *
+ * So `position` and `border-radius` are emitted inside `:where()` *and* inside
+ * the `aff-dev` cascade layer. `:where()` alone is not enough: an unlayered rule
+ * beats a layered one before specificity is ever consulted, so a zero-specificity
+ * unlayered rule still overrides Tailwind's `.rounded-full` and `.absolute`,
+ * which live in `@layer utilities`. Layering ours is what lets the app win.
+ *
+ * Layer priority follows the order layers are first declared, so the layer only
+ * sorts below the app's own layers if `@layer aff-dev;` appears before them in
+ * document order. The sheet opens with that statement for the case where it
+ * lands first, and {@link affHeadInlineRuntime} also prepends a style element
+ * carrying it as the first child of `<head>`, which is what actually guarantees
+ * the order at runtime.
+ *
+ * Everything else here is dev chrome the app has no opinion about, and stays at
+ * its natural specificity.
  */
 export function createFeatureFlagStyles(
   runtime: ResolvedFeatureRuntime,
@@ -111,7 +142,9 @@ export function createFeatureFlagStyles(
     return {
       token,
       baseSelectors,
-      selOutline: baseSelectors.map((s) => `${s}:not([${nsAttr}*=" "])`).join(", "),
+      selOutline: baseSelectors
+        .map((s) => `${s}:not([${nsAttr}*=" "])`)
+        .join(", "),
       selIs: `:is(${baseSelectors.join(", ")})`,
     };
   };
@@ -138,11 +171,15 @@ html {
 html:not([data-ff-outline-${token}="off"]) {
   --aff-outline-c-${token}: var(${v}, ${col});
 }
+@layer ${DEV_LAYER} {
+  :where(${selOutline}) {
+    position: relative;
+    border-radius: ${opts.borderRadius};
+  }
+}
 ${selOutline} {
-  position: relative;
   outline: ${opts.outlineWidth} solid var(--aff-outline-c-${token});
   outline-offset: ${opts.outlineOffset};
-  border-radius: ${opts.borderRadius};
 }
 html:not([data-ff-badge-${token}="off"]) ${selIsSingleBadge}::before {
   box-sizing: border-box;
@@ -226,11 +263,15 @@ html[data-ff-enabled-${token}="off"] ${selIs} {
 
   // Multi-token value on a single element: show combined badge text and a gradient outline.
   chunks.push(`
+@layer ${DEV_LAYER} {
+  :where([${nsAttr}*=" "]) {
+    position: relative;
+    border-radius: ${opts.borderRadius};
+  }
+}
 [${nsAttr}*=" "] {
-  position: relative;
   outline: none !important;
   outline-offset: 0 !important;
-  border-radius: ${opts.borderRadius};
 }
 html [${nsAttr}*=" "]::after {
   content: "";
@@ -404,7 +445,7 @@ html[data-ff-outline-${token}="off"] ${selIs}[${nsAttr}*=" "]::after {
 `);
   }
 
-  return "\n" + chunks.join("\n") + "\n";
+  return `\n@layer ${DEV_LAYER};\n` + chunks.join("\n") + "\n";
 }
 
 /**

package/src/dev-toolbar-app.ts

@@ -79,11 +79,9 @@ function loadState(tokens: string[], namespace: string): AffState {
     if (!raw) return next;
     const parsed = JSON.parse(raw) as Record<string, unknown>;
     const outline = (parsed.outline ?? parsed.chrome) as
-      | Record<string, boolean>
-      | undefined;
+      Record<string, boolean> | undefined;
     const enabled = (parsed.enabled ?? parsed.render) as
-      | Record<string, boolean>
-      | undefined;
+      Record<string, boolean> | undefined;
     const badge = parsed.badge as Record<string, boolean> | undefined;
     const colors = parsed.colors as Record<string, string> | undefined;
     if (outline) Object.assign(next.outline, outline);

package/src/index.ts

@@ -42,21 +42,38 @@ import {
   buildAffDevBootstrapScript,
   createFeatureFlagStyles,
   createProductionGateStyles,
+  DEV_LAYER,
 } from "./dev-outline-css";
 import { applyProductionHtmlCullToDist } from "./production-html-cull";
+import { applySitemapPruneToDist } from "./sitemap-prune";
 import { buildAffDevHeadInline } from "./dev-head-inject";
 import { routePrefixJsHelper } from "./route-prefix-js";
 
-export { createFeatureFlagStyles, createProductionGateStyles };
+export { createFeatureFlagStyles, createProductionGateStyles, DEV_LAYER };
 export {
   cullProductionHtml,
   applyProductionHtmlCullToDist,
 } from "./production-html-cull";
+export type { SitemapPruneResult } from "./sitemap-prune";
+export {
+  applySitemapPruneToDist,
+  pruneSitemapIndexXml,
+  pruneSitemapXml,
+  sitemapUrlCount,
+} from "./sitemap-prune";
 
 export interface AstroFeatureFlagsOptions extends ResolveFeatureRuntimeOptions {
   css?: DevOutlineCssOptions;
   /** When false, keeps static build output untouched (no route pruning / HTML cull). */
   staticMinify?: boolean;
+  /**
+   * When false, leaves generated sitemaps alone. On by default: a pruned route that is
+   * still advertised in `sitemap-0.xml` is a 404 handed to every crawler that reads it.
+   *
+   * Needs this integration to sit **after** `@astrojs/sitemap` in `integrations`, because
+   * Astro runs `astro:build:done` in array order.
+   */
+  pruneSitemap?: boolean;
 }
 
 /** Prefer `prod` if present; else first non-`dev` key (sorted); else `"prod"`. */
@@ -80,13 +97,14 @@ function withDefaultEnvironments(
       ? { ...options.environments }
       : {};
   delete raw.dev;
-  const environments: NonNullable<ResolveFeatureRuntimeOptions["environments"]> =
-    {
-      dev: {
-        when: mode !== "production",
-      },
-      ...raw,
-    };
+  const environments: NonNullable<
+    ResolveFeatureRuntimeOptions["environments"]
+  > = {
+    dev: {
+      when: mode !== "production",
+    },
+    ...raw,
+  };
   if (Object.keys(environments).length < 2) {
     environments.prod = environments.prod ?? {
       when: mode === "production",
@@ -130,7 +148,9 @@ export function createVirtualModuleSource(
       Object.fromEntries(flagNames.map((name) => [name, toToken(name)])),
       runtime.namespace,
     );
-  const affRoutePatternToPrefix = routePrefixJsHelper("affRoutePatternToPrefix");
+  const affRoutePatternToPrefix = routePrefixJsHelper(
+    "affRoutePatternToPrefix",
+  );
 
   return `${affRoutePatternToPrefix}
 
@@ -301,7 +321,12 @@ export {
 export default function astroFeatureFlags(
   options: AstroFeatureFlagsOptions = {},
 ): any {
-  const { css, staticMinify = true, ...flagOpts } = options;
+  const {
+    css,
+    staticMinify = true,
+    pruneSitemap = true,
+    ...flagOpts
+  } = options;
   const opts = withDefaultEnvironments(flagOpts);
   const mode = opts.mode ?? process.env.NODE_ENV ?? "development";
 
@@ -310,15 +335,23 @@ export default function astroFeatureFlags(
     mode,
   });
 
+  /**
+   * Set in `astro:config:setup`, read in `astro:build:done`, so that a sitemap this
+   * pass never saw can be reported as an ordering mistake rather than silently skipped.
+   */
+  let sitemapIntegrationPresent = false;
+
   return {
     name: "astro-feature-flags",
     hooks: {
       "astro:config:setup": ({
+        config,
         updateConfig,
         addDevToolbarApp,
         command,
         injectScript,
       }: {
+        config?: { integrations?: { name?: string }[] };
         updateConfig: (config: unknown) => void;
         addDevToolbarApp?: (opts: {
           id: string;
@@ -329,6 +362,9 @@ export default function astroFeatureFlags(
         command?: string;
         injectScript?: (stage: string, content: string) => void;
       }) => {
+        sitemapIntegrationPresent = (config?.integrations ?? []).some(
+          (integration) => integration?.name === "@astrojs/sitemap",
+        );
         const flagNames = Object.keys(runtime.flags);
         const flagTokens = flagNames.map((name) => toToken(name));
         const flagsByEnvironment = resolveFeatureFlagsByEnvironment(opts);
@@ -400,7 +436,13 @@ export default function astroFeatureFlags(
           },
         });
       },
-      "astro:build:done": ({ dir }: { dir: URL }) => {
+      "astro:build:done": ({
+        dir,
+        logger,
+      }: {
+        dir: URL;
+        logger?: { warn: (message: string) => void };
+      }) => {
         if (runtime.isDev || !staticMinify) return;
         const outDir = fileURLToPath(dir);
         const prunePaths = routePathsToPrune({
@@ -411,6 +453,13 @@ export default function astroFeatureFlags(
           rmSync(join(outDir, routePath), { recursive: true, force: true });
         }
         applyProductionHtmlCullToDist(outDir, runtime);
+        if (!pruneSitemap) return;
+        const sitemaps = applySitemapPruneToDist(outDir, runtime);
+        if (!sitemaps.found && sitemapIntegrationPresent && prunePaths.length) {
+          logger?.warn(
+            "@astrojs/sitemap is configured but no sitemap was on disk yet, so pruned routes may still be listed. Move astroFeatureFlags() after sitemap() in `integrations`.",
+          );
+        }
       },
     },
   };

package/src/inline-script.ts

@@ -2,7 +2,9 @@ export function compactInlineScript(source: string): string {
   const lines = source
     .split("\n")
     .map((line) => line.trim())
-    .filter((line, idx, arr) => line.length > 0 || (idx > 0 && idx < arr.length - 1));
+    .filter(
+      (line, idx, arr) => line.length > 0 || (idx > 0 && idx < arr.length - 1),
+    );
   return lines.join("\n").trim();
 }