@angular/ssr 19.0.0-rc.0 → 19.0.0-rc.2

package/fesm2022/tokens.mjs

@@ -1,20 +1,63 @@
 import { InjectionToken } from '@angular/core';
 
 /**
- * Injection token for the current request.
+ * Injection token representing the current HTTP request object.
+ *
+ * Use this token to access the current request when handling server-side
+ * rendering (SSR).
+ *
+ * @remarks
+ * This token may be `null` in the following scenarios:
+ *
+ * * During the build processes.
+ * * When the application is rendered in the browser (client-side rendering).
+ * * When performing static site generation (SSG).
+ * * During route extraction in development (at the time of the request).
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | `Request` on MDN}
+ *
  * @developerPreview
  */
-const REQUEST = new InjectionToken('REQUEST');
+const REQUEST = new InjectionToken('REQUEST', {
+    providedIn: 'platform',
+    factory: () => null,
+});
 /**
- * Injection token for the response initialization options.
+ * Injection token for response initialization options.
+ *
+ * Use this token to provide response options for configuring or initializing
+ * HTTP responses in server-side rendering or API endpoints.
+ *
+ * @remarks
+ * This token may be `null` in the following scenarios:
+ *
+ * * During the build processes.
+ * * When the application is rendered in the browser (client-side rendering).
+ * * When performing static site generation (SSG).
+ * * During route extraction in development (at the time of the request).
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Response/Response | `ResponseInit` on MDN}
+ *
  * @developerPreview
  */
-const RESPONSE_INIT = new InjectionToken('RESPONSE_INIT');
+const RESPONSE_INIT = new InjectionToken('RESPONSE_INIT', {
+    providedIn: 'platform',
+    factory: () => null,
+});
 /**
  * Injection token for additional request context.
+ *
+ * Use this token to pass custom metadata or context related to the current request in server-side rendering.
+ *
+ * @remarks
+ * This token is only available during server-side rendering and will be `null` in other contexts.
+ *
  * @developerPreview
  */
-const REQUEST_CONTEXT = new InjectionToken('REQUEST_CONTEXT');
+const REQUEST_CONTEXT = new InjectionToken('REQUEST_CONTEXT', {
+    providedIn: 'platform',
+    factory: () => null,
+});
 
 export { REQUEST, REQUEST_CONTEXT, RESPONSE_INIT };
 //# sourceMappingURL=tokens.mjs.map

