@ecopages/core 0.2.0-alpha.26 → 0.2.0-alpha.28

package/src/route-renderer/orchestration/ownership-planning.service.d.ts

@@ -0,0 +1,24 @@
+import type { OwnershipPlan, OwnershipValidationError, EcoComponent } from '../../types/public-types.js';
+type OwnershipPlanBuildInput = {
+    routeFile: string;
+    currentIntegrationName: string;
+    HtmlTemplate: EcoComponent;
+    Layout?: EcoComponent;
+    Page: EcoComponent;
+    validationErrors?: OwnershipValidationError[];
+};
+/**
+ * Builds a declared ownership plan from the component dependency graph.
+ *
+ * The plan reflects the declared component dependency graph for one route after
+ * route-root ownership validation has already run. It records ownership shape,
+ * foreign-edge counts, and any validation errors supplied by an earlier
+ * validation pass.
+ */
+export declare class OwnershipPlanningService {
+    /**
+     * Builds the structural ownership plan for one route render.
+     */
+    buildPlan(input: OwnershipPlanBuildInput): OwnershipPlan;
+}
+export {};

package/src/route-renderer/orchestration/ownership-planning.service.js

@@ -0,0 +1,63 @@
+import { mapDeclaredOwnershipGraph } from "./declared-ownership-graph.js";
+class OwnershipPlanningService {
+  /**
+   * Builds the structural ownership plan for one route render.
+   */
+  buildPlan(input) {
+    const validationErrors = input.validationErrors ?? [];
+    const rendererNames = /* @__PURE__ */ new Set([input.currentIntegrationName]);
+    let foreignEdgeCount = 0;
+    const roots = [
+      { component: input.HtmlTemplate, source: "html-template" },
+      ...input.Layout ? [{ component: input.Layout, source: "layout" }] : [],
+      { component: input.Page, source: "page" }
+    ];
+    const children = mapDeclaredOwnershipGraph({
+      roots,
+      currentIntegrationName: input.currentIntegrationName,
+      mapNode: ({ component, source, integrationName, componentId, isForeignToParent }, children2) => {
+        const componentMeta = component.config?.__eco;
+        rendererNames.add(integrationName);
+        if (isForeignToParent) {
+          foreignEdgeCount += 1;
+        }
+        return {
+          id: componentId,
+          source,
+          ownership: {
+            integrationName,
+            componentId,
+            componentFile: componentMeta?.file,
+            isPageEntry: source === "page",
+            isForeignToParent
+          },
+          children: children2,
+          declaredDependenciesValid: true
+        };
+      }
+    });
+    const root = {
+      id: `route:${input.routeFile}`,
+      source: "route",
+      ownership: {
+        integrationName: input.currentIntegrationName,
+        componentId: `route:${input.routeFile}`,
+        componentFile: input.routeFile,
+        isPageEntry: false,
+        isForeignToParent: false
+      },
+      children,
+      declaredDependenciesValid: validationErrors.length === 0
+    };
+    return {
+      root,
+      rendererNames: Array.from(rendererNames),
+      foreignEdgeCount,
+      hasValidationErrors: validationErrors.length > 0,
+      validationErrors
+    };
+  }
+}
+export {
+  OwnershipPlanningService
+};

package/src/route-renderer/orchestration/ownership-validation.service.d.ts

@@ -0,0 +1,29 @@
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { OwnershipPlanNodeSource, OwnershipValidationError, EcoComponent } from '../../types/public-types.js';
+type OwnershipValidationInput = {
+    currentIntegrationName: string;
+    roots: Array<{
+        component: EcoComponent;
+        source: Extract<OwnershipPlanNodeSource, 'page' | 'layout' | 'html-template'>;
+    }>;
+};
+/**
+ * Validates foreign ownership as soon as the route root graph is loaded.
+ *
+ * This check runs before route data and dependency preparation so ownership and
+ * metadata problems are surfaced from the loaded component graph itself rather
+ * than being entangled with ownership-plan construction.
+ */
+export declare class OwnershipValidationService {
+    private readonly appConfig;
+    /**
+     * Creates the ownership validator for one finalized app config.
+     */
+    constructor(appConfig: EcoPagesAppConfig);
+    /**
+     * Validates foreign ownership edges reachable from the supplied route roots.
+     */
+    validate(input: OwnershipValidationInput): OwnershipValidationError[];
+    private isRegisteredIntegration;
+}
+export {};

package/src/route-renderer/orchestration/ownership-validation.service.js

