astro 5.13.10 → 5.13.11

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

@@ -86,4 +86,12 @@ export interface FontFileReader {
         style: Style;
     };
 }
+export interface UrlProxyHashResolver {
+    resolve: (input: {
+        originalUrl: string;
+        type: FontType;
+        cssVariable: string;
+        data: Partial<unifont.FontFaceData>;
+    }) => string;
+}
 export {};

package/dist/assets/fonts/implementations/data-collector.d.ts

@@ -1,3 +1,3 @@
 import type { DataCollector } from '../definitions.js';
 import type { CreateUrlProxyParams } from '../types.js';
-export declare function createDataCollector({ hasUrl, saveUrl, savePreload, saveFontData, }: Omit<CreateUrlProxyParams, 'local'>): DataCollector;
+export declare function createDataCollector({ hasUrl, saveUrl, savePreload, saveFontData, }: Pick<CreateUrlProxyParams, 'hasUrl' | 'saveUrl' | 'savePreload' | 'saveFontData'>): DataCollector;

package/dist/assets/fonts/implementations/url-proxy-hash-resolver.d.ts

@@ -0,0 +1,8 @@
+import type { Hasher, UrlProxyContentResolver, UrlProxyHashResolver } from '../definitions.js';
+export declare function createBuildUrlProxyHashResolver({ hasher, contentResolver, }: {
+    hasher: Hasher;
+    contentResolver: UrlProxyContentResolver;
+}): UrlProxyHashResolver;
+export declare function createDevUrlProxyHashResolver({ baseHashResolver, }: {
+    baseHashResolver: UrlProxyHashResolver;
+}): UrlProxyHashResolver;

package/dist/assets/fonts/implementations/url-proxy-hash-resolver.js

@@ -0,0 +1,24 @@
+function createBuildUrlProxyHashResolver({
+  hasher,
+  contentResolver
+}) {
+  return {
+    resolve({ originalUrl, type }) {
+      return `${hasher.hashString(contentResolver.resolve(originalUrl))}.${type}`;
+    }
+  };
+}
+function createDevUrlProxyHashResolver({
+  baseHashResolver
+}) {
+  return {
+    resolve(input) {
+      const { cssVariable, data } = input;
+      return [cssVariable.slice(2), data.weight, data.style, baseHashResolver.resolve(input)].filter(Boolean).join("-");
+    }
+  };
+}
+export {
+  createBuildUrlProxyHashResolver,
+  createDevUrlProxyHashResolver
+};

package/dist/assets/fonts/implementations/url-proxy.d.ts

