astro 5.15.3 → 6.0.0-alpha.0

package/dist/content/utils.js

@@ -8,7 +8,6 @@ import xxhash from "xxhash-wasm";
 import { z } from "zod";
 import { AstroError, AstroErrorData, errorMap, MarkdownError } from "../core/errors/index.js";
 import { isYAMLException } from "../core/errors/utils.js";
-import { appendForwardSlash } from "../core/path.js";
 import { normalizePath } from "../core/viteUtils.js";
 import {
   CONTENT_LAYER_TYPE,
@@ -18,7 +17,6 @@ import {
   LIVE_CONTENT_TYPE,
   PROPAGATED_ASSET_FLAG
 } from "./consts.js";
-import { glob } from "./loaders/glob.js";
 import { createImage } from "./runtime-assets.js";
 const entryTypeSchema = z.object({
   id: z.string({
@@ -38,14 +36,6 @@ const loaderReturnSchema = z.union([
   )
 ]);
 const collectionConfigParser = z.union([
-  z.object({
-    type: z.literal("content").optional().default("content"),
-    schema: z.any().optional()
-  }),
-  z.object({
-    type: z.literal("data"),
-    schema: z.any().optional()
-  }),
   z.object({
     type: z.literal(CONTENT_LAYER_TYPE),
     schema: z.any().optional(),
@@ -76,9 +66,7 @@ const collectionConfigParser = z.union([
         schema: z.any().optional(),
         render: z.function(z.tuple([z.any()], z.unknown())).optional()
       })
-    ]),
-    /** deprecated */
-    _legacy: z.boolean().optional()
+    ])
   }),
   z.object({
     type: z.literal(LIVE_CONTENT_TYPE).optional().default(LIVE_CONTENT_TYPE),
@@ -104,25 +92,14 @@ function parseEntrySlug({
     });
   }
 }
-async function getEntryDataAndImages(entry, collectionConfig, shouldEmitFile, experimentalSvgEnabled, pluginContext) {
-  let data;
-  if (collectionConfig.type === "content" || collectionConfig._legacy) {
-    const { slug, ...unvalidatedData } = entry.unvalidatedData;
-    data = unvalidatedData;
-  } else {
-    data = entry.unvalidatedData;
-  }
+async function getEntryDataAndImages(entry, collectionConfig, shouldEmitFile, pluginContext) {
+  let data = entry.unvalidatedData;
   let schema = collectionConfig.schema;
   const imageImports = /* @__PURE__ */ new Set();
   if (typeof schema === "function") {
     if (pluginContext) {
       schema = schema({
-        image: createImage(
-          pluginContext,
-          shouldEmitFile,
-          entry._internal.filePath,
-          experimentalSvgEnabled
-        )
+        image: createImage(pluginContext, shouldEmitFile, entry._internal.filePath)
       });
     } else if (collectionConfig.type === CONTENT_LAYER_TYPE) {
       schema = schema({
@@ -138,12 +115,6 @@ async function getEntryDataAndImages(entry, collectionConfig, shouldEmitFile, ex
     }
   }
   if (schema) {
-    if (collectionConfig.type === "content" && typeof schema === "object" && "shape" in schema && schema.shape.slug) {
-      throw new AstroError({
-        ...AstroErrorData.ContentSchemaContainsSlugError,
-        message: AstroErrorData.ContentSchemaContainsSlugError.message(entry.collection)
-      });
-    }
     let formattedError;
     const parsed = await schema.safeParseAsync(data, {
       errorMap(error, ctx) {
@@ -157,10 +128,13 @@ async function getEntryDataAndImages(entry, collectionConfig, shouldEmitFile, ex
       data = parsed.data;
     } else {
       if (!formattedError) {
-        const errorType = collectionConfig.type === "content" ? AstroErrorData.InvalidContentEntryFrontmatterError : AstroErrorData.InvalidContentEntryDataError;
         formattedError = new AstroError({
-          ...errorType,
-          message: errorType.message(entry.collection, entry.id, parsed.error),
+          ...AstroErrorData.InvalidContentEntryDataError,
+          message: AstroErrorData.InvalidContentEntryDataError.message(
+            entry.collection,
+            entry.id,
+            parsed.error
+          ),
           location: {
             file: entry._internal?.filePath,
             line: getYAMLErrorLine(
@@ -176,12 +150,11 @@ async function getEntryDataAndImages(entry, collectionConfig, shouldEmitFile, ex
   }
   return { data, imageImports: Array.from(imageImports) };
 }
-async function getEntryData(entry, collectionConfig, shouldEmitFile, experimentalSvgEnabled, pluginContext) {
+async function getEntryData(entry, collectionConfig, shouldEmitFile, pluginContext) {
   const { data } = await getEntryDataAndImages(
     entry,
     collectionConfig,
     shouldEmitFile,
-    experimentalSvgEnabled,
     pluginContext
   );
   return data;
@@ -392,96 +365,21 @@ async function loadContentConfig({
 ${message}
 `
     );
-    if (settings.config.experimental.liveContentCollections) {
-      const liveCollections = Object.entries(unparsedConfig.collections ?? {}).filter(
-        ([, collection]) => collection?.type === LIVE_CONTENT_TYPE
-      );
-      if (liveCollections.length > 0) {
-        throw new AstroError({
-          ...AstroErrorData.LiveContentConfigError,
-          message: AstroErrorData.LiveContentConfigError.message(
-            "Live collections must be defined in a `src/live.config.ts` file.",
-            path.relative(fileURLToPath(settings.config.root), configPathname)
-          )
-        });
-      }
+    const liveCollections = Object.entries(unparsedConfig.collections ?? {}).filter(
+      ([, collection]) => collection?.type === LIVE_CONTENT_TYPE
+    );
+    if (liveCollections.length > 0) {
+      throw new AstroError({
+        ...AstroErrorData.LiveContentConfigError,
+        message: AstroErrorData.LiveContentConfigError.message(
+          "Live collections must be defined in a `src/live.config.ts` file.",
+          path.relative(fileURLToPath(settings.config.root), configPathname)
+        )
+      });
     }
     return void 0;
   }
 }
-async function autogenerateCollections({
-  config,
-  settings,
-  fs
-}) {
-  if (settings.config.legacy.collections) {
-    return config;
-  }
-  const contentDir = new URL("./content/", settings.config.srcDir);
-  const collections = config?.collections ?? {};
-  const contentExts = getContentEntryExts(settings);
-  const dataExts = getDataEntryExts(settings);
-  const contentPattern = globWithUnderscoresIgnored("", contentExts);
-  const dataPattern = globWithUnderscoresIgnored("", dataExts);
-  let usesContentLayer = false;
-  for (const collectionName of Object.keys(collections)) {
-    if (collections[collectionName]?.type === "content_layer" || collections[collectionName]?.type === "live") {
-      usesContentLayer = true;
-      continue;
-    }
-    const isDataCollection = collections[collectionName]?.type === "data";
-    const base = new URL(`${collectionName}/`, contentDir);
-    const _legacy = !isDataCollection || void 0;
-    collections[collectionName] = {
-      ...collections[collectionName],
-      type: "content_layer",
-      _legacy,
-      loader: glob({
-        base,
-        pattern: isDataCollection ? dataPattern : contentPattern,
-        _legacy,
-        // Legacy data collections IDs aren't slugified
-        generateId: isDataCollection ? ({ entry }) => getDataEntryId({
-          entry: new URL(entry, base),
-          collection: collectionName,
-          contentDir
-        }) : void 0
-        // Zod weirdness has trouble with typing the args to the load function
-      })
-    };
-  }
-  if (!usesContentLayer && fs.existsSync(contentDir)) {
-    const orphanedCollections = [];
-    for (const entry of await fs.promises.readdir(contentDir, { withFileTypes: true })) {
-      const collectionName = entry.name;
-      if (["_", "."].includes(collectionName.at(0) ?? "")) {
-        continue;
-      }
-      if (entry.isDirectory() && !(collectionName in collections)) {
-        orphanedCollections.push(collectionName);
-        const base = new URL(`${collectionName}/`, contentDir);
-        collections[collectionName] = {
-          type: "content_layer",
-          loader: glob({
-            base,
-            pattern: contentPattern,
-            _legacy: true
-          })
-        };
-      }
-    }
-    if (orphanedCollections.length > 0) {
-      console.warn(
-        `
-Auto-generating collections for folders in "src/content/" that are not defined as collections.
-This is deprecated, so you should define these collections yourself in "src/content.config.ts".
-The following collections have been auto-generated: ${orphanedCollections.map((name) => colors.green(name)).join(", ")}
-`
-      );
-    }
-  }
-  return { ...config, collections };
-}
 async function reloadContentConfigObserver({
   observer = globalContentConfigObserver,
   ...loadContentConfigOpts
@@ -489,10 +387,6 @@ async function reloadContentConfigObserver({
   observer.set({ status: "loading" });
   try {
     let config = await loadContentConfig(loadContentConfigOpts);
-    config = await autogenerateCollections({
-      config,
-      ...loadContentConfigOpts
-    });
     if (config) {
       observer.set({ status: "loaded", config });
     } else {
@@ -527,14 +421,19 @@ function contentObservable(initialCtx) {
     subscribe
   };
 }
-function getContentPaths({
-  srcDir,
-  legacy,
-  root,
-  experimental
-}, fs = fsMod) {
-  const configStats = searchConfig(fs, srcDir, legacy?.collections);
-  const liveConfigStats = experimental?.liveContentCollections ? searchLiveConfig(fs, srcDir) : { exists: false, url: new URL("./", srcDir) };
+function getContentPaths({ srcDir, root }, fs = fsMod) {
+  const configStats = searchConfig(fs, srcDir);
+  if (!configStats.exists) {
+    const legacyConfigStats = searchLegacyConfig(fs, srcDir);
+    if (legacyConfigStats.exists) {
+      const relativePath = path.relative(fileURLToPath(root), fileURLToPath(legacyConfigStats.url));
+      throw new AstroError({
+        ...AstroErrorData.LegacyContentConfigError,
+        message: AstroErrorData.LegacyContentConfigError.message(relativePath)
+      });
+    }
+  }
+  const liveConfigStats = searchLiveConfig(fs, srcDir);
   const pkgBase = new URL("../../", import.meta.url);
   return {
     root: new URL("./", root),
@@ -546,13 +445,21 @@ function getContentPaths({
     liveConfig: liveConfigStats
   };
 }
-function searchConfig(fs, srcDir, legacy) {
+function searchConfig(fs, srcDir) {
   const paths = [
-    ...legacy ? [] : ["content.config.mjs", "content.config.js", "content.config.mts", "content.config.ts"],
-    "content/config.mjs",
+    "content.config.mjs",
+    "content.config.js",
+    "content.config.mts",
+    "content.config.ts"
+  ];
+  return search(fs, srcDir, paths);
+}
+function searchLegacyConfig(fs, srcDir) {
+  const paths = [
+    "content/config.ts",
     "content/config.js",
-    "content/config.mts",
-    "content/config.ts"
+    "content/config.mjs",
+    "content/config.mts"
   ];
   return search(fs, srcDir, paths);
 }
@@ -589,12 +496,6 @@ async function getEntrySlug({
   });
   return parseEntrySlug({ generatedSlug, frontmatterSlug, id, collection });
 }
-function getExtGlob(exts) {
-  return exts.length === 1 ? (
-    // Wrapping {...} breaks when there is only one extension
-    exts[0]
-  ) : `{${exts.join(",")}}`;
-}
 function hasAssetPropagationFlag(id) {
   try {
     return new URL(id, "file://").searchParams.has(PROPAGATED_ASSET_FLAG);
@@ -602,15 +503,6 @@ function hasAssetPropagationFlag(id) {
     return false;
   }
 }
-function globWithUnderscoresIgnored(relContentDir, exts) {
-  const extGlob = getExtGlob(exts);
-  const contentDir = relContentDir.length > 0 ? appendForwardSlash(relContentDir) : relContentDir;
-  return [
-    `${contentDir}**/*${extGlob}`,
-    `!${contentDir}**/_*/**/*${extGlob}`,
-    `!${contentDir}**/_*${extGlob}`
-  ];
-}
 function posixifyPath(filePath) {
   return filePath.split(path.sep).join("/");
 }
@@ -657,9 +549,7 @@ export {
   getEntryDataAndImages,
   getEntrySlug,
   getEntryType,
-  getExtGlob,
   getSymlinkedContentCollections,
-  globWithUnderscoresIgnored,
   globalContentConfigObserver,
   hasAssetPropagationFlag,
   hasContentFlag,

package/dist/content/vite-plugin-content-imports.js

@@ -171,8 +171,6 @@ async function getContentEntryModule(params) {
     { id, collection, _internal, unvalidatedData },
     collectionConfig,
     params.shouldEmitFile,
-    // FUTURE: Remove in this in v6
-    id.endsWith(".svg"),
     pluginContext
   ) : unvalidatedData;
   const contentEntryModule = {
@@ -198,8 +196,6 @@ async function getDataEntryModule(params) {
     { id, collection, _internal, unvalidatedData },
     collectionConfig,
     params.shouldEmitFile,
-    // FUTURE: Remove in this in v6
-    id.endsWith(".svg"),
     pluginContext
   ) : unvalidatedData;
   const dataEntryModule = {

package/dist/content/vite-plugin-content-virtual-mod.js

@@ -1,9 +1,6 @@
 import nodeFs from "node:fs";
-import { extname } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
+import { fileURLToPath } from "node:url";
 import { dataToEsm } from "@rollup/pluginutils";
-import pLimit from "p-limit";
-import { glob } from "tinyglobby";
 import { normalizePath } from "vite";
 import { AstroError, AstroErrorData } from "../core/errors/index.js";
 import { rootRelativePath } from "../core/viteUtils.js";
@@ -12,9 +9,7 @@ import {
   ASSET_IMPORTS_FILE,
   ASSET_IMPORTS_RESOLVED_STUB_ID,
   ASSET_IMPORTS_VIRTUAL_ID,
-  CONTENT_FLAG,
   CONTENT_RENDER_FLAG,
-  DATA_FLAG,
   DATA_STORE_VIRTUAL_ID,
   MODULES_IMPORTS_FILE,
   MODULES_MJS_ID,
@@ -24,19 +19,7 @@ import {
   VIRTUAL_MODULE_ID
 } from "./consts.js";
 import { getDataStoreFile } from "./content-layer.js";
-import {
-  getContentEntryIdAndSlug,
-  getContentPaths,
-  getDataEntryExts,
-  getDataEntryId,
-  getEntryCollectionName,
-  getEntryConfigByExtMap,
-  getEntrySlug,
-  getEntryType,
-  getExtGlob,
-  globWithUnderscoresIgnored,
-  isDeferredModule
-} from "./utils.js";
+import { getContentPaths, isDeferredModule } from "./utils.js";
 function invalidateDataStore(server) {
   const module = server.moduleGraph.getModuleById(RESOLVED_DATA_STORE_VIRTUAL_ID);
   if (module) {
@@ -111,15 +94,10 @@ function astroContentVirtualModPlugin({
     },
     async load(id, args) {
       if (id === RESOLVED_VIRTUAL_MODULE_ID) {
-        const lookupMap = settings.config.legacy.collections ? await generateLookupMap({
-          settings,
-          fs
-        }) : {};
         const isClient = !args?.ssr;
         const code = await generateContentEntryFile({
           settings,
           fs,
-          lookupMap,
           isClient
         });
         const astro = createDefaultAstroMetadata();
@@ -180,32 +158,10 @@ function astroContentVirtualModPlugin({
 }
 async function generateContentEntryFile({
   settings,
-  lookupMap,
   isClient
 }) {
   const contentPaths = getContentPaths(settings.config);
   const relContentDir = rootRelativePath(settings.config.root, contentPaths.contentDir);
-  let contentEntryGlobResult = '""';
-  let dataEntryGlobResult = '""';
-  let renderEntryGlobResult = '""';
-  if (settings.config.legacy.collections) {
-    const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);
-    const contentEntryExts = [...contentEntryConfigByExt.keys()];
-    const dataEntryExts = getDataEntryExts(settings);
-    const createGlob = (value, flag) => `import.meta.glob(${JSON.stringify(value)}, { query: { ${flag}: true } })`;
-    contentEntryGlobResult = createGlob(
-      globWithUnderscoresIgnored(relContentDir, contentEntryExts),
-      CONTENT_FLAG
-    );
-    dataEntryGlobResult = createGlob(
-      globWithUnderscoresIgnored(relContentDir, dataEntryExts),
-      DATA_FLAG
-    );
-    renderEntryGlobResult = createGlob(
-      globWithUnderscoresIgnored(relContentDir, contentEntryExts),
-      CONTENT_RENDER_FLAG
-    );
-  }
   let virtualModContents;
   if (isClient) {
     throw new AstroError({
@@ -213,7 +169,7 @@ async function generateContentEntryFile({
       message: AstroErrorData.ServerOnlyModule.message("astro:content")
     });
   } else {
-    virtualModContents = nodeFs.readFileSync(contentPaths.virtualModTemplate, "utf-8").replace("@@CONTENT_DIR@@", relContentDir).replace("'@@CONTENT_ENTRY_GLOB_PATH@@'", contentEntryGlobResult).replace("'@@DATA_ENTRY_GLOB_PATH@@'", dataEntryGlobResult).replace("'@@RENDER_ENTRY_GLOB_PATH@@'", renderEntryGlobResult).replace("/* @@LOOKUP_MAP_ASSIGNMENT@@ */", `lookupMap = ${JSON.stringify(lookupMap)};`).replace(
+    virtualModContents = nodeFs.readFileSync(contentPaths.virtualModTemplate, "utf-8").replace("@@CONTENT_DIR@@", relContentDir).replace(
       "/* @@LIVE_CONTENT_CONFIG@@ */",
       contentPaths.liveConfig.exists ? (
         // Dynamic import so it extracts the chunk and avoids a circular import
@@ -223,93 +179,6 @@ async function generateContentEntryFile({
   }
   return virtualModContents;
 }
-async function generateLookupMap({ settings, fs }) {
-  const { root } = settings.config;
-  const contentPaths = getContentPaths(settings.config);
-  const relContentDir = rootRelativePath(root, contentPaths.contentDir, false);
-  const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);
-  const dataEntryExts = getDataEntryExts(settings);
-  const { contentDir } = contentPaths;
-  const contentEntryExts = [...contentEntryConfigByExt.keys()];
-  let lookupMap = {};
-  const contentGlob = await glob(
-    `${relContentDir}**/*${getExtGlob([...dataEntryExts, ...contentEntryExts])}`,
-    {
-      absolute: true,
-      cwd: fileURLToPath(root),
-      expandDirectories: false
-    }
-  );
-  const limit = pLimit(10);
-  const promises = [];
-  for (const filePath of contentGlob) {
-    promises.push(
-      limit(async () => {
-        const entryType = getEntryType(filePath, contentPaths, contentEntryExts, dataEntryExts);
-        if (entryType !== "content" && entryType !== "data") return;
-        const collection = getEntryCollectionName({ contentDir, entry: pathToFileURL(filePath) });
-        if (!collection) throw UnexpectedLookupMapError;
-        if (lookupMap[collection]?.type && lookupMap[collection].type !== entryType) {
-          throw new AstroError({
-            ...AstroErrorData.MixedContentDataCollectionError,
-            message: AstroErrorData.MixedContentDataCollectionError.message(collection)
-          });
-        }
-        if (entryType === "content") {
-          const contentEntryType = contentEntryConfigByExt.get(extname(filePath));
-          if (!contentEntryType) throw UnexpectedLookupMapError;
-          const { id, slug: generatedSlug } = getContentEntryIdAndSlug({
-            entry: pathToFileURL(filePath),
-            contentDir,
-            collection
-          });
-          const slug = await getEntrySlug({
-            id,
-            collection,
-            generatedSlug,
-            fs,
-            fileUrl: pathToFileURL(filePath),
-            contentEntryType
-          });
-          if (lookupMap[collection]?.entries?.[slug]) {
-            throw new AstroError({
-              ...AstroErrorData.DuplicateContentEntrySlugError,
-              message: AstroErrorData.DuplicateContentEntrySlugError.message(
-                collection,
-                slug,
-                lookupMap[collection].entries[slug],
-                rootRelativePath(root, filePath)
-              ),
-              hint: slug !== generatedSlug ? `Check the \`slug\` frontmatter property in **${id}**.` : void 0
-            });
-          }
-          lookupMap[collection] = {
-            type: "content",
-            entries: {
-              ...lookupMap[collection]?.entries,
-              [slug]: rootRelativePath(root, filePath)
-            }
-          };
-        } else {
-          const id = getDataEntryId({ entry: pathToFileURL(filePath), contentDir, collection });
-          lookupMap[collection] = {
-            type: "data",
-            entries: {
-              ...lookupMap[collection]?.entries,
-              [id]: rootRelativePath(root, filePath)
-            }
-          };
-        }
-      })
-    );
-  }
-  await Promise.all(promises);
-  return lookupMap;
-}
-const UnexpectedLookupMapError = new AstroError({
-  ...AstroErrorData.UnknownContentCollectionError,
-  message: `Unexpected error while parsing content entry IDs and slugs.`
-});
 export {
   astroContentVirtualModPlugin
 };

package/dist/core/app/index.d.ts

@@ -82,7 +82,7 @@ export declare class App {
      * @param allowPrerenderedRoutes
      */
     match(request: Request, allowPrerenderedRoutes?: boolean): RouteData | undefined;
-    render(request: Request, renderOptions?: RenderOptions): Promise<Response>;
+    render(request: Request, { addCookieHeader, clientAddress, locals, prerenderedErrorPageFetch, routeData, }?: RenderOptions): Promise<Response>;
     setCookieHeaders(response: Response): Generator<string, string[], any>;
     /**
      * Reads all the cookies written by `Astro.cookie.set()` onto the passed response.

package/dist/core/app/index.js

@@ -232,14 +232,15 @@ class App {
     }
     return pathname;
   }
-  async render(request, renderOptions) {
-    let routeData;
-    let locals;
-    let clientAddress;
-    let addCookieHeader;
+  async render(request, {
+    addCookieHeader,
+    clientAddress = Reflect.get(request, clientAddressSymbol),
+    locals,
+    prerenderedErrorPageFetch = fetch,
+    routeData
+  } = {}) {
     const url = new URL(request.url);
     const redirect = this.#redirectTrailingSlash(url.pathname);
-    const prerenderedErrorPageFetch = renderOptions?.prerenderedErrorPageFetch ?? fetch;
     if (redirect !== url.pathname) {
       const status = request.method === "GET" ? 301 : 308;
       return new Response(
@@ -257,10 +258,6 @@ class App {
         }
       );
     }
-    addCookieHeader = renderOptions?.addCookieHeader;
-    clientAddress = renderOptions?.clientAddress ?? Reflect.get(request, clientAddressSymbol);
-    routeData = renderOptions?.routeData;
-    locals = renderOptions?.locals;
     if (routeData) {
       this.#logger.debug(
         "router",

package/dist/core/app/node.d.ts

@@ -1,10 +1,8 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import type { RemotePattern } from '../../types/public/config.js';
-import type { RouteData } from '../../types/public/internal.js';
 import type { RenderOptions } from './index.js';
 import { App } from './index.js';
 import type { NodeAppHeadersJson, SSRManifest } from './types.js';
-export { apply as applyPolyfills } from '../polyfill.js';
 /**
  * Allow the request body to be explicitly overridden. For example, this
  * is used by the Express JSON middleware.
@@ -15,13 +13,8 @@ interface NodeRequest extends IncomingMessage {
 export declare class NodeApp extends App {
     headersMap: NodeAppHeadersJson | undefined;
     setHeadersMap(headers: NodeAppHeadersJson): void;
-    match(req: NodeRequest | Request, allowPrerenderedRoutes?: boolean): RouteData | undefined;
+    match(req: NodeRequest | Request, allowPrerenderedRoutes?: boolean): import("../../index.js").RouteData | undefined;
     render(request: NodeRequest | Request, options?: RenderOptions): Promise<Response>;
-    /**
-     * @deprecated Instead of passing `RouteData` and locals individually, pass an object with `routeData` and `locals` properties.
-     * See https://github.com/withastro/astro/pull/9199 for more information.
-     */
-    render(request: NodeRequest | Request, routeData?: RouteData, locals?: object): Promise<Response>;
     /**
      * Converts a NodeJS IncomingMessage into a web standard Request.
      * ```js
@@ -58,3 +51,4 @@ export declare class NodeApp extends App {
 }
 export declare function loadManifest(rootFolder: URL): Promise<SSRManifest>;
 export declare function loadApp(rootFolder: URL): Promise<NodeApp>;
+export {};

package/dist/core/app/node.js

@@ -4,7 +4,6 @@ import { clientAddressSymbol, nodeRequestAbortControllerCleanupSymbol } from "..
 import { deserializeManifest } from "./common.js";
 import { createOutgoingHttpHeaders } from "./createOutgoingHttpHeaders.js";
 import { App } from "./index.js";
-import { apply } from "../polyfill.js";
 class NodeApp extends App {
   headersMap = void 0;
   setHeadersMap(headers) {
@@ -19,13 +18,13 @@ class NodeApp extends App {
     }
     return super.match(req, allowPrerenderedRoutes);
   }
-  render(req, routeDataOrOptions, maybeLocals) {
-    if (!(req instanceof Request)) {
-      req = NodeApp.createRequest(req, {
+  render(request, options) {
+    if (!(request instanceof Request)) {
+      request = NodeApp.createRequest(request, {
         allowedDomains: this.manifest.allowedDomains
       });
     }
-    return super.render(req, routeDataOrOptions, maybeLocals);
+    return super.render(request, options);
   }
   /**
    * Converts a NodeJS IncomingMessage into a web standard Request.
@@ -258,7 +257,6 @@ async function loadApp(rootFolder) {
 }
 export {
   NodeApp,
-  apply as applyPolyfills,
   loadApp,
   loadManifest
 };

package/dist/core/build/generate.js

@@ -214,7 +214,6 @@ async function getPathsForRoute(route, mod, pipeline, builtPaths) {
       mod,
       route,
       routeCache,
-      logger,
       ssr: serverLike,
       base: config.base
     }).catch((err) => {

package/dist/core/build/index.js

@@ -18,9 +18,7 @@ import { createVite } from "../create-vite.js";
 import { createKey, getEnvironmentKey, hasEnvironmentKey } from "../encryption.js";
 import { AstroError, AstroErrorData } from "../errors/index.js";
 import { levels, timerMessage } from "../logger/core.js";
-import { apply as applyPolyfill } from "../polyfill.js";
 import { createRoutesList } from "../routing/index.js";
-import { getServerIslandRouteData } from "../server-islands/endpoint.js";
 import { clearContentLayerCache } from "../sync/index.js";
 import { ensureProcessNodeEnv } from "../util.js";
 import { collectPagesData } from "./page-data.js";
@@ -28,7 +26,6 @@ import { staticBuild, viteBuild } from "./static-build.js";
 import { getTimeStat } from "./util.js";
 async function build(inlineConfig, options = {}) {
   ensureProcessNodeEnv(options.devOutput ? "development" : "production");
-  applyPolyfill();
   const logger = createNodeLogger(inlineConfig);
   const { userConfig, astroConfig } = await resolveConfig(inlineConfig, "build");
   telemetry.record(eventCliSession("build", userConfig));
@@ -167,7 +164,7 @@ class AstroBuilder {
     await runHookBuildDone({
       settings: this.settings,
       pages: pageNames,
-      routes: Object.values(allPages).flat().map((pageData) => pageData.route).concat(hasServerIslands ? getServerIslandRouteData(this.settings.config) : []),
+      routes: Object.values(allPages).flat().map((pageData) => pageData.route),
       logger: this.logger
     });
     if (this.logger.level && levels[this.logger.level()] <= levels["info"]) {