astro 7.0.9 → 7.1.0

package/dist/core/logger/impls/json.d.ts

@@ -1,4 +1,4 @@
-import { AstroLogger, type AstroLoggerDestination, type AstroLoggerLevel, type AstroLoggerMessage } from '../core.js';
+import { AstroLogger, type AstroLoggerDestination, type AstroLoggerLevel } from '../core.js';
 import type { AstroInlineConfig } from '../../../types/public/index.js';
 export type JsonHandlerConfig = {
     /**
@@ -11,5 +11,5 @@ export type JsonHandlerConfig = {
     level?: AstroLoggerLevel;
 };
 export declare const SGR_REGEX: RegExp;
-export default function jsonLoggerDestination(config?: JsonHandlerConfig): AstroLoggerDestination<AstroLoggerMessage>;
+export default function jsonLoggerDestination(config?: JsonHandlerConfig): AstroLoggerDestination;
 export declare function createJsonLoggerFromFlags(config: AstroInlineConfig): AstroLogger;

package/dist/core/logger/impls/json.js

@@ -8,24 +8,13 @@ function jsonLoggerDestination(config = {}) {
   const { pretty = false, level = "info" } = config;
   return {
     write(event) {
-      let dest = process.stderr;
-      if (levels[event.level] < levels["error"]) {
-        dest = process.stdout;
-      }
       if (!matchesLevel(event.level, level)) {
         return;
       }
-      let trailingLine = event.newLine ? "\n" : "";
+      const dest = levels[event.level] >= levels["error"] ? console.error : console.info;
       const message = event.message.replace(SGR_REGEX, "");
-      if (pretty) {
-        dest.write(
-          JSON.stringify({ message, label: event.label, level: event.level }, null, 2) + trailingLine
-        );
-      } else {
-        dest.write(
-          JSON.stringify({ message, label: event.label, level: event.level }) + trailingLine
-        );
-      }
+      const payload = pretty ? JSON.stringify({ message, label: event.label, level: event.level }, null, 2) : JSON.stringify({ message, label: event.label, level: event.level });
+      dest(payload);
     }
   };
 }

package/dist/core/logger/impls/node.d.ts

@@ -1,7 +1,7 @@
-import { AstroLogger, type AstroLoggerDestination, type AstroLoggerLevel, type AstroLoggerMessage } from '../core.js';
+import { AstroLogger, type AstroLoggerDestination, type AstroLoggerLevel } from '../core.js';
 import type { AstroInlineConfig } from '../../../types/public/index.js';
 export type NodeHandlerConfig = {
     level?: AstroLoggerLevel;
 };
-export default function (options?: NodeHandlerConfig): AstroLoggerDestination<AstroLoggerMessage>;
+export default function (options?: NodeHandlerConfig): AstroLoggerDestination;
 export declare function createNodeLoggerFromFlags(inlineConfig: AstroInlineConfig): AstroLogger;

package/dist/core/logger/load.d.ts

@@ -1,7 +1,7 @@
-import { AstroLogger, type AstroLoggerLevel } from './core.js';
+import { AstroLogger, type AstroLoggerDestination } from './core.js';
 import type { LoggerHandlerConfig } from './config.js';
 import type { AstroConfig, AstroInlineConfig } from '../../types/public/index.js';
-export declare function loadLogger(config: LoggerHandlerConfig, level?: AstroLoggerLevel): Promise<AstroLogger>;
+export declare function loadLoggerDestination(config: LoggerHandlerConfig): Promise<AstroLoggerDestination>;
 /**
  * It attempts to load a logger from the entrypoint.
  * If not provided, it creates a new logger instance on the fly.

package/dist/core/logger/load.js

@@ -5,27 +5,22 @@ import { default as nodeLoggerCreator, createNodeLoggerFromFlags } from "./impls
 import { default as consoleLoggerCreator } from "./impls/console.js";
 import { default as jsonLoggerCreator } from "./impls/json.js";
 import { default as composeLoggerCreator } from "./impls/compose.js";
-async function loadLogger(config, level = "info") {
+function normalizeEntrypoint(entrypoint) {
+  return entrypoint instanceof URL ? entrypoint.href : entrypoint;
+}
+async function loadLoggerDestination(config) {
   let cause = void 0;
+  const entrypoint = normalizeEntrypoint(config.entrypoint);
   try {
     switch (config.entrypoint) {
       case "astro/logger/node": {
-        return new AstroLogger({
-          destination: nodeLoggerCreator(config.config),
-          level
-        });
+        return nodeLoggerCreator(config.config);
       }
       case "astro/logger/console": {
-        return new AstroLogger({
-          destination: consoleLoggerCreator(config.config),
-          level
-        });
+        return consoleLoggerCreator(config.config);
       }
       case "astro/logger/json": {
-        return new AstroLogger({
-          destination: jsonLoggerCreator(config.config),
-          level
-        });
+        return jsonLoggerCreator(config.config);
       }
       case "astro/logger/compose": {
         let destinations = [];
@@ -35,26 +30,20 @@ async function loadLogger(config, level = "info") {
             loggers.map(async (loggerConfig) => {
               const logger = await import(
                 /* @vite-ignore */
-                loggerConfig.entrypoint
+                normalizeEntrypoint(loggerConfig.entrypoint)
               );
               return logger.default(loggerConfig.config);
             })
           );
         }
