astro 7.2.2 → 7.2.3

package/dist/vite-plugin-app/createAstroServerApp.js

@@ -1,5 +1,5 @@
 import { manifest } from "virtual:astro:manifest";
-import { routes } from "virtual:astro:routes";
+import { clearActions } from "../actions/load.js";
 import { getPackageManager } from "../cli/info/core/get-package-manager.js";
 import { DevDebugInfoProvider } from "../cli/info/infra/dev-debug-info-provider.js";
 import { ProcessNodeVersionProvider } from "../cli/info/infra/process-node-version-provider.js";
@@ -9,11 +9,17 @@ import { BuildTimeAstroVersionProvider } from "../cli/infra/build-time-astro-ver
 import { PassthroughTextStyler } from "../cli/infra/passthrough-text-styler.js";
 import { ProcessOperatingSystemProvider } from "../cli/infra/process-operating-system-provider.js";
 import { TinyexecCommandExecutor } from "../cli/infra/tinyexec-command-executor.js";
-import { AstroServerApp } from "./app.js";
+import { DevFacadeApp } from "../core/app/dev-facade.js";
+import { setEnvironment } from "../core/environment/index.js";
 import { createNodeLoggerFromFlags } from "../core/logger/impls/node.js";
+import { setLogger } from "../core/logger/manifest-logger.js";
+import { clearMiddleware } from "../core/middleware/load.js";
+import { getRouteCache } from "../core/render/route-cache.js";
+import { updateRouteTable } from "../core/routing/route-table.js";
+import { createRunnableEnvironment } from "./environment.js";
+import { handleDevRequest } from "./handle-request.js";
 async function createAstroServerApp(controller, settings, loader, logger) {
   const actualLogger = logger ?? createNodeLoggerFromFlags({});
-  const routesList = { routes: routes.map((r) => r.routeData) };
   const debugInfoProvider = new DevDebugInfoProvider({
     config: settings.config,
     astroVersionProvider: new BuildTimeAstroVersionProvider(),
@@ -28,22 +34,21 @@ async function createAstroServerApp(controller, settings, loader, logger) {
     textStyler: new PassthroughTextStyler()
   });
   const debugInfo = debugInfoFormatter.format(await debugInfoProvider.get());
-  const app = await AstroServerApp.create(
+  setLogger(manifest, actualLogger);
+  setEnvironment(
     manifest,
-    routesList,
-    actualLogger,
-    loader,
-    settings,
-    async () => debugInfo
+    createRunnableEnvironment({ loader, settings, getDebugInfo: async () => debugInfo })
   );
+  const app = new DevFacadeApp(manifest, true);
+  const deps = { loader, settings, controller };
   if (import.meta.hot) {
     import.meta.hot.on("astro:routes-updated", async () => {
       try {
         const { routes: newRoutes } = await import("virtual:astro:routes");
-        const newRoutesList = {
-          routes: newRoutes.map((r) => r.routeData)
-        };
-        app.updateRoutes(newRoutesList);
+        updateRouteTable(
+          manifest,
+          newRoutes.map((r) => r.routeData)
+        );
         actualLogger.debug("router", "Routes updated via HMR");
       } catch (e) {
         actualLogger.error("router", `Failed to update routes via HMR:
@@ -51,22 +56,21 @@ async function createAstroServerApp(controller, settings, loader, logger) {
       }
     });
     import.meta.hot.on("astro:content-changed", () => {
-      app.clearRouteCache();
+      getRouteCache(manifest).clearAll();
       actualLogger.debug("router", "Route cache cleared due to content change");
     });
     import.meta.hot.on("astro:middleware-updated", () => {
-      app.clearMiddleware();
+      clearMiddleware(manifest);
       actualLogger.debug("router", "Middleware cache cleared due to file change");
     });
     import.meta.hot.on("astro:actions-updated", () => {
-      app.clearActions();
+      clearActions(manifest);
       actualLogger.debug("router", "Actions cache cleared due to file change");
     });
   }
   return {
     handler(incomingRequest, incomingResponse, options) {
-      return app.handleRequest({
-        controller,
+      return handleDevRequest(app, deps, {
         incomingRequest,
         incomingResponse,
         isHttps: loader?.isHttps() ?? false,

package/dist/vite-plugin-app/environment.d.ts

@@ -0,0 +1,18 @@
+import type { RenderEnvironment } from '../core/environment/index.js';
+import type { ModuleLoader } from '../core/module-loader/index.js';
+import type { AstroSettings } from '../types/astro.js';
+import type { SSRLoadedRenderer, SSRManifest } from '../types/public/internal.js';
+export declare function getDevRenderers(manifest: SSRManifest): SSRLoadedRenderer[];
+export declare function setDevRenderers(manifest: SSRManifest, renderers: SSRLoadedRenderer[]): void;
+export interface RunnableEnvironmentOptions {
+    loader: ModuleLoader;
+    settings: AstroSettings;
+    getDebugInfo: () => Promise<string>;
+}
+/**
+ * The runnable dev environment (the Vite SSR environment can load modules at
+ * runtime). The ModuleLoader and AstroSettings are captured in this closure at
+ * composition time (`createAstroServerApp`) and are unreachable from
+ * requests/states by design — only the environment functions close over them.
+ */
+export declare function createRunnableEnvironment({ loader, settings, getDebugInfo, }: RunnableEnvironmentOptions): RenderEnvironment;

package/dist/vite-plugin-app/environment.js

@@ -0,0 +1,210 @@
+import { fileURLToPath } from "node:url";
+import { ASTRO_VERSION } from "../core/constants.js";
+import { enhanceViteSSRError } from "../core/errors/dev/index.js";
+import { AggregateError, CSSError, MarkdownError } from "../core/errors/index.js";
+import { getLogger } from "../core/logger/manifest-logger.js";
+import { req } from "../core/messages/runtime.js";
+import {
+  RedirectComponentInstance,
+  RedirectSinglePageBuiltModule
+} from "../core/redirects/index.js";
+import { loadRenderer } from "../core/render/index.js";
+import { getDefaultRoutes } from "../core/routing/default.js";
+import { routeIsRedirect } from "../core/routing/helpers.js";
+import { findRouteToRewrite } from "../core/routing/rewrite.js";
+import { getRouteTable } from "../core/routing/route-table.js";
+import { isPage } from "../core/util.js";
+import { resolveIdToUrl } from "../core/viteUtils.js";
+import { stringifyForScript } from "../runtime/server/escape.js";
+import { getComponentMetadata } from "../vite-plugin-astro-server/metadata.js";
+import { PAGE_SCRIPT_ID } from "../vite-plugin-scripts/index.js";
+const devRenderers = /* @__PURE__ */ new WeakMap();
+function getDevRenderers(manifest) {
+  return devRenderers.get(manifest) ?? [];
+}
+function setDevRenderers(manifest, renderers) {
+  devRenderers.set(manifest, renderers);
+}
+async function getModuleForRoute(manifest, route) {
+  for (const defaultRoute of getDefaultRoutes(manifest)) {
+    if (route.component === defaultRoute.component) {
+      return {
+        page: () => Promise.resolve(defaultRoute.instance)
+      };
+    }
+  }
+  if (route.type === "redirect") {
+    return RedirectSinglePageBuiltModule;
+  } else {
+    if (manifest.pageMap) {
+      const importComponentInstance = manifest.pageMap.get(route.component);
+      if (!importComponentInstance) {
+        throw new Error(
+          `Unexpectedly unable to find a component instance for route ${route.route}`
+        );
+      }
+      return await importComponentInstance();
+    } else if (manifest.pageModule) {
+      return manifest.pageModule;
+    }
+    throw new Error(
+      "Astro couldn't find the correct page to render, probably because it wasn't correctly mapped for SSR usage. This is an internal error, please file an issue."
+    );
+  }
+}
+function createRunnableEnvironment({
+  loader,
+  settings,
+  getDebugInfo
+}) {
+  async function getComponentByRoute(manifest, routeData) {
+    if (routeIsRedirect(routeData)) {
+      return RedirectComponentInstance;
+    }
+    const filePath = new URL(`${routeData.component}`, manifest.rootDir);
+    for (const route of getDefaultRoutes(manifest)) {
+      if (route.matchesComponent(filePath)) {
+        return route.instance;
+      }
+    }
+    if (settings) {
+      const renderers__ = settings.renderers.map((r) => loadRenderer(r, loader));
+      const renderers_ = await Promise.all(renderers__);
+      setDevRenderers(
+        manifest,
+        renderers_.filter((r) => Boolean(r))
+      );
+    }
+    try {
+      return await loader.import(filePath.toString());
+    } catch (error) {
+      if (MarkdownError.is(error) || CSSError.is(error) || AggregateError.is(error)) {
+        throw error;
+      }
+      throw enhanceViteSSRError({ error, filePath, loader });
+    }
+  }
+  return {
+    name: "dev-runnable",
+    runtimeMode: "development",
+    // Dev always streams.
+    defaultStreaming: () => true,
+    resolve(manifest, specifier) {
+      return resolveIdToUrl(loader, specifier, manifest.rootDir);
+    },
+    async headElements(manifest, routeData) {
+      const filePath = new URL(`${routeData.component}`, manifest.rootDir);
+      const scripts = /* @__PURE__ */ new Set();
+      if (settings) {
+        if (isPage(filePath, settings)) {
+          scripts.add({
+            props: { type: "module", src: "/@vite/client" },
+            children: ""
+          });
+          if (manifest.devToolbar.enabled) {
+            scripts.add({
+              props: {
+                type: "module",
+                src: "/@id/astro/runtime/client/dev-toolbar/entrypoint.js"
+              },
+              children: ""
+            });
+            const additionalMetadata = {
+              root: fileURLToPath(settings.config.root),
+              version: ASTRO_VERSION,
+              latestAstroVersion: settings.latestAstroVersion,
+              // TODO: Currently the debug info is always fetched, which slows things down.
+              // We should look into not loading it if the dev toolbar is disabled. And when
+              // enabled, it would nice to request the debug info through import.meta.hot
+              // when the button is click to defer execution as much as possible
+              debugInfo: await getDebugInfo(),
+              placement: settings.config.devToolbar.placement
+            };
+            const children = `window.__astro_dev_toolbar__ = ${stringifyForScript(additionalMetadata)}`;
+            scripts.add({ props: {}, children });
+          }
+        }
+        for (const script of settings.scripts) {
+          if (script.stage === "head-inline") {
+            scripts.add({
+              props: {},
+              children: script.content
+            });
+          } else if (script.stage === "page" && isPage(filePath, settings)) {
+            scripts.add({
+              props: { type: "module", src: `/@id/${PAGE_SCRIPT_ID}` },
+              children: ""
+            });
+          }
+        }
+      }
+      const { devCSSMap } = await import("virtual:astro:dev-css-all");
+      const importer = devCSSMap.get(routeData.component);
+      let css = /* @__PURE__ */ new Set();
+      if (importer) {
+        const cssModule = await importer();
+        css = cssModule.css;
+      } else {
+        getLogger(manifest).warn(
+          "assets",
+          `Unable to find CSS for ${routeData.component}. This is likely a bug in Astro.`
+        );
+      }
+      const links = /* @__PURE__ */ new Set();
+      const styles = /* @__PURE__ */ new Set();
+      for (const { id, url: src, content } of css) {
+        scripts.add({ props: { type: "module", src }, children: "" });
+        styles.add({ props: { "data-vite-dev-id": id }, children: content });
+      }
+      return { scripts, styles, links };
+    },
+    componentMetadata(manifest, routeData) {
+      const filePath = new URL(`${routeData.component}`, manifest.rootDir);
+      return getComponentMetadata(filePath, loader);
+    },
+    getComponentByRoute,
+    getModuleForRoute,
+    async tryRewrite(manifest, payload, request) {
+      const { routeData, pathname, newUrl } = findRouteToRewrite({
+        payload,
+        request,
+        // The single fresh route table: HMR route updates are visible
+        // to rewrites at the same instant as every other consumer.
+        routes: getRouteTable(manifest).routes,
+        trailingSlash: manifest.trailingSlash,
+        buildFormat: manifest.buildFormat,
+        base: manifest.base,
+        outDir: manifest.outDir
+      });
+      const componentInstance = await getComponentByRoute(manifest, routeData);
+      return { newUrl, pathname, componentInstance, routeData };
+    },
+    getRenderers(manifest) {
+      return getDevRenderers(manifest);
+    },
+    errorStrategy: "dev",
+    injectCspMetaTagsOnErrorPages: true,
+    logRequest(manifest, payload) {
+      const { pathname, method, statusCode, isRewrite, timeStart } = payload;
+      if (pathname === "/favicon.ico") {
+        return;
+      }
+      const reqTime = performance.now() - timeStart;
+      getLogger(manifest).info(
+        null,
+        req({
+          url: pathname,
+          method,
+          statusCode,
+          isRewrite,
+          reqTime
+        })
+      );
+    }
+  };
+}
+export {
+  createRunnableEnvironment,
+  getDevRenderers,
+  setDevRenderers
+};

package/dist/vite-plugin-app/handle-request.d.ts

@@ -0,0 +1,30 @@
+import type http from 'node:http';
+import type { DevFacadeApp } from '../core/app/dev-facade.js';
+import type { ModuleLoader } from '../core/module-loader/index.js';
+import type { AstroSettings } from '../types/astro.js';
+import type { DevServerController } from '../vite-plugin-astro-server/controller.js';
+/** Composition-time dependencies closed over by `createAstroServerApp`. */
+export interface DevRequestDeps {
+    loader: ModuleLoader;
+    settings: AstroSettings;
+    controller: DevServerController;
+}
+export interface DevRequestIO {
+    incomingRequest: http.IncomingMessage;
+    incomingResponse: http.ServerResponse;
+    isHttps: boolean;
+    /** When true, only handle prerendered routes. Returns false for SSR routes. */
+    prerenderOnly?: boolean;
+}
+/**
+ * Handle a dev-server request: the HTTP glue that drives the `DevFacadeApp`
+ * the way an adapter does — it sits outside the functional core, like the
+ * node adapter's `serve-app.ts`. The ModuleLoader and AstroSettings are
+ * closed over at composition time in `createAstroServerApp` and passed as
+ * `deps`.
+ *
+ * @returns Whether or not the request was handled by this handler. If the
+ * result is not `true`, then the request has not been handled yet and other
+ * handlers can be run.
+ */
+export declare function handleDevRequest(app: DevFacadeApp, deps: DevRequestDeps, { incomingRequest, incomingResponse, isHttps, prerenderOnly }: DevRequestIO): Promise<boolean>;

package/dist/vite-plugin-app/handle-request.js

@@ -0,0 +1,129 @@
+import { removeTrailingForwardSlash } from "@astrojs/internal-helpers/path";
+import { shouldAppendForwardSlash } from "../core/build/util.js";
+import { clientLocalsSymbol } from "../core/constants.js";
+import { getEnvironment, setEnvironment } from "../core/environment/index.js";
+import { createSafeError } from "../core/errors/index.js";
+import { setLogger } from "../core/logger/manifest-logger.js";
+import { createRequest } from "../core/request.js";
+import { SERIALIZED_MANIFEST_ID } from "../manifest/serialized.js";
+import { recordServerError } from "../vite-plugin-astro-server/error.js";
+import { runWithErrorHandling } from "../vite-plugin-astro-server/index.js";
+import { handle500Response, writeSSRResult } from "../vite-plugin-astro-server/response.js";
+const runnerManifests = /* @__PURE__ */ new WeakMap();
+async function loadFetchHandler(app, loader) {
+  try {
+    const { manifest } = await loader.import(SERIALIZED_MANIFEST_ID);
+    if (manifest && manifest !== runnerManifests.get(loader) && manifest !== app.manifest) {
+      setEnvironment(manifest, getEnvironment(app.manifest));
+      setLogger(manifest, app.logger);
+      runnerManifests.set(loader, manifest);
+    }
+  } catch {
+  }
+  try {
+    const mod = await loader.import("virtual:astro:fetchable");
+    if (mod?.default && !mod.isDefaultFetchHandler) {
+      app.setFetchHandler(mod.default);
+    }
+  } catch {
+  }
+}
+async function handleDevRequest(app, deps, { incomingRequest, incomingResponse, isHttps, prerenderOnly }) {
+  const { loader, settings, controller } = deps;
+  const manifest = app.manifest;
+  const protocol = isHttps ? "https" : "http";
+  const host = incomingRequest.headers[":authority"] ?? incomingRequest.headers.host;
+  const origin = `${protocol}://${host}`;
+  const url = new URL(origin + incomingRequest.url);
+  let pathname;
+  if (manifest.trailingSlash === "never" && !incomingRequest.url) {
+    pathname = "";
+  } else {
+    pathname = decodeURI(url.pathname);
+  }
+  url.pathname = removeTrailingForwardSlash(manifest.base) + url.pathname;
+  if (url.pathname.endsWith("/") && !shouldAppendForwardSlash(manifest.trailingSlash, manifest.buildFormat)) {
+    url.pathname = url.pathname.slice(0, -1);
+  }
+  await loadFetchHandler(app, loader);
+  let handled = true;
+  await runWithErrorHandling({
+    controller,
+    pathname,
+    async run() {
+      const matchedRoute = await app.devMatch(pathname, { prerenderOnly });
+      if (!matchedRoute) {
+        if (prerenderOnly) {
+          handled = false;
+          return;
+        }
+        throw new Error("No route matched, and default 404 route was not found.");
+      }
+      if (prerenderOnly && !matchedRoute.routeData.prerender) {
+        handled = false;
+        return;
+      }
+      let body = void 0;
+      if (!(incomingRequest.method === "GET" || incomingRequest.method === "HEAD")) {
+        let bytes = [];
+        await new Promise((resolve, reject) => {
+          incomingRequest.on("data", (part) => {
+            bytes.push(part);
+          });
+          incomingRequest.on("end", resolve);
+          incomingRequest.on("error", reject);
+        });
+        body = Buffer.concat(bytes);
+      }
+      const abortController = new AbortController();
+      const socket = incomingRequest.socket;
+      const onSocketClose = () => {
+        if (!abortController.signal.aborted) {
+          abortController.abort();
+        }
+      };
+      if (socket.destroyed) {
+        onSocketClose();
+      } else {
+        socket.on("close", onSocketClose);
+      }
+      try {
+        const request = createRequest({
+          url,
+          headers: incomingRequest.headers,
+          method: incomingRequest.method,
+          body,
+          logger: app.logger,
+          isPrerendered: matchedRoute.routeData.prerender,
+          routePattern: matchedRoute.routeData.component,
+          init: { signal: abortController.signal }
+        });
+        const locals = Reflect.get(incomingRequest, clientLocalsSymbol);
+        for (const [name, value] of Object.entries(settings.config.server.headers ?? {})) {
+          if (value) incomingResponse.setHeader(name, value);
+        }
+        const clientAddress = incomingRequest.socket.remoteAddress;
+        const response = await app.render(request, {
+          locals,
+          routeData: matchedRoute.routeData,
+          clientAddress
+        });
+        await writeSSRResult(request, response, incomingResponse);
+      } finally {
+        socket.off("close", onSocketClose);
+      }
+    },
+    onError(_err) {
+      const error = createSafeError(_err);
+      if (loader) {
+        const { errorWithMetadata } = recordServerError(loader, manifest, app.logger, error);
+        handle500Response(loader, incomingResponse, errorWithMetadata);
+      }
+      return error;
+    }
+  });
+  return handled;
+}
+export {
+  handleDevRequest
+};

package/dist/vite-plugin-app/index.d.ts

@@ -1,3 +1,3 @@
 import type * as vite from 'vite';
-export declare const ASTRO_DEV_SERVER_APP_ID = "astro:server-app";
+export declare const ASTRO_DEV_SERVER_APP_ID = "virtual:astro:server-app";
 export declare function vitePluginApp(): vite.Plugin[];

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

@@ -1,6 +1,6 @@
 const ASTRO_APP_ID = "virtual:astro:app";
 const RESOLVED_ASTRO_APP_ID = "\0" + ASTRO_APP_ID;
-const ASTRO_DEV_SERVER_APP_ID = "astro:server-app";
+const ASTRO_DEV_SERVER_APP_ID = "virtual:astro:server-app";
 function vitePluginApp() {
   let command;
   return [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "astro",
-  "version": "7.2.2",
+  "version": "7.2.3",
   "description": "Astro is a modern site builder with web best practices, performance, and DX front-of-mind.",
   "type": "module",
   "author": "withastro",
@@ -78,6 +78,12 @@
     "./logger/compose": "./dist/core/logger/impls/compose.js",
     "./logger/console": "./dist/core/logger/impls/console.js"
   },
+  "imports": {
+    "#astro-internal/ambient-manifest": {
+      "types": "./src/core/manifest/ambient-source.ts",
+      "default": "./dist/core/manifest/ambient-source.js"
+    }
+  },
   "bin": {
     "astro": "./bin/astro.mjs"
   },
@@ -86,6 +92,7 @@
     "tsconfigs",
     "dist",
     "types",
+    "src/core/manifest/ambient-source.ts",
     "bin",
     "env.d.ts",
     "client.d.ts",
@@ -139,22 +146,22 @@
     "tinyexec": "^1.0.4",
     "tinyglobby": "^0.2.15",
     "ultrahtml": "^1.6.0",
-    "unifont": "~0.7.4",
+    "unifont": "~0.7.5",
     "unstorage": "^1.17.5",
     "vite": "^8.0.13",
     "vitefu": "^1.1.2",
     "xxhash-wasm": "^1.1.0",
     "yargs-parser": "^22.0.0",
     "zod": "^4.3.6",
-    "@astrojs/telemetry": "3.3.3",
-    "@astrojs/markdown-satteri": "0.3.5",
-    "@astrojs/internal-helpers": "0.10.2"
+    "@astrojs/internal-helpers": "0.10.3",
+    "@astrojs/markdown-satteri": "0.3.6",
+    "@astrojs/telemetry": "3.3.3"
   },
   "optionalDependencies": {
     "sharp": "^0.34.0 || ^0.35.0"
   },
   "peerDependencies": {
-    "@astrojs/markdown-remark": "7.2.2"
+    "@astrojs/markdown-remark": "7.2.3"
   },
   "peerDependenciesMeta": {
     "@astrojs/markdown-remark": {
@@ -186,8 +193,8 @@
     "typescript": "^6.0.3",
     "undici": "^7.22.0",
     "vitest": "^4.1.0",
-    "@astrojs/markdown-remark": "7.2.2",
     "@astrojs/check": "0.9.10",
+    "@astrojs/markdown-remark": "7.2.3",
     "astro-scripts": "0.0.14"
   },
   "engines": {

package/src/core/README.md

@@ -0,0 +1,37 @@
+# `core/`
+
+Code that executes directly on Node (not processed by vite). Contains the main Astro logic for the `build`, `dev`, `preview`, and `sync` commands, and also manages the lifecycle of the Vite server.
+
+The `core/index.ts` module exports the CLI commands as functions and is the main entrypoint of the `astro` package.
+
+```ts
+import { dev, build, preview, sync } from 'astro';
+```
+
+[See CONTRIBUTING.md](../../../../CONTRIBUTING.md) for a code overview.
+
+## Request handling: the functional core
+
+Server-side request handling is a **purely functional core** keyed off the
+`SSRManifest` — the one allowed ambient source of truth, exposed to bundled
+code as the `virtual:astro:manifest` virtual module. There are no stateful
+app/pipeline god objects: behavior lives in plain functions that read static
+data from the manifest plus per-request state.
+
+- **Owning modules** hold per-manifest derived/mutable state in WeakMaps and
+  expose accessors: `routing/route-table.ts` (`getRouteTable`, `matchRoute`,
+  `updateRouteTable`), `middleware/load.ts`, `../actions/load.ts`,
+  `session/driver.ts`, `cache/provider.ts`, `render/route-cache.ts`,
+  `routing/default.ts`, `logger/manifest-logger.ts`, `fetch/features.ts`,
+  `manifest/ambient.ts`.
+- **`environment/`** expresses what genuinely varies between rendering
+  environments (production SSR, the two dev paths, build/prerender, the
+  container) as a stateless `RenderEnvironment` record registered per manifest
+  via `setEnvironment`; production is the unregistered default.
+- **`fetch/`** owns the per-request `FetchState` (constructible from a bare
+  `Request`, resolving the ambient manifest) and the handler functions
+  (`handleRequest` and the middleware/pages/error stages) that drive a request
+  through the chain.
+- **Facades**: `App` (`core/app/`) and `NodeApp` (`core/app/node.ts`) survive
+  as thin public compatibility shells — every method delegates to the
+  functional core.

package/src/core/manifest/ambient-source.ts

@@ -0,0 +1,9 @@
+import type { SSRManifest } from '../app/types.js';
+
+// This module is the NON-VITE fallback for the '#astro-internal/ambient-manifest'
+// specifier (mapped here by the package.json `imports` field). In every
+// Vite-processed server environment the serialized-manifest plugin resolves that
+// specifier to `virtual:astro:manifest` instead, so this file is never loaded
+// there. In plain Node (unit tests, embedders) the ambient manifest is simply
+// absent until `setAmbientManifest()` registers one.
+export const manifest: SSRManifest | undefined = undefined;

package/src/types/README.md

@@ -0,0 +1,5 @@
+# `types/`
+
+In this folder rest the types that are used throughout Astro. Typically folders for corresponding features will have a corresponding `types.ts` file in their folder. For example, the `src/assets/types.ts` contain the types for `astro:assets`. However this folder can be useful for types that are used across multiple features, or generally don't fit in any other folder.
+
+This folder additionally contain a `public` folder, which contains types that are exposed to users one way or another. Remember that these types are part of the public API, and as such follow the same semver contract as the rest of Astro.

package/dist/container/pipeline.d.ts

@@ -1,14 +0,0 @@
-import { type HeadElements, Pipeline, type TryRewriteResult } from '../core/base-pipeline.js';
-import type { ComponentInstance } from '../types/astro.js';
-import type { RewritePayload } from '../types/public/common.js';
-import type { RouteData, SSRResult } from '../types/public/internal.js';
-export declare class ContainerPipeline extends Pipeline {
-    #private;
-    getName(): string;
-    static create({ logger, manifest, renderers, resolve, streaming, }: Pick<ContainerPipeline, 'logger' | 'manifest' | 'renderers' | 'resolve' | 'streaming'>): ContainerPipeline;
-    componentMetadata(_routeData: RouteData): Promise<SSRResult['componentMetadata']> | void;
-    headElements(routeData: RouteData): Promise<HeadElements> | HeadElements;
-    tryRewrite(payload: RewritePayload, request: Request): Promise<TryRewriteResult>;
-    insertRoute(route: RouteData, componentInstance: ComponentInstance): void;
-    getComponentByRoute(routeData: RouteData): Promise<ComponentInstance>;
-}