astro 6.0.0-alpha.0 → 6.0.0-alpha.1

package/dist/types/public/context.d.ts

@@ -1,5 +1,4 @@
-import type { z } from 'zod';
-import type { ActionAccept, ActionClient, ActionReturnType } from '../../actions/runtime/server.js';
+import type { ActionClient, ActionReturnType } from '../../actions/runtime/types.js';
 import type { AstroCookies } from '../../core/cookies/cookies.js';
 import type { CspDirective, CspHash } from '../../core/csp/config.js';
 import type { AstroSession } from '../../core/session.js';
@@ -240,11 +239,11 @@ interface AstroSharedContext<Props extends Record<string, any> = Record<string,
     /**
      * Get action result on the server when using a form POST.
      */
-    getActionResult: <TAccept extends ActionAccept, TInputSchema extends z.ZodType, TAction extends ActionClient<unknown, TAccept, TInputSchema>>(action: TAction) => ActionReturnType<TAction> | undefined;
+    getActionResult: <TAction extends ActionClient<any, any, any>>(action: TAction) => ActionReturnType<TAction> | undefined;
     /**
      * Call action handler from the server.
      */
-    callAction: <TAccept extends ActionAccept, TInputSchema extends z.ZodType, TOutput, TAction extends ActionClient<TOutput, TAccept, TInputSchema> | ActionClient<TOutput, TAccept, TInputSchema>['orThrow']>(action: TAction, input: Parameters<TAction>[0]) => Promise<ActionReturnType<TAction>>;
+    callAction: <TAction extends ActionClient<any, any, any> | ActionClient<any, any, any>['orThrow']>(action: TAction, input: Parameters<TAction>[0]) => Promise<ActionReturnType<TAction>>;
     /**
      * Route parameters for this request if this is a dynamic route.
      */

package/dist/types/public/index.d.ts

@@ -3,11 +3,12 @@ export type { MarkdownHeading, RehypePlugins, RemarkPlugins, ShikiConfig, } from
 export type { ExternalImageService, ImageService, LocalImageService, } from '../../assets/services/service.js';
 export type { GetImageResult, ImageInputFormat, ImageMetadata, ImageOutputFormat, ImageQuality, ImageQualityPreset, ImageTransform, UnresolvedImageTransform, } from '../../assets/types.js';
 export type { ContainerRenderer } from '../../container/index.js';
-export type { AssetsPrefix, NodeAppHeadersJson, SSRManifest } from '../../core/app/types.js';
+export type { AssetsPrefix, NodeAppHeadersJson, RouteInfo, SSRManifest, } from '../../core/app/types.js';
 export type { AstroCookieGetOptions, AstroCookieSetOptions, AstroCookies, } from '../../core/cookies/index.js';
 export type { AstroIntegrationLogger } from '../../core/logger/core.js';
 export { AstroSession } from '../../core/session.js';
 export type { ToolbarServerHelpers } from '../../runtime/client/dev-toolbar/helpers.js';
+export type { AstroEnvironmentNames } from '../../core/constants.js';
 export type * from './common.js';
 export type * from './config.js';
 export type * from './content.js';

package/dist/types/public/integrations.d.ts

@@ -91,6 +91,13 @@ export interface AstroAdapter {
     exports?: string[];
     args?: any;
     adapterFeatures?: AstroAdapterFeatures;
+    /**
+     * Determines how the adapter's entrypoint is handled during the build.
+     * - `'self'`: The adapter defines its own entrypoint and sets rollupOptions.input
+     * - `'legacy-dynamic'`: Uses the virtual module entrypoint with dynamic exports
+     * @default 'legacy-dynamic'
+     */
+    entryType?: 'self' | 'legacy-dynamic';
     /**
      * List of features supported by an adapter.
      *
@@ -235,7 +242,7 @@ export type HeaderPayload = {
     headers: Headers;
     route: IntegrationResolvedRoute;
 };
-export interface IntegrationResolvedRoute extends Pick<RouteData, 'generate' | 'params' | 'pathname' | 'segments' | 'type' | 'redirect' | 'origin'> {
+export interface IntegrationResolvedRoute extends Pick<RouteData, 'params' | 'pathname' | 'segments' | 'type' | 'redirect' | 'origin'> {
     /**
      * {@link RouteData.route}
      */
@@ -256,5 +263,20 @@ export interface IntegrationResolvedRoute extends Pick<RouteData, 'generate' | '
      * {@link RouteData.redirectRoute}
      */
     redirectRoute?: IntegrationResolvedRoute;
+    /**
+     * @param {any} data The optional parameters of the route
+     *
+     * @description
+     * A function that accepts a list of params, interpolates them with the route pattern, and returns the path name of the route.
+     *
+     * ## Example
+     *
+     * For a route such as `/blog/[...id].astro`, the `generate` function would return something like this:
+     *
+     * ```js
+     * console.log(generate({ id: 'presentation' })) // will log `/blog/presentation`
+     * ```
+     */
+    generate: (data?: any) => string;
 }
 export {};

package/dist/types/public/internal.d.ts

