blume 2.1.1 → 2.1.2

package/src/core/sources/notion.ts

@@ -22,6 +22,7 @@ import {
   image,
   linkParts,
   renderInline,
+  renderInlineMdx,
 } from "./lower.ts";
 import { slugify, slugifyPath } from "./normalize.ts";
 import { missingSecretError } from "./remote.ts";
@@ -143,6 +144,14 @@ export interface NotionSourceOptions {
    * Status/select property are always imported as published.
    */
   publishedValue?: string;
+  /**
+   * Read the text of text blocks (paragraphs, headings, list items, quotes,
+   * callouts) as MDX source, so a component, expression, or Markdown typed in
+   * Notion renders instead of showing as written. MDX runs code at build
+   * time, so this hands everyone who can edit the database the site's build:
+   * set it only when you trust them with that. Default false.
+   */
+  mdx?: boolean;
   /** Opt-in dev polling interval (seconds); omit to freeze for the session. */
   pollInterval?: number;
   /** Injected for tests; otherwise built from `@notionhq/client`. */
@@ -174,9 +183,10 @@ interface LinkedRuns {
  * itself instead of opening a JSX expression, a tag, or emphasis, a code run
  * keeps its text verbatim inside a long-enough code span, neighbors share
  * their marks' delimiters, and neighbors that link to one `href` share one
- * link.
+ * link. With `mdx`, the text goes in as typed instead (see
+ * `NotionSourceOptions.mdx`).
  */
-const richToMarkdown = (rich: NotionRichText[] = []): string => {
+const richToMarkdown = (rich: NotionRichText[] = [], mdx = false): string => {
   const linked: LinkedRuns[] = [];
   for (const { annotations = {}, href, plain_text: text } of rich) {
     const run: InlineRun = {
@@ -195,11 +205,18 @@ const richToMarkdown = (rich: NotionRichText[] = []): string => {
       linked.push({ href: href ?? undefined, runs: [run] });
     }
   }
-  return renderInline(
-    linked.flatMap(({ href, runs }) => linkParts(runs, href))
-  );
+  const parts = linked.flatMap(({ href, runs }) => linkParts(runs, href, mdx));
+  return mdx ? renderInlineMdx(parts) : renderInline(parts);
 };
 
+/**
+ * A text block's rich text: Markdown that renders as written, guarded at its
+ * block start — or, with `mdx`, MDX source as typed, which an `.mdx` file's
+ * own block starts (`import`, `#`, indentation) read the same way.
+ */
+const blockText = (rich: NotionRichText[] | undefined, mdx: boolean): string =>
+  mdx ? richToMarkdown(rich, true) : guardBlockStart(richToMarkdown(rich));
+
 const isBlockPayload = (
   value: NotionBlockPayload | boolean | string | undefined
 ): value is NotionBlockPayload => typeof value === "object";
@@ -340,9 +357,9 @@ const renderVideo = (data: NotionBlockPayload): string => {
 };
 
 /** Render a leaf (non-container) block to Markdown, or null for containers. */
-const renderLeaf = (block: NotionBlock): string | null => {
+const renderLeaf = (block: NotionBlock, mdx: boolean): string | null => {
   const data = payloadOf(block) ?? {};
-  const text = guardBlockStart(richToMarkdown(blockField(block)));
+  const text = blockText(blockField(block), mdx);
   switch (block.type) {
     case "paragraph": {
       return text;
@@ -398,6 +415,7 @@ export const notionSource = (
   ctx?: SourceContext
 ): ContentSource => {
   const props = options.properties ?? {};
+  const textAsMdx = options.mdx ?? false;
   // A FIFO semaphore: at most N calls run at once, the rest queue. Notion's
   // rate limit is per-integration (an average of 3 req/s), and a large
   // database fans out one block-children request per page plus one per nested
@@ -481,7 +499,7 @@ export const notionSource = (
 
     if (block.type === "callout") {
       const body = [
-        guardBlockStart(richToMarkdown(blockField(block))),
+        blockText(blockField(block), textAsMdx),
         await children(block),
       ]
         .filter(Boolean)
@@ -509,7 +527,7 @@ export const notionSource = (
   ): Promise<string> => {
     const parts = await Promise.all(
       blocks.map(async (block) => {
-        const leaf = renderLeaf(block);
+        const leaf = renderLeaf(block, textAsMdx);
         if (leaf === null) {
           return renderContainer(client, block, renderBlocks);
         }

package/src/deploy/cloudflare-negotiation.ts

@@ -40,8 +40,9 @@
  * Cloudflare does not apply `_headers` to worker-first routes, so the wrapper
  * also re-stamps what the static layer would otherwise add on the routes it
  * takes over: the homepage agent-discovery `Link` header, the Markdown
- * `charset=utf-8`, and the sandbox on the SVGs a content source downloaded
- * (see `deploy/headers.ts`). The raw `.md`/`.mdx` URLs are
+ * `charset=utf-8`, the sandbox on the SVGs a content source downloaded (see
+ * `deploy/headers.ts`), and `X-Powered-By` unless `poweredBy` is `false`. The
+ * raw `.md`/`.mdx` URLs are
  * exempted from worker-first routing with negative rules, keeping their
  * `_headers` treatment and their zero-Worker serving path.
  *
@@ -85,6 +86,7 @@ import {
   OPENAPI_PATH,
 } from "../ai/api/paths.ts";
 import { normalizeBasePath, normalizePath } from "../core/base-path.ts";
+import { POWERED_BY_HEADERS } from "../core/powered-by.ts";
 import { compileRedirects, isPatternPath } from "../core/redirect-patterns.ts";
 import { CONTENT_ASSETS_ROOT, SVG_ASSET_HEADERS } from "./headers.ts";
 import type { NotFoundVariants } from "./vercel-negotiation.ts";
@@ -244,6 +246,8 @@ export interface NegotiationWorkerOptions {
   base?: string;
   /** Homepage agent-discovery `Link` header (see `ai/link-headers.ts`). */
   homeLinkHeader?: string | null;
+  /** Whether responses identify Blume with `X-Powered-By`. Defaults to `true`. */
+  poweredBy?: boolean;
   /** Estimated token count of the homepage Markdown mirror. */
   homeTokens?: number;
   /** Configured redirects the wrapper answers with their exact status. */
@@ -277,6 +281,9 @@ export const buildNegotiationWorker = (
   const binding = JSON.stringify(options.assetsBinding);
   const prefix = JSON.stringify(encodeURI(normalizeBasePath(options.base)));
   const homeLinkHeader = JSON.stringify(options.homeLinkHeader ?? null);
+  const poweredBy = JSON.stringify(
+    options.poweredBy === false ? {} : POWERED_BY_HEADERS
+  );
   const homeTokens = JSON.stringify(
     options.homeTokens === undefined ? null : String(options.homeTokens)
   );
@@ -331,6 +338,7 @@ const PATTERN_REDIRECTS = ${patternRedirects}.map(
 );
 const NOT_FOUND = ${notFound};
 const SVG_ASSET_HEADERS = ${JSON.stringify(SVG_ASSET_HEADERS)};
+const POWERED_BY = ${poweredBy};
 
 // An SVG a content source downloaded: a document that could run script as the
 // docs site if opened directly, so it goes out sandboxed. Matched on the
@@ -542,12 +550,30 @@ const isHomePath = (pathname) => {
   return rest === "" || rest === "/";
 };
 
+// Blume's X-Powered-By, on every answer the wrapper gives unless the
+// response already names its own (the project's middleware, say).
+const identify = (headers) => {
+  for (const [name, value] of Object.entries(POWERED_BY)) {
+    if (!headers.has(name)) {
+      headers.set(name, value);
+    }
+  }
+};
+
 const withHeaders = (response, apply) => {
   const patched = new Response(response.body, response);
   apply(patched.headers);
+  identify(patched.headers);
   return patched;
 };
 
+// A response that already carries the header (Blume's runtime middleware sets
+// it on every page Astro renders) goes out as it is.
+const withPoweredBy = (response) =>
+  Object.keys(POWERED_BY).every((name) => response.headers.has(name))
+    ? response
+    : withHeaders(response, () => {});
+
 export default {
   async fetch(request, env, context) {
     const url = new URL(request.url);
@@ -556,7 +582,10 @@ export default {
     const redirect = redirectFor(url.pathname);
     if (redirect !== null) {
       return new Response(null, {
-        headers: { location: redirectLocation(redirect[0], url.search) },
+        headers: {
+          ...POWERED_BY,
+          location: redirectLocation(redirect[0], url.search),
+        },
         status: redirect[1],
       });
     }
@@ -568,7 +597,7 @@ export default {
       });
     }
     if (request.method !== "GET" && request.method !== "HEAD") {
-      return server.fetch(request, env, context);
+      return withPoweredBy(await server.fetch(request, env, context));
     }
     const assets = env[ASSETS_BINDING];
     // The request goes through untouched, so a conditional revalidation
@@ -577,7 +606,7 @@ export default {
     if (assets !== undefined && isPageJson(url.pathname)) {
       const asset = await assets.fetch(request);
       if (asset.status !== 404) {
-        return asset;
+        return withPoweredBy(asset);
       }
     }
     const variant = markdownVariantUrl(url.pathname + url.search);
@@ -608,10 +637,10 @@ export default {
     const response = await server.fetch(request, env, context);
     const twin = await notFoundTwin(request, url, response, assets);
     if (twin !== null) {
-      return twin;
+      return withPoweredBy(twin);
     }
     if (variant === null && !(home && HOME_LINK_HEADER !== null)) {
-      return response;
+      return withPoweredBy(response);
     }
     return withHeaders(response, (headers) => {
       if (variant !== null) {

package/src/deploy/headers.ts

@@ -10,6 +10,7 @@ import {
   SIGNATURES_DIRECTORY_TYPE,
 } from "../ai/web-bot-auth.ts";
 import { normalizeBasePath } from "../core/base-path.ts";
+import { POWERED_BY_HEADERS } from "../core/powered-by.ts";
 import type { ResolvedConfig } from "../core/schema.ts";
 
 /**
@@ -98,6 +99,13 @@ export const headerRules = (
     path: `${deployBase}/*.${rule.ext}`,
     value: rule.contentType,
   }));
+  // One rule for the whole site: `/*` matches the homepage too, and a host
+  // that joins the values of overlapping rules would send a second one twice.
+  if (config.poweredBy) {
+    for (const [name, value] of Object.entries(POWERED_BY_HEADERS)) {
+      rules.push({ name, path: `${deployBase}/*`, value });
+    }
+  }
   if (homeLinkHeader) {
     rules.push({ name: "Link", path: `${deployBase}/`, value: homeLinkHeader });
   }
@@ -212,9 +220,15 @@ export const escapeVercelSource = (path: string): string =>
  * A `_headers` path as a `vercel.json` `source`, which `path-to-regexp` reads:
  * the literal parts are escaped, and a `*` glob becomes the `(.*)` group that
  * spans path segments as the glob does. An exact directory path (the homepage
- * rule's `/docs/`) drops its trailing slash, the URL Vercel serves it at.
+ * rule's `/docs/`) drops its trailing slash, the URL Vercel serves it at. A
+ * whole-directory glob (`/docs/*`) becomes an optional group,
+ * `/docs/:path(.*)?`, so it matches that bare URL as well as every path
+ * beneath it.
  */
 const vercelSource = (path: string): string => {
+  if (path.endsWith("/*")) {
+    return `${escapeVercelSource(path.slice(0, -2))}/:path(.*)?`;
+  }
   const trimmed =
     path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path;
   return trimmed.split("*").map(escapeVercelSource).join("(.*)");

package/src/deploy/node-headers.ts

@@ -14,6 +14,7 @@ import {
   SIGNATURES_DIRECTORY_TYPE,
 } from "../ai/web-bot-auth.ts";
 import { normalizeBasePath, normalizePath } from "../core/base-path.ts";
+import { POWERED_BY_HEADERS } from "../core/powered-by.ts";
 import type { BlumeProject } from "../core/project-graph.ts";
 import { compileRedirects, isPatternPath } from "../core/redirect-patterns.ts";
 import type { CompiledRedirect } from "../core/redirect-patterns.ts";
@@ -159,6 +160,8 @@ export const nodePatternRedirects = (
 export interface NodeEntryOptions {
   /** `deployment.base`, normalized (`""` at the root). */
   base?: string;
+  /** Whether responses identify Blume with `X-Powered-By`. Defaults to `true`. */
+  poweredBy?: boolean;
   /** The configured redirects, from {@link nodeRedirects}. */
   redirects?: NodeRedirects;
   /** The configured pattern redirects, from {@link nodePatternRedirects}. */
@@ -169,7 +172,12 @@ export interface NodeEntryOptions {
  * The entry that replaces Astro's: it answers a configured redirect with its
  * exact status, and otherwise stamps the rules' headers on the response and
  * hands the request to Astro's handler. `send` leaves a Content-Type that is
- * already set alone, so the registered media type wins.
+ * already set alone, so the registered media type wins. Unless `poweredBy` is
+ * `false`, every answer also names Blume in `X-Powered-By` — the redirects,
+ * and the prerendered pages and files the static handler serves, which
+ * Blume's runtime middleware never sees. A middleware-mode entry leaves that
+ * header to the middleware: Astro hands a request it has no route for back to
+ * the host app through `next()`, and that response is the host's own.
  *
  * A rule matches the file the static handler will serve, not the raw URL:
  * Astro strips the base when it leads the path and serves the rest from the
@@ -194,10 +202,11 @@ export const nodeEntryWrapper = (
 // This wrapper answers the configured redirects with their exact status and
 // sets the headers the standalone server's static handler can't (the media
 // types and CORS headers of the .well-known discovery files, the sandbox on
-// downloaded SVGs), then hands every other request to Astro.
+// downloaded SVGs, X-Powered-By), then hands every other request to Astro.
 import { posix } from "node:path";
 
 const BASE = ${JSON.stringify(options.base ?? "")};
+const POWERED_BY = ${JSON.stringify(options.poweredBy === false ? {} : POWERED_BY_HEADERS)};
 const RULES = new Map(${JSON.stringify(exactRules(rules))});
 const PATTERNS = ${JSON.stringify(patternRules(rules))};
 const REDIRECTS = ${JSON.stringify(options.redirects ?? {})};
@@ -221,20 +230,20 @@ const servedPath = (req) => {
       : path;
   return BASE + (rest || "/");
 };
-const applyHeaders = (req, res) => {
+const applyHeaders = (req, res, identify) => {
   const path = servedPath(req);
   const lower = path.toLowerCase();
-  const headers =
-    RULES.get(path) ??
-    PATTERNS.find(
-      ([prefix, suffix]) =>
-        lower.startsWith(prefix.toLowerCase()) &&
-        lower.endsWith(suffix.toLowerCase())
-    )?.[2];
-  if (headers) {
-    for (const [name, value] of Object.entries(headers)) {
-      res.setHeader(name, value);
-    }
+  const headers = {
+    ...(identify ? POWERED_BY : {}),
+    ...(RULES.get(path) ??
+      PATTERNS.find(
+        ([prefix, suffix]) =>
+          lower.startsWith(prefix.toLowerCase()) &&
+          lower.endsWith(suffix.toLowerCase())
+      )?.[2]),
+  };
+  for (const [name, value] of Object.entries(headers)) {
+    res.setHeader(name, value);
   }
 };
 // A pattern redirect's Location: its template, each $n filled with that
@@ -268,7 +277,7 @@ const answerRedirect = (req, res) => {
     return false;
   }
   const [location, status] = redirect;
-  res.writeHead(status, { location });
+  res.writeHead(status, { ...POWERED_BY, location });
   res.end();
   return true;
 };
@@ -285,7 +294,7 @@ export const handler = (req, res, ...rest) => {
   if (answerRedirect(req, res)) {
     return;
   }
-  applyHeaders(req, res);
+  applyHeaders(req, res, options.mode !== "middleware");
   return astro.handler(req, res, ...rest);
 };
 export const startServer = () => {
@@ -301,7 +310,7 @@ export const startServer = () => {
       if (answerRedirect(req, res)) {
         return;
       }
-      applyHeaders(req, res);
+      applyHeaders(req, res, true);
       for (const listener of astroListeners) {
         listener.call(httpServer, req, res);
       }
@@ -315,9 +324,10 @@ if (options.mode === "standalone" && previous !== "disabled") {
 `;
 
 /**
- * Put the wrapper in front of a Node server build's entry. A build with no
- * rule (no API catalog, AI catalog, MCP server, signatures directory, or
- * downloaded content assets) and no redirect leaves Astro's entry alone.
+ * Put the wrapper in front of a Node server build's entry. A build with
+ * `poweredBy` off, no rule (no API catalog, AI catalog, MCP server,
+ * signatures directory, or downloaded content assets), and no redirect leaves
+ * Astro's entry alone.
  */
 export const wrapNodeEntry = async (
   project: BlumeProject,
@@ -341,6 +351,7 @@ export const wrapNodeEntry = async (
   const redirects = nodeRedirects(project);
   const patternRedirects = nodePatternRedirects(project);
   if (
+    !project.config.poweredBy &&
     rules.length === 0 &&
     Object.keys(redirects).length === 0 &&
     patternRedirects.length === 0
@@ -365,6 +376,7 @@ export const wrapNodeEntry = async (
     nodeEntryWrapper(rules, {
       base: normalizeBasePath(project.config.deployment.options.base),
       patternRedirects,
+      poweredBy: project.config.poweredBy,
       redirects,
     }),
     "utf-8"

package/src/deploy/platforms/cloudflare.ts

@@ -122,6 +122,7 @@ export const emitCloudflareNegotiation = async (
             )
             .map((route) => pageJsonPath(route.path))
         : [],
+      poweredBy: config.poweredBy,
       // The wrapper Worker matches full served URLs, so the redirects are
       // based the same way the platform files are — it answers any the
       // worker-first rules claim, where `_redirects` is never consulted and

package/src/deploy/platforms/vercel.ts

@@ -151,7 +151,8 @@ export const emitVercelNegotiation = async (
     // Downloaded content assets are prerendered static files; only a build
     // that has them needs the SVG sandbox route.
     existsSync(join(builtDir, "blume-assets")),
-    base
+    base,
+    config.poweredBy
   );
   if (injected === null) {
     log.warn(
@@ -269,8 +270,8 @@ export const rebaseVercelRoutes = async (
  * hidden runtime silently drops the function's chunks and `node_modules`.
  * Static assets are served from the tree's `static/` half, so the deploy
  * artifacts are written there; headers (the discovery files', the sandbox on
- * downloaded SVGs) arrive through the routing config rather than a
- * `_headers` file, which Vercel never reads. The adapter ignores
+ * downloaded SVGs, `X-Powered-By`) arrive through the routing config rather
+ * than a `_headers` file, which Vercel never reads. The adapter ignores
  * `deployment.base`, so under one the build moves the static files and the
  * routes beneath it.
  */

package/src/deploy/vercel-negotiation.ts

@@ -21,6 +21,7 @@
  */
 
 import { mountBasePath } from "../core/base-path.ts";
+import { POWERED_BY_HEADERS } from "../core/powered-by.ts";
 import { SVG_ASSET_HEADERS } from "./headers.ts";
 
 /*
@@ -374,6 +375,31 @@ const svgAssetRoute = (base: string): VercelRoute => ({
   src: svgAssetSource(base),
 });
 
+/** The `src` of the `X-Powered-By` route: the base and every path beneath it. */
+const poweredBySource = (base: string): string =>
+  `^${routePattern(base)}(?:/.*)?$`;
+
+/**
+ * A main-phase `continue` route naming Blume in `X-Powered-By` (see
+ * `core/powered-by.ts`) on every response: the prerendered pages and files
+ * the static layer serves, which Blume's runtime middleware never sees, the
+ * functions, and the redirects.
+ */
+const poweredByRoute = (base: string): VercelRoute => ({
+  continue: true,
+  headers: Object.fromEntries(
+    Object.entries(POWERED_BY_HEADERS).map(([name, value]) => [
+      name.toLowerCase(),
+      value,
+    ])
+  ),
+  src: poweredBySource(base),
+});
+
+/** Whether a route is the {@link poweredByRoute}. */
+const isPoweredByRoute = (route: VercelRoute, base: string): boolean =>
+  route.continue === true && route.src === poweredBySource(base);
+
 /** Whether a route is a `corsRoute` — the same three-field shape test as the others. */
 const isCorsRoute = (route: VercelRoute): boolean =>
   route.continue === true &&
@@ -389,7 +415,8 @@ const isCorsRoute = (route: VercelRoute): boolean =>
  * the one re-added); the homepage `Link` route by its three-field
  * continue-with-link shape (the Build Output config is adapter-generated, so
  * no user-authored route competes in this file); the Markdown 404 routes by
- * their `/404.md` destination.
+ * their `/404.md` destination; the SVG and `X-Powered-By` routes by their
+ * `src`.
  */
 const isNegotiationRoute = (route: VercelRoute, base: string): boolean =>
   route.has?.some((condition) => MARKDOWN_VALUES.has(condition.value)) ===
@@ -407,7 +434,8 @@ const isNegotiationRoute = (route: VercelRoute, base: string): boolean =>
     route.src === homeSource(base) &&
     Object.keys(route).length === 3) ||
   isCorsRoute(route) ||
-  (route.continue === true && route.src === svgAssetSource(base));
+  (route.continue === true && route.src === svgAssetSource(base)) ||
+  isPoweredByRoute(route, base);
 
 /**
  * Splice the negotiation routes into a Build Output `config.json`, plus — when
@@ -426,7 +454,9 @@ const isNegotiationRoute = (route: VercelRoute, base: string): boolean =>
  * phase right before the adapter's `/404.html` fallback — and nowhere when
  * that fallback is absent, since a `dest` with no file behind it would serve
  * nothing. With `svgAssets`, a main-phase route also sandboxes the SVGs a
- * content source downloaded (see {@link svgAssetRoute}). Under a `base`, every
+ * content source downloaded (see {@link svgAssetRoute}). With `poweredBy`, a
+ * route at the head of the config, ahead of the adapter's redirects, names
+ * Blume on every response (see {@link poweredByRoute}). Under a `base`, every
  * route matches and names paths beneath it, and the fallback anchor is the
  * one {@link rebaseAdapterRoutes} moved there. Returns the updated JSON
  * text (tab-indented, like the adapter's own output), or `null` when there is
@@ -442,7 +472,8 @@ export const injectNegotiationRoutes = (
   notFound: NotFoundVariants = {},
   corsPaths: readonly string[] = [],
   svgAssets = false,
-  base = ""
+  base = "",
+  poweredBy = false
 ): string | null => {
   const overrideEntries = Object.entries(contentTypeOverrides ?? {});
   let config: {
@@ -491,6 +522,9 @@ export const injectNegotiationRoutes = (
   // route then terminates (Markdown negotiation on the homepage) still carries
   // the Link header.
   routes.splice(filesystemIndex, 0, ...headerRoutes, ...rewriteRoutes);
+  if (poweredBy) {
+    routes.unshift(poweredByRoute(base));
+  }
   const notFoundRoutes = [
     ...(notFound.markdown ? notFoundMarkdownRoutes(base) : []),
     ...(notFound.json ? notFoundJsonRoutes(base) : []),

package/src/markdown/base-links.ts

@@ -24,6 +24,21 @@ interface MdastUrlContext {
 const isUrl = (url: string | null | undefined): url is string =>
   typeof url === "string";
 
+/** Record `based(url)` on the node when its root-relative URL changes. */
+const rebase = (
+  node: UrlNode,
+  ctx: MdastUrlContext,
+  based: (url: string) => string
+): void => {
+  const { url } = node;
+  if (isUrl(url) && isInternalPath(url)) {
+    const next = based(url);
+    if (next !== url) {
+      ctx.setProperty(node, "url", next);
+    }
+  }
+};
+
 export interface BaseLinksPluginOptions {
   /**
    * The `blume:data` JSON file, for an ejected app: with no CLI in the process
@@ -72,20 +87,6 @@ export const baseLinksPlugin = (
   const servesPage = (route: string): boolean =>
     servesRoute(servedRoutes(), route);
 
-  /** Record `based(url)` on the node when its root-relative URL changes. */
-  const rebase = (
-    node: UrlNode,
-    ctx: MdastUrlContext,
-    based: (url: string) => string
-  ): void => {
-    const { url } = node;
-    if (isUrl(url) && isInternalPath(url)) {
-      const next = based(url);
-      if (next !== url) {
-        ctx.setProperty(node, "url", next);
-      }
-    }
-  };
   const rebaseLink = (node: UrlNode, ctx: MdastUrlContext): void =>
     rebase(node, ctx, (url) =>
       withAuthoredBasePath(deployBase, basePath, url, servesPage)

package/src/markdown/package-commands.ts

@@ -205,6 +205,9 @@ const buildCommand = (manager: PackageManager, intent: Intent): string => {
   return words.join(" ");
 };
 
+const normalizeCommand = (command: string): string =>
+  command.replaceAll(WHITESPACE_RUN, " ").trim();
+
 /**
  * Convert an install command into the equivalent for every supported package
  * manager. Accepts a bare package list (`react`) or a full command
@@ -212,14 +215,12 @@ const buildCommand = (manager: PackageManager, intent: Intent): string => {
  */
 export const toPackageCommands = (input: string) => {
   const intent = parseIntent(input);
-  const normalize = (command: string): string =>
-    command.replaceAll(WHITESPACE_RUN, " ").trim();
   return {
-    aube: normalize(buildCommand("aube", intent)),
-    bun: normalize(buildCommand("bun", intent)),
-    npm: normalize(buildCommand("npm", intent)),
-    nub: normalize(buildCommand("nub", intent)),
-    pnpm: normalize(buildCommand("pnpm", intent)),
-    yarn: normalize(buildCommand("yarn", intent)),
+    aube: normalizeCommand(buildCommand("aube", intent)),
+    bun: normalizeCommand(buildCommand("bun", intent)),
+    npm: normalizeCommand(buildCommand("npm", intent)),
+    nub: normalizeCommand(buildCommand("nub", intent)),
+    pnpm: normalizeCommand(buildCommand("pnpm", intent)),
+    yarn: normalizeCommand(buildCommand("yarn", intent)),
   } satisfies Record<PackageManager, string>;
 };