@ecopages/core 0.2.0-alpha.52 → 0.2.0-alpha.54

package/src/route-renderer/orchestration/route-render-orchestrator.ts

@@ -0,0 +1,879 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileSystem } from '@ecopages/file-system';
+import type { EcoPagesAppConfig } from '../../types/internal-types.ts';
+import type {
+	ComponentRenderResult,
+	DependencyAttributes,
+	EcoComponent,
+	EcoComponentConfig,
+	EcoPageComponent,
+	EcoPageFile,
+	HtmlTemplateProps,
+	IntegrationRendererRenderOptions,
+	PageBrowserGraphContribution,
+	PageBrowserGraphResult,
+	PageMetadataProps,
+	PageProps,
+	ResolvedLazyTrigger,
+	RouteRendererBody,
+	RouteRendererOptions,
+	RouteRenderResult,
+} from '../../types/public-types.ts';
+import {
+	type AssetDefinition,
+	type AssetProcessingService,
+	AssetFactory,
+	createPagePackage,
+	type ProcessedAsset,
+} from '../../services/assets/asset-processing-service/index.ts';
+import type { HtmlDocumentContribution } from '../../services/html/html-transformer.service.ts';
+import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from '../../eco/global-injector-map.ts';
+import { LocalsAccessError } from '../../errors/locals-access-error.ts';
+import { appLogger } from '../../global/app-logger.ts';
+import { inspectUnresolvedMarkerArtifactHtml } from './render-output.utils.ts';
+import { OwnershipValidationService } from './ownership-validation.service.ts';
+import { OwnershipPlanningService } from './ownership-planning.service.ts';
+import { dedupeProcessedAssets } from './processed-asset-dedupe.ts';
+
+export type RouteRenderOrchestratorResolvedInputs = {
+	Page: EcoPageFile['default'] | EcoPageComponent<any>;
+	HtmlTemplate: EcoComponent<HtmlTemplateProps>;
+	Layout?: EcoComponent;
+	props: Record<string, unknown>;
+	metadata: PageMetadataProps;
+	integrationSpecificProps: Record<string, unknown>;
+};
+
+export type RouteRenderOrchestratorResolvedDependencies = {
+	resolvedDependencies: ProcessedAsset[];
+};
+
+/**
+ * Structural HTML work applied after the route body has been fully resolved.
+ *
+ * The shared route flow only needs to know whether a post-render HTML step
+ * exists. When `finalizeHtml` is absent, the captured body can be reused as-is.
+ */
+export type RouteHtmlFinalization = {
+	finalizeHtml?(html: string): string;
+	htmlContributions?: HtmlDocumentContribution[];
+};
+
+function createPageLocalsProxy(filePath: string): Record<string, never> {
+	const errorMessage = `[ecopages] Request locals are only available during request-time rendering with cache: 'dynamic'. Page: ${filePath}. If you meant to use locals here, set cache: 'dynamic' and provide locals from route middleware/handlers.`;
+
+	return new Proxy(
+		{},
+		{
+			get: () => {
+				throw new LocalsAccessError(errorMessage);
+			},
+			set: () => {
+				throw new LocalsAccessError(errorMessage);
+			},
+			has: () => {
+				throw new LocalsAccessError(errorMessage);
+			},
+			ownKeys: () => {
+				throw new LocalsAccessError(errorMessage);
+			},
+			deleteProperty: () => {
+				throw new LocalsAccessError(errorMessage);
+			},
+			defineProperty: () => {
+				throw new LocalsAccessError(errorMessage);
+			},
+			getOwnPropertyDescriptor: () => {
+				throw new LocalsAccessError(errorMessage);
+			},
+		},
+	);
+}
+
+function isGroupedContentScriptAsset(asset: AssetDefinition): asset is Extract<
+	AssetDefinition,
+	{ kind: 'script'; source: 'content' }
+> & {
+	groupedBundle: {
+		id: string;
+		entryName: string;
+	};
+} {
+	return asset.kind === 'script' && asset.source === 'content' && Boolean(asset.groupedBundle?.id);
+}
+
+function getGroupedBundleAssetKey(groupedBundle: { id: string; entryName: string }): string {
+	return `${groupedBundle.id}:${groupedBundle.entryName}`;
+}
+
+type GroupedPageBrowserAssetsResult = {
+	assetsByRoute: Map<string, ProcessedAsset[]>;
+	hasCollectionFailures: boolean;
+};
+
+export interface RouteRenderOrchestratorAdapter<C> {
+	/**
+	 * Name of the owning Integration for the current route render.
+	 */
+	readonly name: string;
+	/**
+	 * Loads the Integration-owned route inputs needed for one Page render.
+	 */
+	resolveRouteRenderInputs(routeOptions: RouteRendererOptions): Promise<RouteRenderOrchestratorResolvedInputs>;
+	/**
+	 * Resolves route-owned dependencies needed before Integration rendering starts.
+	 */
+	resolveRouteDependencies(input: {
+		components: (EcoComponent | Partial<EcoComponent>)[];
+	}): Promise<RouteRenderOrchestratorResolvedDependencies>;
+	/**
+	 * Collects declarative Page Browser Graph requirements for one route.
+	 */
+	collectPageBrowserGraphContribution(routeFile: string): Promise<PageBrowserGraphContribution | undefined>;
+	/**
+	 * Resolves the optional page-root render through the foreign-child-aware component contract.
+	 */
+	resolveRoutePageComponentRender(input: {
+		Page: EcoComponent;
+		Layout?: EcoComponent;
+		props: Record<string, unknown>;
+		routeOptions: RouteRendererOptions;
+	}): Promise<ComponentRenderResult | undefined>;
+	/**
+	 * Executes the Integration-specific route render.
+	 */
+	renderRouteBody(renderOptions: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody>;
+	/**
+	 * Returns the structural Html finalization plan for one prepared route render.
+	 */
+	getRouteHtmlFinalization(renderOptions: IntegrationRendererRenderOptions<C>): RouteHtmlFinalization;
+	/**
+	 * Runs SSR-policy response transformation and returns the body value exposed to callers.
+	 */
+	transformRouteResponse(
+		response: Response,
+		htmlContributions?: HtmlDocumentContribution[],
+	): Promise<RouteRendererBody>;
+}
+
+/**
+ * Captured route-render output in both replayable body and string HTML forms.
+ */
+export interface CapturedHtmlRenderResult {
+	body: RouteRendererBody;
+	html: string;
+}
+
+/**
+ * Optional app-scoped collaborators used by the route render orchestrator.
+ */
+export interface RouteRenderOrchestratorDependencies {
+	ownershipPlanningService?: OwnershipPlanningService;
+	ownershipValidationService?: OwnershipValidationService;
+}
+
+/**
+ * Owns one route render from normalized module loading through final HTML output.
+ *
+ * This orchestrator keeps route rendering as one app-scoped unit while still
+ * delegating integration-specific behavior through the adapter seam. It owns
+ * route-root validation, dependency aggregation, page package creation, and the
+ * final HTML/body handling that happens after the integration render returns.
+ */
+export class RouteRenderOrchestrator {
+	private readonly appConfig: EcoPagesAppConfig;
+	private readonly assetProcessingService: AssetProcessingService;
+	private readonly ownershipPlanningService: OwnershipPlanningService;
+	private readonly ownershipValidationService: OwnershipValidationService;
+	private readonly pageBrowserGraphCache = new Map<string, Promise<PageBrowserGraphResult | undefined>>();
+	private readonly groupedPageBrowserGraphCache = new Map<string, Promise<Map<string, ProcessedAsset[]>>>();
+
+	constructor(
+		appConfig: EcoPagesAppConfig,
+		assetProcessingService: AssetProcessingService,
+		dependencies: RouteRenderOrchestratorDependencies = {},
+	) {
+		this.appConfig = appConfig;
+		this.assetProcessingService = assetProcessingService;
+		this.ownershipPlanningService = dependencies.ownershipPlanningService ?? new OwnershipPlanningService();
+		this.ownershipValidationService =
+			dependencies.ownershipValidationService ?? new OwnershipValidationService(appConfig);
+	}
+
+	/**
+	 * Builds normalized route render options before the integration render runs.
+	 *
+	 * This preparation step validates route-root ownership, resolves page data,
+	 * collects processed assets, captures optional page-root render metadata, and
+	 * produces the page package consumed by downstream HTML transformation.
+	 */
+	async prepareRenderOptions<C = unknown>(
+		routeOptions: RouteRendererOptions,
+		adapter: RouteRenderOrchestratorAdapter<C>,
+	): Promise<IntegrationRendererRenderOptions<C>> {
+		const resolvedInputs = await adapter.resolveRouteRenderInputs(routeOptions);
+		const { Page, HtmlTemplate, Layout, props, metadata, integrationSpecificProps } = resolvedInputs;
+		const validationErrors = this.ownershipValidationService.validate({
+			currentIntegrationName: adapter.name,
+			roots: [
+				{ component: HtmlTemplate as EcoComponent, source: 'html-template' },
+				...(Layout ? [{ component: Layout as EcoComponent, source: 'layout' as const }] : []),
+				{ component: Page as EcoComponent, source: 'page' },
+			],
+		});
+		const ownershipPlan = this.ownershipPlanningService.buildPlan({
+			routeFile: routeOptions.file,
+			currentIntegrationName: adapter.name,
+			HtmlTemplate: HtmlTemplate as EcoComponent,
+			Layout,
+			Page: Page as EcoComponent,
+			validationErrors,
+		});
+
+		const componentsToResolve = Layout ? [HtmlTemplate, Layout, Page] : [HtmlTemplate, Page];
+		const { resolvedDependencies } = await adapter.resolveRouteDependencies({
+			components: componentsToResolve,
+		});
+		const pageBrowserGraph = await this.resolvePageBrowserGraph({
+			routeFile: routeOptions.file,
+			integrationName: adapter.name,
+			collectContribution: async (routeFile) => await adapter.collectPageBrowserGraphContribution(routeFile),
+		});
+		const usedIntegrationDependencies = this.collectUsedIntegrationDependencies(componentsToResolve, adapter.name);
+		const allDependencies = [...resolvedDependencies, ...usedIntegrationDependencies];
+
+		const componentRender = await adapter.resolveRoutePageComponentRender({
+			Page: Page as EcoComponent,
+			Layout,
+			props,
+			routeOptions,
+		});
+
+		if (componentRender?.assets?.length) {
+			allDependencies.push(...componentRender.assets);
+		}
+
+		const triggers = this.collectResolvedTriggers(componentsToResolve);
+		if (triggers.length > 0) {
+			const globalAssets = await this.buildGlobalInjectorAssets(triggers, adapter.name);
+			allDependencies.push(...globalAssets);
+		}
+
+		const eagerSsrLazyAssets = await this.buildEagerSsrLazyAssets(componentsToResolve, adapter.name);
+		if (eagerSsrLazyAssets.length > 0) {
+			allDependencies.push(...eagerSsrLazyAssets);
+		}
+
+		const dedupedDependencies = dedupeProcessedAssets(allDependencies);
+		const pagePackage = createPagePackage(dedupedDependencies, { pageBrowserGraph });
+		const pageProps = {
+			...props,
+			params: routeOptions.params || {},
+			query: routeOptions.query || {},
+		};
+		const cacheStrategy = (Page as EcoPageComponent<any>).cache;
+		const defaultCacheStrategy = this.appConfig.cache?.defaultStrategy ?? 'static';
+		const effectiveCacheStrategy = cacheStrategy ?? defaultCacheStrategy;
+		const localsAvailable = effectiveCacheStrategy === 'dynamic' && routeOptions.locals !== undefined;
+
+		const pageLocals = localsAvailable
+			? routeOptions.locals!
+			: (createPageLocalsProxy(routeOptions.file) as RouteRendererOptions['locals']);
+
+		const locals = localsAvailable ? routeOptions.locals : undefined;
+		const preparedOptions: IntegrationRendererRenderOptions<C> = {
+			...routeOptions,
+			resolvedDependencies,
+			pagePackage,
+			componentRender,
+			HtmlTemplate: HtmlTemplate as EcoComponent<HtmlTemplateProps, C>,
+			Layout,
+			props,
+			Page: Page as EcoComponent<PageProps, C>,
+			metadata,
+			params: routeOptions.params || {},
+			query: routeOptions.query || {},
+			pageProps,
+			locals,
+			pageLocals,
+			cacheStrategy,
+			ownershipPlan,
+		};
+
+		return {
+			...integrationSpecificProps,
+			...preparedOptions,
+		};
+	}
+
+	async resolveDeclaredPageBrowserGraph(input: {
+		routeFile: string;
+		integrationName: string;
+		collectContribution: (routeFile: string) => Promise<PageBrowserGraphContribution | undefined>;
+	}): Promise<PageBrowserGraphResult | undefined> {
+		return await this.resolvePageBrowserGraph(input);
+	}
+
+	private async resolvePageBrowserGraph(input: {
+		routeFile: string;
+		integrationName: string;
+		collectContribution: (routeFile: string) => Promise<PageBrowserGraphContribution | undefined>;
+	}): Promise<PageBrowserGraphResult | undefined> {
+		if (this.isHmrEnabled()) {
+			return await this.buildPageBrowserGraph(input);
+		}
+
+		const cacheKey = `${input.integrationName}:${input.routeFile}`;
+		const cachedGraph = this.pageBrowserGraphCache.get(cacheKey);
+
+		if (cachedGraph) {
+			return await cachedGraph;
+		}
+
+		const pendingGraph = this.buildPageBrowserGraph(input).catch((error) => {
+			this.pageBrowserGraphCache.delete(cacheKey);
+			throw error;
+		});
+		this.pageBrowserGraphCache.set(cacheKey, pendingGraph);
+
+		return await pendingGraph;
+	}
+
+	private isHmrEnabled(): boolean {
+		return (
+			typeof this.assetProcessingService.getHmrManager === 'function' &&
+			this.assetProcessingService.getHmrManager()?.isEnabled() === true
+		);
+	}
+
+	private async buildPageBrowserGraph(input: {
+		routeFile: string;
+		integrationName: string;
+		collectContribution: (routeFile: string) => Promise<PageBrowserGraphContribution | undefined>;
+	}): Promise<PageBrowserGraphResult | undefined> {
+		const contribution = await input.collectContribution(input.routeFile);
+
+		if (!contribution) {
+			return undefined;
+		}
+
+		const groupedDependencies = (contribution.dependencies ?? []).filter((dep) => isGroupedContentScriptAsset(dep));
+		const ungroupedDependencies = (contribution.dependencies ?? []).filter(
+			(dep) => !isGroupedContentScriptAsset(dep),
+		);
+
+		const groupedAssets = groupedDependencies.length
+			? ((await this.resolveGroupedPageBrowserAssets(input, contribution)).get(input.routeFile) ?? [])
+			: [];
+
+		const processedDependencies = ungroupedDependencies.length
+			? await this.assetProcessingService.processDependencies(
+					ungroupedDependencies,
+					`${input.integrationName}:${input.routeFile}`,
+				)
+			: [];
+		const resolvedAssets = [...processedDependencies, ...groupedAssets, ...(contribution.assets ?? [])];
+
+		return this.partitionPageBrowserGraphAssets(resolvedAssets);
+	}
+
+	/**
+	 * Resolves grouped page-browser assets for all routes owned by one integration.
+	 *
+	 * @remarks
+	 * This keeps one shared browser-build result available across sibling routes so
+	 * navigation can reuse the same emitted client graph instead of rebuilding one
+	 * page entry at a time. HMR bypasses this cache because the grouped build must
+	 * reflect the latest source on every request.
+	 */
+	private async resolveGroupedPageBrowserAssets(
+		input: {
+			routeFile: string;
+			integrationName: string;
+			collectContribution: (routeFile: string) => Promise<PageBrowserGraphContribution | undefined>;
+		},
+		currentContribution: PageBrowserGraphContribution,
+	): Promise<Map<string, ProcessedAsset[]>> {
+		if (this.isHmrEnabled()) {
+			const result = await this.buildGroupedPageBrowserAssets(input, currentContribution);
+			return result.assetsByRoute;
+		}
+
+		const cacheKey = input.integrationName;
+		const cached = this.groupedPageBrowserGraphCache.get(cacheKey);
+		if (cached) {
+			return await cached;
+		}
+
+		const pendingGroupedAssets = this.buildGroupedPageBrowserAssets(input, currentContribution)
+			.then((result) => {
+				if (result.hasCollectionFailures) {
+					this.groupedPageBrowserGraphCache.delete(cacheKey);
+				}
+
+				return result.assetsByRoute;
+			})
+			.catch((error) => {
+				this.groupedPageBrowserGraphCache.delete(cacheKey);
+				throw error;
+			});
+		this.groupedPageBrowserGraphCache.set(cacheKey, pendingGroupedAssets);
+
+		return await pendingGroupedAssets;
+	}
+
+	/**
+	 * Builds the shared grouped page-browser asset map for one integration.
+	 *
+	 * @remarks
+	 * Each route can declare grouped content-script dependencies that should be
+	 * emitted together. This method collects those declarations across the owning
+	 * integration, runs the grouped processor once, and then maps the emitted
+	 * assets back onto the routes that reference them.
+	 */
+	private async buildGroupedPageBrowserAssets(
+		input: {
+			routeFile: string;
+			integrationName: string;
+			collectContribution: (routeFile: string) => Promise<PageBrowserGraphContribution | undefined>;
+		},
+		currentContribution: PageBrowserGraphContribution,
+	): Promise<GroupedPageBrowserAssetsResult> {
+		const routeFiles = await this.listIntegrationRouteFiles(input.integrationName);
+		const currentRouteGroupedDependencies = (currentContribution.dependencies ?? []).filter((dep) =>
+			isGroupedContentScriptAsset(dep),
+		);
+		const groupedDependencies: AssetDefinition[] = [...currentRouteGroupedDependencies];
+		const groupedAssetKeysByRoute = new Map<string, Set<string>>();
+		let hasCollectionFailures = false;
+		if (currentRouteGroupedDependencies.length > 0) {
+			groupedAssetKeysByRoute.set(
+				input.routeFile,
+				new Set(currentRouteGroupedDependencies.map((dep) => getGroupedBundleAssetKey(dep.groupedBundle))),
+			);
+		}
+
+		for (const routeFile of routeFiles) {
+			if (routeFile === input.routeFile) {
+				continue;
+			}
+
+			let contribution: PageBrowserGraphContribution | undefined;
+			try {
+				contribution = await input.collectContribution(routeFile);
+			} catch (error) {
+				hasCollectionFailures = true;
+				appLogger.warn(
+					`Skipping grouped page-browser contribution for ${routeFile}: ${error instanceof Error ? error.message : String(error)}`,
+				);
+				continue;
+			}
+
+			if (!contribution?.dependencies?.length) {
+				continue;
+			}
+
+			const routeGroupedDependencies = contribution.dependencies.filter((dep) =>
+				isGroupedContentScriptAsset(dep),
+			);
+			if (routeGroupedDependencies.length === 0) {
+				continue;
+			}
+
+			groupedDependencies.push(...routeGroupedDependencies);
+			groupedAssetKeysByRoute.set(
+				routeFile,
+				new Set(routeGroupedDependencies.map((dep) => getGroupedBundleAssetKey(dep.groupedBundle))),
+			);
+		}
+
+		if (groupedDependencies.length === 0) {
+			return {
+				assetsByRoute: new Map(),
+				hasCollectionFailures,
+			};
+		}
+
+		const processedGroupedDependencies = await this.assetProcessingService.processDependencies(
+			groupedDependencies,
+			`${input.integrationName}:grouped-page-browser-graph`,
+		);
+		const groupedAssetsByRoute = new Map<string, ProcessedAsset[]>();
+
+		for (const [routeFile, groupedAssetKeys] of groupedAssetKeysByRoute) {
+			groupedAssetsByRoute.set(
+				routeFile,
+				processedGroupedDependencies.filter((asset) => {
+					if (!asset.groupedBundle) {
+						return false;
+					}
+
+					return groupedAssetKeys.has(getGroupedBundleAssetKey(asset.groupedBundle));
+				}),
+			);
+		}
+
+		return {
+			assetsByRoute: groupedAssetsByRoute,
+			hasCollectionFailures,
+		};
+	}
+
+	private async listIntegrationRouteFiles(integrationName: string): Promise<string[]> {
+		const integration = this.appConfig.integrations.find((plugin) => plugin.name === integrationName);
+		if (!integration) {
+			return [];
+		}
+
+		const scannedFiles = await fileSystem.glob(
+			integration.extensions.map((extension) => `**/*${extension}`),
+			{ cwd: this.appConfig.absolutePaths.pagesDir },
+		);
+
+		return scannedFiles
+			.filter((file) => !file.includes('.ecopages-node.'))
+			.map((file) => path.join(this.appConfig.absolutePaths.pagesDir, file))
+			.sort((left, right) => left.localeCompare(right));
+	}
+
+	private partitionPageBrowserGraphAssets(assets: ProcessedAsset[]): PageBrowserGraphResult {
+		const entryAssets: ProcessedAsset[] = [];
+		const chunkAssets: ProcessedAsset[] = [];
+
+		for (const asset of assets) {
+			if (asset.packageRole === 'dynamic-chunk') {
+				chunkAssets.push(asset);
+				continue;
+			}
+
+			entryAssets.push(asset);
+		}
+
+		return { entryAssets, chunkAssets };
+	}
+
+	/**
+	 * Captures one route render body as HTML while preserving a replayable body value.
+	 */
+	async captureHtmlRender(render: () => Promise<RouteRendererBody>): Promise<CapturedHtmlRenderResult> {
+		const renderedBody = await render();
+		const capturedRender = await this.captureRenderedBody(renderedBody);
+
+		return {
+			body: capturedRender.body,
+			html: capturedRender.html,
+		};
+	}
+
+	/**
+	 * Executes the full route-render flow and returns the final body plus cache strategy.
+	 */
+	async execute<C = unknown>(
+		options: RouteRendererOptions,
+		adapter: RouteRenderOrchestratorAdapter<C>,
+	): Promise<RouteRenderResult> {
+		const renderOptions = await this.prepareRenderOptions(options, adapter);
+		return this.executePrepared(renderOptions, adapter);
+	}
+
+	/**
+	 * Executes the route-render finalization path for already prepared render options.
+	 */
+	async executePrepared<C = unknown>(
+		renderOptions: IntegrationRendererRenderOptions<C>,
+		adapter: RouteRenderOrchestratorAdapter<C>,
+	): Promise<RouteRenderResult> {
+		const renderExecution = await this.captureHtmlRender(async () => adapter.renderRouteBody(renderOptions));
+		const unresolvedArtifactInspection = inspectUnresolvedMarkerArtifactHtml(renderExecution.html);
+		const htmlFinalization = adapter.getRouteHtmlFinalization(renderOptions);
+		const hasUnresolvedMarkerHtml = unresolvedArtifactInspection.hasUnresolvedMarkerArtifacts;
+
+		if (hasUnresolvedMarkerHtml) {
+			throw new Error(
+				'[ecopages] Route render returned unresolved eco-marker artifact HTML. Full-route unresolved-marker fallback has been removed; resolve mixed foreign children inside renderComponentWithForeignChildren().',
+			);
+		}
+
+		const canReuseCapturedBody = !hasUnresolvedMarkerHtml && htmlFinalization.finalizeHtml === undefined;
+
+		if (canReuseCapturedBody) {
+			const body = await adapter.transformRouteResponse(
+				new Response(renderExecution.body as BodyInit, {
+					headers: {
+						'Content-Type': 'text/html',
+					},
+				}),
+				htmlFinalization.htmlContributions,
+			);
+
+			return {
+				body,
+				cacheStrategy: renderOptions.cacheStrategy,
+			};
+		}
+
+		const finalization = htmlFinalization.finalizeHtml
+			? htmlFinalization.finalizeHtml(unresolvedArtifactInspection.normalizedHtml)
+			: unresolvedArtifactInspection.normalizedHtml;
+
+		const body = await adapter.transformRouteResponse(
+			new Response(finalization, {
+				headers: {
+					'Content-Type': 'text/html',
+				},
+			}),
+			htmlFinalization.htmlContributions,
+		);
+
+		return {
+			body,
+			cacheStrategy: renderOptions.cacheStrategy,
+		};
+	}
+
+	private async captureRenderedBody(body: RouteRendererBody): Promise<{ body: RouteRendererBody; html: string }> {
+		const response = new Response(body as BodyInit);
+
+		if (typeof body === 'string') {
+			return {
+				body,
+				html: await response.text(),
+			};
+		}
+
+		if (!response.body) {
+			return {
+				body,
+				html: await response.text(),
+			};
+		}
+
+		const [capturedBody, replayBody] = response.body.tee();
+
+		return {
+			body: replayBody,
+			html: await new Response(capturedBody).text(),
+		};
+	}
+
+	private collectResolvedTriggers(
+		components: (EcoComponent | Partial<EcoComponent>)[],
+		seen = new Set<object>(),
+	): ResolvedLazyTrigger[] {
+		const triggers: ResolvedLazyTrigger[] = [];
+		for (const comp of components) {
+			if (!comp) {
+				continue;
+			}
+
+			const ecoComp = comp as EcoComponent;
+			if (seen.has(ecoComp)) {
+				continue;
+			}
+			seen.add(ecoComp);
+			const ownTriggers = ecoComp.config?._resolvedLazyTriggers;
+			if (ownTriggers?.length) {
+				triggers.push(...ownTriggers);
+			}
+			const nested = ecoComp.config?.dependencies?.components;
+			if (nested?.length) {
+				triggers.push(...this.collectResolvedTriggers(nested, seen));
+			}
+		}
+		return triggers;
+	}
+
+	private collectUsedIntegrationDependencies(
+		components: (EcoComponent | Partial<EcoComponent>)[],
+		currentIntegrationName: string,
+	): ProcessedAsset[] {
+		const integrationNames = this.collectIntegrationNames(components);
+		const dependencies: ProcessedAsset[] = [];
+
+		for (const integrationName of integrationNames) {
+			if (integrationName === currentIntegrationName) {
+				continue;
+			}
+
+			const integrationPlugin = this.appConfig.integrations.find(
+				(integration) => integration.name === integrationName,
+			);
+			if (!integrationPlugin || typeof integrationPlugin.getResolvedIntegrationDependencies !== 'function') {
+				continue;
+			}
+
+			dependencies.push(...integrationPlugin.getResolvedIntegrationDependencies());
+		}
+
+		return dependencies;
+	}
+
+	private collectIntegrationNames(
+		components: (EcoComponent | Partial<EcoComponent>)[],
+		seen = new Set<object>(),
+	): Set<string> {
+		const integrationNames = new Set<string>();
+
+		for (const comp of components) {
+			if (!comp) {
+				continue;
+			}
+
+			const ecoComp = comp as EcoComponent;
+			if (seen.has(ecoComp)) {
+				continue;
+			}
+			seen.add(ecoComp);
+
+			const integrationName = ecoComp.config?.integration ?? ecoComp.config?.__eco?.integration;
+			if (integrationName) {
+				integrationNames.add(integrationName);
+			}
+
+			const nested = ecoComp.config?.dependencies?.components;
+			if (nested?.length) {
+				const nestedNames = this.collectIntegrationNames(nested, seen);
+				for (const nestedName of nestedNames) {
+					integrationNames.add(nestedName);
+				}
+			}
+		}
+
+		return integrationNames;
+	}
+
+	private async buildGlobalInjectorAssets(
+		triggers: ResolvedLazyTrigger[],
+		currentIntegrationName: string,
+	): Promise<ProcessedAsset[]> {
+		const appProjectDir = this.appConfig.rootDir ?? this.appConfig.absolutePaths?.projectDir ?? process.cwd();
+		const appPackageRequire = createRequire(path.join(appProjectDir, 'package.json'));
+		const corePackageEntryPath = appPackageRequire.resolve('@ecopages/core');
+		const globalInjectorImportPath = createRequire(corePackageEntryPath).resolve(
+			'@ecopages/scripts-injector/global',
+		);
+
+		const mapScript = AssetFactory.createInlineContentScript({
+			position: 'head',
+			name: 'ecopages-global-injector-map',
+			content: buildGlobalInjectorMapScript(triggers),
+			attributes: { type: 'ecopages/global-injector-map' },
+			packageRole: 'keep-separate',
+			bundle: false,
+		});
+		const bootstrapInlineScript = AssetFactory.createInlineContentScript({
+			position: 'head',
+			name: 'ecopages-global-injector-bootstrap',
+			content: buildGlobalInjectorBootstrapContent(globalInjectorImportPath),
+			attributes: { type: 'module' },
+			packageRole: 'keep-separate',
+			bundle: true,
+		});
+
+		return this.assetProcessingService.processDependencies(
+			[mapScript, bootstrapInlineScript],
+			currentIntegrationName,
+		);
+	}
+
+	private async buildEagerSsrLazyAssets(
+		components: (EcoComponent | Partial<EcoComponent>)[],
+		currentIntegrationName: string,
+	): Promise<ProcessedAsset[]> {
+		const dependencies = this.collectEagerSsrLazyDependencies(components);
+		if (dependencies.length === 0) {
+			return [];
+		}
+
+		return this.assetProcessingService.processDependencies(dependencies, `${currentIntegrationName}:ssr-lazy`);
+	}
+
+	private collectEagerSsrLazyDependencies(
+		components: (EcoComponent | Partial<EcoComponent>)[],
+	): ReturnType<AssetProcessingService['processDependencies']> extends Promise<infer _>
+		? Parameters<AssetProcessingService['processDependencies']>[0]
+		: never {
+		const dependencies = [] as Parameters<AssetProcessingService['processDependencies']>[0];
+		const visitedConfigs = new Set<EcoComponentConfig>();
+		const seenKeys = new Set<string>();
+
+		const normalizeAttributes = (attributes?: DependencyAttributes) => ({
+			type: 'module',
+			defer: '',
+			...(attributes ?? {}),
+		});
+
+		const collect = (config?: EcoComponentConfig) => {
+			if (!config || visitedConfigs.has(config)) {
+				return;
+			}
+
+			visitedConfigs.add(config);
+
+			const componentFile = config.__eco?.file;
+			if (componentFile) {
+				const componentDir = path.dirname(componentFile);
+				for (const script of config.dependencies?.scripts ?? []) {
+					if (typeof script === 'string' || !script.lazy || script.ssr !== true) {
+						continue;
+					}
+
+					const attributes = normalizeAttributes(script.attributes);
+
+					if (script.content) {
+						const key = `content:${script.content}:${JSON.stringify(attributes)}`;
+						if (seenKeys.has(key)) {
+							continue;
+						}
+
+						seenKeys.add(key);
+						dependencies.push(
+							AssetFactory.createContentScript({
+								position: 'head',
+								content: script.content,
+								attributes,
+								packageRole: 'dynamic-chunk',
+							}),
+						);
+						continue;
+					}
+
+					if (!script.src) {
+						continue;
+					}
+
+					const resolvedPath = path.resolve(componentDir, script.src);
+					const key = `file:${resolvedPath}:${JSON.stringify(attributes)}`;
+					if (seenKeys.has(key)) {
+						continue;
+					}
+
+					seenKeys.add(key);
+					dependencies.push(
+						AssetFactory.createFileScript({
+							filepath: resolvedPath,
+							position: 'head',
+							attributes,
+							packageRole: 'dynamic-chunk',
+						}),
+					);
+				}
+			}
+
+			if (config.layout?.config) {
+				collect(config.layout.config);
+			}
+
+			for (const nestedComponent of config.dependencies?.components ?? []) {
+				collect(nestedComponent?.config);
+			}
+		};
+
+		for (const component of components) {
+			collect(component.config);
+		}
+
+		return dependencies;
+	}
+}