astro 5.8.2 → 5.9.1

package/dist/env/schema.d.ts

@@ -16,22 +16,22 @@ declare const StringSchema: z.ZodObject<{
     includes?: string | undefined;
     endsWith?: string | undefined;
     startsWith?: string | undefined;
-    default?: string | undefined;
     optional?: boolean | undefined;
+    url?: boolean | undefined;
+    default?: string | undefined;
     max?: number | undefined;
     min?: number | undefined;
-    url?: boolean | undefined;
 }, {
     type: "string";
     length?: number | undefined;
     includes?: string | undefined;
     endsWith?: string | undefined;
     startsWith?: string | undefined;
-    default?: string | undefined;
     optional?: boolean | undefined;
+    url?: boolean | undefined;
+    default?: string | undefined;
     max?: number | undefined;
     min?: number | undefined;
-    url?: boolean | undefined;
 }>;
 export type StringSchema = z.infer<typeof StringSchema>;
 declare const NumberSchema: z.ZodObject<{
@@ -45,8 +45,8 @@ declare const NumberSchema: z.ZodObject<{
     int: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     type: "number";
-    default?: number | undefined;
     optional?: boolean | undefined;
+    default?: number | undefined;
     max?: number | undefined;
     min?: number | undefined;
     gt?: number | undefined;
@@ -54,8 +54,8 @@ declare const NumberSchema: z.ZodObject<{
     int?: boolean | undefined;
 }, {
     type: "number";
-    default?: number | undefined;
     optional?: boolean | undefined;
+    default?: number | undefined;
     max?: number | undefined;
     min?: number | undefined;
     gt?: number | undefined;
@@ -69,12 +69,12 @@ declare const BooleanSchema: z.ZodObject<{
     default: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     type: "boolean";
-    default?: boolean | undefined;
     optional?: boolean | undefined;
+    default?: boolean | undefined;
 }, {
     type: "boolean";
-    default?: boolean | undefined;
     optional?: boolean | undefined;
+    default?: boolean | undefined;
 }>;
 declare const EnumSchema: z.ZodObject<{
     type: z.ZodLiteral<"enum">;
@@ -84,13 +84,13 @@ declare const EnumSchema: z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     values: string[];
     type: "enum";
-    default?: string | undefined;
     optional?: boolean | undefined;
+    default?: string | undefined;
 }, {
     values: string[];
     type: "enum";
-    default?: string | undefined;
     optional?: boolean | undefined;
+    default?: string | undefined;
 }>;
 export type EnumSchema = z.infer<typeof EnumSchema>;
 declare const EnvFieldType: z.ZodUnion<[z.ZodObject<{
@@ -110,22 +110,22 @@ declare const EnvFieldType: z.ZodUnion<[z.ZodObject<{
     includes?: string | undefined;
     endsWith?: string | undefined;
     startsWith?: string | undefined;
-    default?: string | undefined;
     optional?: boolean | undefined;
+    url?: boolean | undefined;
+    default?: string | undefined;
     max?: number | undefined;
     min?: number | undefined;
-    url?: boolean | undefined;
 }, {
     type: "string";
     length?: number | undefined;
     includes?: string | undefined;
     endsWith?: string | undefined;
     startsWith?: string | undefined;
-    default?: string | undefined;
     optional?: boolean | undefined;
+    url?: boolean | undefined;
+    default?: string | undefined;
     max?: number | undefined;
     min?: number | undefined;
-    url?: boolean | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"number">;
     optional: z.ZodOptional<z.ZodBoolean>;
@@ -137,8 +137,8 @@ declare const EnvFieldType: z.ZodUnion<[z.ZodObject<{
     int: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     type: "number";
-    default?: number | undefined;
     optional?: boolean | undefined;
+    default?: number | undefined;
     max?: number | undefined;
     min?: number | undefined;
     gt?: number | undefined;
@@ -146,8 +146,8 @@ declare const EnvFieldType: z.ZodUnion<[z.ZodObject<{
     int?: boolean | undefined;
 }, {
     type: "number";
-    default?: number | undefined;
     optional?: boolean | undefined;
+    default?: number | undefined;
     max?: number | undefined;
     min?: number | undefined;
     gt?: number | undefined;
@@ -159,12 +159,12 @@ declare const EnvFieldType: z.ZodUnion<[z.ZodObject<{
     default: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     type: "boolean";
-    default?: boolean | undefined;
     optional?: boolean | undefined;
+    default?: boolean | undefined;
 }, {
     type: "boolean";
-    default?: boolean | undefined;
     optional?: boolean | undefined;
+    default?: boolean | undefined;
 }>, z.ZodEffects<z.ZodObject<{
     type: z.ZodLiteral<"enum">;
     values: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
@@ -173,23 +173,23 @@ declare const EnvFieldType: z.ZodUnion<[z.ZodObject<{
 }, "strip", z.ZodTypeAny, {
     values: string[];
     type: "enum";
-    default?: string | undefined;
     optional?: boolean | undefined;
+    default?: string | undefined;
 }, {
     values: string[];
     type: "enum";
-    default?: string | undefined;
     optional?: boolean | undefined;
+    default?: string | undefined;
 }>, {
     values: string[];
     type: "enum";
-    default?: string | undefined;
     optional?: boolean | undefined;
+    default?: string | undefined;
 }, {
     values: string[];
     type: "enum";
-    default?: string | undefined;
     optional?: boolean | undefined;
+    default?: string | undefined;
 }>]>;
 export type EnvFieldType = z.infer<typeof EnvFieldType>;
 declare const EnvFieldMetadata: z.ZodEffects<z.ZodType<{
@@ -282,22 +282,22 @@ export declare const EnvSchema: z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodStrin
     includes?: string | undefined;
     endsWith?: string | undefined;
     startsWith?: string | undefined;
-    default?: string | undefined;
     optional?: boolean | undefined;
+    url?: boolean | undefined;
+    default?: string | undefined;
     max?: number | undefined;
     min?: number | undefined;
-    url?: boolean | undefined;
 }, {
     type: "string";
     length?: number | undefined;
     includes?: string | undefined;
     endsWith?: string | undefined;
     startsWith?: string | undefined;
-    default?: string | undefined;
     optional?: boolean | undefined;
+    url?: boolean | undefined;
+    default?: string | undefined;
     max?: number | undefined;
     min?: number | undefined;
-    url?: boolean | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"number">;
     optional: z.ZodOptional<z.ZodBoolean>;
@@ -309,8 +309,8 @@ export declare const EnvSchema: z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodStrin
     int: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     type: "number";
-    default?: number | undefined;
     optional?: boolean | undefined;
+    default?: number | undefined;
     max?: number | undefined;
     min?: number | undefined;
     gt?: number | undefined;
@@ -318,8 +318,8 @@ export declare const EnvSchema: z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodStrin
     int?: boolean | undefined;
 }, {
     type: "number";
-    default?: number | undefined;
     optional?: boolean | undefined;
+    default?: number | undefined;
     max?: number | undefined;
     min?: number | undefined;
     gt?: number | undefined;
@@ -331,12 +331,12 @@ export declare const EnvSchema: z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodStrin
     default: z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     type: "boolean";
-    default?: boolean | undefined;
     optional?: boolean | undefined;
+    default?: boolean | undefined;
 }, {
     type: "boolean";
-    default?: boolean | undefined;
     optional?: boolean | undefined;
+    default?: boolean | undefined;
 }>, z.ZodEffects<z.ZodObject<{
     type: z.ZodLiteral<"enum">;
     values: z.ZodArray<z.ZodEffects<z.ZodString, string, string>, "many">;
@@ -345,23 +345,23 @@ export declare const EnvSchema: z.ZodRecord<z.ZodEffects<z.ZodEffects<z.ZodStrin
 }, "strip", z.ZodTypeAny, {
     values: string[];
     type: "enum";
-    default?: string | undefined;
     optional?: boolean | undefined;
+    default?: string | undefined;
 }, {
     values: string[];
     type: "enum";
-    default?: string | undefined;
     optional?: boolean | undefined;
+    default?: string | undefined;
 }>, {
     values: string[];
     type: "enum";
-    default?: string | undefined;
     optional?: boolean | undefined;
+    default?: string | undefined;
 }, {
     values: string[];
     type: "enum";
-    default?: string | undefined;
     optional?: boolean | undefined;
+    default?: string | undefined;
 }>]>>>;
 type Prettify<T> = {
     [K in keyof T]: T[K];

package/dist/integrations/features-validation.js

@@ -72,49 +72,55 @@ function unwrapSupportKind(supportKind) {
 function getSupportMessage(supportKind) {
   return typeof supportKind === "object" ? supportKind.message : void 0;
 }
+function getSupportMessageSuppression(supportKind) {
+  return typeof supportKind === "object" ? supportKind.suppress : void 0;
+}
 function validateSupportKind(supportKind, adapterName, logger, featureName, hasCorrectConfig) {
   const supportValue = unwrapSupportKind(supportKind);
   const message = getSupportMessage(supportKind);
+  const suppress = getSupportMessageSuppression(supportKind);
   if (!supportValue) {
     return false;
   }
   if (supportValue === AdapterFeatureStability.STABLE) {
     return true;
   } else if (hasCorrectConfig()) {
-    logFeatureSupport(adapterName, logger, featureName, supportValue, message);
+    logFeatureSupport(adapterName, logger, featureName, supportValue, message, suppress);
   }
   return false;
 }
-function logFeatureSupport(adapterName, logger, featureName, supportKind, adapterMessage) {
-  switch (supportKind) {
-    case AdapterFeatureStability.STABLE:
-      break;
-    case AdapterFeatureStability.DEPRECATED:
-      logger.warn(
-        "config",
-        `The adapter ${adapterName} has deprecated its support for "${featureName}", and future compatibility is not guaranteed. The adapter may completely remove support for this feature without warning.`
-      );
-      break;
-    case AdapterFeatureStability.EXPERIMENTAL:
-      logger.warn(
-        "config",
-        `The adapter ${adapterName} provides experimental support for "${featureName}". You may experience issues or breaking changes until this feature is fully supported by the adapter.`
-      );
-      break;
-    case AdapterFeatureStability.LIMITED:
-      logger.warn(
-        "config",
-        `The adapter ${adapterName} has limited support for "${featureName}". Certain features may not work as expected.`
-      );
-      break;
-    case AdapterFeatureStability.UNSUPPORTED:
-      logger.error(
-        "config",
-        `The adapter ${adapterName} does not currently support the feature "${featureName}". Your project may not build correctly.`
-      );
-      break;
+function logFeatureSupport(adapterName, logger, featureName, supportKind, adapterMessage, suppress) {
+  if (!suppress) {
+    switch (supportKind) {
+      case AdapterFeatureStability.STABLE:
+        break;
+      case AdapterFeatureStability.DEPRECATED:
+        logger.warn(
+          "config",
+          `The adapter ${adapterName} has deprecated its support for "${featureName}", and future compatibility is not guaranteed. The adapter may completely remove support for this feature without warning.`
+        );
+        break;
+      case AdapterFeatureStability.EXPERIMENTAL:
+        logger.warn(
+          "config",
+          `The adapter ${adapterName} provides experimental support for "${featureName}". You may experience issues or breaking changes until this feature is fully supported by the adapter.`
+        );
+        break;
+      case AdapterFeatureStability.LIMITED:
+        logger.warn(
+          "config",
+          `The adapter ${adapterName} has limited support for "${featureName}". Certain features may not work as expected.`
+        );
+        break;
+      case AdapterFeatureStability.UNSUPPORTED:
+        logger.error(
+          "config",
+          `The adapter ${adapterName} does not currently support the feature "${featureName}". Your project may not build correctly.`
+        );
+        break;
+    }
   }
-  if (adapterMessage) {
+  if (adapterMessage && suppress !== "all") {
     logger.warn("adapter", adapterMessage);
   }
 }

package/dist/integrations/hooks.d.ts

@@ -38,13 +38,14 @@ export declare function getToolbarServerCommunicationHelpers(server: ViteDevServ
 };
 export declare function normalizeCodegenDir(integrationName: string): string;
 export declare function normalizeInjectedTypeFilename(filename: string, integrationName: string): string;
-export declare function runHookConfigSetup({ settings, command, logger, isRestart, fs, }: {
+interface RunHookConfigSetup {
     settings: AstroSettings;
     command: 'dev' | 'build' | 'preview' | 'sync';
     logger: Logger;
     isRestart?: boolean;
     fs?: typeof fsMod;
-}): Promise<AstroSettings>;
+}
+export declare function runHookConfigSetup({ settings, command, logger, isRestart, fs, }: RunHookConfigSetup): Promise<AstroSettings>;
 export declare function runHookConfigDone({ settings, logger, command, }: {
     settings: AstroSettings;
     logger: Logger;

package/dist/runtime/server/astro-island-styles.d.ts

@@ -0,0 +1 @@
+export declare const ISLAND_STYLES = "astro-island,astro-slot,astro-static-slot{display:contents}";

package/dist/runtime/server/astro-island-styles.js

@@ -0,0 +1,4 @@
+const ISLAND_STYLES = "astro-island,astro-slot,astro-static-slot{display:contents}";
+export {
+  ISLAND_STYLES
+};

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

@@ -5,6 +5,7 @@ export { escapeHTML, HTMLBytes, HTMLString, isHTMLString, markHTMLString, unesca
 export { renderJSX } from './jsx.js';
 export { addAttribute, createHeadAndContent, defineScriptVars, Fragment, maybeRenderHead, renderTemplate as render, renderComponent, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderScript, renderScriptElement, renderSlot, renderSlotToString, renderTemplate, renderToString, renderUniqueStylesheet, voidElementNames, } from './render/index.js';
 export type { AstroComponentFactory, AstroComponentInstance, ComponentSlots, RenderInstruction, } from './render/index.js';
+export type { ServerIslandComponent } from './render/server-islands.js';
 export { createTransitionScope, renderTransition } from './transition.js';
 export declare function mergeSlots(...slotted: unknown[]): Record<string, () => any>;
 export declare function spreadAttributes(values?: Record<any, any>, _name?: string, { class: scopedClassName }?: {

package/dist/runtime/server/render/astro/factory.d.ts

@@ -1,7 +1,7 @@
 import type { PropagationHint, SSRResult } from '../../../../types/public/internal.js';
-import type { HeadAndContent } from './head-and-content.js';
+import type { HeadAndContent, ThinHead } from './head-and-content.js';
 import type { RenderTemplateResult } from './render-template.js';
-export type AstroFactoryReturnValue = RenderTemplateResult | Response | HeadAndContent;
+export type AstroFactoryReturnValue = RenderTemplateResult | Response | HeadAndContent | ThinHead;
 export interface AstroComponentFactory {
     (result: any, props: any, slots: any): AstroFactoryReturnValue | Promise<AstroFactoryReturnValue>;
     isAstroComponentFactory?: boolean;
@@ -10,3 +10,4 @@ export interface AstroComponentFactory {
 }
 export declare function isAstroComponentFactory(obj: any): obj is AstroComponentFactory;
 export declare function isAPropagatingComponent(result: SSRResult, factory: AstroComponentFactory): boolean;
+export declare function getPropagationHint(result: SSRResult, factory: AstroComponentFactory): PropagationHint;

package/dist/runtime/server/render/astro/factory.js

@@ -2,13 +2,18 @@ function isAstroComponentFactory(obj) {
   return obj == null ? false : obj.isAstroComponentFactory === true;
 }
 function isAPropagatingComponent(result, factory) {
+  const hint = getPropagationHint(result, factory);
+  return hint === "in-tree" || hint === "self";
+}
+function getPropagationHint(result, factory) {
   let hint = factory.propagation || "none";
   if (factory.moduleId && result.componentMetadata.has(factory.moduleId) && hint === "none") {
     hint = result.componentMetadata.get(factory.moduleId).propagation;
   }
-  return hint === "in-tree" || hint === "self";
+  return hint;
 }
 export {
+  getPropagationHint,
   isAPropagatingComponent,
   isAstroComponentFactory
 };

package/dist/runtime/server/render/astro/head-and-content.d.ts

@@ -5,6 +5,13 @@ export type HeadAndContent = {
     head: string;
     content: RenderTemplateResult;
 };
+/**
+ * A head that doesn't contain any content
+ */
+export type ThinHead = {
+    [headAndContentSym]: true;
+};
 export declare function isHeadAndContent(obj: unknown): obj is HeadAndContent;
 export declare function createHeadAndContent(head: string, content: RenderTemplateResult): HeadAndContent;
+export declare function createThinHead(): ThinHead;
 export {};

package/dist/runtime/server/render/astro/head-and-content.js

@@ -9,7 +9,13 @@ function createHeadAndContent(head, content) {
     content
   };
 }
+function createThinHead() {
+  return {
+    [headAndContentSym]: true
+  };
+}
 export {
   createHeadAndContent,
+  createThinHead,
   isHeadAndContent
 };

package/dist/runtime/server/render/astro/render.d.ts

@@ -2,4 +2,5 @@ import type { RouteData, SSRResult } from '../../../../types/public/internal.js'
 import type { AstroComponentFactory } from './factory.js';
 export declare function renderToString(result: SSRResult, componentFactory: AstroComponentFactory, props: any, children: any, isPage?: boolean, route?: RouteData): Promise<string | Response>;
 export declare function renderToReadableStream(result: SSRResult, componentFactory: AstroComponentFactory, props: any, children: any, isPage?: boolean, route?: RouteData): Promise<ReadableStream | Response>;
+export declare function bufferHeadContent(result: SSRResult): Promise<void>;
 export declare function renderToAsyncIterable(result: SSRResult, componentFactory: AstroComponentFactory, props: any, children: any, isPage?: boolean, route?: RouteData): Promise<AsyncIterable<Uint8Array> | Response>;

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

@@ -124,7 +124,7 @@ async function bufferHeadContent(result) {
       break;
     }
     const returnValue = await value.init(result);
-    if (isHeadAndContent(returnValue)) {
+    if (isHeadAndContent(returnValue) && returnValue.head) {
       result._metadata.extraHead.push(returnValue.head);
     }
   }
@@ -229,6 +229,7 @@ function toPromise(fn) {
   }
 }
 export {
+  bufferHeadContent,
   renderToAsyncIterable,
   renderToReadableStream,
   renderToString

package/dist/runtime/server/render/common.d.ts

@@ -1,6 +1,6 @@
-import type { RenderInstruction } from './instruction.js';
 import type { SSRResult } from '../../../types/public/internal.js';
 import type { HTMLBytes, HTMLString } from '../escape.js';
+import type { RenderInstruction } from './instruction.js';
 import { type SlotString } from './slot.js';
 /**
  * Possible chunk types to be written to the destination, and it'll

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

@@ -20,9 +20,11 @@ function stringifyChunk(result, chunk) {
         const { hydration } = instruction;
         let needsHydrationScript = hydration && determineIfNeedsHydrationScript(result);
         let needsDirectiveScript = hydration && determinesIfNeedsDirectiveScript(result, hydration.directive);
-        let prescriptType = needsHydrationScript ? "both" : needsDirectiveScript ? "directive" : null;
-        if (prescriptType) {
-          let prescripts = getPrescripts(result, prescriptType, hydration.directive);
+        if (needsHydrationScript) {
+          let prescripts = getPrescripts(result, "both", hydration.directive);
+          return markHTMLString(prescripts);
+        } else if (needsDirectiveScript) {
+          let prescripts = getPrescripts(result, "directive", hydration.directive);
           return markHTMLString(prescripts);
         } else {
           return "";

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

@@ -9,6 +9,7 @@ import { isPromise } from "../util.js";
 import { isAstroComponentFactory } from "./astro/factory.js";
 import { renderTemplate } from "./astro/index.js";
 import { createAstroComponentInstance } from "./astro/instance.js";
+import { bufferHeadContent } from "./astro/render.js";
 import {
   Fragment,
   Renderer,
@@ -16,7 +17,7 @@ import {
 } from "./common.js";
 import { componentIsHTMLElement, renderHTMLElement } from "./dom.js";
 import { maybeRenderHead } from "./head.js";
-import { containsServerDirective, renderServerIsland } from "./server-islands.js";
+import { ServerIslandComponent, containsServerDirective } from "./server-islands.js";
 import { renderSlotToString, renderSlots } from "./slot.js";
 import { formatList, internalSpreadAttributes, renderElement, voidElementNames } from "./util.js";
 const needsHeadRenderingSymbol = Symbol.for("astro.needsHeadRendering");
@@ -342,7 +343,9 @@ async function renderHTMLComponent(result, Component, _props, slots = {}) {
 }
 function renderAstroComponent(result, displayName, Component, props, slots = {}) {
   if (containsServerDirective(props)) {
-    return renderServerIsland(result, displayName, props, slots);
+    const serverIslandComponent = new ServerIslandComponent(result, props, slots, displayName);
+    result._metadata.propagators.add(serverIslandComponent);
+    return serverIslandComponent;
   }
   const instance = createAstroComponentInstance(result, displayName, Component, props, slots);
   return {
@@ -412,6 +415,9 @@ async function renderComponentToString(result, displayName, Component, props, sl
       }
     };
     const renderInstance = await renderComponent(result, displayName, Component, props, slots);
+    if (containsServerDirective(props)) {
+      await bufferHeadContent(result);
+    }
     await renderInstance.render(destination);
   } catch (e) {
     if (AstroError.is(e) && !e.loc) {

package/dist/runtime/server/render/csp.d.ts

@@ -0,0 +1,2 @@
+import type { SSRResult } from '../../../types/public/index.js';
+export declare function renderCspContent(result: SSRResult): string;

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

@@ -0,0 +1,35 @@
+function renderCspContent(result) {
+  const finalScriptHashes = /* @__PURE__ */ new Set();
+  const finalStyleHashes = /* @__PURE__ */ new Set();
+  for (const scriptHash of result.scriptHashes) {
+    finalScriptHashes.add(`'${scriptHash}'`);
+  }
+  for (const styleHash of result.styleHashes) {
+    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 scriptResources = "'self'";
+  if (result.scriptResources.length > 0) {
+    scriptResources = result.scriptResources.map((r) => `'${r}'`).join(" ");
+  }
+  let styleResources = "'self'";
+  if (result.styleResources.length > 0) {
+    styleResources = result.styleResources.map((r) => `'${r}'`).join(" ");
+  }
+  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}`;
+}
+export {
+  renderCspContent
+};

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

@@ -1,4 +1,5 @@
 import { markHTMLString } from "../escape.js";
+import { renderCspContent } from "./csp.js";
 import { createRenderInstruction } from "./instruction.js";
 import { renderElement } from "./util.js";
 const uniqueElements = (item, index, all) => {
@@ -25,6 +26,19 @@ function renderAllHeadContent(result) {
       content += part;
     }
   }
+  if (result.shouldInjectCspMetaTags) {
+    content += renderElement(
+      "meta",
+      {
+        props: {
+          "http-equiv": "content-security-policy",
+          content: renderCspContent(result)
+        },
+        children: ""
+      },
+      false
+    );
+  }
   return markHTMLString(content);
 }
 function renderHead() {

package/dist/runtime/server/render/page.d.ts

@@ -1,4 +1,4 @@
+import type { RouteData, SSRResult } from '../../../types/public/internal.js';
 import { type NonAstroPageComponent } from './component.js';
 import type { AstroComponentFactory } from './index.js';
-import type { RouteData, SSRResult } from '../../../types/public/internal.js';
 export declare function renderPage(result: SSRResult, componentFactory: AstroComponentFactory | NonAstroPageComponent, props: any, children: any, streaming: boolean, route?: RouteData): Promise<Response>;

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

@@ -1,7 +1,7 @@
-import { renderComponentToString } from "./component.js";
 import { isAstroComponentFactory } from "./astro/index.js";
 import { renderToAsyncIterable, renderToReadableStream, renderToString } from "./astro/render.js";
 import { encoder } from "./common.js";
+import { renderComponentToString } from "./component.js";
 import { isDeno, isNode } from "./util.js";
 async function renderPage(result, componentFactory, props, children, streaming, route) {
   if (!isAstroComponentFactory(componentFactory)) {

package/dist/runtime/server/render/server-islands.d.ts

@@ -1,6 +1,17 @@
 import type { SSRResult } from '../../../types/public/internal.js';
-import type { RenderInstance } from './common.js';
+import { type ThinHead } from './astro/head-and-content.js';
+import type { RenderDestination } from './common.js';
 import { type ComponentSlots } from './slot.js';
 export declare function containsServerDirective(props: Record<string | number, any>): boolean;
-export declare function renderServerIsland(result: SSRResult, _displayName: string, props: Record<string | number, any>, slots: ComponentSlots): RenderInstance;
-export declare const renderServerIslandRuntime: () => any;
+export declare class ServerIslandComponent {
+    result: SSRResult;
+    props: Record<string | number, any>;
+    slots: ComponentSlots;
+    displayName: string;
+    hostId: string | undefined;
+    islandContent: string | undefined;
+    constructor(result: SSRResult, props: Record<string | number, any>, slots: ComponentSlots, displayName: string);
+    init(): Promise<ThinHead>;
+    render(destination: RenderDestination): Promise<void>;
+}
+export declare const renderServerIslandRuntime: () => string;