@ecopages/core 0.2.0-alpha.1

package/src/route-renderer/render-execution.service.d.ts

@@ -0,0 +1,69 @@
+import { type ComponentRenderBoundaryContext } from '../eco/component-render-context.js';
+import type { EcoComponent, IntegrationRendererRenderOptions, RouteRendererBody, RouteRendererOptions, RouteRenderResult } from '../public-types.js';
+import type { ProcessedAsset } from '../services/asset-processing-service/index.js';
+import type { MarkerGraphContext } from './marker-graph-resolver.js';
+/**
+ * Serializable graph context merged from render-time captured references and
+ * optional explicit page-module graph metadata.
+ */
+export type RenderExecutionGraphContext = {
+    propsByRef?: Record<string, Record<string, unknown>>;
+    slotChildrenByRef?: MarkerGraphContext['slotChildrenByRef'];
+};
+export interface RenderExecutionCallbacks<C> {
+    prepareRenderOptions(options: RouteRendererOptions): Promise<IntegrationRendererRenderOptions<C>>;
+    render(renderOptions: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody>;
+    getComponentRenderBoundaryContext(): ComponentRenderBoundaryContext;
+    resolveMarkerGraphHtml(input: {
+        html: string;
+        componentsToResolve: EcoComponent[];
+        graphContext: RenderExecutionGraphContext;
+    }): Promise<{
+        html: string;
+        assets: ProcessedAsset[];
+    }>;
+    dedupeProcessedAssets(assets: ProcessedAsset[]): ProcessedAsset[];
+    getProcessedDependencies(): ProcessedAsset[];
+    setProcessedDependencies(dependencies: ProcessedAsset[]): void;
+    applyAttributesToFirstBodyElement(html: string, attributes: Record<string, string>): string;
+    transformHtml(html: string): Promise<RouteRendererBody>;
+}
+/**
+ * Executes the main post-preparation rendering flow for integration renderers.
+ *
+ * This service owns the orchestration that happens after normalized render
+ * options have been prepared: the first render pass, graph-context capture,
+ * deferred marker resolution, root-attribute application, and final HTML
+ * transformation into a response body stream.
+ */
+export declare class RenderExecutionService {
+    /**
+     * Executes one integration render pass and returns the final route render
+     * result.
+     *
+     * @typeParam C Integration render output element type.
+     * @param options Route-level render options.
+     * @param currentIntegrationName Active integration name for this render pass.
+     * @param callbacks Renderer-specific hooks required during execution.
+     * @returns Final route render output with body and cache strategy.
+     */
+    execute<C = unknown>(options: RouteRendererOptions, currentIntegrationName: string, callbacks: RenderExecutionCallbacks<C>): Promise<RouteRenderResult>;
+    /**
+     * Merges captured render-time graph references with any explicit graph context
+     * provided by the page module.
+     *
+     * @param capturedGraphContext Graph context captured from the first render pass.
+     * @param explicitGraphContext Optional page-module graph metadata.
+     * @returns Merged graph context used during marker resolution.
+     */
+    private mergeGraphContext;
+    /**
+     * Returns the component set that participates in marker graph resolution for a
+     * render pass.
+     *
+     * @typeParam C Integration render output element type.
+     * @param renderOptions Normalized render options for the pass.
+     * @returns Ordered component list for graph registry construction.
+     */
+    private getComponentsToResolve;
+}

package/src/route-renderer/render-execution.service.js

@@ -0,0 +1,91 @@
+import {
+  runWithComponentRenderContext
+} from "../eco/component-render-context.js";
+class RenderExecutionService {
+  /**
+   * Executes one integration render pass and returns the final route render
+   * result.
+   *
+   * @typeParam C Integration render output element type.
+   * @param options Route-level render options.
+   * @param currentIntegrationName Active integration name for this render pass.
+   * @param callbacks Renderer-specific hooks required during execution.
+   * @returns Final route render output with body and cache strategy.
+   */
+  async execute(options, currentIntegrationName, callbacks) {
+    const renderOptions = await callbacks.prepareRenderOptions(options);
+    const shouldApplyComponentRootAttributes = renderOptions.componentRender?.canAttachAttributes && renderOptions.componentRender.rootAttributes && Object.keys(renderOptions.componentRender.rootAttributes).length > 0;
+    const renderExecution = await runWithComponentRenderContext(
+      {
+        currentIntegration: currentIntegrationName,
+        boundaryContext: callbacks.getComponentRenderBoundaryContext()
+      },
+      async () => callbacks.render(renderOptions)
+    );
+    let renderedHtml = await new Response(renderExecution.value).text();
+    const componentGraphContext = this.mergeGraphContext(
+      renderExecution.graphContext,
+      renderOptions.componentGraphContext
+    );
+    if (renderedHtml.includes("<eco-marker")) {
+      const markerResolution = await callbacks.resolveMarkerGraphHtml({
+        html: renderedHtml,
+        componentsToResolve: this.getComponentsToResolve(renderOptions),
+        graphContext: componentGraphContext
+      });
+      renderedHtml = markerResolution.html;
+      if (markerResolution.assets.length > 0) {
+        const mergedDependencies = callbacks.dedupeProcessedAssets([
+          ...callbacks.getProcessedDependencies(),
+          ...markerResolution.assets
+        ]);
+        callbacks.setProcessedDependencies(mergedDependencies);
+      }
+    }
+    if (shouldApplyComponentRootAttributes) {
+      renderedHtml = callbacks.applyAttributesToFirstBodyElement(
+        renderedHtml,
+        renderOptions.componentRender?.rootAttributes
+      );
+    }
+    const body = await callbacks.transformHtml(renderedHtml);
+    return {
+      body,
+      cacheStrategy: renderOptions.cacheStrategy
+    };
+  }
+  /**
+   * Merges captured render-time graph references with any explicit graph context
+   * provided by the page module.
+   *
+   * @param capturedGraphContext Graph context captured from the first render pass.
+   * @param explicitGraphContext Optional page-module graph metadata.
+   * @returns Merged graph context used during marker resolution.
+   */
+  mergeGraphContext(capturedGraphContext, explicitGraphContext) {
+    return {
+      propsByRef: {
+        ...capturedGraphContext.propsByRef ?? {},
+        ...explicitGraphContext?.propsByRef ?? {}
+      },
+      slotChildrenByRef: {
+        ...capturedGraphContext.slotChildrenByRef ?? {},
+        ...explicitGraphContext?.slotChildrenByRef ?? {}
+      }
+    };
+  }
+  /**
+   * Returns the component set that participates in marker graph resolution for a
+   * render pass.
+   *
+   * @typeParam C Integration render output element type.
+   * @param renderOptions Normalized render options for the pass.
+   * @returns Ordered component list for graph registry construction.
+   */
+  getComponentsToResolve(renderOptions) {
+    return renderOptions.Layout ? [renderOptions.HtmlTemplate, renderOptions.Layout, renderOptions.Page] : [renderOptions.HtmlTemplate, renderOptions.Page];
+  }
+}
+export {
+  RenderExecutionService
+};

package/src/route-renderer/render-execution.service.ts

@@ -0,0 +1,158 @@
+import {
+	runWithComponentRenderContext,
+	type ComponentRenderBoundaryContext,
+	type ComponentGraphContext as CapturedComponentGraphContext,
+} from '../eco/component-render-context.ts';
+import type {
+	EcoComponent,
+	IntegrationRendererRenderOptions,
+	RouteRendererBody,
+	RouteRendererOptions,
+	RouteRenderResult,
+} from '../public-types.ts';
+import type { ProcessedAsset } from '../services/asset-processing-service/index.ts';
+import type { MarkerGraphContext } from './marker-graph-resolver.ts';
+
+/**
+ * Serializable graph context merged from render-time captured references and
+ * optional explicit page-module graph metadata.
+ */
+export type RenderExecutionGraphContext = {
+	propsByRef?: Record<string, Record<string, unknown>>;
+	slotChildrenByRef?: MarkerGraphContext['slotChildrenByRef'];
+};
+
+export interface RenderExecutionCallbacks<C> {
+	prepareRenderOptions(options: RouteRendererOptions): Promise<IntegrationRendererRenderOptions<C>>;
+	render(renderOptions: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody>;
+	getComponentRenderBoundaryContext(): ComponentRenderBoundaryContext;
+	resolveMarkerGraphHtml(input: {
+		html: string;
+		componentsToResolve: EcoComponent[];
+		graphContext: RenderExecutionGraphContext;
+	}): Promise<{ html: string; assets: ProcessedAsset[] }>;
+	dedupeProcessedAssets(assets: ProcessedAsset[]): ProcessedAsset[];
+	getProcessedDependencies(): ProcessedAsset[];
+	setProcessedDependencies(dependencies: ProcessedAsset[]): void;
+	applyAttributesToFirstBodyElement(html: string, attributes: Record<string, string>): string;
+	transformHtml(html: string): Promise<RouteRendererBody>;
+}
+
+/**
+ * Executes the main post-preparation rendering flow for integration renderers.
+ *
+ * This service owns the orchestration that happens after normalized render
+ * options have been prepared: the first render pass, graph-context capture,
+ * deferred marker resolution, root-attribute application, and final HTML
+ * transformation into a response body stream.
+ */
+export class RenderExecutionService {
+	/**
+	 * Executes one integration render pass and returns the final route render
+	 * result.
+	 *
+	 * @typeParam C Integration render output element type.
+	 * @param options Route-level render options.
+	 * @param currentIntegrationName Active integration name for this render pass.
+	 * @param callbacks Renderer-specific hooks required during execution.
+	 * @returns Final route render output with body and cache strategy.
+	 */
+	async execute<C = unknown>(
+		options: RouteRendererOptions,
+		currentIntegrationName: string,
+		callbacks: RenderExecutionCallbacks<C>,
+	): Promise<RouteRenderResult> {
+		const renderOptions = await callbacks.prepareRenderOptions(options);
+		const shouldApplyComponentRootAttributes =
+			renderOptions.componentRender?.canAttachAttributes &&
+			renderOptions.componentRender.rootAttributes &&
+			Object.keys(renderOptions.componentRender.rootAttributes).length > 0;
+
+		const renderExecution = await runWithComponentRenderContext(
+			{
+				currentIntegration: currentIntegrationName,
+				boundaryContext: callbacks.getComponentRenderBoundaryContext(),
+			},
+			async () => callbacks.render(renderOptions),
+		);
+
+		let renderedHtml = await new Response(renderExecution.value as BodyInit).text();
+		const componentGraphContext = this.mergeGraphContext(
+			renderExecution.graphContext,
+			(
+				renderOptions as IntegrationRendererRenderOptions<C> & {
+					componentGraphContext?: RenderExecutionGraphContext;
+				}
+			).componentGraphContext,
+		);
+
+		if (renderedHtml.includes('<eco-marker')) {
+			const markerResolution = await callbacks.resolveMarkerGraphHtml({
+				html: renderedHtml,
+				componentsToResolve: this.getComponentsToResolve(renderOptions),
+				graphContext: componentGraphContext,
+			});
+			renderedHtml = markerResolution.html;
+
+			if (markerResolution.assets.length > 0) {
+				const mergedDependencies = callbacks.dedupeProcessedAssets([
+					...callbacks.getProcessedDependencies(),
+					...markerResolution.assets,
+				]);
+				callbacks.setProcessedDependencies(mergedDependencies);
+			}
+		}
+
+		if (shouldApplyComponentRootAttributes) {
+			renderedHtml = callbacks.applyAttributesToFirstBodyElement(
+				renderedHtml,
+				renderOptions.componentRender?.rootAttributes as Record<string, string>,
+			);
+		}
+
+		const body = await callbacks.transformHtml(renderedHtml);
+
+		return {
+			body,
+			cacheStrategy: renderOptions.cacheStrategy,
+		};
+	}
+
+	/**
+	 * Merges captured render-time graph references with any explicit graph context
+	 * provided by the page module.
+	 *
+	 * @param capturedGraphContext Graph context captured from the first render pass.
+	 * @param explicitGraphContext Optional page-module graph metadata.
+	 * @returns Merged graph context used during marker resolution.
+	 */
+	private mergeGraphContext(
+		capturedGraphContext: CapturedComponentGraphContext,
+		explicitGraphContext?: RenderExecutionGraphContext,
+	): RenderExecutionGraphContext {
+		return {
+			propsByRef: {
+				...(capturedGraphContext.propsByRef ?? {}),
+				...(explicitGraphContext?.propsByRef ?? {}),
+			},
+			slotChildrenByRef: {
+				...(capturedGraphContext.slotChildrenByRef ?? {}),
+				...(explicitGraphContext?.slotChildrenByRef ?? {}),
+			},
+		};
+	}
+
+	/**
+	 * Returns the component set that participates in marker graph resolution for a
+	 * render pass.
+	 *
+	 * @typeParam C Integration render output element type.
+	 * @param renderOptions Normalized render options for the pass.
+	 * @returns Ordered component list for graph registry construction.
+	 */
+	private getComponentsToResolve<C>(renderOptions: IntegrationRendererRenderOptions<C>): EcoComponent[] {
+		return renderOptions.Layout
+			? [renderOptions.HtmlTemplate as EcoComponent, renderOptions.Layout as EcoComponent, renderOptions.Page]
+			: [renderOptions.HtmlTemplate as EcoComponent, renderOptions.Page];
+	}
+}

package/src/route-renderer/render-preparation.service.d.ts

@@ -0,0 +1,112 @@
+import type { EcoPagesAppConfig } from '../internal-types.js';
+import type { ComponentRenderResult, EcoComponent, EcoPageComponent, EcoPageFile, EcoPagesElement, GetMetadata, GetStaticProps, HtmlTemplateProps, IntegrationRendererRenderOptions, PageMetadataProps, RouteRendererOptions } from '../public-types.js';
+import { type AssetProcessingService, type ProcessedAsset } from '../services/asset-processing-service/index.js';
+import { type ComponentRenderBoundaryContext } from '../eco/component-render-context.js';
+type ResolvedPageModule = {
+    Page: EcoPageFile['default'] | EcoPageComponent<any>;
+    getStaticProps?: GetStaticProps<Record<string, unknown>>;
+    getMetadata?: GetMetadata;
+    integrationSpecificProps: Record<string, unknown>;
+};
+export interface RenderPreparationCallbacks {
+    resolvePageModule(file: string): Promise<ResolvedPageModule>;
+    getHtmlTemplate(): Promise<EcoComponent<HtmlTemplateProps>>;
+    resolvePageData(pageModule: {
+        getStaticProps?: GetStaticProps<Record<string, unknown>>;
+        getMetadata?: GetMetadata;
+    }, routeOptions: RouteRendererOptions): Promise<{
+        props: Record<string, unknown>;
+        metadata: PageMetadataProps;
+    }>;
+    resolveDependencies(components: (EcoComponent | Partial<EcoComponent>)[]): Promise<ProcessedAsset[]>;
+    buildRouteRenderAssets(file: string): Promise<ProcessedAsset[]> | undefined;
+    shouldRenderPageComponent(input: {
+        Page: EcoComponent;
+        Layout?: EcoComponent;
+        options: RouteRendererOptions;
+    }): boolean;
+    renderPageComponent(input: {
+        component: EcoComponent;
+        props: Record<string, unknown>;
+    }): Promise<ComponentRenderResult>;
+    /**
+     * Returns the boundary policy context that should be active while rendering
+     * page-root component output during preparation.
+     */
+    getComponentRenderBoundaryContext(): ComponentRenderBoundaryContext;
+    setProcessedDependencies(dependencies: ProcessedAsset[]): void;
+    dedupeProcessedAssets(assets: ProcessedAsset[]): ProcessedAsset[];
+    createPageLocalsProxy(filePath: string): RouteRendererOptions['locals'];
+}
+/**
+ * Prepares the normalized render inputs consumed by `IntegrationRenderer.execute()`.
+ *
+ * This service owns the orchestration that happens before the main HTML render:
+ * page module resolution, data loading, dependency aggregation, page-root
+ * component artifact capture, lazy trigger bootstrap generation, and request
+ * locals policy.
+ */
+export declare class RenderPreparationService {
+    private appConfig;
+    private assetProcessingService;
+    constructor(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService);
+    /**
+     * Builds the final render options object used by the integration-specific
+     * renderer.
+     *
+     * The returned object contains normalized page data, processed dependency
+     * state, component render artifacts, and the locals contract expected by the
+     * rest of the pipeline.
+     *
+     * @typeParam C Integration render output element type.
+     * @param routeOptions Route-level render inputs.
+     * @param currentIntegrationName Active integration name for this preparation pass.
+     * @param callbacks Renderer-specific hooks used during preparation.
+     * @returns Normalized render options.
+     */
+    prepare<C = EcoPagesElement>(routeOptions: RouteRendererOptions, currentIntegrationName: string, callbacks: RenderPreparationCallbacks): Promise<IntegrationRendererRenderOptions<C>>;
+    /**
+     * Collects resolved lazy trigger metadata from the component tree.
+     *
+     * Traversal is depth-first and deduplicated by component identity so shared
+     * component dependencies do not emit duplicate trigger sets.
+     *
+     * @param components Root component set.
+     * @param seen Internal visited set for shared graphs.
+     * @returns All resolved lazy triggers reachable from the root set.
+     */
+    private collectResolvedTriggers;
+    /**
+     * Collects global integration dependencies used by nested components belonging
+     * to integrations other than the current renderer.
+     *
+     * @param components Root component set.
+     * @returns Processed integration dependencies contributed by nested integrations.
+     */
+    private collectUsedIntegrationDependencies;
+    /**
+     * Discovers integration names referenced by the component dependency graph.
+     *
+     * @param components Root component set.
+     * @param seen Internal visited set for shared graphs.
+     * @returns Set of integration names found in the graph.
+     */
+    private collectIntegrationNames;
+    /**
+     * Renders the page root through the component-level render contract so any
+     * integration-specific assets and root attributes are available before the main
+     * document render.
+     *
+     * @param input Page root render inputs.
+     * @returns Structured component render result.
+     */
+    private renderPageRoot;
+    /**
+     * Builds the runtime assets needed to bootstrap global lazy trigger execution.
+     *
+     * @param triggers Fully resolved lazy trigger definitions.
+     * @returns Processed assets that should be merged into the final dependency set.
+     */
+    private buildGlobalInjectorAssets;
+}
+export {};

package/src/route-renderer/render-preparation.service.js

@@ -0,0 +1,243 @@
+import { createRequire } from "node:module";
+import {
+  AssetFactory
+} from "../services/asset-processing-service/index.js";
+import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../eco/global-injector-map.js";
+import { runWithComponentRenderContext } from "../eco/component-render-context.js";
+const coreRequire = createRequire(import.meta.url);
+class RenderPreparationService {
+  constructor(appConfig, assetProcessingService) {
+    this.appConfig = appConfig;
+    this.assetProcessingService = assetProcessingService;
+  }
+  /**
+   * Builds the final render options object used by the integration-specific
+   * renderer.
+   *
+   * The returned object contains normalized page data, processed dependency
+   * state, component render artifacts, and the locals contract expected by the
+   * rest of the pipeline.
+   *
+   * @typeParam C Integration render output element type.
+   * @param routeOptions Route-level render inputs.
+   * @param currentIntegrationName Active integration name for this preparation pass.
+   * @param callbacks Renderer-specific hooks used during preparation.
+   * @returns Normalized render options.
+   */
+  async prepare(routeOptions, currentIntegrationName, callbacks) {
+    const pageModule = await callbacks.resolvePageModule(routeOptions.file);
+    const { Page, integrationSpecificProps } = pageModule;
+    const HtmlTemplate = await callbacks.getHtmlTemplate();
+    const { props, metadata } = await callbacks.resolvePageData(pageModule, routeOptions);
+    const Layout = Page.config?.layout;
+    const componentsToResolve = Layout ? [HtmlTemplate, Layout, Page] : [HtmlTemplate, Page];
+    const resolvedDependencies = await callbacks.resolveDependencies(componentsToResolve);
+    const usedIntegrationDependencies = this.collectUsedIntegrationDependencies(
+      componentsToResolve,
+      currentIntegrationName
+    );
+    const pageDeps = await callbacks.buildRouteRenderAssets(routeOptions.file) || [];
+    const allDependencies = [...resolvedDependencies, ...usedIntegrationDependencies, ...pageDeps];
+    let componentRender;
+    if (callbacks.shouldRenderPageComponent({ Page, Layout, options: routeOptions })) {
+      componentRender = await this.renderPageRoot({
+        currentIntegrationName,
+        Page,
+        props,
+        routeOptions,
+        callbacks
+      });
+      if (componentRender.assets?.length) {
+        allDependencies.push(...componentRender.assets);
+      }
+    }
+    const triggers = this.collectResolvedTriggers(componentsToResolve);
+    if (triggers.length > 0) {
+      const globalAssets = await this.buildGlobalInjectorAssets(triggers, currentIntegrationName);
+      allDependencies.push(...globalAssets);
+    }
+    callbacks.setProcessedDependencies(callbacks.dedupeProcessedAssets(allDependencies));
+    const pageProps = {
+      ...props,
+      params: routeOptions.params || {},
+      query: routeOptions.query || {}
+    };
+    const cacheStrategy = Page.cache;
+    const defaultCacheStrategy = this.appConfig.cache?.defaultStrategy ?? "static";
+    const effectiveCacheStrategy = cacheStrategy ?? defaultCacheStrategy;
+    const localsAvailable = effectiveCacheStrategy === "dynamic" && routeOptions.locals !== void 0;
+    const pageLocals = localsAvailable ? routeOptions.locals : callbacks.createPageLocalsProxy(routeOptions.file);
+    const locals = localsAvailable ? routeOptions.locals : void 0;
+    const preparedOptions = {
+      ...routeOptions,
+      resolvedDependencies,
+      componentRender,
+      HtmlTemplate,
+      Layout,
+      props,
+      Page,
+      metadata,
+      params: routeOptions.params || {},
+      query: routeOptions.query || {},
+      pageProps,
+      locals,
+      pageLocals,
+      cacheStrategy
+    };
+    return {
+      ...integrationSpecificProps,
+      ...preparedOptions
+    };
+  }
+  /**
+   * Collects resolved lazy trigger metadata from the component tree.
+   *
+   * Traversal is depth-first and deduplicated by component identity so shared
+   * component dependencies do not emit duplicate trigger sets.
+   *
+   * @param components Root component set.
+   * @param seen Internal visited set for shared graphs.
+   * @returns All resolved lazy triggers reachable from the root set.
+   */
+  collectResolvedTriggers(components, seen = /* @__PURE__ */ new Set()) {
+    const triggers = [];
+    for (const comp of components) {
+      const ecoComp = comp;
+      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;
+  }
+  /**
+   * Collects global integration dependencies used by nested components belonging
+   * to integrations other than the current renderer.
+   *
+   * @param components Root component set.
+   * @returns Processed integration dependencies contributed by nested integrations.
+   */
+  collectUsedIntegrationDependencies(components, currentIntegrationName) {
+    const integrationNames = this.collectIntegrationNames(components);
+    const dependencies = [];
+    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;
+  }
+  /**
+   * Discovers integration names referenced by the component dependency graph.
+   *
+   * @param components Root component set.
+   * @param seen Internal visited set for shared graphs.
+   * @returns Set of integration names found in the graph.
+   */
+  collectIntegrationNames(components, seen = /* @__PURE__ */ new Set()) {
+    const integrationNames = /* @__PURE__ */ new Set();
+    for (const comp of components) {
+      const ecoComp = comp;
+      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;
+  }
+  /**
+   * Renders the page root through the component-level render contract so any
+   * integration-specific assets and root attributes are available before the main
+   * document render.
+   *
+   * @param input Page root render inputs.
+   * @returns Structured component render result.
+   */
+  async renderPageRoot(input) {
+    const execution = await runWithComponentRenderContext(
+      {
+        currentIntegration: input.currentIntegrationName,
+        boundaryContext: input.callbacks.getComponentRenderBoundaryContext()
+      },
+      async () => input.callbacks.renderPageComponent({
+        component: input.Page,
+        props: {
+          ...input.props,
+          params: input.routeOptions.params || {},
+          query: input.routeOptions.query || {}
+        }
+      })
+    );
+    return execution.value;
+  }
+  /**
+   * Builds the runtime assets needed to bootstrap global lazy trigger execution.
+   *
+   * @param triggers Fully resolved lazy trigger definitions.
+   * @returns Processed assets that should be merged into the final dependency set.
+   */
+  async buildGlobalInjectorAssets(triggers, currentIntegrationName) {
+    const globalInjectorImportPath = coreRequire.resolve("@ecopages/scripts-injector/global");
+    const globalInjectorRuntimeAsset = AssetFactory.createNodeModuleScript({
+      position: "head",
+      name: "ecopages-scripts-injector-global",
+      importPath: globalInjectorImportPath,
+      excludeFromHtml: true
+    });
+    const [globalInjectorRuntimeProcessed] = await this.assetProcessingService.processDependencies(
+      [globalInjectorRuntimeAsset],
+      currentIntegrationName
+    );
+    const globalInjectorModuleUrl = globalInjectorRuntimeProcessed?.srcUrl;
+    if (!globalInjectorModuleUrl) {
+      throw new Error("[ecopages] Failed to resolve global injector runtime asset URL.");
+    }
+    const mapScript = AssetFactory.createInlineContentScript({
+      position: "head",
+      name: "ecopages-global-injector-map",
+      content: buildGlobalInjectorMapScript(triggers),
+      attributes: { type: "ecopages/global-injector-map" },
+      bundle: false
+    });
+    const bootstrapScript = AssetFactory.createContentScript({
+      position: "head",
+      name: "ecopages-global-injector-bootstrap",
+      content: buildGlobalInjectorBootstrapContent(globalInjectorModuleUrl),
+      attributes: { type: "module" },
+      bundle: false
+    });
+    return this.assetProcessingService.processDependencies(
+      [mapScript, bootstrapScript, globalInjectorRuntimeAsset],
+      currentIntegrationName
+    );
+  }
+}
+export {
+  RenderPreparationService
+};