@@ -0,0 +1,53 @@
+import { mapDeclaredOwnershipGraph } from "./declared-ownership-graph.js";
+class OwnershipValidationService {
+  appConfig;
+  /**
+   * Creates the ownership validator for one finalized app config.
+   */
+  constructor(appConfig) {
+    this.appConfig = appConfig;
+  }
+  /**
+   * Validates foreign ownership edges reachable from the supplied route roots.
+   */
+  validate(input) {
+    return mapDeclaredOwnershipGraph({
+      roots: input.roots,
+      currentIntegrationName: input.currentIntegrationName,
+      mapNode: ({ component, integrationName, componentId, isForeignToParent }, children) => {
+        const componentMeta = component.config?.__eco;
+        const errors = children.flat();
+        if (!isForeignToParent) {
+          return errors;
+        }
+        if (!componentMeta) {
+          errors.push({
+            code: "MISSING_COMPONENT_METADATA",
+            message: `[ecopages] Foreign child "${componentId}" must provide stable __eco metadata so ownership diagnostics stay actionable. Declared dependencies must include all possible foreign children.`,
+            componentId,
+            integrationName
+          });
+        }
+        if (!this.isRegisteredIntegration(integrationName, input.currentIntegrationName)) {
+          errors.push({
+            code: "UNKNOWN_INTEGRATION_OWNER",
+            message: `[ecopages] Foreign child "${componentId}" references unknown integration owner "${integrationName}". Declared dependencies must include all possible foreign children and those integrations must be registered.`,
+            componentId,
+            componentFile: componentMeta?.file,
+            integrationName
+          });
+        }
+        return errors;
+      }
+    }).flat();
+  }
+  isRegisteredIntegration(integrationName, currentIntegrationName) {
+    if (integrationName === currentIntegrationName) {
+      return true;
+    }
+    return this.appConfig.integrations.some((integration) => integration.name === integrationName);
+  }
+}
+export {
+  OwnershipValidationService
+};

package/src/route-renderer/orchestration/queued-foreign-subtree-resolution.service.d.ts

