astro 6.0.0-alpha.4 → 6.0.0-beta.0

package/dist/content/utils.js

@@ -8,6 +8,7 @@ import xxhash from "xxhash-wasm";
 import * as z from "zod/v4";
 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,
@@ -17,6 +18,7 @@ import {
   LIVE_CONTENT_TYPE,
   PROPAGATED_ASSET_FLAG
 } from "./consts.js";
+import { glob, secretLegacyFlag } from "./loaders/glob.js";
 import { createImage } from "./runtime-assets.js";
 const entryTypeSchema = z.object({
   id: z.string({
@@ -36,6 +38,16 @@ const loaderReturnSchema = z.union([
   )
 ]);
 const collectionConfigParser = z.union([
+  z.object({
+    type: z.literal("content").optional(),
+    schema: z.any().optional(),
+    loader: z.never().optional()
+  }),
+  z.object({
+    type: z.literal("data").optional(),
+    schema: z.any().optional(),
+    loader: z.never().optional()
+  }),
   z.object({
     type: z.literal(CONTENT_LAYER_TYPE),
     schema: z.any().optional(),
@@ -349,7 +361,11 @@ async function loadContentConfig({
   settings,
   environment
 }) {
-  const contentPaths = getContentPaths(settings.config, fs);
+  const contentPaths = getContentPaths(
+    settings.config,
+    fs,
+    settings.config.legacy?.collectionsBackwardsCompat
+  );
   if (!contentPaths.config.exists) {
     return void 0;
   }
@@ -383,6 +399,74 @@ ${message}
     return void 0;
   }
 }
+async function autogenerateCollections({
+  config,
+  settings,
+  fs
+}) {
+  if (!config) {
+    return config;
+  }
+  if (!settings.config.legacy?.collectionsBackwardsCompat) {
+    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)) {
+    const collection = collections[collectionName];
+    if (collection?.type === CONTENT_LAYER_TYPE || collection?.type === LIVE_CONTENT_TYPE) {
+      usesContentLayer = true;
+      continue;
+    }
+    const isDataCollection = collection?.type === "data";
+    const base = new URL(`${collectionName}/`, contentDir);
+    collections[collectionName] = {
+      ...collection,
+      type: CONTENT_LAYER_TYPE,
+      loader: glob({
+        base,
+        pattern: isDataCollection ? dataPattern : contentPattern,
+        [secretLegacyFlag]: true
+      })
+    };
+  }
+  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_TYPE,
+          loader: glob({
+            base,
+            pattern: contentPattern,
+            [secretLegacyFlag]: 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
@@ -390,6 +474,10 @@ 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 {
@@ -424,20 +512,38 @@ function contentObservable(initialCtx) {
     subscribe
   };
 }
-function getContentPaths({ srcDir, root }, fs = fsMod) {
+function getContentPaths({ srcDir, root }, fs = fsMod, legacyCollectionsBackwardsCompat = false) {
+  const pkgBase = new URL("../../", import.meta.url);
   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)
-      });
+      if (!legacyCollectionsBackwardsCompat) {
+        const relativePath = path.relative(
+          fileURLToPath(root),
+          fileURLToPath(legacyConfigStats.url)
+        );
+        throw new AstroError({
+          ...AstroErrorData.LegacyContentConfigError,
+          message: AstroErrorData.LegacyContentConfigError.message(relativePath)
+        });
+      }
+      return getContentPathsWithConfig(root, srcDir, pkgBase, legacyConfigStats, fs);
     }
   }
   const liveConfigStats = searchLiveConfig(fs, srcDir);
-  const pkgBase = new URL("../../", import.meta.url);
+  return {
+    root: new URL("./", root),
+    contentDir: new URL("./content/", srcDir),
+    assetsDir: new URL("./assets/", srcDir),
+    typesTemplate: new URL("templates/content/types.d.ts", pkgBase),
+    virtualModTemplate: new URL("templates/content/module.mjs", pkgBase),
+    config: configStats,
+    liveConfig: liveConfigStats
+  };
+}
+function getContentPathsWithConfig(root, srcDir, pkgBase, configStats, fs) {
+  const liveConfigStats = searchLiveConfig(fs, srcDir);
   return {
     root: new URL("./", root),
     contentDir: new URL("./content/", srcDir),
@@ -499,6 +605,21 @@ 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 globWithUnderscoresIgnored(relContentDir, exts) {
+  const extGlob = getExtGlob(exts);
+  const contentDir = relContentDir.length > 0 ? appendForwardSlash(relContentDir) : relContentDir;
+  return [
+    `${contentDir}**/*${extGlob}`,
+    `!${contentDir}**/_*/**/*${extGlob}`,
+    `!${contentDir}**/_*${extGlob}`
+  ];
+}
 function hasAssetPropagationFlag(id) {
   try {
     return new URL(id, "file://").searchParams.has(PROPAGATED_ASSET_FLAG);

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

@@ -1,6 +1,6 @@
-import type * as vite from 'vite';
 import { type Plugin } from 'vite';
 import type { BuildInternals } from '../core/build/internal.js';
+import type { ExtractedChunk } from '../core/build/static-build.js';
 import type { AstroSettings } from '../types/astro.js';
 export declare function astroContentAssetPropagationPlugin({ settings, }: {
     settings: AstroSettings;
@@ -10,8 +10,7 @@ export declare function astroContentAssetPropagationPlugin({ settings, }: {
  * Finds chunks with LINKS_PLACEHOLDER and STYLES_PLACEHOLDER, and replaces them
  * with actual styles from propagatedStylesMap.
  */
-export declare function contentAssetsBuildPostHook(base: string, internals: BuildInternals, { ssrOutputs, prerenderOutputs, mutate, }: {
-    ssrOutputs: vite.Rollup.RollupOutput[];
-    prerenderOutputs: vite.Rollup.RollupOutput[];
-    mutate: (chunk: vite.Rollup.OutputChunk, envs: ['server'], code: string) => void;
+export declare function contentAssetsBuildPostHook(base: string, internals: BuildInternals, { chunks, mutate, }: {
+    chunks: ExtractedChunk[];
+    mutate: (fileName: string, code: string, prerender: boolean) => void;
 }): Promise<void>;

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

@@ -148,17 +148,10 @@ async function getStylesForURL(filePath, environment) {
   };
 }
 async function contentAssetsBuildPostHook(base, internals, {
-  ssrOutputs,
-  prerenderOutputs,
+  chunks,
   mutate
 }) {
-  const outputs = ssrOutputs.flatMap((o) => o.output).concat(
-    ...(Array.isArray(prerenderOutputs) ? prerenderOutputs : [prerenderOutputs]).flatMap(
-      (o) => o.output
-    )
-  );
-  for (const chunk of outputs) {
-    if (chunk.type !== "chunk") continue;
+  for (const chunk of chunks) {
     if (!chunk.code.includes(LINKS_PLACEHOLDER)) continue;
     const entryStyles = /* @__PURE__ */ new Set();
     const entryLinks = /* @__PURE__ */ new Set();
@@ -189,7 +182,7 @@ async function contentAssetsBuildPostHook(base, internals, {
     } else {
       newCode = newCode.replace(JSON.stringify(LINKS_PLACEHOLDER), "[]");
     }
-    mutate(chunk, ["server"], newCode);
+    mutate(chunk.fileName, newCode, chunk.prerender);
   }
 }
 export {

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

@@ -40,7 +40,11 @@ function astroContentImportPlugin({
   settings,
   logger
 }) {
-  const contentPaths = getContentPaths(settings.config, fs);
+  const contentPaths = getContentPaths(
+    settings.config,
+    fs,
+    settings.config.legacy?.collectionsBackwardsCompat
+  );
   const contentEntryExts = getContentEntryExts(settings);
   const dataEntryExts = getDataEntryExts(settings);
   const contentEntryConfigByExt = getEntryConfigByExtMap(settings.contentEntryTypes);

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

@@ -46,7 +46,11 @@ function astroContentVirtualModPlugin({
     enforce: "pre",
     config(_, env) {
       dataStoreFile = getDataStoreFile(settings, env.command === "serve");
-      const contentPaths = getContentPaths(settings.config);
+      const contentPaths = getContentPaths(
+        settings.config,
+        void 0,
+        settings.config.legacy?.collectionsBackwardsCompat
+      );
       if (contentPaths.liveConfig.exists) {
         liveConfig = normalizePath(fileURLToPath(contentPaths.liveConfig.url));
       }
@@ -178,7 +182,11 @@ async function generateContentEntryFile({
   settings,
   isClient
 }) {
-  const contentPaths = getContentPaths(settings.config);
+  const contentPaths = getContentPaths(
+    settings.config,
+    void 0,
+    settings.config.legacy?.collectionsBackwardsCompat
+  );
   const relContentDir = rootRelativePath(settings.config.root, contentPaths.contentDir);
   let virtualModContents;
   if (isClient) {

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

@@ -2,4 +2,5 @@ import { BaseApp } from './base.js';
 import { AppPipeline } from './pipeline.js';
 export declare class App extends BaseApp {
     createPipeline(streaming: boolean): AppPipeline;
+    isDev(): boolean;
 }

package/dist/core/app/app.js

@@ -7,6 +7,9 @@ class App extends BaseApp {
       streaming
     });
   }
+  isDev() {
+    return false;
+  }
 }
 export {
   App

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

@@ -6,6 +6,10 @@ import { AstroIntegrationLogger, Logger } from '../logger/core.js';
 import { type CreateRenderContext, RenderContext } from '../render-context.js';
 import type { AppPipeline } from './pipeline.js';
 import type { SSRManifest } from './types.js';
+export interface DevMatch {
+    routeData: RouteData;
+    resolvedPathname: string;
+}
 export interface RenderOptions {
     /**
      * Whether to automatically add all cookies written by `Astro.cookie.set()` to the response headers.
@@ -72,6 +76,7 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
     baseWithoutTrailingSlash: string;
     logger: Logger;
     constructor(manifest: SSRManifest, streaming?: boolean, ...args: any[]);
+    abstract isDev(): boolean;
     createRenderContext(payload: CreateRenderContext): Promise<RenderContext>;
     getAdapterLogger(): AstroIntegrationLogger;
     getAllowedDomains(): Partial<RemotePattern>[] | undefined;
@@ -104,6 +109,13 @@ export declare abstract class BaseApp<P extends Pipeline = AppPipeline> {
      * @param allowPrerenderedRoutes
      */
     match(request: Request, allowPrerenderedRoutes?: boolean): RouteData | undefined;
+    /**
+     * A matching route function to use in the development server.
+     * Contrary to the `.match` function, this function resolves props and params, returning the correct
+     * route based on the priority, segments. It also returns the correct, resolved pathname.
+     * @param pathname
+     */
+    devMatch(pathname?: string): Promise<DevMatch | undefined> | undefined;
     private computePathnameFromDomain;
     private redirectTrailingSlash;
     render(request: Request, renderOptions?: RenderOptions): Promise<Response>;

package/dist/core/app/base.js

@@ -118,6 +118,16 @@ class BaseApp {
     }
     return routeData;
   }
+  /**
+   * A matching route function to use in the development server.
+   * Contrary to the `.match` function, this function resolves props and params, returning the correct
+   * route based on the priority, segments. It also returns the correct, resolved pathname.
+   * @param pathname
+   */
+  devMatch(pathname) {
+    pathname;
+    return void 0;
+  }
   computePathnameFromDomain(request) {
     let pathname = void 0;
     const url = new URL(request.url);
@@ -235,7 +245,14 @@ class BaseApp {
       }
     }
     if (!routeData) {
-      routeData = this.match(request);
+      if (this.isDev()) {
+        const result = await this.devMatch(this.getPathnameFromRequest(request));
+        if (result) {
+          routeData = result.routeData;
+        }
+      } else {
+        routeData = this.match(request);
+      }
       this.logger.debug("router", "Astro matched the following route for " + request.url);
       this.logger.debug("router", "RouteData:\n" + routeData);
     }

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

@@ -1,7 +1,7 @@
 import type { RouteData } from '../../../types/public/index.js';
 import type { Logger } from '../../logger/core.js';
 import type { CreateRenderContext, RenderContext } from '../../render-context.js';
-import { BaseApp, type RenderErrorOptions } from '../base.js';
+import { BaseApp, type DevMatch, type RenderErrorOptions } from '../base.js';
 import type { SSRManifest } from '../types.js';
 import { NonRunnablePipeline } from './pipeline.js';
 /**
@@ -10,9 +10,12 @@ import { NonRunnablePipeline } from './pipeline.js';
 export declare class DevApp extends BaseApp<NonRunnablePipeline> {
     logger: Logger;
     currentRenderContext: RenderContext | undefined;
+    resolvedPathname: string | undefined;
     constructor(manifest: SSRManifest, streaming: boolean | undefined, logger: Logger);
     createPipeline(streaming: boolean, manifest: SSRManifest, logger: Logger): NonRunnablePipeline;
+    isDev(): boolean;
     match(request: Request): RouteData | undefined;
+    devMatch(pathname: string): Promise<DevMatch | undefined>;
     createRenderContext(payload: CreateRenderContext): Promise<RenderContext>;
     renderError(request: Request, { locals, skipMiddleware, error, clientAddress, status }: RenderErrorOptions): Promise<Response>;
 }

package/dist/core/app/dev/app.js

@@ -3,9 +3,11 @@ import { isAstroError } from "../../errors/index.js";
 import { BaseApp } from "../base.js";
 import { NonRunnablePipeline } from "./pipeline.js";
 import { getCustom404Route, getCustom500Route } from "../../routing/helpers.js";
+import { matchRoute } from "../../routing/dev.js";
 class DevApp extends BaseApp {
   logger;
   currentRenderContext = void 0;
+  resolvedPathname = void 0;
   constructor(manifest, streaming = true, logger) {
     super(manifest, streaming, logger);
     this.logger = logger;
@@ -17,12 +19,31 @@ class DevApp extends BaseApp {
       streaming
     });
   }
+  isDev() {
+    return true;
+  }
   match(request) {
     return super.match(request, true);
   }
+  async devMatch(pathname) {
+    const matchedRoute = await matchRoute(
+      pathname,
+      this.manifestData,
+      this.pipeline,
+      this.manifest
+    );
+    if (!matchedRoute) return void 0;
+    this.resolvedPathname = matchedRoute.resolvedPathname;
+    return {
+      routeData: matchedRoute.route,
+      resolvedPathname: matchedRoute.resolvedPathname
+    };
+  }
   async createRenderContext(payload) {
-    this.currentRenderContext = await super.createRenderContext(payload);
-    return this.currentRenderContext;
+    return super.createRenderContext({
+      ...payload,
+      pathname: this.resolvedPathname ?? payload.pathname
+    });
   }
   async renderError(request, { locals, skipMiddleware = false, error, clientAddress, status }) {
     if (isAstroError(error) && [MiddlewareNoDataOrNextCalled.name, MiddlewareNotAResponse.name].includes(error.name)) {
@@ -34,7 +55,7 @@ class DevApp extends BaseApp {
         const renderContext = await this.createRenderContext({
           locals,
           pipeline: this.pipeline,
-          pathname: this.getPathnameFromRequest(request),
+          pathname: await this.getPathnameFromRequest(request),
           skipMiddleware,
           request,
           routeData,

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

@@ -5,6 +5,7 @@ import { BuildPipeline } from './pipeline.js';
 import type { StaticBuildOptions } from './types.js';
 export declare class BuildApp extends BaseApp<BuildPipeline> {
     createPipeline(_streaming: boolean, manifest: SSRManifest, ..._args: any[]): BuildPipeline;
+    isDev(): boolean;
     setInternals(internals: BuildInternals): void;
     setOptions(options: StaticBuildOptions): void;
     getOptions(): StaticBuildOptions;

package/dist/core/build/app.js

@@ -6,6 +6,9 @@ class BuildApp extends BaseApp {
       manifest
     });
   }
+  isDev() {
+    return true;
+  }
   setInternals(internals) {
     this.pipeline.setInternals(internals);
   }

package/dist/core/build/index.js

@@ -17,7 +17,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 { createRoutesList } from "../routing/index.js";
+import { createRoutesList } from "../routing/manifest/create.js";
 import { clearContentLayerCache } from "../sync/index.js";
 import { ensureProcessNodeEnv } from "../util.js";
 import { collectPagesData } from "./page-data.js";

package/dist/core/build/plugins/plugin-manifest.d.ts

@@ -1,5 +1,4 @@
-import type { OutputChunk } from 'rollup';
-import type * as vite from 'vite';
+import type { ExtractedChunk } from '../static-build.js';
 import type { BuildInternals } from '../internal.js';
 import type { StaticBuildOptions } from '../types.js';
 /**
@@ -27,8 +26,7 @@ export declare const MANIFEST_REPLACE = "@@ASTRO_MANIFEST_REPLACE@@";
  * Post-build hook that injects the computed manifest into bundled chunks.
  * Finds the serialized manifest chunk and replaces the placeholder token with real data.
  */
-export declare function manifestBuildPostHook(options: StaticBuildOptions, internals: BuildInternals, { ssrOutputs, prerenderOutputs, mutate, }: {
-    ssrOutputs: vite.Rollup.RollupOutput[];
-    prerenderOutputs: vite.Rollup.RollupOutput[];
-    mutate: (chunk: OutputChunk, envs: ['server'], code: string) => void;
+export declare function manifestBuildPostHook(options: StaticBuildOptions, internals: BuildInternals, { chunks, mutate, }: {
+    chunks: ExtractedChunk[];
+    mutate: (fileName: string, code: string, prerender: boolean) => void;
 }): Promise<void>;

package/dist/core/build/plugins/plugin-manifest.js

@@ -29,30 +29,14 @@ import { sessionConfigToManifest } from "../../session/utils.js";
 const MANIFEST_REPLACE = "@@ASTRO_MANIFEST_REPLACE@@";
 const replaceExp = new RegExp(`['"]${MANIFEST_REPLACE}['"]`, "g");
 async function manifestBuildPostHook(options, internals, {
-  ssrOutputs,
-  prerenderOutputs,
+  chunks,
   mutate
 }) {
   const manifest = await createManifest(options, internals);
-  if (ssrOutputs.length > 0) {
-    let manifestEntryChunk;
-    for (const output of ssrOutputs) {
-      for (const chunk of output.output) {
-        if (chunk.type === "asset") {
-          continue;
-        }
-        if (chunk.code && chunk.moduleIds.includes(SERIALIZED_MANIFEST_RESOLVED_ID)) {
-          manifestEntryChunk = chunk;
-          break;
-        }
-      }
-      if (manifestEntryChunk) {
-        break;
-      }
-    }
-    if (!manifestEntryChunk) {
-      throw new Error(`Did not find serialized manifest chunk for SSR`);
-    }
+  const ssrManifestChunk = chunks.find(
+    (c) => !c.prerender && c.moduleIds.includes(SERIALIZED_MANIFEST_RESOLVED_ID)
+  );
+  if (ssrManifestChunk) {
     const shouldPassMiddlewareEntryPoint = options.settings.adapter?.adapterFeatures?.edgeMiddleware;
     await runHookBuildSsr({
       config: options.settings.config,
@@ -60,29 +44,15 @@ async function manifestBuildPostHook(options, internals, {
       logger: options.logger,
       middlewareEntryPoint: shouldPassMiddlewareEntryPoint ? internals.middlewareEntryPoint : void 0
     });
-    const code = injectManifest(manifest, manifestEntryChunk);
-    mutate(manifestEntryChunk, ["server"], code);
+    const code = injectManifest(manifest, ssrManifestChunk.code);
+    mutate(ssrManifestChunk.fileName, code, false);
   }
-  if (prerenderOutputs?.length > 0) {
-    let prerenderManifestChunk;
-    for (const output of prerenderOutputs) {
-      for (const chunk of output.output) {
-        if (chunk.type === "asset") {
-          continue;
-        }
-        if (chunk.code && chunk.moduleIds.includes(SERIALIZED_MANIFEST_RESOLVED_ID)) {
-          prerenderManifestChunk = chunk;
-          break;
-        }
-      }
-      if (prerenderManifestChunk) {
-        break;
-      }
-    }
-    if (prerenderManifestChunk) {
-      const prerenderCode = injectManifest(manifest, prerenderManifestChunk);
-      mutate(prerenderManifestChunk, ["server"], prerenderCode);
-    }
+  const prerenderManifestChunk = chunks.find(
+    (c) => c.prerender && c.moduleIds.includes(SERIALIZED_MANIFEST_RESOLVED_ID)
+  );
+  if (prerenderManifestChunk) {
+    const code = injectManifest(manifest, prerenderManifestChunk.code);
+    mutate(prerenderManifestChunk.fileName, code, true);
   }
 }
 async function createManifest(buildOpts, internals) {
@@ -99,8 +69,7 @@ async function createManifest(buildOpts, internals) {
   const manifest = await buildManifest(buildOpts, internals, Array.from(staticFiles), encodedKey);
   return manifest;
 }
-function injectManifest(manifest, chunk) {
-  const code = chunk.code;
+function injectManifest(manifest, code) {
   return code.replace(replaceExp, () => {
     return JSON.stringify(manifest);
   });

package/dist/core/build/static-build.d.ts

@@ -1,6 +1,16 @@
 import { type BuildInternals } from '../../core/build/internal.js';
 import type { RouteData } from '../../types/public/internal.js';
 import type { StaticBuildOptions } from './types.js';
+/**
+ * Minimal chunk data extracted from RollupOutput for deferred manifest/content injection.
+ * Allows releasing full RollupOutput objects early to reduce memory usage.
+ */
+export interface ExtractedChunk {
+    fileName: string;
+    code: string;
+    moduleIds: string[];
+    prerender: boolean;
+}
 export declare function viteBuild(opts: StaticBuildOptions): Promise<{
     internals: BuildInternals;
     prerenderOutputDir: URL;