astro 5.7.0 → 5.7.2

package/components/Font.astro

@@ -23,10 +23,10 @@ if (!data) {
 }
 ---
 
-<style set:html={data.css}></style>
 {
 	preload &&
 		data.preloadData.map(({ url, type }) => (
 			<link rel="preload" href={url} as="font" type={`font/${type}`} crossorigin />
 		))
 }
+<style set:html={data.css}></style>

package/dist/assets/fonts/constants.d.ts

@@ -11,5 +11,70 @@ export declare const RESOLVED_VIRTUAL_MODULE_ID: string;
 export declare const URL_PREFIX = "/_astro/fonts/";
 export declare const CACHE_DIR = "./fonts/";
 export declare const FONT_TYPES: readonly ["woff2", "woff", "otf", "ttf", "eot"];
-export declare const DEFAULT_FALLBACKS: Record<string, Array<string>>;
+export declare const SYSTEM_METRICS: {
+    'Times New Roman': {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+    Arial: {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+    'Courier New': {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+    BlinkMacSystemFont: {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+    'Segoe UI': {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+    Roboto: {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+    'Helvetica Neue': {
+        ascent: number;
+        descent: number;
+        lineGap: number;
+        unitsPerEm: number;
+        xWidthAvg: number;
+    };
+};
+export declare const DEFAULT_FALLBACKS: {
+    readonly serif: ["Times New Roman"];
+    readonly 'sans-serif': ["Arial"];
+    readonly monospace: ["Courier New"];
+    readonly cursive: [];
+    readonly fantasy: [];
+    readonly 'system-ui': ["BlinkMacSystemFont", "Segoe UI", "Roboto", "Helvetica Neue", "Arial"];
+    readonly 'ui-serif': ["Times New Roman"];
+    readonly 'ui-sans-serif': ["Arial"];
+    readonly 'ui-monospace': ["Courier New"];
+    readonly 'ui-rounded': [];
+    readonly emoji: [];
+    readonly math: [];
+    readonly fangsong: [];
+};
 export declare const FONTS_TYPES_FILE = "fonts.d.ts";

package/dist/assets/fonts/constants.js

@@ -12,6 +12,57 @@ const RESOLVED_VIRTUAL_MODULE_ID = "\0" + VIRTUAL_MODULE_ID;
 const URL_PREFIX = "/_astro/fonts/";
 const CACHE_DIR = "./fonts/";
 const FONT_TYPES = ["woff2", "woff", "otf", "ttf", "eot"];
+const SYSTEM_METRICS = {
+  "Times New Roman": {
+    ascent: 1825,
+    descent: -443,
+    lineGap: 87,
+    unitsPerEm: 2048,
+    xWidthAvg: 832
+  },
+  Arial: {
+    ascent: 1854,
+    descent: -434,
+    lineGap: 67,
+    unitsPerEm: 2048,
+    xWidthAvg: 913
+  },
+  "Courier New": {
+    ascent: 1705,
+    descent: -615,
+    lineGap: 0,
+    unitsPerEm: 2048,
+    xWidthAvg: 1229
+  },
+  BlinkMacSystemFont: {
+    ascent: 1980,
+    descent: -432,
+    lineGap: 0,
+    unitsPerEm: 2048,
+    xWidthAvg: 853
+  },
+  "Segoe UI": {
+    ascent: 2210,
+    descent: -514,
+    lineGap: 0,
+    unitsPerEm: 2048,
+    xWidthAvg: 908
+  },
+  Roboto: {
+    ascent: 1900,
+    descent: -500,
+    lineGap: 0,
+    unitsPerEm: 2048,
+    xWidthAvg: 911
+  },
+  "Helvetica Neue": {
+    ascent: 952,
+    descent: -213,
+    lineGap: 28,
+    unitsPerEm: 1e3,
+    xWidthAvg: 450
+  }
+};
 const DEFAULT_FALLBACKS = {
   serif: ["Times New Roman"],
   "sans-serif": ["Arial"],
@@ -36,6 +87,7 @@ export {
   FONT_TYPES,
   LOCAL_PROVIDER_NAME,
   RESOLVED_VIRTUAL_MODULE_ID,
+  SYSTEM_METRICS,
   URL_PREFIX,
   VIRTUAL_MODULE_ID
 };

package/dist/assets/fonts/load.js

@@ -81,9 +81,11 @@ async function loadFonts({
         // Name has been set while extracting unifont providers from families (inside familiesToUnifontProviders)
         [family.provider.name]
       );
-      fonts = result.fonts.map((font) => ({
+      fonts = result.fonts.filter(
+        (font) => typeof font.meta?.priority === "number" ? font.meta.priority === 0 : true
+      ).map((font) => ({
         ...font,
-        src: font.src.map(
+        src: font.src.slice(0, 1).map(
           (source) => "name" in source ? source : {
             ...source,
             originalURL: source.url,

package/dist/assets/fonts/metrics.d.ts

@@ -1,10 +1,10 @@
 import { type Font } from '@capsizecss/unpack';
 export type FontFaceMetrics = Pick<Font, 'ascent' | 'descent' | 'lineGap' | 'unitsPerEm' | 'xWidthAvg'>;
-export declare function getMetricsForFamily(family: string): Promise<FontFaceMetrics | null>;
 export declare function readMetrics(family: string, buffer: Buffer): Promise<FontFaceMetrics>;
-export declare function generateFallbackFontFace(metrics: FontFaceMetrics, fallback: {
+export declare function generateFallbackFontFace({ metrics, fallbackMetrics, name: fallbackName, font: fallbackFontName, properties, }: {
+    metrics: FontFaceMetrics;
+    fallbackMetrics: FontFaceMetrics;
     name: string;
     font: string;
-    metrics?: FontFaceMetrics;
-    [key: string]: any;
+    properties?: Record<string, string | undefined>;
 }): string;

package/dist/assets/fonts/metrics.js

@@ -1,7 +1,5 @@
-import { fontFamilyToCamelCase } from "@capsizecss/metrics";
 import { fromBuffer } from "@capsizecss/unpack";
-const QUOTES_RE = /^["']|["']$/g;
-const withoutQuotes = (str) => str.trim().replace(QUOTES_RE, "");
+import { renderFontFace, renderFontSrc } from "./utils.js";
 const metricCache = {};
 function filterRequiredMetrics({
   ascent,
@@ -18,25 +16,6 @@ function filterRequiredMetrics({
     xWidthAvg
   };
 }
-async function getMetricsForFamily(family) {
-  family = withoutQuotes(family);
-  if (family in metricCache) return metricCache[family];
-  try {
-    const name = fontFamilyToCamelCase(family);
-    const { entireMetricsCollection } = await import("@capsizecss/metrics/entireMetricsCollection");
-    const metrics = entireMetricsCollection[name];
-    if (!("descent" in metrics)) {
-      metricCache[family] = null;
-      return null;
-    }
-    const filteredMetrics = filterRequiredMetrics(metrics);
-    metricCache[family] = filteredMetrics;
-    return filteredMetrics;
-  } catch {
-    metricCache[family] = null;
-    return null;
-  }
-}
 async function readMetrics(family, buffer) {
   const metrics = await fromBuffer(buffer);
   metricCache[family] = filterRequiredMetrics(metrics);
@@ -46,39 +25,31 @@ function toPercentage(value, fractionDigits = 4) {
   const percentage = value * 100;
   return `${+percentage.toFixed(fractionDigits)}%`;
 }
-function toCSS(properties, indent = 2) {
-  return Object.entries(properties).map(([key, value]) => `${" ".repeat(indent)}${key}: ${value};`).join("\n");
-}
-function generateFallbackFontFace(metrics, fallback) {
-  const {
-    name: fallbackName,
-    font: fallbackFontName,
-    metrics: fallbackMetrics,
-    ...properties
-  } = fallback;
+function generateFallbackFontFace({
+  metrics,
+  fallbackMetrics,
+  name: fallbackName,
+  font: fallbackFontName,
+  properties = {}
+}) {
   const preferredFontXAvgRatio = metrics.xWidthAvg / metrics.unitsPerEm;
-  const fallbackFontXAvgRatio = fallbackMetrics ? fallbackMetrics.xWidthAvg / fallbackMetrics.unitsPerEm : 1;
-  const sizeAdjust = fallbackMetrics && preferredFontXAvgRatio && fallbackFontXAvgRatio ? preferredFontXAvgRatio / fallbackFontXAvgRatio : 1;
+  const fallbackFontXAvgRatio = fallbackMetrics.xWidthAvg / fallbackMetrics.unitsPerEm;
+  const sizeAdjust = preferredFontXAvgRatio / fallbackFontXAvgRatio;
   const adjustedEmSquare = metrics.unitsPerEm * sizeAdjust;
   const ascentOverride = metrics.ascent / adjustedEmSquare;
   const descentOverride = Math.abs(metrics.descent) / adjustedEmSquare;
   const lineGapOverride = metrics.lineGap / adjustedEmSquare;
-  const declaration = {
-    "font-family": JSON.stringify(fallbackName),
-    src: `local(${JSON.stringify(fallbackFontName)})`,
+  return renderFontFace({
+    "font-family": fallbackName,
+    src: renderFontSrc([{ name: fallbackFontName }]),
     "size-adjust": toPercentage(sizeAdjust),
     "ascent-override": toPercentage(ascentOverride),
     "descent-override": toPercentage(descentOverride),
     "line-gap-override": toPercentage(lineGapOverride),
     ...properties
-  };
-  return `@font-face {
-${toCSS(declaration)}
-}
-`;
+  });
 }
 export {
   generateFallbackFontFace,
-  getMetricsForFamily,
   readMetrics
 };

package/dist/assets/fonts/utils.d.ts

@@ -4,13 +4,14 @@ import { DEFAULT_FALLBACKS } from './constants.js';
 import type { FontFaceMetrics, generateFallbackFontFace } from './metrics.js';
 import { type ResolveProviderOptions } from './providers/utils.js';
 import type { FontFamily, FontType, ResolvedFontFamily } from './types.js';
+export declare function toCSS(properties: Record<string, string | undefined>, indent?: number): string;
+export declare function renderFontFace(properties: Record<string, string | undefined>): string;
 export declare function generateFontFace(family: string, font: unifont.FontFaceData): string;
+export declare function renderFontSrc(sources: Exclude<unifont.FontFaceData['src'][number], string>[]): string;
+export declare function withoutQuotes(str: string): string;
 export declare function extractFontType(str: string): FontType;
 export declare function isFontType(str: string): str is FontType;
-export declare function cache(storage: Storage, key: string, cb: () => Promise<Buffer>): Promise<{
-    cached: boolean;
-    data: Buffer;
-}>;
+export declare function cache(storage: Storage, key: string, cb: () => Promise<Buffer>): Promise<Buffer>;
 export interface ProxyURLOptions {
     /**
      * The original URL
@@ -45,10 +46,10 @@ export declare function isGenericFontFamily(str: string): str is keyof typeof DE
 export type GetMetricsForFamilyFont = {
     hash: string;
     url: string;
-} | null;
+};
 export type GetMetricsForFamily = (name: string, 
 /** A remote url or local filepath to a font file. Used if metrics can't be resolved purely from the family name */
-font: GetMetricsForFamilyFont) => Promise<FontFaceMetrics | null>;
+font: GetMetricsForFamilyFont) => Promise<FontFaceMetrics>;
 /**
  * Generates CSS for a given family fallbacks if possible.
  *
@@ -60,7 +61,7 @@ export declare function generateFallbacksCSS({ family, fallbacks: _fallbacks, fo
     family: Pick<ResolvedFontFamily, 'name' | 'nameWithHash'>;
     /** The family fallbacks */
     fallbacks: Array<string>;
-    font: GetMetricsForFamilyFont;
+    font: GetMetricsForFamilyFont | null;
     metrics: {
         getMetricsForFamily: GetMetricsForFamily;
         generateFontFace: typeof generateFallbackFontFace;

package/dist/assets/fonts/utils.js

@@ -2,30 +2,38 @@ import { createRequire } from "node:module";
 import { extname } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { AstroError, AstroErrorData } from "../../core/errors/index.js";
-import { DEFAULT_FALLBACKS, FONT_TYPES, LOCAL_PROVIDER_NAME } from "./constants.js";
+import { DEFAULT_FALLBACKS, FONT_TYPES, LOCAL_PROVIDER_NAME, SYSTEM_METRICS } from "./constants.js";
 import { resolveProvider } from "./providers/utils.js";
+function toCSS(properties, indent = 2) {
+  return Object.entries(properties).filter(([, value]) => Boolean(value)).map(([key, value]) => `${" ".repeat(indent)}${key}: ${value};`).join("\n");
+}
+function renderFontFace(properties) {
+  return `@font-face {
+	${toCSS(properties)}
+}
+`;
+}
 function generateFontFace(family, font) {
-  return [
-    "@font-face {",
-    `  font-family: ${family};`,
-    `  src: ${renderFontSrc(font.src)};`,
-    `  font-display: ${font.display ?? "swap"};`,
-    font.unicodeRange && `  unicode-range: ${font.unicodeRange};`,
-    font.weight && `  font-weight: ${Array.isArray(font.weight) ? font.weight.join(" ") : font.weight};`,
-    font.style && `  font-style: ${font.style};`,
-    font.stretch && `  font-stretch: ${font.stretch};`,
-    font.featureSettings && `  font-feature-settings: ${font.featureSettings};`,
-    font.variationSettings && `  font-variation-settings: ${font.variationSettings};`,
-    `}`
-  ].filter(Boolean).join("\n");
+  return renderFontFace({
+    "font-family": family,
+    src: renderFontSrc(font.src),
+    "font-display": font.display ?? "swap",
+    "unicode-range": font.unicodeRange?.join(","),
+    "font-weight": Array.isArray(font.weight) ? font.weight.join(" ") : font.weight?.toString(),
+    "font-style": font.style,
+    "font-stretch": font.stretch,
+    "font-feature-settings": font.featureSettings,
+    "font-variation-settings": font.variationSettings
+  });
 }
 function renderFontSrc(sources) {
   return sources.map((src) => {
     if ("url" in src) {
       let rendered = `url("${src.url}")`;
       for (const key of ["format", "tech"]) {
-        if (key in src) {
-          rendered += ` ${key}(${src[key]})`;
+        const value = src[key];
+        if (value) {
+          rendered += ` ${key}(${value})`;
         }
       }
       return rendered;
@@ -33,6 +41,10 @@ function renderFontSrc(sources) {
     return `local("${src.name}")`;
   }).join(", ");
 }
+const QUOTES_RE = /^["']|["']$/g;
+function withoutQuotes(str) {
+  return str.trim().replace(QUOTES_RE, "");
+}
 function extractFontType(str) {
   const extension = extname(str).slice(1);
   if (!isFontType(extension)) {
@@ -54,11 +66,11 @@ function isFontType(str) {
 async function cache(storage, key, cb) {
   const existing = await storage.getItemRaw(key);
   if (existing) {
-    return { cached: true, data: existing };
+    return existing;
   }
   const data = await cb();
   await storage.setItemRaw(key, data);
-  return { cached: false, data };
+  return data;
 }
 function proxyURL({ value, hashString, collect }) {
   const type = extractFontType(value);
@@ -80,7 +92,7 @@ async function generateFallbacksCSS({
     return null;
   }
   let css = "";
-  if (!metrics) {
+  if (!fontData || !metrics) {
     return { css, fallbacks };
   }
   const lastFallback = fallbacks[fallbacks.length - 1];
@@ -101,7 +113,13 @@ async function generateFallbacksCSS({
   }));
   fallbacks = [.../* @__PURE__ */ new Set([...localFontsMappings.map((m) => m.name), ...fallbacks])];
   for (const { font, name } of localFontsMappings) {
-    css += metrics.generateFontFace(foundMetrics, { font, name });
+    css += metrics.generateFontFace({
+      metrics: foundMetrics,
+      fallbackMetrics: SYSTEM_METRICS[font],
+      font,
+      name
+      // TODO: forward some properties once we generate one fallback per font face data
+    });
   }
   return { css, fallbacks };
 }
@@ -209,7 +227,11 @@ export {
   isFontType,
   isGenericFontFamily,
   proxyURL,
+  renderFontFace,
+  renderFontSrc,
   resolveEntrypoint,
   resolveFontFamily,
-  sortObjectByKey
+  sortObjectByKey,
+  toCSS,
+  withoutQuotes
 };

package/dist/assets/fonts/vite-plugin-fonts.js

@@ -17,8 +17,14 @@ import {
   VIRTUAL_MODULE_ID
 } from "./constants.js";
 import { loadFonts } from "./load.js";
-import { generateFallbackFontFace, getMetricsForFamily, readMetrics } from "./metrics.js";
-import { cache, extractFontType, resolveFontFamily, sortObjectByKey } from "./utils.js";
+import { generateFallbackFontFace, readMetrics } from "./metrics.js";
+import {
+  cache,
+  extractFontType,
+  resolveFontFamily,
+  sortObjectByKey,
+  withoutQuotes
+} from "./utils.js";
 async function fetchFont(url) {
   try {
     if (isAbsolute(url)) {
@@ -81,7 +87,7 @@ function fontsPlugin({ settings, sync, logger }) {
           family,
           root: settings.config.root,
           resolveMod,
-          generateNameWithHash: (_family) => `${_family.name}-${h64ToString(JSON.stringify(sortObjectByKey(_family)))}`
+          generateNameWithHash: (_family) => `${withoutQuotes(_family.name)}-${h64ToString(JSON.stringify(sortObjectByKey(_family)))}`
         })
       );
     }
@@ -94,12 +100,7 @@ function fontsPlugin({ settings, sync, logger }) {
       hashString: h64ToString,
       generateFallbackFontFace,
       getMetricsForFamily: async (name, font) => {
-        let metrics = await getMetricsForFamily(name);
-        if (font && !metrics) {
-          const { data } = await cache(storage, font.hash, () => fetchFont(font.url));
-          metrics = await readMetrics(name, data);
-        }
-        return metrics;
+        return await readMetrics(name, await cache(storage, font.hash, () => fetchFont(font.url)));
       },
       log: (message) => logger.info("assets", message)
     });
@@ -151,7 +152,7 @@ function fontsPlugin({ settings, sync, logger }) {
         res.setHeader("Pragma", "no-cache");
         res.setHeader("Expires", 0);
         try {
-          const { data } = await cache(storage, hash, () => fetchFont(url));
+          const data = await cache(storage, hash, () => fetchFont(url));
           res.setHeader("Content-Length", data.length);
           res.setHeader("Content-Type", `font/${extractFontType(hash)}`);
           res.end(data);
@@ -173,8 +174,8 @@ function fontsPlugin({ settings, sync, logger }) {
         return RESOLVED_VIRTUAL_MODULE_ID;
       }
     },
-    load(id, opts) {
-      if (id === RESOLVED_VIRTUAL_MODULE_ID && opts?.ssr) {
+    load(id) {
+      if (id === RESOLVED_VIRTUAL_MODULE_ID) {
         return {
           code: `export const fontsData = new Map(${JSON.stringify(Array.from(resolvedMap?.entries() ?? []))})`
         };
@@ -197,7 +198,7 @@ function fontsPlugin({ settings, sync, logger }) {
           logger.info("assets", "Copying fonts...");
           await Promise.all(
             Array.from(hashToUrlMap.entries()).map(async ([hash, url]) => {
-              const { data } = await cache(storage, hash, () => fetchFont(url));
+              const data = await cache(storage, hash, () => fetchFont(url));
               try {
                 writeFileSync(new URL(hash, fontsDir), data);
               } catch (cause) {

package/dist/config/entrypoint.d.ts

@@ -5,7 +5,7 @@ export { envField } from '../env/config.js';
 export { mergeConfig } from '../core/config/merge.js';
 export { validateConfig } from '../core/config/validate.js';
 export { fontProviders, defineAstroFontProvider } from '../assets/fonts/providers/index.js';
-export type { AstroFontProvider as FontProvider } from '../assets/fonts/types.js';
+export type { AstroFontProvider } from '../assets/fonts/types.js';
 /**
  * Return the configuration needed to use the Sharp-based image service
  */

package/dist/content/content-layer.js

@@ -153,7 +153,7 @@ ${contentConfig.error.message}`);
       logger.info("Content config changed");
       shouldClear = true;
     }
-    if (previousAstroVersion && previousAstroVersion !== "5.7.0") {
+    if (previousAstroVersion && previousAstroVersion !== "5.7.2") {
       logger.info("Astro version changed");
       shouldClear = true;
     }
@@ -161,8 +161,8 @@ ${contentConfig.error.message}`);
       logger.info("Clearing content store");
       this.#store.clearAll();
     }
-    if ("5.7.0") {
-      await this.#store.metaStore().set("astro-version", "5.7.0");
+    if ("5.7.2") {
+      await this.#store.metaStore().set("astro-version", "5.7.2");
     }
     if (currentConfigDigest) {
       await this.#store.metaStore().set("content-config-digest", currentConfigDigest);

package/dist/core/constants.js

@@ -1,4 +1,4 @@
-const ASTRO_VERSION = "5.7.0";
+const ASTRO_VERSION = "5.7.2";
 const REROUTE_DIRECTIVE_HEADER = "X-Astro-Reroute";
 const REWRITE_DIRECTIVE_HEADER_KEY = "X-Astro-Rewrite";
 const REWRITE_DIRECTIVE_HEADER_VALUE = "yes";

package/dist/core/dev/dev.js

@@ -22,7 +22,7 @@ async function dev(inlineConfig) {
   await telemetry.record([]);
   const restart = await createContainerWithAutomaticRestart({ inlineConfig, fs });
   const logger = restart.container.logger;
-  const currentVersion = "5.7.0";
+  const currentVersion = "5.7.2";
   const isPrerelease = currentVersion.includes("-");
   if (!isPrerelease) {
     try {

package/dist/core/messages.js

@@ -38,7 +38,7 @@ function serverStart({
   host,
   base
 }) {
-  const version = "5.7.0";
+  const version = "5.7.2";
   const localPrefix = `${dim("\u2503")} Local    `;
   const networkPrefix = `${dim("\u2503")} Network  `;
   const emptyPrefix = " ".repeat(11);
@@ -282,7 +282,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"5.7.0"}`
+        `v${"5.7.2"}`
       )} ${headline}`
     );
   }

package/dist/core/routing/manifest/create.js

@@ -236,10 +236,8 @@ function createRedirectRoutes({ settings }, routeMap) {
     } else {
       destination = to.destination;
     }
-    if (!destination.startsWith("/")) {
-      if (!/^https?:\/\//.test(destination) && !URL.canParse(destination)) {
-        throw new AstroError(UnsupportedExternalRedirect);
-      }
+    if (URL.canParse(destination) && !/^https?:\/\//.test(destination)) {
+      throw new AstroError(UnsupportedExternalRedirect);
     }
     routes.push({
       type: "redirect",

package/dist/core/routing/rewrite.js

@@ -39,7 +39,7 @@ function findRouteToRewrite({
   if (!pathname.startsWith("/") && shouldAppendSlash && newUrl.pathname.endsWith("/")) {
     pathname = prependForwardSlash(pathname);
   }
-  if (pathname === "/" && !shouldAppendSlash) {
+  if (pathname === "/" && base !== "/" && !shouldAppendSlash) {
     pathname = "";
   }
   if (base !== "/" && (pathname === "" || pathname === "/") && !shouldAppendSlash) {

package/dist/core/session.d.ts

@@ -7,7 +7,7 @@ export declare class AstroSession<TDriver extends SessionDriverName = any> {
     /**
      * Gets a session value. Returns `undefined` if the session or value does not exist.
      */
-    get<T = void, K extends string = string>(key: K): Promise<(T extends void ? (K extends keyof App.SessionData ? App.SessionData[K] : any) : T) | undefined>;
+    get<T = void, K extends string = keyof App.SessionData | (string & {})>(key: K): Promise<(T extends void ? (K extends keyof App.SessionData ? App.SessionData[K] : any) : T) | undefined>;
     /**
      * Checks if a session value exists.
      */
@@ -31,7 +31,7 @@ export declare class AstroSession<TDriver extends SessionDriverName = any> {
     /**
      * Sets a session value. The session is created if it does not exist.
      */
-    set<T = void, K extends string = string>(key: K, value: T extends void ? K extends keyof App.SessionData ? App.SessionData[K] : any : NoInfer<T>, { ttl }?: {
+    set<T = void, K extends string = keyof App.SessionData | (string & {})>(key: K, value: T extends void ? K extends keyof App.SessionData ? App.SessionData[K] : any : NoInfer<T>, { ttl }?: {
         ttl?: number;
     }): void;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "5.7.0",
+  "version": "5.7.2",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -105,7 +105,6 @@
   ],
   "dependencies": {
     "@astrojs/compiler": "^2.11.0",
-    "@capsizecss/metrics": "^3.5.0",
     "@capsizecss/unpack": "^2.4.0",
     "@oslojs/encoding": "^1.1.0",
     "@rollup/pluginutils": "^5.1.4",
@@ -149,7 +148,7 @@
     "tinyglobby": "^0.2.12",
     "tsconfck": "^3.1.5",
     "ultrahtml": "^1.6.0",
-    "unifont": "^0.1.7",
+    "unifont": "~0.2.0",
     "unist-util-visit": "^5.0.0",
     "unstorage": "^1.15.0",
     "vfile": "^6.0.3",
@@ -162,8 +161,8 @@
     "zod-to-json-schema": "^3.24.5",
     "zod-to-ts": "^1.2.0",
     "@astrojs/internal-helpers": "0.6.1",
-    "@astrojs/markdown-remark": "6.3.1",
-    "@astrojs/telemetry": "3.2.0"
+    "@astrojs/telemetry": "3.2.0",
+    "@astrojs/markdown-remark": "6.3.1"
   },
   "optionalDependencies": {
     "sharp": "^0.33.3"