@@ -0,0 +1,90 @@
+import type { ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
+import type { BaseIntegrationContext, ForeignSubtreeRenderPayload, ComponentRenderInput, EcoComponent } from '../../types/public-types.js';
+import type { ForeignChildRuntime } from './component-render-context.js';
+export type QueuedForeignChildDecisionInput = {
+    currentIntegration: string;
+    targetIntegration?: string;
+    component: EcoComponent;
+    props: Record<string, unknown>;
+};
+export type QueuedForeignSubtreeResolution = {
+    token: string;
+    component: EcoComponent;
+    props: Record<string, unknown>;
+    componentInstanceId: string;
+};
+/**
+ * Shared mutable state for one renderer-owned queued foreign-subtree runtime.
+ *
+ * Renderers that cannot resolve foreign children inline can enqueue transport
+ * tokens during their initial render, then resolve those tokens against the
+ * owning renderer before returning final HTML.
+ */
+export type QueuedForeignSubtreeResolutionContext = {
+    rendererCache: Map<string, unknown>;
+    componentInstanceScope?: string;
+    nextForeignSubtreeId: number;
+    queuedResolutions: QueuedForeignSubtreeResolution[];
+};
+type QueuedForeignSubtreeIntegrationContext = BaseIntegrationContext & Record<string, unknown>;
+type QueuedForeignSubtreeChildRenderResult = {
+    assets: ProcessedAsset[];
+    html?: string;
+};
+/**
+ * Lower-level queue orchestration for renderer-owned foreign-child runtimes that emit
+ * temporary transport tokens during one render pass.
+ *
+ * The service keeps three responsibilities in one place:
+ * - storing per-render queue state on the active integration context
+ * - creating a `ForeignChildRuntime` that enqueues foreign children
+ * - resolving queued tokens back through the owning renderer before final HTML
+ *   leaves the current renderer
+ *
+ * The deeper Foreign Subtree execution module composes this queue helper with
+ * renderer-cache delegation and active render-context execution. This service
+ * stays focused on queue bookkeeping, recursion, cycle detection, and asset merging.
+ */
+export declare class QueuedForeignSubtreeResolutionService {
+    /**
+     * Reads the queued foreign-subtree runtime state previously attached to one render.
+     */
+    getRuntimeContext<TContext extends QueuedForeignSubtreeResolutionContext>(input: ComponentRenderInput, runtimeContextKey: string): TContext | undefined;
+    /**
+     * Creates the runtime hook used by `runWithComponentRenderContext()` for one
+     * renderer-owned queue.
+     *
+     * When the renderer decides a foreign child must be handed off, the runtime returns
+     * a resolved transport token instead of rendering the foreign component inline.
+     */
+    createRuntime<TContext extends QueuedForeignSubtreeResolutionContext>(options: {
+        renderInput: ComponentRenderInput;
+        rendererCache: Map<string, unknown>;
+        runtimeContextKey: string;
+        tokenPrefix: string;
+        shouldQueueForeignChild: (input: QueuedForeignChildDecisionInput) => boolean;
+        createRuntimeContext?: (integrationContext: QueuedForeignSubtreeIntegrationContext, rendererCache: Map<string, unknown>) => TContext;
+    }): ForeignChildRuntime;
+    /**
+     * Resolves every queued transport token in one renderer-owned HTML fragment.
+     *
+     * The caller supplies framework-specific child rendering, while this service
+     * handles recursive token replacement, cycle detection, root-attribute
+     * application, and merged asset collection.
+     */
+    resolveQueuedHtml<TContext extends QueuedForeignSubtreeResolutionContext>(options: {
+        html: string;
+        runtimeContext?: TContext;
+        queueLabel: string;
+        renderQueuedChildren: (children: unknown, runtimeContext: TContext, queuedResolutionsByToken: Map<string, QueuedForeignSubtreeResolution>, resolveToken: (token: string) => Promise<string>) => Promise<QueuedForeignSubtreeChildRenderResult>;
+        resolveForeignSubtree: (input: ComponentRenderInput, rendererCache: Map<string, unknown>) => Promise<ForeignSubtreeRenderPayload | undefined>;
+        applyAttributesToFirstElement: (html: string, attributes: Record<string, string>) => string;
+        dedupeProcessedAssets: (assets: ProcessedAsset[]) => ProcessedAsset[];
+    }): Promise<{
+        assets: ProcessedAsset[];
+        html: string;
+    }>;
+    private createForeignSubtreeToken;
+    private ensureRuntimeContext;
+}
+export {};

package/src/route-renderer/orchestration/{queued-boundary-runtime.service.js → queued-foreign-subtree-resolution.service.js}

@@ -1,6 +1,6 @@
-class QueuedBoundaryRuntimeService {
+class QueuedForeignSubtreeResolutionService {
   /**
-   * Reads the queued boundary runtime state previously attached to one render.
+   * Reads the queued foreign-subtree runtime state previously attached to one render.
    */
   getRuntimeContext(input, runtimeContextKey) {
     const integrationContext = input.integrationContext;
@@ -14,23 +14,23 @@ class QueuedBoundaryRuntimeService {
    * Creates the runtime hook used by `runWithComponentRenderContext()` for one
    * renderer-owned queue.
    *
-   * When the renderer decides a boundary must be handed off, the runtime returns
+   * When the renderer decides a foreign child must be handed off, the runtime returns
    * a resolved transport token instead of rendering the foreign component inline.
    */
   createRuntime(options) {
     const runtimeContext = this.ensureRuntimeContext(options);
-    const interceptBoundary = (input) => {
-      if (!options.shouldQueueBoundary(input)) {
+    const interceptForeignChild = (input) => {
+      if (!options.shouldQueueForeignChild(input)) {
         return { kind: "inline" };
       }
-      runtimeContext.nextBoundaryId += 1;
-      const boundaryId = runtimeContext.nextBoundaryId;
-      const token = this.createBoundaryToken(options.tokenPrefix, runtimeContext, boundaryId);
+      runtimeContext.nextForeignSubtreeId += 1;
+      const foreignSubtreeId = runtimeContext.nextForeignSubtreeId;
+      const token = this.createForeignSubtreeToken(options.tokenPrefix, runtimeContext, foreignSubtreeId);
       runtimeContext.queuedResolutions.push({
         token,
         component: input.component,
         props: { ...input.props },
-        componentInstanceId: runtimeContext.componentInstanceScope ? `${runtimeContext.componentInstanceScope}_n_${boundaryId}` : `n_${boundaryId}`
+        componentInstanceId: runtimeContext.componentInstanceScope ? `${runtimeContext.componentInstanceScope}_n_${foreignSubtreeId}` : `n_${foreignSubtreeId}`
       });
       return {
         kind: "resolved",
@@ -38,8 +38,8 @@ class QueuedBoundaryRuntimeService {
       };
     };
     return {
-      interceptBoundary,
-      interceptBoundarySync: interceptBoundary
+      interceptForeignChild,
+      interceptForeignChildSync: interceptForeignChild
     };
   }
   /**
@@ -71,7 +71,7 @@ class QueuedBoundaryRuntimeService {
       }
       if (resolvingTokens.has(token)) {
         throw new Error(
-          `[ecopages] ${options.queueLabel} boundary queue contains a cycle or unresolved dependency links.`
+          `[ecopages] ${options.queueLabel} foreign-subtree queue contains a cycle or unresolved dependency links.`
         );
       }
       resolvingTokens.add(token);
@@ -85,7 +85,7 @@ class QueuedBoundaryRuntimeService {
         if (renderedChildren.assets.length > 0) {
           collectedAssets.push(...renderedChildren.assets);
         }
-        const boundaryRender = await options.resolveBoundary(
+        const foreignSubtreeRender = await options.resolveForeignSubtree(
           {
             component: resolution.component,
             props: { ...resolution.props },
@@ -97,15 +97,18 @@ class QueuedBoundaryRuntimeService {
           },
           runtimeContext.rendererCache
         );
-        if (!boundaryRender) {
+        if (!foreignSubtreeRender) {
           throw new Error(
-            `[ecopages] ${options.queueLabel} queued boundary could not resolve its owning renderer.`
+            `[ecopages] ${options.queueLabel} queued foreign subtree could not resolve its owning renderer.`
           );
         }
-        if ((boundaryRender.assets?.length ?? 0) > 0) {
-          collectedAssets.push(...boundaryRender.assets ?? []);
+        if ((foreignSubtreeRender.assets?.length ?? 0) > 0) {
+          collectedAssets.push(...foreignSubtreeRender.assets ?? []);
         }
-        const resolvedHtml2 = boundaryRender.attachmentPolicy.kind === "first-element" && boundaryRender.rootAttributes ? options.applyAttributesToFirstElement(boundaryRender.html, boundaryRender.rootAttributes) : boundaryRender.html;
+        const resolvedHtml2 = foreignSubtreeRender.attachmentPolicy.kind === "first-element" && foreignSubtreeRender.rootAttributes ? options.applyAttributesToFirstElement(
+          foreignSubtreeRender.html,
+          foreignSubtreeRender.rootAttributes
+        ) : foreignSubtreeRender.html;
         resolvedHtmlByToken.set(token, resolvedHtml2);
         return resolvedHtml2;
       } finally {
@@ -124,13 +127,13 @@ class QueuedBoundaryRuntimeService {
       html: resolvedHtml
     };
   }
-  createBoundaryToken(tokenPrefix, runtimeContext, boundaryId) {
-    return `${tokenPrefix}${runtimeContext.componentInstanceScope ?? "root"}__${boundaryId}__`;
+  createForeignSubtreeToken(tokenPrefix, runtimeContext, foreignSubtreeId) {
+    return `${tokenPrefix}${runtimeContext.componentInstanceScope ?? "root"}__${foreignSubtreeId}__`;
   }
   ensureRuntimeContext(options) {
     let integrationContext;
-    if (typeof options.boundaryInput.integrationContext === "object" && options.boundaryInput.integrationContext !== null) {
-      integrationContext = options.boundaryInput.integrationContext;
+    if (typeof options.renderInput.integrationContext === "object" && options.renderInput.integrationContext !== null) {
+      integrationContext = options.renderInput.integrationContext;
     } else {
       integrationContext = {};
     }
@@ -139,17 +142,17 @@ class QueuedBoundaryRuntimeService {
       integrationContext[options.runtimeContextKey] = options.createRuntimeContext?.(integrationContext, options.rendererCache) ?? {
         rendererCache: options.rendererCache,
         componentInstanceScope: integrationContext.componentInstanceId,
-        nextBoundaryId: 0,
+        nextForeignSubtreeId: 0,
         queuedResolutions: []
       };
     } else {
       existingRuntimeContext.rendererCache = options.rendererCache;
     }
     integrationContext.rendererCache = options.rendererCache;
-    options.boundaryInput.integrationContext = integrationContext;
+    options.renderInput.integrationContext = integrationContext;
     return integrationContext[options.runtimeContextKey];
   }
 }
 export {
-  QueuedBoundaryRuntimeService
+  QueuedForeignSubtreeResolutionService
 };

package/src/route-renderer/orchestration/render-output.utils.d.ts

@@ -58,9 +58,9 @@ export declare function wrapWithScriptsInjector<T extends TemplateContentShape>(
 export declare function wrapWithScriptsInjector<T extends MarkupNodeLikeShape>(content: T, lazyGroups: ResolvedLazyScriptGroups): T;
 export declare function wrapWithScriptsInjector(content: unknown, lazyGroups: ResolvedLazyScriptGroups): string | TemplateContentShape | MarkupNodeLikeShape;
 export declare function decodeHtmlEntities(value: string): string;
-export declare function normalizeBoundaryArtifactHtml(html: string): string;
-export declare function inspectBoundaryArtifactHtml(html: string): {
-    hasUnresolvedBoundaryArtifacts: boolean;
+export declare function normalizeUnresolvedMarkerArtifactHtml(html: string): string;
+export declare function inspectUnresolvedMarkerArtifactHtml(html: string): {
+    hasUnresolvedMarkerArtifacts: boolean;
     normalizedHtml: string;
 };
 export {};

package/src/route-renderer/orchestration/render-output.utils.js

@@ -148,24 +148,24 @@ function decodeHtmlEntities(value) {
   } while (decoded !== previous);
   return decoded;
 }
-function normalizeBoundaryArtifactHtml(html) {
+function normalizeUnresolvedMarkerArtifactHtml(html) {
   return html.replace(
     /&(?:amp;)?lt;eco-marker\b[\s\S]*?&(?:amp;)?gt;&(?:amp;)?lt;\/eco-marker&(?:amp;)?gt;/g,
     (marker) => decodeHtmlEntities(marker)
   );
 }
-function inspectBoundaryArtifactHtml(html) {
-  const normalizedHtml = normalizeBoundaryArtifactHtml(html);
+function inspectUnresolvedMarkerArtifactHtml(html) {
+  const normalizedHtml = normalizeUnresolvedMarkerArtifactHtml(html);
   return {
     normalizedHtml,
-    hasUnresolvedBoundaryArtifacts: normalizedHtml.includes("<eco-marker")
+    hasUnresolvedMarkerArtifacts: normalizedHtml.includes("<eco-marker")
   };
 }
 export {
   addTriggerAttribute,
   decodeHtmlEntities,
-  inspectBoundaryArtifactHtml,
+  inspectUnresolvedMarkerArtifactHtml,
   isThenable,
-  normalizeBoundaryArtifactHtml,
+  normalizeUnresolvedMarkerArtifactHtml,
   wrapWithScriptsInjector
 };

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

@@ -0,0 +1,120 @@
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { ComponentRenderResult, EcoComponent, EcoPageComponent, EcoPageFile, HtmlTemplateProps, IntegrationRendererRenderOptions, PageBrowserGraphResult, PageMetadataProps, RouteRendererBody, RouteRendererOptions, RouteRenderResult } from '../../types/public-types.js';
+import { type AssetProcessingService, type ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
+import { OwnershipValidationService } from './ownership-validation.service.js';
+import { OwnershipPlanningService } from './ownership-planning.service.js';
+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 RouteRenderOrchestratorResolvedAssets = {
+    resolvedDependencies: ProcessedAsset[];
+    pageBrowserGraph?: PageBrowserGraphResult;
+};
+/**
+ * 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;
+};
+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 assets needed before Integration rendering starts.
+     */
+    resolveRouteAssets(input: {
+        routeOptions: RouteRendererOptions;
+        components: (EcoComponent | Partial<EcoComponent>)[];
+    }): Promise<RouteRenderOrchestratorResolvedAssets>;
+    /**
+     * 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): 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 declare class RouteRenderOrchestrator {
+    private readonly appConfig;
+    private readonly assetProcessingService;
+    private readonly ownershipPlanningService;
+    private readonly ownershipValidationService;
+    constructor(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService, dependencies?: RouteRenderOrchestratorDependencies);
+    /**
+     * 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.
+     */
+    prepareRenderOptions<C = unknown>(routeOptions: RouteRendererOptions, adapter: RouteRenderOrchestratorAdapter<C>): Promise<IntegrationRendererRenderOptions<C>>;
+    /**
+     * Captures one route render body as HTML while preserving a replayable body value.
+     */
+    captureHtmlRender(render: () => Promise<RouteRendererBody>): Promise<CapturedHtmlRenderResult>;
+    /**
+     * Executes the full route-render flow and returns the final body plus cache strategy.
+     */
+    execute<C = unknown>(options: RouteRendererOptions, adapter: RouteRenderOrchestratorAdapter<C>): Promise<RouteRenderResult>;
+    /**
+     * Executes the route-render finalization path for already prepared render options.
+     */
+    executePrepared<C = unknown>(renderOptions: IntegrationRendererRenderOptions<C>, adapter: RouteRenderOrchestratorAdapter<C>): Promise<RouteRenderResult>;
+    private captureRenderedBody;
+    private collectResolvedTriggers;
+    private collectUsedIntegrationDependencies;
+    private collectIntegrationNames;
+    private buildGlobalInjectorAssets;
+    private buildEagerSsrLazyAssets;
+    private collectEagerSsrLazyDependencies;
+}