blume 1.5.0 → 1.5.1

package/src/deploy/vercel-negotiation.ts

@@ -36,6 +36,7 @@ export interface VercelRoute {
   has?: { key?: string; type: string; value?: string }[];
   headers?: Record<string, string>;
   src?: string;
+  status?: number;
 }
 
 /** Whether a parsed route field is a real string (the config is raw JSON). */
@@ -163,6 +164,21 @@ export const buildNegotiationRoutes = (
 /** The `src` of the injected homepage `Link` header route. */
 const HOME_SRC = "^/$";
 
+/**
+ * Permanent redirect from any trailing-slash URL to its slashless twin, so
+ * `/docs/` and `/docs` don't serve as duplicate URLs (canonicals, sitemap, and
+ * hreflang all use the slashless form; the root `/` is untouched — `.+`
+ * requires a non-empty path). Spliced into the main phase before `handle:
+ * "filesystem"`, after the Markdown rewrites, so an agent's `Accept:
+ * text/markdown` request on a slashed URL still rewrites without the extra
+ * hop. Vercel carries the query string over to the `Location` target itself.
+ */
+export const TRAILING_SLASH_REDIRECT: VercelRoute = {
+  headers: { Location: "/$1" },
+  src: "^/(.+)/$",
+  status: 308,
+};
+
 /**
  * Whether a route is one this module previously injected, so re-injection
  * replaces rather than duplicates. Rewrites are identified by their `accept`
@@ -183,7 +199,9 @@ const isNegotiationRoute = (route: VercelRoute): boolean =>
   (route.continue === true &&
     isString(route.headers?.link) &&
     route.src === HOME_SRC &&
-    Object.keys(route).length === 3);
+    Object.keys(route).length === 3) ||
+  (route.status === TRAILING_SLASH_REDIRECT.status &&
+    route.src === TRAILING_SLASH_REDIRECT.src);
 
 /**
  * Splice the negotiation routes into a Build Output `config.json`, plus — when
@@ -193,10 +211,12 @@ const isNegotiationRoute = (route: VercelRoute): boolean =>
  * rides on the prerendered homepage response. `contentTypeOverrides` maps static-dir
  * relative paths to media types via the Build Output `overrides` field — the
  * platform's mechanism for extensionless static files (e.g. the Web Bot Auth
- * signature directory). Returns the updated JSON text (tab-indented, like the
- * adapter's own output), or `null` when there is nothing to do or nowhere
- * safe to do it: nothing to inject, an unparsable config, no `routes` array,
- * or no `handle: "filesystem"` marker to anchor the splice.
+ * signature directory). The trailing-slash 308 redirect is always spliced in
+ * alongside, so slashed duplicates of every page collapse onto the canonical
+ * slashless URL. Returns the updated JSON text (tab-indented, like the
+ * adapter's own output), or `null` when there is nowhere safe to splice: an
+ * unparsable config, no `routes` array, or no `handle: "filesystem"` marker
+ * to anchor the splice.
  */
 export const injectNegotiationRoutes = (
   configText: string,
@@ -206,13 +226,6 @@ export const injectNegotiationRoutes = (
   homeTokens?: number
 ): string | null => {
   const overrideEntries = Object.entries(contentTypeOverrides ?? {});
-  if (
-    routePaths.length === 0 &&
-    !homeLinkHeader &&
-    overrideEntries.length === 0
-  ) {
-    return null;
-  }
   let config: {
     overrides?: Record<string, { contentType?: string; path?: string }>;
     routes?: VercelRoute[];
@@ -250,8 +263,15 @@ export const injectNegotiationRoutes = (
   }
   // Headers first: `continue` routes accumulate, so a request the rewrite
   // route then terminates (Markdown negotiation on the homepage) still carries
-  // the Link header.
-  routes.splice(filesystemIndex, 0, ...headerRoutes, ...rewriteRoutes);
+  // the Link header. The trailing-slash redirect goes last so a slashed URL's
+  // Markdown negotiation still rewrites directly instead of bouncing.
+  routes.splice(
+    filesystemIndex,
+    0,
+    ...headerRoutes,
+    ...rewriteRoutes,
+    TRAILING_SLASH_REDIRECT
+  );
   config.routes = routes;
   return `${JSON.stringify(config, null, "\t")}\n`;
 };

package/src/og/card.ts

@@ -340,7 +340,9 @@ export const renderOgImage = async (
         color: foreground,
         fontSize: titleSize(options.title),
         fontWeight: 600,
-        letterSpacing: "-0.03em",
+        // Matches the theme's heading tracking (entry.ts h1-h6 rule), tuned
+        // for Inter since the display default dropped Inter Tight.
+        letterSpacing: "-0.05em",
         lineHeight: 1.05,
         maxWidth: 1010,
         textWrap: "balance",

package/src/theme/entry.ts

@@ -179,7 +179,11 @@ ${THEME_MAPPING}
     scroll-padding-top: 4.5rem;
     text-rendering: optimizeLegibility;
   }
-  /* Headings use the display font (defaults to the body font when unset). */
+  /* Headings use the display font (defaults to the body font when unset).
+     The tightened tracking is part of the theme, not the font: display-tuned
+     families bake it into their metrics, but a text family promoted to
+     headings (including the Inter default) reads loose without it. -0.05em
+     was matched visually against Inter Tight, the previous display default. */
   h1,
   h2,
   h3,
@@ -187,6 +191,7 @@ ${THEME_MAPPING}
   h5,
   h6 {
     font-family: var(--font-display);
+    letter-spacing: -0.05em;
   }
   :focus-visible {
     outline: 2px solid var(--blume-accent);
@@ -207,6 +212,22 @@ ${THEME_MAPPING}
   }
 }
 
+/* Same-origin navigations are full document loads (no client router); opting
+   into cross-document view transitions has the browser crossfade between the
+   old and new page instead of hard-swapping, in browsers that support it.
+   Pairs with the prefetch option in the generated Astro config. */
+@view-transition {
+  navigation: auto;
+}
+
+@media (prefers-reduced-motion: reduce) {
+  ::view-transition-group(*),
+  ::view-transition-old(*),
+  ::view-transition-new(*) {
+    animation: none !important;
+  }
+}
+
 /* Code reads left-to-right regardless of page direction; only the surrounding
    chrome mirrors for RTL. Inline code is isolated so LTR identifiers don't
    disturb the bidi flow of right-to-left prose. */
@@ -242,9 +263,10 @@ ${THEME_MAPPING}
   line-height: 1.7;
 }
 
+/* No letter-spacing here: prose headings inherit the base h1-h6 rule's
+   display tracking, same as headings outside the prose column. */
 .prose :where(h1, h2, h3, h4) {
   font-weight: 500;
-  letter-spacing: 0;
 }
 
 /* A heading can carry one long unbreakable token — an OpenAPI operation's title

package/src/theme/fonts.ts

@@ -352,6 +352,78 @@ export const buildFontsCss = (fonts: FontsConfig): string => {
     : "";
 };
 
-/** The CSS variables to feed Astro's `<Font>` component in the document head. */
-export const configuredCssVars = (fonts: FontsConfig): string[] =>
-  buildFontEntries(fonts).map((entry) => entry.cssVariable);
+/**
+ * Weights worth preloading per role — the faces above-the-fold text actually
+ * renders in: body copy and UI chrome at 400/500, headings at 500/600, code at
+ * 400. Every other face still loads on demand through its `@font-face` rule
+ * (and `font-display: swap` never blocks text on it), so preloading the long
+ * tail only competes with the critical CSS for bandwidth and pushes LCP out.
+ */
+const PRELOAD_WEIGHTS = {
+  body: [400, 500],
+  display: [500, 600],
+  mono: [400],
+} satisfies Record<FontSlot, number[]>;
+
+/** One `<Font>` render in the head: its CSS variable + weights to preload. */
+export interface FontHead {
+  cssVariable: string;
+  preloadWeights: number[];
+}
+
+/** The weights an entry's faces declare (`undefined` = inferred from files). */
+const entryWeights = (entry: FontEntry): (number | string | undefined)[] =>
+  entry.kind === "remote"
+    ? entry.weights
+    : entry.variants.map((variant) => variant.weight);
+
+/**
+ * The role's preferred preload weights, narrowed to faces the family loads.
+ * Variable ranges (`"100..900"`) and weight-inferred local files can serve any
+ * weight, so they keep the preferred list; a family whose numeric weights miss
+ * the preferred ones entirely preloads all of its faces instead — those are
+ * what its text renders in.
+ */
+const preloadWeightsFor = (slot: FontSlot, entry: FontEntry): number[] => {
+  const preferred = PRELOAD_WEIGHTS[slot];
+  const weights = entryWeights(entry);
+  const numeric = weights.filter(
+    (weight): weight is number => typeof weight === "number"
+  );
+  const hits = preferred.filter((weight) => numeric.includes(weight));
+  if (hits.length > 0) {
+    return hits;
+  }
+  return numeric.length === weights.length ? numeric : preferred;
+};
+
+/**
+ * The fonts to feed Astro's `<Font>` component in the document head, deduped
+ * by CSS variable with preload weights unioned across the roles that share a
+ * family (so `display` and `body` both set to Inter preload 400/500/600 once).
+ */
+export const configuredFonts = (fonts: FontsConfig): FontHead[] => {
+  if (!fonts) {
+    return [];
+  }
+  const heads = new Map<string, Set<number>>();
+  for (const slot of SLOTS) {
+    const value = fonts[slot];
+    if (value === undefined) {
+      continue;
+    }
+    const entry = resolveFontValue(slot, value);
+    if (!entry) {
+      continue;
+    }
+    const weights = heads.get(entry.cssVariable) ?? new Set();
+    for (const weight of preloadWeightsFor(slot, entry)) {
+      weights.add(weight);
+    }
+    heads.set(entry.cssVariable, weights);
+  }
+  return [...heads].map(([cssVariable, weights]) => ({
+    cssVariable,
+    preloadWeights: [...weights].toSorted((a, b) => a - b),
+  }));
+};