@@ -1,7 +1,7 @@
-import type { DataCollector, Hasher, UrlProxy, UrlProxyContentResolver, UrlResolver } from '../definitions.js';
-export declare function createUrlProxy({ contentResolver, hasher, dataCollector, urlResolver, }: {
-    contentResolver: UrlProxyContentResolver;
-    hasher: Hasher;
+import type { DataCollector, UrlProxy, UrlProxyHashResolver, UrlResolver } from '../definitions.js';
+export declare function createUrlProxy({ hashResolver, dataCollector, urlResolver, cssVariable, }: {
+    hashResolver: UrlProxyHashResolver;
     dataCollector: DataCollector;
     urlResolver: UrlResolver;
+    cssVariable: string;
 }): UrlProxy;

package/dist/assets/fonts/implementations/url-proxy.js

@@ -1,12 +1,12 @@
 function createUrlProxy({
-  contentResolver,
-  hasher,
+  hashResolver,
   dataCollector,
-  urlResolver
+  urlResolver,
+  cssVariable
 }) {
   return {
     proxy({ url: originalUrl, type, data, collectPreload, init }) {
-      const hash = `${hasher.hashString(contentResolver.resolve(originalUrl))}.${type}`;
+      const hash = hashResolver.resolve({ cssVariable, data, originalUrl, type });
       const url = urlResolver.resolve(hash);
       dataCollector.collect({
         url: originalUrl,

package/dist/assets/fonts/orchestrate.js

@@ -59,7 +59,8 @@ async function orchestrate({
         !collectedFonts.some((f) => JSON.stringify(f.data) === JSON.stringify(collected.data))) {
           collectedFonts.push(collected);
         }
-      }
+      },
+      cssVariable: family.cssVariable
     });
     let fonts;
     if (family.provider === LOCAL_PROVIDER_NAME) {

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

@@ -59,6 +59,7 @@ export interface CreateUrlProxyParams {
     saveUrl: (input: FontFileData) => void;
     savePreload: (preload: PreloadData) => void;
     saveFontData: (collected: CollectedFontForMetrics) => void;
+    cssVariable: string;
 }
 /**
  * Holds associations of hash and original font file URLs, so they can be

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

@@ -37,6 +37,10 @@ import {
   createLocalUrlProxyContentResolver,
   createRemoteUrlProxyContentResolver
 } from "./implementations/url-proxy-content-resolver.js";
+import {
+  createBuildUrlProxyHashResolver,
+  createDevUrlProxyHashResolver
+} from "./implementations/url-proxy-hash-resolver.js";
 import { createBuildUrlResolver, createDevUrlResolver } from "./implementations/url-resolver.js";
 import { orchestrate } from "./orchestrate.js";
 function fontsPlugin({ settings, sync, logger }) {
@@ -75,7 +79,8 @@ function fontsPlugin({ settings, sync, logger }) {
     cacheDir,
     modResolver,
     cssRenderer,
-    urlResolver
+    urlResolver,
+    createHashResolver
   }) {
     const { root } = settings.config;
     const hasher = await createXxHasher();
@@ -119,14 +124,14 @@ function fontsPlugin({ settings, sync, logger }) {
       fontTypeExtractor,
       fontFileReader,
       logger,
-      createUrlProxy: ({ local, ...params }) => {
+      createUrlProxy: ({ local, cssVariable, ...params }) => {
         const dataCollector = createDataCollector(params);
         const contentResolver = local ? createLocalUrlProxyContentResolver({ errorHandler }) : createRemoteUrlProxyContentResolver();
         return createUrlProxy({
           urlResolver,
-          contentResolver,
-          hasher,
-          dataCollector
+          hashResolver: createHashResolver({ hasher, contentResolver }),
+          dataCollector,
+          cssVariable
         });
       },
       defaults: DEFAULTS
@@ -158,7 +163,8 @@ function fontsPlugin({ settings, sync, logger }) {
           urlResolver: createBuildUrlResolver({
             base: baseUrl,
             assetsPrefix: settings.config.build.assetsPrefix
-          })
+          }),
+          createHashResolver: (dependencies) => createBuildUrlProxyHashResolver(dependencies)
         });
       }
     },
@@ -168,7 +174,10 @@ function fontsPlugin({ settings, sync, logger }) {
         cacheDir: new URL(CACHE_DIR, settings.dotAstroDir),
         modResolver: createDevServerRemoteFontProviderModResolver({ server }),
         cssRenderer: createMinifiableCssRenderer({ minify: false }),
-        urlResolver: createDevUrlResolver({ base: baseUrl })
+        urlResolver: createDevUrlResolver({ base: baseUrl }),
+        createHashResolver: (dependencies) => createDevUrlProxyHashResolver({
+          baseHashResolver: createBuildUrlProxyHashResolver(dependencies)
+        })
       });
       const localPaths = [...fontFileDataMap.values()].filter(({ url }) => isAbsolute(url)).map((v) => v.url);
       server.watcher.on("change", (path) => {

package/dist/assets/services/sharp.js

@@ -89,8 +89,9 @@ const sharpService = {
       }
     }
     const { data, info } = await result.toBuffer({ resolveWithObject: true });
+    const needsCopy = "buffer" in data && data.buffer instanceof SharedArrayBuffer;
     return {
-      data,
+      data: needsCopy ? new Uint8Array(data) : data,
       format: info.format
     };
   }

package/dist/cli/info/index.js

@@ -258,8 +258,7 @@ async function getVersion(packageManager, dependency) {
         return void 0;
     }
     return void 0;
-  } catch (err) {
-    console.error(err);
+  } catch {
     return void 0;
   }
 }

package/dist/cli/preview/index.d.ts

@@ -2,5 +2,5 @@ import { type Flags } from '../flags.js';
 interface PreviewOptions {
     flags: Flags;
 }
-export declare function preview({ flags }: PreviewOptions): Promise<import("../../types/public/preview.js").PreviewServer | undefined>;
+export declare function preview({ flags }: PreviewOptions): Promise<import("../../index.js").PreviewServer | undefined>;
 export {};

package/dist/container/index.d.ts

@@ -82,7 +82,6 @@ export type ContainerRenderOptions = {
 };
 export type AddServerRenderer = {
     renderer: NamedSSRLoadedRendererValue;
-    name: never;
 } | {
     renderer: SSRLoadedRendererValue;
     name: string;

package/dist/container/index.js

@@ -129,7 +129,7 @@ class experimental_AstroContainer {
    * @param options.renderer The server renderer exported by integration.
    */
   addServerRenderer(options) {
-    const { renderer, name } = options;
+    const { renderer } = options;
     if (!renderer.check || !renderer.renderToStaticMarkup) {
       throw new Error(
         "The renderer you passed isn't valid. A renderer is usually an object that exposes the `check` and `renderToStaticMarkup` functions.\nUsually, the renderer is exported by a /server.js entrypoint e.g. `import renderer from '@astrojs/react/server.js'`"
@@ -140,11 +140,15 @@ class experimental_AstroContainer {
         name: renderer.name,
         ssr: renderer
       });
-    } else {
+    } else if ("name" in options) {
       this.#pipeline.manifest.renderers.push({
-        name,
+        name: options.name,
         ssr: renderer
       });
+    } else {
+      throw new Error(
+        "The renderer name must be provided when adding a server renderer that is not a named renderer."
+      );
     }
   }
   /**

package/dist/content/content-layer.js

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

package/dist/core/app/node.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import { Http2ServerResponse } from "node:http2";
-import { clientAddressSymbol } from "../constants.js";
+import { clientAddressSymbol, nodeRequestAbortControllerCleanupSymbol } from "../constants.js";
 import { deserializeManifest } from "./common.js";
 import { createOutgoingHttpHeaders } from "./createOutgoingHttpHeaders.js";
 import { App } from "./index.js";
@@ -38,6 +38,7 @@ class NodeApp extends App {
    * ```
    */
   static createRequest(req, { skipBody = false } = {}) {
+    const controller = new AbortController();
     const isEncrypted = "encrypted" in req.socket && req.socket.encrypted;
     const getFirstForwardedValue = (multiValueHeader) => {
       return multiValueHeader?.toString()?.split(",").map((e) => e.trim())?.[0];
@@ -59,13 +60,48 @@ class NodeApp extends App {
     }
     const options = {
       method: req.method || "GET",
-      headers: makeRequestHeaders(req)
+      headers: makeRequestHeaders(req),
+      signal: controller.signal
     };
     const bodyAllowed = options.method !== "HEAD" && options.method !== "GET" && skipBody === false;
     if (bodyAllowed) {
       Object.assign(options, makeRequestBody(req));
     }
     const request = new Request(url, options);
+    const socket = getRequestSocket(req);
+    if (socket && typeof socket.on === "function") {
+      const existingCleanup = getAbortControllerCleanup(req);
+      if (existingCleanup) {
+        existingCleanup();
+      }
+      let cleanedUp = false;
+      const removeSocketListener = () => {
+        if (typeof socket.off === "function") {
+          socket.off("close", onSocketClose);
+        } else if (typeof socket.removeListener === "function") {
+          socket.removeListener("close", onSocketClose);
+        }
+      };
+      const cleanup = () => {
+        if (cleanedUp) return;
+        cleanedUp = true;
+        removeSocketListener();
+        controller.signal.removeEventListener("abort", cleanup);
+        Reflect.deleteProperty(req, nodeRequestAbortControllerCleanupSymbol);
+      };
+      const onSocketClose = () => {
+        cleanup();
+        if (!controller.signal.aborted) {
+          controller.abort();
+        }
+      };
+      socket.on("close", onSocketClose);
+      controller.signal.addEventListener("abort", cleanup, { once: true });
+      Reflect.set(req, nodeRequestAbortControllerCleanupSymbol, cleanup);
+      if (socket.destroyed) {
+        onSocketClose();
+      }
+    }
     const forwardedClientIp = getFirstForwardedValue(req.headers["x-forwarded-for"]);
     const clientIp = forwardedClientIp || req.socket?.remoteAddress;
     if (clientIp) {
@@ -94,6 +130,23 @@ class NodeApp extends App {
       destination.statusMessage = statusText;
     }
     destination.writeHead(status, createOutgoingHttpHeaders(headers));
+    const cleanupAbortFromDestination = getAbortControllerCleanup(
+      destination.req ?? void 0
+    );
+    if (cleanupAbortFromDestination) {
+      const runCleanup = () => {
+        cleanupAbortFromDestination();
+        if (typeof destination.off === "function") {
+          destination.off("finish", runCleanup);
+          destination.off("close", runCleanup);
+        } else {
+          destination.removeListener?.("finish", runCleanup);
+          destination.removeListener?.("close", runCleanup);
+        }
+      };
+      destination.on("finish", runCleanup);
+      destination.on("close", runCleanup);
+    }
     if (!body) return destination.end();
     try {
       const reader = body.getReader();
@@ -165,6 +218,21 @@ function asyncIterableToBodyProps(iterable) {
     duplex: "half"
   };
 }
+function getAbortControllerCleanup(req) {
+  if (!req) return void 0;
+  const cleanup = Reflect.get(req, nodeRequestAbortControllerCleanupSymbol);
+  return typeof cleanup === "function" ? cleanup : void 0;
+}
+function getRequestSocket(req) {
+  if (req.socket && typeof req.socket.on === "function") {
+    return req.socket;
+  }
+  const http2Socket = req.stream?.session?.socket;
+  if (http2Socket && typeof http2Socket.on === "function") {
+    return http2Socket;
+  }
+  return void 0;
+}
 async function loadManifest(rootFolder) {
   const manifestFile = new URL("./manifest.json", rootFolder);
   const rawManifest = await fs.promises.readFile(manifestFile, "utf-8");

package/dist/core/build/pipeline.d.ts

@@ -14,7 +14,7 @@ export declare class BuildPipeline extends Pipeline {
     readonly internals: BuildInternals;
     readonly manifest: SSRManifest;
     readonly options: StaticBuildOptions;
-    readonly config: import("../../types/public/config.js").AstroConfig;
+    readonly config: import("../../index.js").AstroConfig;
     readonly settings: AstroSettings;
     readonly defaultRoutes: {
         instance: ComponentInstance;