package/fesm2022/tokens.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"tokens.mjs","sources":["../../../../../../darwin_arm64-fastbuild-ST-70f2edae98f4/bin/packages/angular/ssr/tokens/src/tokens.mjs"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\nimport { InjectionToken } from '@angular/core';\n/**\n * Injection token for the current request.\n * @developerPreview\n */\nexport const REQUEST = new InjectionToken('REQUEST');\n/**\n * Injection token for the response initialization options.\n * @developerPreview\n */\nexport const RESPONSE_INIT = new InjectionToken('RESPONSE_INIT');\n/**\n * Injection token for additional request context.\n * @developerPreview\n */\nexport const REQUEST_CONTEXT = new InjectionToken('REQUEST_CONTEXT');\n//# sourceMappingURL=tokens.js.map"],"names":[],"mappings":";;AAQA;AACA;AACA;AACA;AACY,MAAC,OAAO,GAAG,IAAI,cAAc,CAAC,SAAS;AACnD;AACA;AACA;AACA;AACY,MAAC,aAAa,GAAG,IAAI,cAAc,CAAC,eAAe;AAC/D;AACA;AACA;AACA;AACY,MAAC,eAAe,GAAG,IAAI,cAAc,CAAC,iBAAiB;;;;"}
+{"version":3,"file":"tokens.mjs","sources":["../../../../../../k8-fastbuild-ST-70f2edae98f4/bin/packages/angular/ssr/tokens/src/tokens.mjs"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\nimport { InjectionToken } from '@angular/core';\n/**\n * Injection token representing the current HTTP request object.\n *\n * Use this token to access the current request when handling server-side\n * rendering (SSR).\n *\n * @remarks\n * This token may be `null` in the following scenarios:\n *\n * * During the build processes.\n * * When the application is rendered in the browser (client-side rendering).\n * * When performing static site generation (SSG).\n * * During route extraction in development (at the time of the request).\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request | `Request` on MDN}\n *\n * @developerPreview\n */\nexport const REQUEST = new InjectionToken('REQUEST', {\n    providedIn: 'platform',\n    factory: () => null,\n});\n/**\n * Injection token for response initialization options.\n *\n * Use this token to provide response options for configuring or initializing\n * HTTP responses in server-side rendering or API endpoints.\n *\n * @remarks\n * This token may be `null` in the following scenarios:\n *\n * * During the build processes.\n * * When the application is rendered in the browser (client-side rendering).\n * * When performing static site generation (SSG).\n * * During route extraction in development (at the time of the request).\n *\n * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Response/Response | `ResponseInit` on MDN}\n *\n * @developerPreview\n */\nexport const RESPONSE_INIT = new InjectionToken('RESPONSE_INIT', {\n    providedIn: 'platform',\n    factory: () => null,\n});\n/**\n * Injection token for additional request context.\n *\n * Use this token to pass custom metadata or context related to the current request in server-side rendering.\n *\n * @remarks\n * This token is only available during server-side rendering and will be `null` in other contexts.\n *\n * @developerPreview\n */\nexport const REQUEST_CONTEXT = new InjectionToken('REQUEST_CONTEXT', {\n    providedIn: 'platform',\n    factory: () => null,\n});\n//# sourceMappingURL=tokens.js.map"],"names":[],"mappings":";;AAQA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,OAAO,GAAG,IAAI,cAAc,CAAC,SAAS,EAAE;AACrD,IAAI,UAAU,EAAE,UAAU;AAC1B,IAAI,OAAO,EAAE,MAAM,IAAI;AACvB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,aAAa,GAAG,IAAI,cAAc,CAAC,eAAe,EAAE;AACjE,IAAI,UAAU,EAAE,UAAU;AAC1B,IAAI,OAAO,EAAE,MAAM,IAAI;AACvB,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACY,MAAC,eAAe,GAAG,IAAI,cAAc,CAAC,iBAAiB,EAAE;AACrE,IAAI,UAAU,EAAE,UAAU;AAC1B,IAAI,OAAO,EAAE,MAAM,IAAI;AACvB,CAAC;;;;"}

package/index.d.ts

@@ -8,12 +8,21 @@ import type { Type } from '@angular/core';
  * Manages Angular server applications (including localized ones), handles rendering requests,
  * and optionally transforms index HTML before rendering.
  *
- * @note This class should be instantiated once and used as a singleton across the server-side
+ * @remarks This class should be instantiated once and used as a singleton across the server-side
  * application to ensure consistent handling of rendering requests and resource management.
  *
  * @developerPreview
  */
 export declare class AngularAppEngine {
+    /**
+     * A flag to enable or disable the rendering of prerendered routes.
+     *
+     * Typically used during development to avoid prerendering all routes ahead of time,
+     * allowing them to be rendered on the fly as requested.
+     *
+     * @private
+     */
+    static ɵallowStaticRouteRender: boolean;
     /**
      * Hooks for extending or modifying the behavior of the server application.
      * These hooks are used by the Angular CLI when running the development server and
@@ -31,30 +40,29 @@ export declare class AngularAppEngine {
      */
     private readonly entryPointsCache;
     /**
-     * Renders a response for the given HTTP request using the server application.
+     * Handles an incoming HTTP request by serving prerendered content, performing server-side rendering,
+     * or delivering a static file for client-side rendered routes based on the `RenderMode` setting.
      *
-     * This method processes the request, determines the appropriate route and rendering context,
-     * and returns an HTTP response.
+     * @param request - The HTTP request to handle.
+     * @param requestContext - Optional context for rendering, such as metadata associated with the request.
+     * @returns A promise that resolves to the resulting HTTP response object, or `null` if no matching Angular route is found.
      *
-     * If the request URL appears to be for a file (excluding `/index.html`), the method returns `null`.
-     * A request to `https://www.example.com/page/index.html` will render the Angular route
+     * @remarks A request to `https://www.example.com/page/index.html` will serve or render the Angular route
      * corresponding to `https://www.example.com/page`.
-     *
-     * @param request - The incoming HTTP request object to be rendered.
-     * @param requestContext - Optional additional context for the request, such as metadata.
-     * @returns A promise that resolves to a Response object, or `null` if the request URL represents a file (e.g., `./logo.png`)
-     * rather than an application route.
      */
-    render(request: Request, requestContext?: unknown): Promise<Response | null>;
+    handle(request: Request, requestContext?: unknown): Promise<Response | null>;
     /**
-     * Retrieves HTTP headers for a request associated with statically generated (SSG) pages,
-     * based on the URL pathname.
+     * Retrieves the Angular server application instance for a given request.
+     *
+     * This method checks if the request URL corresponds to an Angular application entry point.
+     * If so, it initializes or retrieves an instance of the Angular server application for that entry point.
+     * Requests that resemble file requests (except for `/index.html`) are skipped.
      *
-     * @param request - The incoming request object.
-     * @returns A `Map` containing the HTTP headers as key-value pairs.
-     * @note This function should be used exclusively for retrieving headers of SSG pages.
+     * @param request - The incoming HTTP request object.
+     * @returns A promise that resolves to an `AngularServerApp` instance if a valid entry point is found,
+     * or `null` if no entry point matches the request URL.
      */
-    getPrerenderHeaders(request: Request): ReadonlyMap<string, string>;
+    private getAngularServerAppForRequest;
     /**
      * Retrieves the exports for a specific entry point, caching the result.
      *
@@ -92,15 +100,6 @@ declare interface AngularAppEngineManifest {
      * This is used to determine the root path of the application.
      */
     readonly basePath: string;
-    /**
-     * A map that associates static paths with their corresponding HTTP headers.
-     * Each entry in the map consists of:
-     * - `key`: The static path as a string.
-     * - `value`: An array of tuples, where each tuple contains:
-     *   - `headerName`: The name of the HTTP header.
-     *   - `headerValue`: The value of the HTTP header.
-     */
-    readonly staticPathsHeaders: ReadonlyMap<string, readonly [headerName: string, headerValue: string][]>;
 }
 
 /**
@@ -113,7 +112,7 @@ declare interface AngularAppManifest {
      * - `key`: The path of the asset.
      * - `value`: A function returning a promise that resolves to the file contents of the asset.
      */
-    readonly assets: ReadonlyMap<string, () => Promise<string>>;
+    readonly assets: ReadonlyMap<string, ServerAsset>;
     /**
      * The bootstrap mechanism for the server application.
      * A function that returns a promise that resolves to an `NgModule` or a function
@@ -175,6 +174,10 @@ declare interface AngularRouterConfigResult {
      * A list of errors encountered during the route extraction process.
      */
     errors: string[];
+    /**
+     * The specified route for the app-shell, if configured.
+     */
+    appShellRoute?: string;
 }
 
 /**
@@ -183,11 +186,25 @@ declare interface AngularRouterConfigResult {
  * The `AngularServerApp` class handles server-side rendering and asset management for a specific locale.
  */
 declare class AngularServerApp {
+    private readonly options;
     /**
-     * Hooks for extending or modifying the behavior of the server application.
-     * This instance can be used to attach custom functionality to various events in the server application lifecycle.
+     * Whether prerendered routes should be rendered on demand or served directly.
+     *
+     * @see {@link AngularServerAppOptions.allowStaticRouteRender} for more details.
+     */
+    private readonly allowStaticRouteRender;
+    /**
+     * Hooks for extending or modifying server behavior.
+     *
+     * @see {@link AngularServerAppOptions.hooks} for more details.
+     */
+    readonly hooks: Hooks;
+    /**
+     * Constructs an instance of `AngularServerApp`.
+     *
+     * @param options Optional configuration options for the server application.
      */
-    hooks: Hooks;
+    constructor(options?: Readonly<AngularServerAppOptions>);
     /**
      * The manifest associated with this server application.
      */
@@ -217,44 +234,71 @@ declare class AngularServerApp {
      */
     private readonly criticalCssLRUCache;
     /**
-     * Renders a response for the given HTTP request using the server application.
-     *
-     * This method processes the request and returns a response based on the specified rendering context.
+     * Handles an incoming HTTP request by serving prerendered content, performing server-side rendering,
+     * or delivering a static file for client-side rendered routes based on the `RenderMode` setting.
      *
-     * @param request - The incoming HTTP request to be rendered.
-     * @param requestContext - Optional additional context for rendering, such as request metadata.
+     * @param request - The HTTP request to handle.
+     * @param requestContext - Optional context for rendering, such as metadata associated with the request.
+     * @returns A promise that resolves to the resulting HTTP response object, or `null` if no matching Angular route is found.
      *
-     * @returns A promise that resolves to the HTTP response object resulting from the rendering, or null if no match is found.
+     * @remarks A request to `https://www.example.com/page/index.html` will serve or render the Angular route
+     * corresponding to `https://www.example.com/page`.
      */
-    render(request: Request, requestContext?: unknown): Promise<Response | null>;
+    handle(request: Request, requestContext?: unknown): Promise<Response | null>;
     /**
-     * Renders a page based on the provided URL via server-side rendering and returns the corresponding HTTP response.
-     * The rendering process can be interrupted by an abort signal, where the first resolved promise (either from the abort
-     * or the render process) will dictate the outcome.
+     * Handles serving a prerendered static asset if available for the matched route.
      *
-     * @param url - The full URL to be processed and rendered by the server.
-     * @param signal - (Optional) An `AbortSignal` object that allows for the cancellation of the rendering process.
-     * @returns A promise that resolves to the generated HTTP response object, or `null` if no matching route is found.
-     */
-    renderStatic(url: URL, signal?: AbortSignal): Promise<Response | null>;
-    /**
-     * Creates a promise that rejects when the request is aborted.
+     * This method only supports `GET` and `HEAD` requests.
      *
-     * @param request - The HTTP request to monitor for abortion.
-     * @returns A promise that never resolves but rejects with an `AbortError` if the request is aborted.
+     * @param request - The incoming HTTP request for serving a static page.
+     * @param matchedRoute - The metadata of the matched route for rendering.
+     * If not provided, the method attempts to find a matching route based on the request URL.
+     * @returns A promise that resolves to a `Response` object if the prerendered page is found, or `null`.
      */
-    private createAbortPromise;
+    private handleServe;
     /**
      * Handles the server-side rendering process for the given HTTP request.
      * This method matches the request URL to a route and performs rendering if a matching route is found.
      *
      * @param request - The incoming HTTP request to be processed.
-     * @param isSsrMode - A boolean indicating whether the rendering is performed in server-side rendering (SSR) mode.
+     * @param matchedRoute - The metadata of the matched route for rendering.
+     * If not provided, the method attempts to find a matching route based on the request URL.
      * @param requestContext - Optional additional context for rendering, such as request metadata.
      *
      * @returns A promise that resolves to the rendered response, or null if no matching route is found.
      */
     private handleRendering;
+    /**
+     * Returns a promise that rejects if the request is aborted.
+     *
+     * @param request - The HTTP request object being monitored for abortion.
+     * @returns A promise that never resolves and rejects with an `AbortError`
+     * if the request is aborted.
+     */
+    private waitForRequestAbort;
+}
+
+/**
+ * Options for configuring an `AngularServerApp`.
+ */
+declare interface AngularServerAppOptions {
+    /**
+     * Whether to allow rendering of prerendered routes.
+     *
+     * When enabled, prerendered routes will be served directly. When disabled, they will be
+     * rendered on demand.
+     *
+     * Defaults to `false`.
+     */
+    allowStaticRouteRender?: boolean;
+    /**
+     *  Hooks for extending or modifying server behavior.
+     *
+     * This allows customization of the server's rendering process and other lifecycle events.
+     *
+     * If not provided, a new `Hooks` instance is created.
+     */
+    hooks?: Hooks;
 }
 
 declare interface BeastiesBase {
@@ -296,7 +340,7 @@ declare interface EntryPointExports {
     /**
      * A reference to the function that creates an Angular server application instance.
      *
-     * @note The return type is `unknown` to prevent circular dependency issues.
+     * @remarks The return type is `unknown` to prevent circular dependency issues.
      */
     ɵgetOrCreateAngularServerApp: () => unknown;
     /**
@@ -397,7 +441,7 @@ declare interface PartialHTMLElement {
 /**
  * Defines the fallback strategies for Static Site Generation (SSG) routes when a pre-rendered path is not available.
  * This is particularly relevant for routes with parameterized URLs where some paths might not be pre-rendered at build time.
- *
+ * @see {@link ServerRoutePrerenderWithParams}
  * @developerPreview
  */
 export declare enum PrerenderFallback {
@@ -419,27 +463,37 @@ export declare enum PrerenderFallback {
 }
 
 /**
- * Configures the necessary providers for server routes configuration.
+ /**
+ * Sets up the necessary providers for configuring server routes.
+ * This function accepts an array of server routes and optional configuration
+ * options, returning an `EnvironmentProviders` object that encapsulates
+ * the server routes and configuration settings.
  *
  * @param routes - An array of server routes to be provided.
+ * @param options - (Optional) An object containing additional configuration options for server routes.
+ * @returns An `EnvironmentProviders` instance with the server routes configuration.
+ *
  * @returns An `EnvironmentProviders` object that contains the server routes configuration.
+ *
+ * @see {@link ServerRoute}
+ * @see {@link ServerRoutesConfigOptions}
  * @developerPreview
  */
-export declare function provideServerRoutesConfig(routes: ServerRoute[]): EnvironmentProviders;
+export declare function provideServerRoutesConfig(routes: ServerRoute[], options?: ServerRoutesConfigOptions): EnvironmentProviders;
 
 /**
  * Different rendering modes for server routes.
+ * @see {@link provideServerRoutesConfig}
+ * @see {@link ServerRoute}
  * @developerPreview
  */
 export declare enum RenderMode {
-    /** AppShell rendering mode, typically used for pre-rendered shells of the application. */
-    AppShell = 0,
     /** Server-Side Rendering (SSR) mode, where content is rendered on the server for each request. */
-    Server = 1,
+    Server = 0,
     /** Client-Side Rendering (CSR) mode, where content is rendered on the client side in the browser. */
-    Client = 2,
+    Client = 1,
     /** Static Site Generation (SSG) mode, where content is pre-rendered at build time and served as static files. */
-    Prerender = 3
+    Prerender = 2
 }
 
 
@@ -449,8 +503,9 @@ export declare enum RenderMode {
  * @param request - The incoming HTTP request object.
  * @returns A Promise resolving to a `Response` object, `null`, or directly a `Response`,
  * supporting both synchronous and asynchronous handling.
+ * @developerPreview
  */
-declare type RequestHandlerFunction = (request: Request) => Promise<Response | null> | null | Response;
+export declare type RequestHandlerFunction = (request: Request) => Promise<Response | null> | null | Response;
 
 /**
  * A route tree implementation that supports efficient route matching, including support for wildcard routes.
@@ -623,9 +678,8 @@ declare interface RouteTreeNodeMetadata {
     headers?: Record<string, string>;
     /**
      * Specifies the rendering mode used for this route.
-     * If not provided, the default rendering mode for the application will be used.
      */
-    renderMode?: RenderMode;
+    renderMode: RenderMode;
 }
 
 /**
@@ -640,31 +694,47 @@ declare type RouteTreeNodeMetadataWithoutRoute = Omit<RouteTreeNodeMetadata, 'ro
 declare type SerializableRouteTreeNode = ReadonlyArray<RouteTreeNodeMetadata>;
 
 /**
- * Server route configuration.
- * @developerPreview
+ * Represents of a server asset stored in the manifest.
  */
-export declare type ServerRoute = ServerRouteAppShell | ServerRouteClient | ServerRoutePrerender | ServerRoutePrerenderWithParams | ServerRouteServer;
+declare interface ServerAsset {
+    /**
+     * Retrieves the text content of the asset.
+     *
+     * @returns A promise that resolves to the asset's content as a string.
+     */
+    text: () => Promise<string>;
+    /**
+     * A hash string representing the asset's content.
+     */
+    hash: string;
+    /**
+     * The size of the asset's content in bytes.
+     */
+    size: number;
+}
 
 /**
- * A server route that uses AppShell rendering mode.
+ * Server route configuration.
+ * @see {@link provideServerRoutesConfig}
+ * @developerPreview
  */
-declare interface ServerRouteAppShell extends Omit<ServerRouteCommon, 'headers' | 'status'> {
-    /** Specifies that the route uses AppShell rendering mode. */
-    renderMode: RenderMode.AppShell;
-}
+export declare type ServerRoute = ServerRouteClient | ServerRoutePrerender | ServerRoutePrerenderWithParams | ServerRouteServer;
 
 /**
  * A server route that uses Client-Side Rendering (CSR) mode.
+ * @see {@link RenderMode}
+ * @developerPreview
  */
-declare interface ServerRouteClient extends ServerRouteCommon {
+export declare interface ServerRouteClient extends ServerRouteCommon {
     /** Specifies that the route uses Client-Side Rendering (CSR) mode. */
     renderMode: RenderMode.Client;
 }
 
 /**
  * Common interface for server routes, providing shared properties.
+ * @developerPreview
  */
-declare interface ServerRouteCommon {
+export declare interface ServerRouteCommon {
     /** The path associated with this route. */
     path: string;
     /** Optional additional headers to include in the response for this route. */
@@ -675,8 +745,10 @@ declare interface ServerRouteCommon {
 
 /**
  * A server route that uses Static Site Generation (SSG) mode.
+ * @see {@link RenderMode}
+ * @developerPreview
  */
-declare interface ServerRoutePrerender extends Omit<ServerRouteCommon, 'status'> {
+export declare interface ServerRoutePrerender extends Omit<ServerRouteCommon, 'status'> {
     /** Specifies that the route uses Static Site Generation (SSG) mode. */
     renderMode: RenderMode.Prerender;
     /** Fallback cannot be specified unless `getPrerenderParams` is used. */
@@ -685,8 +757,12 @@ declare interface ServerRoutePrerender extends Omit<ServerRouteCommon, 'status'>
 
 /**
  * A server route configuration that uses Static Site Generation (SSG) mode, including support for routes with parameters.
+ * @see {@link RenderMode}
+ * @see {@link ServerRoutePrerender}
+ * @see {@link PrerenderFallback}
+ * @developerPreview
  */
-declare interface ServerRoutePrerenderWithParams extends Omit<ServerRoutePrerender, 'fallback'> {
+export declare interface ServerRoutePrerenderWithParams extends Omit<ServerRoutePrerender, 'fallback'> {
     /**
      * Optional strategy to use if the SSG path is not pre-rendered.
      * This is especially relevant for routes with parameterized URLs, where some paths may not be pre-rendered at build time.
@@ -725,10 +801,32 @@ declare interface ServerRoutePrerenderWithParams extends Omit<ServerRoutePrerend
     getPrerenderParams: () => Promise<Record<string, string>[]>;
 }
 
+/**
+ * Configuration options for server routes.
+ *
+ * This interface defines the optional settings available for configuring server routes
+ * in the server-side environment, such as specifying a path to the app shell route.
+ *
+ * @see {@link provideServerRoutesConfig}
+ * @developerPreview
+ */
+export declare interface ServerRoutesConfigOptions {
+    /**
+     * Defines the route to be used as the app shell, which serves as the main entry
+     * point for the application. This route is often used to enable server-side rendering
+     * of the application shell for requests that do not match any specific server route.
+     *
+     * @see {@link https://angular.dev/ecosystem/service-workers/app-shell | App shell pattern on Angular.dev}
+     */
+    appShellRoute?: string;
+}
+
 /**
  * A server route that uses Server-Side Rendering (SSR) mode.
+ * @see {@link RenderMode}
+ * @developerPreview
  */
-declare interface ServerRouteServer extends ServerRouteCommon {
+export declare interface ServerRouteServer extends ServerRouteCommon {
     /** Specifies that the route uses Server-Side Rendering (SSR) mode. */
     renderMode: RenderMode.Server;
 }
@@ -759,10 +857,12 @@ export declare function ɵdestroyAngularServerApp(): void;
  *
  * @returns A promise that resolves to an object containing:
  *  - `routeTree`: A populated `RouteTree` containing all extracted routes from the Angular application.
+ *  - `appShellRoute`: The specified route for the app-shell, if configured.
  *  - `errors`: An array of strings representing any errors encountered during the route extraction process.
  */
 export declare function ɵextractRoutesAndCreateRouteTree(url: URL, manifest?: AngularAppManifest, invokeGetPrerenderParams?: boolean, includePrerenderFallbackRoutes?: boolean): Promise<{
     routeTree: RouteTree;
+    appShellRoute?: string;
     errors: string[];
 }>;
 
@@ -770,9 +870,12 @@ export declare function ɵextractRoutesAndCreateRouteTree(url: URL, manifest?: A
  * Retrieves or creates an instance of `AngularServerApp`.
  * - If an instance of `AngularServerApp` already exists, it will return the existing one.
  * - If no instance exists, it will create a new one with the provided options.
+ *
+ * @param options Optional configuration options for the server application.
+ *
  * @returns The existing or newly created instance of `AngularServerApp`.
  */
-export declare function ɵgetOrCreateAngularServerApp(): AngularServerApp;
+export declare function ɵgetOrCreateAngularServerApp(options?: Readonly<AngularServerAppOptions>): AngularServerApp;
 
 /**
  * Retrieves routes from the given Angular application.

package/node/index.d.ts

@@ -1,4 +1,6 @@
 import { ApplicationRef } from '@angular/core';
+import type { Http2ServerRequest } from 'node:http2';
+import type { Http2ServerResponse } from 'node:http2';
 import type { IncomingMessage } from 'node:http';
 import type { ServerResponse } from 'node:http';
 import { StaticProvider } from '@angular/core';
@@ -9,7 +11,7 @@ import { Type } from '@angular/core';
  * Manages Angular server applications (including localized ones), handles rendering requests,
  * and optionally transforms index HTML before rendering.
  *
- * @note This class should be instantiated once and used as a singleton across the server-side
+ * @remarks This class should be instantiated once and used as a singleton across the server-side
  * application to ensure consistent handling of rendering requests and resource management.
  *
  * @developerPreview
@@ -17,46 +19,20 @@ import { Type } from '@angular/core';
 export declare class AngularNodeAppEngine {
     private readonly angularAppEngine;
     /**
-     * Renders an HTTP response based on the incoming request using the Angular server application.
+     * Handles an incoming HTTP request by serving prerendered content, performing server-side rendering,
+     * or delivering a static file for client-side rendered routes based on the `RenderMode` setting.
      *
-     * The method processes the incoming request, determines the appropriate route, and prepares the
-     * rendering context to generate a response. If the request URL corresponds to a static file (excluding `/index.html`),
-     * the method returns `null`.
+     * This method adapts Node.js's `IncomingMessage` or `Http2ServerRequest`
+     * to a format compatible with the `AngularAppEngine` and delegates the handling logic to it.
      *
-     * Example: A request to `https://www.example.com/page/index.html` will render the Angular route
-     * associated with `https://www.example.com/page`.
+     * @param request - The incoming HTTP request (`IncomingMessage` or `Http2ServerRequest`).
+     * @param requestContext - Optional context for rendering, such as metadata associated with the request.
+     * @returns A promise that resolves to the resulting HTTP response object, or `null` if no matching Angular route is found.
      *
-     * @param request - The incoming HTTP request object to be rendered.
-     * @param requestContext - Optional additional context for the request, such as metadata or custom settings.
-     * @returns A promise that resolves to a `Response` object, or `null` if the request URL is for a static file
-     * (e.g., `./logo.png`) rather than an application route.
+     * @remarks A request to `https://www.example.com/page/index.html` will serve or render the Angular route
+     * corresponding to `https://www.example.com/page`.
      */
-    render(request: IncomingMessage, requestContext?: unknown): Promise<Response | null>;
-    /**
-     * Retrieves HTTP headers for a request associated with statically generated (SSG) pages,
-     * based on the URL pathname.
-     *
-     * @param request - The incoming request object.
-     * @returns A `Map` containing the HTTP headers as key-value pairs.
-     * @note This function should be used exclusively for retrieving headers of SSG pages.
-     * @example
-     * ```typescript
-     * const angularAppEngine = new AngularNodeAppEngine();
-     *
-     * app.use(express.static('dist/browser', {
-     *   setHeaders: (res, path) => {
-     *     // Retrieve headers for the current request
-     *     const headers = angularAppEngine.getPrerenderHeaders(res.req);
-     *
-     *     // Apply the retrieved headers to the response
-     *     for (const [key, value] of headers) {
-     *       res.setHeader(key, value);
-     *     }
-     *   }
-     }));
-     * ```
-     */
-    getPrerenderHeaders(request: IncomingMessage): ReadonlyMap<string, string>;
+    handle(request: IncomingMessage | Http2ServerRequest, requestContext?: unknown): Promise<Response | null>;
 }
 
 /**
@@ -153,16 +129,20 @@ export declare interface CommonEngineRenderOptions {
  * ```
  * @developerPreview
  */
-export declare function createNodeRequestHandler<T extends RequestHandlerFunction>(handler: T): T;
+export declare function createNodeRequestHandler<T extends NodeRequestHandlerFunction>(handler: T): T;
 
 /**
- * Converts a Node.js `IncomingMessage` into a Web Standard `Request`.
+ * Converts a Node.js `IncomingMessage` or `Http2ServerRequest` into a
+ * Web Standard `Request` object.
+ *
+ * This function adapts the Node.js request objects to a format that can
+ * be used by web platform APIs.
  *
- * @param nodeRequest - The Node.js `IncomingMessage` object to convert.
+ * @param nodeRequest - The Node.js request object (`IncomingMessage` or `Http2ServerRequest`) to convert.
  * @returns A Web Standard `Request` object.
  * @developerPreview
  */
-export declare function createWebRequestFromNodeRequest(nodeRequest: IncomingMessage): Request;
+export declare function createWebRequestFromNodeRequest(nodeRequest: IncomingMessage | Http2ServerRequest): Request;
 
 
 /**
@@ -191,17 +171,22 @@ export declare function isMainModule(url: string): boolean;
  * @param next - A callback function that signals the completion of the middleware or forwards the error if provided.
  *
  * @returns A Promise that resolves to void or simply void. The handler can be asynchronous.
+ * @developerPreview
  */
-declare type RequestHandlerFunction = (req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => Promise<void> | void;
+export declare type NodeRequestHandlerFunction = (req: IncomingMessage, res: ServerResponse, next: (err?: unknown) => void) => Promise<void> | void;
 
 /**
- * Streams a web-standard `Response` into a Node.js `ServerResponse`.
+ * Streams a web-standard `Response` into a Node.js `ServerResponse`
+ * or `Http2ServerResponse`.
+ *
+ * This function adapts the web `Response` object to write its content
+ * to a Node.js response object, handling both HTTP/1.1 and HTTP/2.
  *
  * @param source - The web-standard `Response` object to stream from.
- * @param destination - The Node.js `ServerResponse` object to stream into.
+ * @param destination - The Node.js response object (`ServerResponse` or `Http2ServerResponse`) to stream into.
  * @returns A promise that resolves once the streaming operation is complete.
  * @developerPreview
  */
-export declare function writeResponseToNodeResponse(source: Response, destination: ServerResponse): Promise<void>;
+export declare function writeResponseToNodeResponse(source: Response, destination: ServerResponse | Http2ServerResponse<Http2ServerRequest>): Promise<void>;
 
 export { }