@@ -46,21 +46,6 @@ export interface RouteData {
      *  Source component URL
      */
     component: string;
-    /**
-     * @param {any} data The optional parameters of the route
-     *
-     * @description
-     * A function that accepts a list of params, interpolates them with the route pattern, and returns the path name of the route.
-     *
-     * ## Example
-     *
-     * For a route such as `/blog/[...id].astro`, the `generate` function would return something like this:
-     *
-     * ```js
-     * console.log(generate({ id: 'presentation' })) // will log `/blog/presentation`
-     * ```
-     */
-    generate: (data?: any) => string;
     /**
      * Dynamic and spread route params
      * ex. "/pages/[lang]/[...slug].astro" will output the params ['lang', '...slug']
@@ -74,7 +59,7 @@ export interface RouteData {
     /**
      * The paths of the physical files emitted by this route. When a route **isn't** prerendered, the value is either `undefined` or an empty array.
      */
-    distURL?: URL[];
+    distURL: URL[];
     /**
      *
      * regex used for matching an input URL against a requested route

package/dist/types/public/preview.d.ts

@@ -15,6 +15,12 @@ export interface PreviewServerParams {
     base: string;
     logger: AstroIntegrationLogger;
     headers?: OutgoingHttpHeaders;
+    /**
+     * DO NOT USE. This is for internal use only and might be removed soon.
+     * @deprecated
+     */
+    createCodegenDir: () => URL;
+    root: URL;
 }
 export type CreatePreviewServer = (params: PreviewServerParams) => PreviewServer | Promise<PreviewServer>;
 export interface PreviewModule {

package/dist/virtual-modules/i18n.d.ts

@@ -195,7 +195,15 @@ export declare let requestHasLocale: (context: APIContext) => boolean;
  */
 export declare let redirectToFallback: RedirectToFallback;
 type OnlyObject<T> = T extends object ? T : never;
-type NewAstroRoutingConfigWithoutManual = OnlyObject<NonNullable<AstroConfig['i18n']>['routing']>;
+export type I18nMiddlewareOptions = {
+    fallbackType: OnlyObject<NonNullable<AstroConfig['i18n']>['routing']>['fallbackType'];
+} & ({
+    prefixDefaultLocale: false;
+    redirectToDefaultLocale: false;
+} | {
+    prefixDefaultLocale: true;
+    redirectToDefaultLocale: boolean;
+});
 /**
  * @param {AstroConfig['i18n']['routing']} customOptions
  *
@@ -226,7 +234,7 @@ type NewAstroRoutingConfigWithoutManual = OnlyObject<NonNullable<AstroConfig['i1
  *
  * ```
  */
-export declare let middleware: (customOptions: NewAstroRoutingConfigWithoutManual) => MiddlewareHandler;
+export declare let middleware: (customOptions: I18nMiddlewareOptions) => MiddlewareHandler;
 /**
  * Replaces underscores (`_`) with hyphens (`-`) in the given locale before
  * returning a lowercase version.

package/dist/virtual-modules/i18n.js

@@ -1,11 +1,15 @@
-import { IncorrectStrategyForI18n } from "../core/errors/errors-data.js";
+import * as config from "astro:config/server";
+import { toFallbackType } from "../core/app/common.js";
+import { toRoutingStrategy } from "../core/app/index.js";
+import {
+  IncorrectStrategyForI18n,
+  InvalidI18nMiddlewareConfiguration
+} from "../core/errors/errors-data.js";
 import { AstroError } from "../core/errors/index.js";
 import * as I18nInternals from "../i18n/index.js";
-import { toFallbackType, toRoutingStrategy } from "../i18n/utils.js";
-const { trailingSlash, format, site, i18n, isBuild } = (
-  // @ts-expect-error
-  __ASTRO_INTERNAL_I18N_CONFIG__
-);
+const { trailingSlash, site, i18n, build } = config;
+const { format } = build;
+const isBuild = import.meta.env.PROD;
 const { defaultLocale, locales, domains, fallback, routing } = i18n;
 const base = import.meta.env.BASE_URL;
 let strategy = toRoutingStrategy(routing, domains);
@@ -126,6 +130,10 @@ if (i18n?.routing === "manual") {
 let middleware;
 if (i18n?.routing === "manual") {
   middleware = (customOptions) => {
+    if (customOptions.prefixDefaultLocale === false && // @ts-expect-error types do not allow this but we also check at runtime
+    customOptions.redirectToDefaultLocale === true) {
+      throw new AstroError(InvalidI18nMiddlewareConfiguration);
+    }
     strategy = toRoutingStrategy(customOptions, {});
     fallbackType = toFallbackType(customOptions);
     const manifest = {
@@ -133,7 +141,8 @@ if (i18n?.routing === "manual") {
       strategy,
       domainLookupTable: {},
       fallbackType,
-      fallback: i18n.fallback
+      fallback: i18n.fallback,
+      domains: i18n.domains
     };
     return I18nInternals.createMiddleware(manifest, base, trailingSlash, format);
   };

package/dist/virtual-modules/live-config.d.ts

@@ -1,4 +1,4 @@
-export * as z from 'zod';
+export * as z from 'zod/v4';
 export { defineLiveCollection } from '../content/config.js';
 export declare const getCollection: () => never;
 export declare const render: () => never;

package/dist/virtual-modules/live-config.js

@@ -1,4 +1,4 @@
-import * as z from "zod";
+import * as z from "zod/v4";
 import { defineLiveCollection } from "../content/config.js";
 function createErrorFunction(message) {
   return () => {

package/dist/virtual-modules/middleware.d.ts

@@ -1 +1,2 @@
-export { defineMiddleware, sequence } from '../core/middleware/index.js';
+export { defineMiddleware } from '../core/middleware/defineMiddleware.js';
+export { sequence } from '../core/middleware/sequence.js';

package/dist/virtual-modules/middleware.js

@@ -1,4 +1,5 @@
-import { defineMiddleware, sequence } from "../core/middleware/index.js";
+import { defineMiddleware } from "../core/middleware/defineMiddleware.js";
+import { sequence } from "../core/middleware/sequence.js";
 export {
   defineMiddleware,
   sequence

package/dist/vite-plugin-adapter-config/index.js

@@ -1,3 +1,4 @@
+import { isAstroServerEnvironment } from "../environments.js";
 const VIRTUAL_CLIENT_ID = "virtual:astro:adapter-config/client";
 const RESOLVED_VIRTUAL_CLIENT_ID = "\0" + VIRTUAL_CLIENT_ID;
 function vitePluginAdapterConfig(settings) {
@@ -8,9 +9,9 @@ function vitePluginAdapterConfig(settings) {
         return RESOLVED_VIRTUAL_CLIENT_ID;
       }
     },
-    load(id, options) {
+    load(id) {
       if (id === RESOLVED_VIRTUAL_CLIENT_ID) {
-        if (options?.ssr) {
+        if (isAstroServerEnvironment(this.environment)) {
           return {
             code: `export const internalFetchHeaders = {};`
           };

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

@@ -0,0 +1,47 @@
+import type http from 'node:http';
+import { BaseApp, type RenderErrorOptions } from '../core/app/index.js';
+import type { Logger } from '../core/logger/core.js';
+import type { ModuleLoader } from '../core/module-loader/index.js';
+import type { CreateRenderContext, RenderContext } from '../core/render-context.js';
+import type { AstroSettings, RoutesList } from '../types/astro.js';
+import type { RouteData, SSRManifest } from '../types/public/index.js';
+import type { DevServerController } from '../vite-plugin-astro-server/controller.js';
+import { AstroServerPipeline } from './pipeline.js';
+export declare class AstroServerApp extends BaseApp<AstroServerPipeline> {
+    settings: AstroSettings;
+    logger: Logger;
+    loader: ModuleLoader;
+    manifestData: RoutesList;
+    currentRenderContext: RenderContext | undefined;
+    constructor(manifest: SSRManifest, streaming: boolean | undefined, logger: Logger, manifestData: RoutesList, loader: ModuleLoader, settings: AstroSettings, getDebugInfo: () => Promise<string>);
+    static create(manifest: SSRManifest, routesList: RoutesList, logger: Logger, loader: ModuleLoader, settings: AstroSettings, getDebugInfo: () => Promise<string>): Promise<AstroServerApp>;
+    createPipeline(_streaming: boolean, manifest: SSRManifest, settings: AstroSettings, logger: Logger, loader: ModuleLoader, manifestData: RoutesList, getDebugInfo: () => Promise<string>): AstroServerPipeline;
+    createRenderContext(payload: CreateRenderContext): Promise<RenderContext>;
+    clearRouteCache(): void;
+    handleRequest({ controller, incomingRequest, incomingResponse, isHttps, }: HandleRequest): Promise<void>;
+    handleRoute({ matchedRoute, incomingRequest, incomingResponse, body, url, pathname, }: HandleRoute): Promise<void>;
+    match(request: Request, _allowPrerenderedRoutes: boolean): RouteData | undefined;
+    renderError(request: Request, { locals, skipMiddleware, error, clientAddress, status }: RenderErrorOptions): Promise<Response>;
+}
+type HandleRequest = {
+    controller: DevServerController;
+    incomingRequest: http.IncomingMessage;
+    incomingResponse: http.ServerResponse;
+    isHttps: boolean;
+};
+type AsyncReturnType<T extends (...args: any) => Promise<any>> = T extends (...args: any) => Promise<infer R> ? R : any;
+type HandleRoute = {
+    matchedRoute: AsyncReturnType<typeof matchRoute>;
+    url: URL;
+    pathname: string;
+    body: BodyInit | undefined;
+    incomingRequest: http.IncomingMessage;
+    incomingResponse: http.ServerResponse;
+};
+interface MatchedRoute {
+    route: RouteData;
+    filePath: URL;
+    resolvedPathname: string;
+}
+declare function matchRoute(pathname: string, routesList: RoutesList, pipeline: AstroServerPipeline, manifest: SSRManifest): Promise<MatchedRoute | undefined>;
+export {};