astro 2.0.5 → 2.0.7

package/dist/core/render/paginate.js

@@ -1,3 +1,4 @@
+import { AstroError, AstroErrorData } from "../errors/index.js";
 function generatePaginateFunction(routeMatch) {
   return function paginateUtility(data, args = {}) {
     let { pageSize: _pageSize, params: _params, props: _props } = args;
@@ -11,10 +12,10 @@ function generatePaginateFunction(routeMatch) {
     } else if (routeMatch.params.includes(`${paramName}`)) {
       includesFirstPageNumber = true;
     } else {
-      throw new Error(
-        `[paginate()] page number param \`${paramName}\` not found in your filepath.
-Rename your file to \`[...page].astro\` or customize the param name via the \`paginate([], {param: '...'}\` option.`
-      );
+      throw new AstroError({
+        ...AstroErrorData.PageNumberParamNotFound,
+        message: AstroErrorData.PageNumberParamNotFound.message(paramName)
+      });
     }
     const lastPage = Math.max(1, Math.ceil(data.length / pageSize));
     const result = [...Array(lastPage).keys()].map((num) => {

package/dist/core/render/result.js

@@ -17,7 +17,12 @@ var __privateSet = (obj, member, value, setter) => {
   return value;
 };
 var _result, _slots, _loggingOpts;
-import { renderSlot, stringifyChunk } from "../../runtime/server/index.js";
+import {
+  createScopedResult,
+  renderSlot,
+  ScopeFlags,
+  stringifyChunk
+} from "../../runtime/server/index.js";
 import { renderJSX } from "../../runtime/server/jsx.js";
 import { AstroCookies } from "../cookies/index.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
@@ -72,6 +77,7 @@ class Slots {
   async render(name, args = []) {
     if (!__privateGet(this, _slots) || !this.has(name))
       return;
+    const scoped = createScopedResult(__privateGet(this, _result), ScopeFlags.RenderSlot);
     if (!Array.isArray(args)) {
       warn(
         __privateGet(this, _loggingOpts),
@@ -80,22 +86,20 @@ class Slots {
       );
     } else if (args.length > 0) {
       const slotValue = __privateGet(this, _slots)[name];
-      const component = typeof slotValue === "function" ? await slotValue() : await slotValue;
+      const component = typeof slotValue === "function" ? await slotValue(scoped) : await slotValue;
       const expression = getFunctionExpression(component);
       if (expression) {
-        const slot = expression(...args);
-        return await renderSlot(__privateGet(this, _result), slot).then(
-          (res) => res != null ? String(res) : res
-        );
+        const slot = () => expression(...args);
+        return await renderSlot(scoped, slot).then((res) => res != null ? String(res) : res);
       }
       if (typeof component === "function") {
-        return await renderJSX(__privateGet(this, _result), component(...args)).then(
+        return await renderJSX(scoped, component(...args)).then(
           (res) => res != null ? String(res) : res
         );
       }
     }
-    const content = await renderSlot(__privateGet(this, _result), __privateGet(this, _slots)[name]);
-    const outHTML = stringifyChunk(__privateGet(this, _result), content);
+    const content = await renderSlot(scoped, __privateGet(this, _slots)[name]);
+    const outHTML = stringifyChunk(scoped, content);
     return outHTML;
   }
 }
@@ -126,6 +130,7 @@ function createResult(args) {
     propagation: args.propagation ?? /* @__PURE__ */ new Map(),
     propagators: /* @__PURE__ */ new Map(),
     extraHead: [],
+    scope: 0,
     cookies,
     createAstro(astroGlobal, props, slots) {
       const astroSlots = new Slots(result, slots, args.logging);

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

@@ -3,8 +3,8 @@ export { createAstro } from './astro-global.js';
 export { renderEndpoint } from './endpoint.js';
 export { escapeHTML, HTMLBytes, HTMLString, markHTMLString, unescapeHTML } from './escape.js';
 export { renderJSX } from './jsx.js';
-export { addAttribute, createHeadAndContent, defineScriptVars, Fragment, maybeRenderHead, renderAstroTemplateResult as renderAstroComponent, renderComponent, renderComponentToIterable, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderScriptElement, renderSlot, renderStyleElement, renderTemplate as render, renderTemplate, renderToString, renderUniqueStylesheet, stringifyChunk, voidElementNames, } from './render/index.js';
-export type { AstroComponentFactory, AstroComponentInstance, AstroComponentSlots, AstroComponentSlotsWithValues, RenderInstruction, } from './render/index.js';
+export { addAttribute, addScopeFlag, createHeadAndContent, createScopedResult, defineScriptVars, Fragment, maybeRenderHead, removeScopeFlag, renderAstroTemplateResult as renderAstroComponent, renderComponent, renderComponentToIterable, Renderer as Renderer, renderHead, renderHTMLElement, renderPage, renderScriptElement, renderSlot, renderStyleElement, renderTemplate as render, renderTemplate, renderToString, renderUniqueStylesheet, ScopeFlags, stringifyChunk, voidElementNames, } from './render/index.js';
+export type { AstroComponentFactory, AstroComponentInstance, ComponentSlots, RenderInstruction, } from './render/index.js';
 export declare function mergeSlots(...slotted: unknown[]): Record<string, () => any>;
 /** @internal Associate JSX components with a specific renderer (see /src/vite-plugin-jsx/tag.ts) */
 export declare function __astro_tag_component__(Component: unknown, rendererName: string): void;

package/dist/runtime/server/index.js

@@ -5,10 +5,13 @@ import { escapeHTML, HTMLBytes, HTMLString, markHTMLString, unescapeHTML } from
 import { renderJSX } from "./jsx.js";
 import {
   addAttribute,
+  addScopeFlag,
   createHeadAndContent,
+  createScopedResult,
   defineScriptVars,
   Fragment,
   maybeRenderHead,
+  removeScopeFlag,
   renderAstroTemplateResult,
   renderComponent,
   renderComponentToIterable,
@@ -23,6 +26,7 @@ import {
   renderTemplate as renderTemplate2,
   renderToString,
   renderUniqueStylesheet,
+  ScopeFlags,
   stringifyChunk,
   voidElementNames
 } from "./render/index.js";
@@ -85,17 +89,21 @@ export {
   HTMLBytes,
   HTMLString,
   Renderer,
+  ScopeFlags,
   __astro_tag_component__,
   addAttribute,
+  addScopeFlag,
   createAstro,
   createComponent,
   createHeadAndContent,
+  createScopedResult,
   defineScriptVars,
   defineStyleVars,
   escapeHTML,
   markHTMLString,
   maybeRenderHead,
   mergeSlots,
+  removeScopeFlag,
   renderTemplate as render,
   renderAstroTemplateResult as renderAstroComponent,
   renderComponent,

package/dist/runtime/server/jsx.js

@@ -9,6 +9,7 @@ import {
   voidElementNames
 } from "./index.js";
 import { HTMLParts } from "./render/common.js";
+import { createScopedResult, ScopeFlags } from "./render/scope.js";
 const ClientOnlyPlaceholder = "astro-client-only";
 class Skip {
   constructor(vnode) {
@@ -77,7 +78,9 @@ Did you forget to import the component or is it possible there is a typo?`);
             props[key] = value;
           }
         }
-        return markHTMLString(await renderToString(result, vnode.type, props, slots));
+        const scoped = createScopedResult(result, ScopeFlags.JSX);
+        const html = markHTMLString(await renderToString(scoped, vnode.type, props, slots));
+        return html;
       }
       case (!vnode.type && vnode.type !== 0):
         return "";

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

@@ -1,11 +1,13 @@
 import { HTMLParts } from "../common.js";
+import { createScopedResult, ScopeFlags } from "../scope.js";
 import { isHeadAndContent } from "./head-and-content.js";
 import { renderAstroTemplateResult } from "./render-template.js";
 function isAstroComponentFactory(obj) {
   return obj == null ? false : obj.isAstroComponentFactory === true;
 }
 async function renderToString(result, componentFactory, props, children) {
-  const factoryResult = await componentFactory(result, props, children);
+  const scoped = createScopedResult(result, ScopeFlags.Astro);
+  const factoryResult = await componentFactory(scoped, props, children);
   if (factoryResult instanceof Response) {
     const response = factoryResult;
     throw response;

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

@@ -1,6 +1,6 @@
 export type { AstroComponentFactory } from './factory';
 export { isAstroComponentFactory, renderToString } from './factory.js';
 export { createHeadAndContent, isHeadAndContent } from './head-and-content.js';
-export type { AstroComponentInstance, ComponentSlots, ComponentSlotsWithValues } from './instance';
+export type { AstroComponentInstance } from './instance';
 export { createAstroComponentInstance, isAstroComponentInstance } from './instance.js';
 export { isRenderTemplateResult, renderAstroTemplateResult, renderTemplate, } from './render-template.js';

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

@@ -1,10 +1,7 @@
 import type { SSRResult } from '../../../../@types/astro';
+import type { ComponentSlots } from '../slot.js';
 import type { AstroComponentFactory, AstroFactoryReturnValue } from './factory.js';
-import type { renderTemplate } from './render-template.js';
 type ComponentProps = Record<string | number, any>;
-type ComponentSlotValue = () => ReturnType<typeof renderTemplate>;
-export type ComponentSlots = Record<string, ComponentSlotValue>;
-export type ComponentSlotsWithValues = Record<string, ReturnType<ComponentSlotValue>>;
 declare const astroComponentInstanceSym: unique symbol;
 export declare class AstroComponentInstance {
     [astroComponentInstanceSym]: boolean;
@@ -14,7 +11,7 @@ export declare class AstroComponentInstance {
     private readonly factory;
     private returnValue;
     constructor(result: SSRResult, props: ComponentProps, slots: ComponentSlots, factory: AstroComponentFactory);
-    init(): Promise<AstroFactoryReturnValue>;
+    init(result: SSRResult): Promise<AstroFactoryReturnValue>;
     render(): AsyncGenerator<any, void, undefined>;
 }
 export declare function createAstroComponentInstance(result: SSRResult, displayName: string, factory: AstroComponentFactory, props: ComponentProps, slots?: any): AstroComponentInstance;

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

@@ -2,6 +2,7 @@ var _a;
 import { HydrationDirectiveProps } from "../../hydration.js";
 import { isPromise } from "../../util.js";
 import { renderChild } from "../any.js";
+import { createScopedResult, ScopeFlags } from "../scope.js";
 import { isAPropagatingComponent } from "./factory.js";
 import { isHeadAndContent } from "./head-and-content.js";
 const astroComponentInstanceSym = Symbol.for("astro.componentInstance");
@@ -12,17 +13,19 @@ class AstroComponentInstance {
     this.props = props;
     this.factory = factory;
     this.slotValues = {};
+    const scoped = createScopedResult(result, ScopeFlags.Slot);
     for (const name in slots) {
-      this.slotValues[name] = slots[name]();
+      const value = slots[name](scoped);
+      this.slotValues[name] = () => value;
     }
   }
-  async init() {
-    this.returnValue = this.factory(this.result, this.props, this.slotValues);
+  async init(result) {
+    this.returnValue = this.factory(result, this.props, this.slotValues);
     return this.returnValue;
   }
   async *render() {
     if (this.returnValue === void 0) {
-      await this.init();
+      await this.init(this.result);
     }
     let value = this.returnValue;
     if (isPromise(value)) {

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

@@ -5,6 +5,7 @@ import {
   getPrescripts
 } from "../scripts.js";
 import { renderAllHeadContent } from "./head.js";
+import { ScopeFlags } from "./scope.js";
 import { isSlotString } from "./slot.js";
 const Fragment = Symbol.for("astro:fragment");
 const Renderer = Symbol.for("astro:renderer");
@@ -32,6 +33,25 @@ function stringifyChunk(result, chunk) {
         }
         return renderAllHeadContent(result);
       }
+      case "maybe-head": {
+        if (result._metadata.hasRenderedHead) {
+          return "";
+        }
+        const scope = instruction.scope;
+        switch (scope) {
+          case ScopeFlags.JSX | ScopeFlags.Slot | ScopeFlags.Astro:
+          case ScopeFlags.JSX | ScopeFlags.Astro | ScopeFlags.HeadBuffer:
+          case ScopeFlags.JSX | ScopeFlags.Slot | ScopeFlags.Astro | ScopeFlags.HeadBuffer: {
+            return "";
+          }
+          case ScopeFlags.RenderSlot | ScopeFlags.Astro:
+          case ScopeFlags.RenderSlot | ScopeFlags.Astro | ScopeFlags.JSX:
+          case ScopeFlags.RenderSlot | ScopeFlags.Astro | ScopeFlags.JSX | ScopeFlags.HeadBuffer: {
+            return "";
+          }
+        }
+        return renderAllHeadContent(result);
+      }
     }
   } else {
     if (isSlotString(chunk)) {

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

@@ -32,7 +32,8 @@ function guessRenderers(componentUrl) {
         "@astrojs/preact",
         "@astrojs/solid-js",
         "@astrojs/vue",
-        "@astrojs/svelte"
+        "@astrojs/svelte",
+        "@astrojs/lit"
       ];
   }
 }

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

@@ -5,6 +5,7 @@ export declare function renderHead(result: SSRResult): Generator<{
     readonly result: SSRResult;
 }, void, unknown>;
 export declare function maybeRenderHead(result: SSRResult): Generator<{
-    readonly type: "head";
+    readonly type: "maybe-head";
     readonly result: SSRResult;
+    readonly scope: number;
 }, void, unknown>;

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

@@ -28,7 +28,7 @@ function* maybeRenderHead(result) {
   if (result._metadata.hasRenderedHead) {
     return;
   }
-  yield { type: "head", result };
+  yield { type: "maybe-head", result, scope: result.scope };
 }
 export {
   maybeRenderHead,

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

@@ -1,11 +1,12 @@
-export type { AstroComponentFactory, AstroComponentInstance, ComponentSlots as AstroComponentSlots, ComponentSlotsWithValues as AstroComponentSlotsWithValues, } from './astro/index';
+export type { AstroComponentFactory, AstroComponentInstance } from './astro/index';
 export { createHeadAndContent, renderAstroTemplateResult, renderTemplate, renderToString, } from './astro/index.js';
 export { Fragment, Renderer, stringifyChunk } from './common.js';
 export { renderComponent, renderComponentToIterable } from './component.js';
 export { renderHTMLElement } from './dom.js';
 export { maybeRenderHead, renderHead } from './head.js';
 export { renderPage } from './page.js';
-export { renderSlot } from './slot.js';
+export { addScopeFlag, createScopedResult, removeScopeFlag, ScopeFlags } from './scope.js';
+export { renderSlot, type ComponentSlots } from './slot.js';
 export { renderScriptElement, renderStyleElement, renderUniqueStylesheet } from './tags.js';
 export type { RenderInstruction } from './types';
 export { addAttribute, defineScriptVars, voidElementNames } from './util.js';

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

@@ -9,16 +9,21 @@ import { renderComponent, renderComponentToIterable } from "./component.js";
 import { renderHTMLElement } from "./dom.js";
 import { maybeRenderHead, renderHead } from "./head.js";
 import { renderPage } from "./page.js";
+import { addScopeFlag, createScopedResult, removeScopeFlag, ScopeFlags } from "./scope.js";
 import { renderSlot } from "./slot.js";
 import { renderScriptElement, renderStyleElement, renderUniqueStylesheet } from "./tags.js";
 import { addAttribute, defineScriptVars, voidElementNames } from "./util.js";
 export {
   Fragment,
   Renderer,
+  ScopeFlags,
   addAttribute,
+  addScopeFlag,
   createHeadAndContent,
+  createScopedResult,
   defineScriptVars,
   maybeRenderHead,
+  removeScopeFlag,
   renderAstroTemplateResult,
   renderComponent,
   renderComponentToIterable,

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

@@ -11,6 +11,7 @@ import {
 import { chunkToByteArray, encoder, HTMLParts } from "./common.js";
 import { renderComponent } from "./component.js";
 import { maybeRenderHead } from "./head.js";
+import { createScopedResult, ScopeFlags } from "./scope.js";
 const needsHeadRenderingSymbol = Symbol.for("astro.needsHeadRendering");
 function nonAstroPageNeedsHeadInjection(pageComponent) {
   return needsHeadRenderingSymbol in pageComponent && !!pageComponent[needsHeadRenderingSymbol];
@@ -36,12 +37,13 @@ async function iterableToHTMLBytes(result, iterable, onDocTypeInjection) {
 }
 async function bufferHeadContent(result) {
   const iterator = result.propagators.values();
+  const scoped = createScopedResult(result, ScopeFlags.HeadBuffer);
   while (true) {
     const { value, done } = iterator.next();
     if (done) {
       break;
     }
-    const returnValue = await value.init();
+    const returnValue = await value.init(scoped);
     if (isHeadAndContent(returnValue)) {
       result.extraHead.push(returnValue.head);
     }

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

@@ -0,0 +1,13 @@
+import type { SSRResult } from '../../../@types/astro';
+export declare const ScopeFlags: {
+    readonly Astro: number;
+    readonly JSX: number;
+    readonly Slot: number;
+    readonly HeadBuffer: number;
+    readonly RenderSlot: number;
+};
+type ScopeFlagValues = (typeof ScopeFlags)[keyof typeof ScopeFlags];
+export declare function addScopeFlag(result: SSRResult, flag: ScopeFlagValues): void;
+export declare function removeScopeFlag(result: SSRResult, flag: ScopeFlagValues): void;
+export declare function createScopedResult(result: SSRResult, flag?: ScopeFlagValues): SSRResult;
+export {};

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

@@ -0,0 +1,31 @@
+const ScopeFlags = {
+  Astro: 1 << 0,
+  JSX: 1 << 1,
+  Slot: 1 << 2,
+  HeadBuffer: 1 << 3,
+  RenderSlot: 1 << 4
+};
+function addScopeFlag(result, flag) {
+  result.scope |= flag;
+}
+function removeScopeFlag(result, flag) {
+  result.scope &= ~flag;
+}
+function createScopedResult(result, flag) {
+  const scopedResult = Object.create(result, {
+    scope: {
+      writable: true,
+      value: result.scope
+    }
+  });
+  if (flag != null) {
+    addScopeFlag(scopedResult, flag);
+  }
+  return scopedResult;
+}
+export {
+  ScopeFlags,
+  addScopeFlag,
+  createScopedResult,
+  removeScopeFlag
+};

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

@@ -1,6 +1,10 @@
 import type { SSRResult } from '../../../@types/astro.js';
+import type { renderTemplate } from './astro/render-template.js';
 import type { RenderInstruction } from './types.js';
 import { HTMLString } from '../escape.js';
+type RenderTemplateResult = ReturnType<typeof renderTemplate>;
+export type ComponentSlots = Record<string, ComponentSlotValue>;
+export type ComponentSlotValue = (result: SSRResult) => RenderTemplateResult;
 declare const slotString: unique symbol;
 export declare class SlotString extends HTMLString {
     instructions: null | RenderInstruction[];
@@ -8,10 +12,10 @@ export declare class SlotString extends HTMLString {
     constructor(content: string, instructions: null | RenderInstruction[]);
 }
 export declare function isSlotString(str: string): str is any;
-export declare function renderSlot(_result: any, slotted: string, fallback?: any): Promise<string>;
+export declare function renderSlot(result: SSRResult, slotted: ComponentSlotValue | RenderTemplateResult, fallback?: ComponentSlotValue | RenderTemplateResult): Promise<string>;
 interface RenderSlotsResult {
     slotInstructions: null | RenderInstruction[];
     children: Record<string, string>;
 }
-export declare function renderSlots(result: SSRResult, slots?: any): Promise<RenderSlotsResult>;
+export declare function renderSlots(result: SSRResult, slots?: ComponentSlots): Promise<RenderSlotsResult>;
 export {};

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

@@ -1,5 +1,6 @@
 import { HTMLString, markHTMLString } from "../escape.js";
 import { renderChild } from "./any.js";
+import { createScopedResult, ScopeFlags } from "./scope.js";
 const slotString = Symbol.for("astro:slot-string");
 class SlotString extends HTMLString {
   constructor(content, instructions) {
@@ -12,9 +13,10 @@ slotString;
 function isSlotString(str) {
   return !!str[slotString];
 }
-async function renderSlot(_result, slotted, fallback) {
+async function renderSlot(result, slotted, fallback) {
   if (slotted) {
-    let iterator = renderChild(slotted);
+    const scoped = createScopedResult(result, ScopeFlags.Slot);
+    let iterator = renderChild(typeof slotted === "function" ? slotted(scoped) : slotted);
     let content = "";
     let instructions = null;
     for await (const chunk of iterator) {
@@ -29,7 +31,10 @@ async function renderSlot(_result, slotted, fallback) {
     }
     return markHTMLString(new SlotString(content, instructions));
   }
-  return fallback;
+  if (fallback) {
+    return renderSlot(result, fallback);
+  }
+  return "";
 }
 async function renderSlots(result, slots = {}) {
   let slotInstructions = null;

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

@@ -9,4 +9,9 @@ export type RenderHeadInstruction = {
     type: 'head';
     result: SSRResult;
 };
-export type RenderInstruction = RenderDirectiveInstruction | RenderHeadInstruction;
+export type MaybeRenderHeadInstruction = {
+    type: 'maybe-head';
+    result: SSRResult;
+    scope: number;
+};
+export type RenderInstruction = RenderDirectiveInstruction | RenderHeadInstruction | MaybeRenderHeadInstruction;

package/dist/vite-plugin-astro-server/route.js

@@ -139,7 +139,7 @@ async function handleRoute(matchedRoute, url, pathname, body, origin, env, manif
       if (computedMimeType) {
         contentType = computedMimeType;
       }
-      const response = new Response(result.body, {
+      const response = new Response(Buffer.from(result.body, result.encoding), {
         status: 200,
         headers: {
           "Content-Type": `${contentType};charset=utf-8`

package/dist/vite-plugin-head-propagation/index.d.ts

@@ -1,4 +1,7 @@
 import type { AstroSettings } from '../@types/astro';
+import type { BuildInternals } from '../core/build/internal.js';
+import type { AstroBuildPlugin } from '../core/build/plugin.js';
+import type { StaticBuildOptions } from '../core/build/types';
 import * as vite from 'vite';
 /**
  * If any component is marked as doing head injection, walk up the tree
@@ -9,3 +12,4 @@ import * as vite from 'vite';
 export default function configHeadPropagationVitePlugin({ settings, }: {
     settings: AstroSettings;
 }): vite.Plugin;
+export declare function astroHeadPropagationBuildPlugin(options: StaticBuildOptions, internals: BuildInternals): AstroBuildPlugin;

package/dist/vite-plugin-head-propagation/index.js

@@ -1,3 +1,4 @@
+import { walkParentInfos } from "../core/build/graph.js";
 import { getAstroMetadata } from "../vite-plugin-astro/index.js";
 const injectExp = /^\/\/\s*astro-head-inject/;
 function configHeadPropagationVitePlugin({
@@ -39,6 +40,47 @@ function configHeadPropagationVitePlugin({
     }
   };
 }
+function astroHeadPropagationBuildPlugin(options, internals) {
+  return {
+    build: "ssr",
+    hooks: {
+      "build:before"() {
+        const map = /* @__PURE__ */ new Map();
+        return {
+          vitePlugin: {
+            name: "vite-plugin-head-propagation-build",
+            generateBundle(_opts, bundle) {
+              const appendPropagation = (info) => {
+                const astroMetadata = getAstroMetadata(info);
+                if (astroMetadata) {
+                  astroMetadata.propagation = "in-tree";
+                  map.set(info.id, "in-tree");
+                }
+              };
+              for (const [bundleId, output] of Object.entries(bundle)) {
+                if (output.type !== "chunk")
+                  continue;
+                for (const [id, mod] of Object.entries(output.modules)) {
+                  if (mod.code && injectExp.test(mod.code)) {
+                    for (const [info2] of walkParentInfos(id, this)) {
+                      appendPropagation(info2);
+                    }
+                  }
+                  const info = this.getModuleInfo(id);
+                  if (info) {
+                    appendPropagation(info);
+                  }
+                }
+              }
+              internals.propagation = map;
+            }
+          }
+        };
+      }
+    }
+  };
+}
 export {
+  astroHeadPropagationBuildPlugin,
   configHeadPropagationVitePlugin as default
 };

package/dist/vite-plugin-scanner/index.js

@@ -23,6 +23,7 @@ function astroScannerPlugin({ settings }) {
       const { meta = {} } = this.getModuleInfo(id) ?? {};
       return {
         code,
+        map: null,
         meta: {
           ...meta,
           astro: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "2.0.5",
+  "version": "2.0.7",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -85,7 +85,7 @@
     "src/content/template"
   ],
   "dependencies": {
-    "@astrojs/compiler": "^1.0.1",
+    "@astrojs/compiler": "^1.1.0",
     "@astrojs/language-server": "^0.28.3",
     "@astrojs/markdown-remark": "^2.0.1",
     "@astrojs/telemetry": "^2.0.0",

package/dist/content/vite-plugin-content-server.d.ts

@@ -1,13 +0,0 @@
-/// <reference types="node" />
-import fsMod from 'node:fs';
-import type { Plugin } from 'vite';
-import type { AstroSettings } from '../@types/astro.js';
-import { LogOptions } from '../core/logger/core.js';
-interface AstroContentServerPluginParams {
-    fs: typeof fsMod;
-    logging: LogOptions;
-    settings: AstroSettings;
-    mode: string;
-}
-export declare function astroContentServerPlugin({ fs, settings, logging, mode, }: AstroContentServerPluginParams): Plugin[];
-export {};