-        return new AstroLogger({
-          destination: composeLoggerCreator(destinations),
-          level
-        });
+        return composeLoggerCreator(destinations);
       }
       default: {
-        const nodeLogger = await import(
+        const logger = await import(
           /* @vite-ignore */
-          config.entrypoint
+          entrypoint
         );
-        return new AstroLogger({
-          destination: nodeLogger.default(config.config),
-          level
-        });
+        return logger.default(config.config);
       }
     }
   } catch (e) {
@@ -64,7 +53,7 @@ async function loadLogger(config, level = "info") {
   }
   const error = new AstroError({
     ...UnableToLoadLogger,
-    message: UnableToLoadLogger.message(config.entrypoint)
+    message: UnableToLoadLogger.message(entrypoint)
   });
   if (cause) {
     error.cause = cause;
@@ -75,7 +64,10 @@ async function loadOrCreateNodeLogger(astroConfig, inlineAstroConfig) {
   if (inlineAstroConfig._logger) return inlineAstroConfig._logger;
   try {
     if (astroConfig.logger) {
-      return await loadLogger(astroConfig.logger, inlineAstroConfig.logLevel);
+      return new AstroLogger({
+        destination: await loadLoggerDestination(astroConfig.logger),
+        level: inlineAstroConfig.logLevel ?? "info"
+      });
     } else {
       return createNodeLoggerFromFlags(inlineAstroConfig);
     }
@@ -84,6 +76,6 @@ async function loadOrCreateNodeLogger(astroConfig, inlineAstroConfig) {
   }
 }
 export {
-  loadLogger,
+  loadLoggerDestination,
   loadOrCreateNodeLogger
 };

package/dist/core/messages/runtime.d.ts

@@ -58,3 +58,11 @@ export declare function printHelp({ commandName, headline, usage, tables, descri
     description?: string;
 }): void;
 export declare function warnIfCspWithShiki(config: AstroConfig, logger: AstroLogger): void;
+/**
+ * Warns when a `scriptDirective`/`styleDirective` defines `default`-kind resources alongside
+ * `element`/`attribute`-kind entries. Because the more specific directive (`*-src-elem`/`*-src-attr`)
+ * overrides the generic one for its scope and browsers do not fall back, the generic resources will
+ * not apply there. Astro's generated hashes are folded automatically, so this only concerns
+ * user-provided resources.
+ */
+export declare function warnIfCspResourceFallbackShadowing(config: AstroConfig, logger: AstroLogger): void;

package/dist/core/messages/runtime.js

@@ -1,4 +1,5 @@
 import colors from "piccolore";
+import { partitionByKind } from "../csp/runtime.js";
 import { getDocsForError, renderErrorMarkdown } from "../errors/dev/runtime.js";
 import {
   AstroError,
@@ -269,7 +270,7 @@ function printHelp({
     message.push(
       linebreak(),
       `  ${bgGreen(black(` ${commandName} `))} ${green(
-        `v${"7.0.9"}`
+        `v${"7.1.0"}`
       )} ${headline}`
     );
   }
@@ -304,6 +305,37 @@ function warnIfCspWithShiki(config, logger) {
     );
   }
 }
+function warnIfCspResourceFallbackShadowing(config, logger) {
+  const csp = config.security.csp;
+  if (typeof csp !== "object") return;
+  const families = [
+    { name: "script", directive: csp.scriptDirective },
+    { name: "style", directive: csp.styleDirective }
+  ];
+  for (const { name, directive } of families) {
+    const sources = partitionByKind({
+      resources: directive?.resources ?? [],
+      hashes: directive?.hashes ?? []
+    });
+    if (sources.default.resources.length === 0) continue;
+    const shadowed = [];
+    if (sources.element.resources.length > 0 || sources.element.hashes.length > 0) {
+      shadowed.push(`\`${name}-src-elem\``);
+    }
+    if (sources.attribute.resources.length > 0 || sources.attribute.hashes.length > 0) {
+      shadowed.push(`\`${name}-src-attr\``);
+    }
+    if (shadowed.length === 0) continue;
+    logger.warn(
+      "csp",
+      `\`security.csp.${name}Directive\` defines \`${name}-src\` resources (${sources.default.resources.join(
+        " "
+      )}) as well as ${shadowed.join(" and ")} resources or hashes. Because ${shadowed.join(
+        " and "
+      )} override \`${name}-src\` for their scope (browsers do not fall back), those \`${name}-src\` resources will not apply there. Add them to the corresponding \`kind\` if needed.`
+    );
+  }
+}
 export {
   actionRequired,
   cancelled,
@@ -327,5 +359,6 @@ export {
   telemetryEnabled,
   telemetryNotice,
   telemetryReset,
+  warnIfCspResourceFallbackShadowing,
   warnIfCspWithShiki
 };

package/dist/core/render/paginate.js

@@ -4,11 +4,12 @@ import { getRouteGenerator } from "../routing/generator.js";
 function generatePaginateFunction(routeMatch, base, trailingSlash) {
   return function paginateUtility(data, args = {}) {
     const generate = getRouteGenerator(routeMatch.segments, trailingSlash);
-    let { pageSize: _pageSize, params: _params, props: _props } = args;
+    let { pageSize: _pageSize, params: _params, props: _props, format: _format } = args;
     const pageSize = _pageSize || 10;
     const paramName = "page";
     const additionalParams = _params || {};
     const additionalProps = _props || {};
+    const formatUrl = _format || ((url) => url);
     let includesFirstPageNumber;
     if (routeMatch.params.includes(`...${paramName}`)) {
       includesFirstPageNumber = false;
@@ -29,23 +30,27 @@ function generatePaginateFunction(routeMatch, base, trailingSlash) {
         ...additionalParams,
         [paramName]: includesFirstPageNumber || pageNum > 1 ? String(pageNum) : void 0
       };
-      const current = addRouteBase(generate({ ...params }), base);
-      const next = pageNum === lastPage ? void 0 : addRouteBase(generate({ ...params, page: String(pageNum + 1) }), base);
-      const prev = pageNum === 1 ? void 0 : addRouteBase(
-        generate({
-          ...params,
-          page: !includesFirstPageNumber && pageNum - 1 === 1 ? void 0 : String(pageNum - 1)
-        }),
-        base
+      const current = formatUrl(addRouteBase(generate({ ...params }), base));
+      const next = pageNum === lastPage ? void 0 : formatUrl(addRouteBase(generate({ ...params, page: String(pageNum + 1) }), base));
+      const prev = pageNum === 1 ? void 0 : formatUrl(
+        addRouteBase(
+          generate({
+            ...params,
+            page: !includesFirstPageNumber && pageNum - 1 === 1 ? void 0 : String(pageNum - 1)
+          }),
+          base
+        )
       );
-      const first = pageNum === 1 ? void 0 : addRouteBase(
-        generate({
-          ...params,
-          page: includesFirstPageNumber ? "1" : void 0
-        }),
-        base
+      const first = pageNum === 1 ? void 0 : formatUrl(
+        addRouteBase(
+          generate({
+            ...params,
+            page: includesFirstPageNumber ? "1" : void 0
+          }),
+          base
+        )
       );
-      const last = pageNum === lastPage ? void 0 : addRouteBase(generate({ ...params, page: String(lastPage) }), base);
+      const last = pageNum === lastPage ? void 0 : formatUrl(addRouteBase(generate({ ...params, page: String(lastPage) }), base));
       return {
         params,
         props: {

package/dist/core/sync/index.js

@@ -6,7 +6,7 @@ import colors from "piccolore";
 import { createServer } from "vite";
 import { syncFonts } from "../../assets/fonts/sync.js";
 import { CONTENT_TYPES_FILE } from "../../content/consts.js";
-import { getDataStoreFile } from "../../content/content-layer.js";
+import { getDataStoreDir, getDataStoreFile } from "../../content/paths.js";
 import { globalContentLayer } from "../../content/instance.js";
 import { createContentTypesGenerator } from "../../content/index.js";
 import { MutableDataStore } from "../../content/mutable-data-store.js";
@@ -59,11 +59,21 @@ async function clearContentLayerCache({
   fs = fsMod,
   isDev
 }) {
-  const dataStore = getDataStoreFile(settings, isDev);
-  if (fs.existsSync(dataStore)) {
-    logger.debug("content", "clearing data store");
-    await fs.promises.rm(dataStore, { force: true });
-    logger.warn("content", "data store cleared (force)");
+  if (settings.config.experimental.collectionStorage === "chunked") {
+    const dataStore = getDataStoreDir(settings, isDev);
+    if (fs.existsSync(dataStore)) {
+      logger.debug("content", "clearing data store");
+      await fs.promises.rm(dataStore, { force: true, recursive: true });
+      await fs.promises.mkdir(dataStore, { recursive: true });
+      logger.warn("content", "data store cleared (force)");
+    }
+  } else {
+    const dataStore = getDataStoreFile(settings, isDev);
+    if (fs.existsSync(dataStore)) {
+      logger.debug("content", "clearing data store");
+      await fs.promises.rm(dataStore, { force: true });
+      logger.warn("content", "data store cleared (force)");
+    }
   }
 }
 async function syncInternal({
@@ -88,8 +98,13 @@ async function syncInternal({
       settings.timer.start("Sync content layer");
       let store;
       try {
-        const dataStoreFile = getDataStoreFile(settings, isDev);
-        store = await MutableDataStore.fromFile(dataStoreFile);
+        if (settings.config.experimental.collectionStorage === "chunked") {
+          const dataStoreDir = getDataStoreDir(settings, isDev);
+          store = await MutableDataStore.fromDir(dataStoreDir);
+        } else {
+          const dataStoreFile = getDataStoreFile(settings, isDev);
+          store = await MutableDataStore.fromFile(dataStoreFile);
+        }
       } catch (err) {
         logger.error("content", err.message);
       }

package/dist/integrations/hooks.js

@@ -14,6 +14,7 @@ import { validateSetAdapter } from "../core/dev/adapter-validation.js";
 import { getRouteGenerator } from "../core/routing/generator.js";
 import { getClientOutputDirectory } from "../prerender/utils.js";
 import { validateSupportedFeatures } from "./features-validation.js";
+import { loadLoggerDestination } from "../core/logger/load.js";
 async function withTakingALongTimeMsg({
   name,
   hookName,
@@ -139,6 +140,7 @@ async function runHookConfigSetup({
   let astroJSXRenderer = null;
   for (let i = 0; i < updatedConfig.integrations.length; i++) {
     const integration = updatedConfig.integrations[i];
+    let isLoggerUpdated = false;
     const { integrationLogger } = await runHookInternal({
       integration,
       hookName: "astro:config:setup",
@@ -169,6 +171,9 @@ async function runHookConfigSetup({
             updatedSettings.scripts.push({ stage, content });
           },
           updateConfig: (newConfig) => {
+            if (newConfig.logger?.entrypoint) {
+              isLoggerUpdated = true;
+            }
             updatedConfig = mergeConfig(updatedConfig, newConfig);
             return { ...updatedConfig };
           },
@@ -254,6 +259,9 @@ async function runHookConfigSetup({
     }
     try {
       updatedConfig = await validateConfigRefined(updatedConfig);
+      if (isLoggerUpdated) {
+        logger.setDestination(await loadLoggerDestination(updatedConfig.logger));
+      }
     } catch (error) {
       integrationLogger.error("An error occurred while updating the config");
       throw error;

package/dist/manifest/serialized.js

@@ -14,6 +14,7 @@ import {
   getStyleResources,
   shouldTrackCspHashes
 } from "../core/csp/common.js";
+import { partitionByKind } from "../core/csp/runtime.js";
 import { createKey, encodeKey, getEnvironmentKey, hasEnvironmentKey } from "../core/encryption.js";
 import { MIDDLEWARE_MODULE_ID } from "../core/middleware/vite-plugin.js";
 import { SERVER_ISLAND_MANIFEST } from "../core/server-islands/vite-plugin-server-islands.js";
@@ -131,15 +132,29 @@ async function createSerializedManifest(settings, encodedKey) {
     };
   }
   if (shouldTrackCspHashes(settings.config.security.csp)) {
+    const cspConfig = settings.config.security.csp;
+    const scriptDirective = {
+      resources: getScriptResources(cspConfig),
+      hashes: getScriptHashes(cspConfig),
+      strictDynamic: getStrictDynamic(cspConfig)
+    };
+    const styleDirective = {
+      resources: getStyleResources(cspConfig),
+      hashes: getStyleHashes(cspConfig)
+    };
+    const scriptDefault = partitionByKind(scriptDirective).default;
+    const styleDefault = partitionByKind(styleDirective).default;
     csp = {
       cspDestination: settings.adapter?.adapterFeatures?.staticHeaders ? "adapter" : void 0,
-      scriptHashes: getScriptHashes(settings.config.security.csp),
-      scriptResources: getScriptResources(settings.config.security.csp),
-      styleHashes: getStyleHashes(settings.config.security.csp),
-      styleResources: getStyleResources(settings.config.security.csp),
-      algorithm: getAlgorithm(settings.config.security.csp),
+      algorithm: getAlgorithm(cspConfig),
       directives: getDirectives(settings),
-      isStrictDynamic: getStrictDynamic(settings.config.security.csp)
+      scriptHashes: scriptDefault.hashes,
+      scriptResources: scriptDefault.resources,
+      isStrictDynamic: scriptDirective.strictDynamic,
+      styleHashes: styleDefault.hashes,
+      styleResources: styleDefault.resources,
+      scriptDirective,
+      styleDirective
     };
   }
   let loggerConfig = void 0;

package/dist/runtime/server/escape.d.ts

@@ -7,6 +7,8 @@ export declare const escapeHTML: (str: string) => string;
  * @see https://mathiasbynens.be/notes/etago
  */
 export declare function stringifyForScript(value: any): string;
+/** Escapes CSS text so it can be embedded inside a `<style>` tag. */
+export declare function escapeStyleText(value: string): string;
 export declare class HTMLBytes extends Uint8Array {
 }
 declare const htmlStringSymbol: unique symbol;

package/dist/runtime/server/escape.js

@@ -4,6 +4,9 @@ const escapeHTML = escape;
 function stringifyForScript(value) {
   return JSON.stringify(value)?.replace(/</g, "\\u003c");
 }
+function escapeStyleText(value) {
+  return value.replaceAll("<", "\\3C ");
+}
 class HTMLBytes extends Uint8Array {
 }
 Object.defineProperty(HTMLBytes.prototype, Symbol.toStringTag, {
@@ -77,6 +80,7 @@ export {
   HTMLBytes,
   HTMLString,
   escapeHTML,
+  escapeStyleText,
   isHTMLBytes,
   isHTMLString,
   markHTMLString,

package/dist/runtime/server/render/csp.js

@@ -1,34 +1,95 @@
+import { partitionByKind } from "../../../core/csp/runtime.js";
 function renderCspContent(result) {
+  const { scriptDirective, styleDirective, directives } = result;
+  const script = partitionByKind(scriptDirective);
+  const style = partitionByKind(styleDirective);
   const finalScriptHashes = /* @__PURE__ */ new Set();
-  const finalStyleHashes = /* @__PURE__ */ new Set();
-  for (const scriptHash of result.scriptHashes) {
+  for (const scriptHash of script.default.hashes) {
     finalScriptHashes.add(`'${scriptHash}'`);
   }
-  for (const styleHash of result.styleHashes) {
+  for (const scriptHash of result._metadata.extraScriptHashes) {
+    finalScriptHashes.add(`'${scriptHash}'`);
+  }
+  const finalStyleHashes = /* @__PURE__ */ new Set();
+  for (const styleHash of style.default.hashes) {
     finalStyleHashes.add(`'${styleHash}'`);
   }
   for (const styleHash of result._metadata.extraStyleHashes) {
     finalStyleHashes.add(`'${styleHash}'`);
   }
-  for (const scriptHash of result._metadata.extraScriptHashes) {
-    finalScriptHashes.add(`'${scriptHash}'`);
-  }
-  let directives;
-  if (result.directives.length > 0) {
-    directives = result.directives.join(";") + ";";
+  let directivesContent;
+  if (directives.length > 0) {
+    directivesContent = directives.join(";") + ";";
   }
-  let scriptResources = "'self'";
-  if (result.scriptResources.length > 0) {
-    scriptResources = result.scriptResources.map((r) => `${r}`).join(" ");
+  const scriptResources = script.default.resources.length > 0 ? script.default.resources.join(" ") : "'self'";
+  const styleResources = style.default.resources.length > 0 ? style.default.resources.join(" ") : "'self'";
+  const scriptElementDefaultResource = script.default.resources.length > 0 ? "" : "'self'";
+  const styleElementDefaultResource = style.default.resources.length > 0 ? "" : "'self'";
+  const scriptElemActive = isEnabled(script.element);
+  const styleElemActive = isEnabled(style.element);
+  const strictDynamicSuffix = scriptDirective.strictDynamic ? ` 'strict-dynamic'` : "";
+  const scriptBaselineTokens = [
+    ...scriptElemActive ? [] : [...finalScriptHashes],
+    ...scriptDirective.strictDynamic ? [`'strict-dynamic'`] : []
+  ];
+  const scriptSrc = `script-src ${scriptResources} ${scriptBaselineTokens.join(" ")};`;
+  const styleSrc = `style-src ${styleResources} ${(styleElemActive ? [] : [...finalStyleHashes]).join(" ")};`;
+  const scriptSrcElem = scriptElemActive ? renderSpecificDirective(
+    "script-src-elem",
+    script.element.resources,
+    scriptElementDefaultResource,
+    finalScriptHashes,
+    script.element.hashes,
+    strictDynamicSuffix
+  ) : void 0;
+  const scriptSrcAttr = isEnabled(script.attribute) ? renderSpecificDirective(
+    "script-src-attr",
+    script.attribute.resources,
+    "'none'",
+    void 0,
+    script.attribute.hashes
+  ) : void 0;
+  const styleSrcElem = styleElemActive ? renderSpecificDirective(
+    "style-src-elem",
+    style.element.resources,
+    styleElementDefaultResource,
+    finalStyleHashes,
+    style.element.hashes
+  ) : void 0;
+  const styleSrcAttr = isEnabled(style.attribute) ? renderSpecificDirective(
+    "style-src-attr",
+    style.attribute.resources,
+    "'none'",
+    void 0,
+    style.attribute.hashes
+  ) : void 0;
+  return [
+    directivesContent,
+    scriptSrc,
+    scriptSrcElem,
+    scriptSrcAttr,
+    styleSrc,
+    styleSrcElem,
+    styleSrcAttr
+  ].filter(Boolean).join(" ");
+}
+function isEnabled(sources) {
+  return sources.resources.length > 0 || sources.hashes.length > 0;
+}
+function renderSpecificDirective(name, resources, defaultResource, sharedHashes, ownHashes, suffix = "") {
+  const hashes = new Set(sharedHashes);
+  for (const hash of ownHashes) {
+    hashes.add(`'${hash}'`);
   }
-  let styleResources = "'self'";
-  if (result.styleResources.length > 0) {
-    styleResources = result.styleResources.map((r) => `${r}`).join(" ");
+  let finalResources;
+  if (resources.length > 0) {
+    finalResources = resources.map((r) => `${r}`).join(" ");
+  } else if (defaultResource === "'none'" && hashes.size > 0) {
+    finalResources = "";
+  } else {
+    finalResources = defaultResource;
   }
-  const strictDynamic = result.isStrictDynamic ? ` 'strict-dynamic'` : "";
-  const scriptSrc = `script-src ${scriptResources} ${Array.from(finalScriptHashes).join(" ")}${strictDynamic};`;
-  const styleSrc = `style-src ${styleResources} ${Array.from(finalStyleHashes).join(" ")};`;
-  return [directives, scriptSrc, styleSrc].filter(Boolean).join(" ");
+  return `${name} ${[finalResources, ...hashes].filter(Boolean).join(" ")}${suffix};`;
 }
 export {
   renderCspContent

package/dist/runtime/server/render/server-islands.js

@@ -5,6 +5,7 @@ import { createThinHead } from "./astro/head-and-content.js";
 import { createRenderInstruction } from "./instruction.js";
 import { SERVER_ISLAND_START } from "./server-islands-shared.js";
 import { renderSlotToString } from "./slot.js";
+import { toAttributeString } from "./util.js";
 const internalProps = /* @__PURE__ */ new Set([
   "server:component-path",
   "server:component-export",
@@ -148,16 +149,17 @@ class ServerIslandComponent {
       serverIslandUrl += "?" + potentialSearchParams.toString();
       this.result._metadata.extraHead.push(
         markHTMLString(
-          `<link rel="preload" as="fetch" href="${serverIslandUrl}" crossorigin="anonymous">`
+          `<link rel="preload" as="fetch" href="${toAttributeString(serverIslandUrl)}" crossorigin="anonymous">`
         )
       );
     }
     const adapterHeaders = this.result.internalFetchHeaders || {};
     const headersJson = stringifyForScript(adapterHeaders);
+    const serverIslandUrlJson = stringifyForScript(serverIslandUrl);
     const method = useGETRequest ? (
       // GET request
       `const headers = new Headers(${headersJson});
-let response = await fetch('${serverIslandUrl}', { headers });`
+let response = await fetch(${serverIslandUrlJson}, { headers });`
     ) : (
       // POST request
       `let data = {
@@ -166,13 +168,13 @@ let response = await fetch('${serverIslandUrl}', { headers });`
 	encryptedSlots: ${stringifyForScript(slotsEncrypted)},
 };
 const headers = new Headers({ 'Content-Type': 'application/json', ...${headersJson} });
-let response = await fetch('${serverIslandUrl}', {
+let response = await fetch(${serverIslandUrlJson}, {
 	method: 'POST',
 	body: JSON.stringify(data),
 	headers,
 });`
     );
-    this.islandContent = `${method}replaceServerIsland('${hostId}', response);`;
+    this.islandContent = `${method}replaceServerIsland(${stringifyForScript(hostId)}, response);`;
     return this.islandContent;
   }
 }

package/dist/runtime/server/transition.js

@@ -1,6 +1,6 @@
 import cssesc from "../../transitions/cssesc.js";
 import { fade, slide } from "../../transitions/index.js";
-import { markHTMLString } from "./escape.js";
+import { escapeStyleText, markHTMLString } from "./escape.js";
 const transitionNameMap = /* @__PURE__ */ new WeakMap();
 function incrementTransitionNumber(result) {
   let num = 1;
@@ -56,7 +56,7 @@ function renderTransition(result, hash, animationName, transitionName) {
     sheet.addAnimationRaw("new", "animation: none; mix-blend-mode: normal;");
     sheet.addModern("group", "animation: none");
   }
-  const css = sheet.toString();
+  const css = escapeStyleText(sheet.toString());
   result._metadata.extraHead.push(markHTMLString(`<style>${css}</style>`));
   return scope;
 }

package/dist/types/astro.d.ts

@@ -1,4 +1,5 @@
 import type { Server } from 'node:http';
+import type { CspHash } from '../core/csp/config.js';
 import type { AstroTimer } from '../core/config/timer.js';
 import type { TSConfig } from '../core/config/tsconfig.js';
 import type { AstroLogger, AstroLoggerLevel } from '../core/logger/core.js';
@@ -18,7 +19,6 @@ export type SerializedRouteData = Omit<RouteData, 'generate' | 'pattern' | 'redi
         trailingSlash: AstroConfig['trailingSlash'];
     };
 };
-type CspObject = Required<Exclude<AstroConfig['security']['csp'], boolean>>;
 export interface AstroSettings {
     config: AstroConfig;
     adapter: AstroAdapter | undefined;
@@ -64,7 +64,7 @@ export interface AstroSettings {
     buildOutput: undefined | 'static' | 'server';
     injectedCsp: {
         fontResources: Set<string>;
-        styleHashes: Required<CspObject['styleDirective']>['hashes'];
+        styleHashes: CspHash[];
     };
     logLevel: AstroLoggerLevel;
     fontsHttpServer: Server | null;
@@ -89,4 +89,3 @@ export interface ImportedDevStyle {
     url: string;
     content: string;
 }
-export {};