npm - @ecopages/core - Versions diffs - 0.2.0-alpha.25 → 0.2.0-alpha.27 - Mend

@ecopages/core 0.2.0-alpha.25 → 0.2.0-alpha.27

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (111) hide show

package/src/route-renderer/orchestration/integration-renderer.ts CHANGED Viewed

@@ -8,16 +8,12 @@ import type { EcoPagesAppConfig, IHmrManager } from '../../types/internal-types.
 import type {
 	ComponentRenderInput,
 	ComponentRenderResult,
-	BoundaryRenderPayload,
+	ForeignSubtreeRenderPayload,
 	EcoComponent,
 	EcoComponentDependencies,
 	EcoFunctionComponent,
-	EcoPageComponent,
 	EcoPageFile,
 	EcoPagesElement,
-	GetMetadata,
-	GetMetadataContext,
-	GetStaticProps,
 	BaseIntegrationContext,
 	HtmlTemplateProps,
 	IntegrationRendererRenderOptions,
@@ -28,6 +24,7 @@ import type {
 } from '../../types/public-types.ts';
 import {
 	type AssetProcessingService,
+	createPagePackage,
 	type ProcessedAsset,
 } from '../../services/assets/asset-processing-service/index.ts';
 import { HtmlTransformerService } from '../../services/html/html-transformer.service.ts';
@@ -35,23 +32,20 @@ import { invariant } from '../../utils/invariant.ts';
 import { HttpError } from '../../errors/http-error.ts';
 import { DependencyResolverService } from '../page-loading/dependency-resolver.ts';
 import { PageModuleLoaderService } from '../page-loading/page-module-loader.ts';
-import { PagePackagingService } from './page-packaging.service.ts';
-import { RenderExecutionService } from './render-execution.service.ts';
-import { RenderPreparationService } from './render-preparation.service.ts';
-import { RouteShellComposer } from './route-shell-composer.service.ts';
-import type { ComponentBoundaryRuntime } from './component-render-context.ts';
-import { normalizeBoundaryArtifactHtml } from './render-output.utils.ts';
-import { getComponentRenderContext, runWithComponentRenderContext } from './component-render-context.ts';
+import { OwnershipValidationService } from './ownership-validation.service.ts';
 import {
-	QueuedBoundaryRuntimeService,
-	type QueuedBoundaryResolution,
-	type QueuedBoundaryRuntimeContext,
-} from './queued-boundary-runtime.service.ts';
-type BoundaryRenderDecisionInput = {
-	currentIntegration: string;
-	targetIntegration?: string;
-};
+	type RouteHtmlFinalization,
+	RouteRenderOrchestrator,
+	type RouteRenderOrchestratorAdapter,
+	type RouteRenderOrchestratorResolvedInputs,
+} from './route-render-orchestrator.ts';
+import type { ForeignChildRuntime } from './component-render-context.ts';
+import { normalizeUnresolvedMarkerArtifactHtml } from './render-output.utils.ts';
+import {
+	ForeignSubtreeExecutionService,
+	type ForeignSubtreeExecutionOwningRenderer,
+} from './foreign-subtree-execution.service.ts';
+import { type QueuedForeignSubtreeResolutionContext } from './queued-foreign-subtree-resolution.service.ts';
 /**
  * Controls how one route module is loaded outside the normal render path.
@@ -91,11 +85,8 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 	protected runtimeOrigin: string;
 	protected dependencyResolverService: DependencyResolverService;
 	protected pageModuleLoaderService: PageModuleLoaderService;
-	protected renderPreparationService: RenderPreparationService;
-	protected renderExecutionService: RenderExecutionService;
-	protected pagePackagingService: PagePackagingService;
-	protected readonly routeShellComposer = new RouteShellComposer();
-	protected readonly queuedBoundaryRuntimeService = new QueuedBoundaryRuntimeService();
+	protected routeRenderOrchestrator: RouteRenderOrchestrator;
+	protected readonly foreignSubtreeExecutionService = new ForeignSubtreeExecutionService();
 	protected DOC_TYPE = '<!DOCTYPE html>';
@@ -112,7 +103,7 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 	}
 	/**
-	 * Reads the execution-scoped foreign renderer cache from one boundary input.
+	 * Reads the execution-scoped owning-renderer cache from one render input.
 	 *
 	 * Shared page/layout/document shell helpers pass one cache through
 	 * `integrationContext` so repeated delegation to the same foreign integration
@@ -121,10 +112,10 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 	 * stored on the renderer, which avoids leaking mutable integration state across
 	 * requests while still preventing redundant renderer initialization.
 	 *
-	 * @param integrationContext - Optional boundary context carried with one render input.
+	 * @param integrationContext - Optional render context carried with one render input.
 	 * @returns The current execution cache when present.
 	 */
-	private getBoundaryRendererCache(
+	private getOwningRendererCache(
 		integrationContext?: BaseIntegrationContext,
 	): Map<string, IntegrationRenderer<any>> | undefined {
 		if (integrationContext?.rendererCache instanceof Map) {
@@ -134,7 +125,7 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 		return undefined;
 	}
-	private getRegisteredBoundaryOwner(component: EcoComponent): string | undefined {
+	private getForeignOwnerIntegrationName(component: EcoComponent): string | undefined {
 		const integrationName = component.config?.integration ?? component.config?.__eco?.integration;
 		if (!integrationName || integrationName === this.name) {
 			return undefined;
@@ -146,18 +137,18 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 	}
 	/**
-	 * Attaches an execution-scoped foreign renderer cache to one boundary input.
+	 * Attaches an execution-scoped owning-renderer cache to one render input.
 	 *
 	 * Foreign-owned page, layout, or document shells may delegate several times in
 	 * the same render flow. Threading the cache through `integrationContext`
-	 * preserves renderer reuse without changing the public boundary input contract.
+	 * preserves renderer reuse without changing the public render input contract.
 	 * Existing integration-specific context is preserved and augmented.
 	 *
-	 * @param input - Original boundary render input.
+	 * @param input - Original render input.
 	 * @param rendererCache - Execution-scoped renderer cache to propagate.
-	 * @returns Boundary input augmented with the shared renderer cache.
+	 * @returns Render input augmented with the shared renderer cache.
 	 */
-	private withBoundaryRendererCache(
+	private withOwningRendererCache(
 		input: ComponentRenderInput,
 		rendererCache: Map<string, IntegrationRenderer<any>>,
 	): ComponentRenderInput {
@@ -270,7 +261,7 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 		const resolvedDependencies = this.htmlTransformer.dedupeProcessedAssets(
 			await this.resolveDependencies(componentsToResolve),
 		);
-		this.htmlTransformer.setPagePackage(this.pagePackagingService.createPagePackage(resolvedDependencies));
+		this.htmlTransformer.setPagePackage(createPagePackage(resolvedDependencies));
 		return resolvedDependencies;
 	}
@@ -278,7 +269,7 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 	 * Merges component-scoped assets into the active HTML transformer state.
 	 *
 	 * Explicit page, layout, and document shell composition can produce assets at
-	 * each boundary. This helper deduplicates those groups and folds them back into
+	 * each foreign subtree. This helper deduplicates those groups and folds them back into
 	 * the transformer so downstream HTML finalization sees one canonical asset set.
 	 *
 	 * @param assetGroups - Optional groups of processed assets to merge.
@@ -300,7 +291,7 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 			...nextDependencies,
 		]);
-		this.htmlTransformer.setPagePackage(this.pagePackagingService.createPagePackage(mergedDependencies));
+		this.htmlTransformer.setPagePackage(createPagePackage(mergedDependencies));
 		return nextDependencies;
 	}
@@ -332,7 +323,7 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 	 *
 	 * Same-integration views can optionally stream or render inline via the caller's
 	 * `renderInline()` hook. Once a view may cross integration boundaries, this
-	 * helper routes the render through `renderComponentBoundary()` instead so mixed
+	 * helper routes the render through `renderComponentWithForeignChildren()` instead so mixed
 	 * shells can reuse the execution-scoped renderer cache and resolve nested
 	 * foreign ownership before the partial response is returned.
 	 *
@@ -346,17 +337,19 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 		renderInline?: () => Promise<BodyInit>;
 		transformHtml?: (html: string) => string;
 	}): Promise<Response> {
-		return this.routeShellComposer.renderPartialViewResponse(input, {
-			hasForeignBoundaryDescendants: (component) => this.hasForeignBoundaryDescendants(component),
-			createHtmlResponse: (body, ctx) => this.createHtmlResponse(body, ctx),
-			renderComponentBoundary: (boundaryInput) => this.renderComponentBoundary(boundaryInput),
-			prepareViewDependencies: (view, layout) => this.prepareViewDependencies(view, layout),
-			getHtmlTemplate: () => this.getHtmlTemplate(),
-			resolveViewMetadata: (view, props) => this.resolveViewMetadata(view, props),
-			appendProcessedDependencies: (...assetGroups) => this.appendProcessedDependencies(...assetGroups),
-			finalizeResolvedHtml: (options) => this.finalizeResolvedHtml(options),
-			docType: this.DOC_TYPE,
+		if (input.renderInline && !this.hasForeignChildDescendants(input.view as EcoComponent)) {
+			return this.createHtmlResponse(await input.renderInline(), input.ctx);
+		}
+		const rendererCache = new Map<string, unknown>() as BaseIntegrationContext['rendererCache'];
+		const viewRender = await this.renderComponentWithForeignChildren({
+			component: input.view as EcoComponent,
+			props: (input.props ?? {}) as Record<string, unknown>,
+			integrationContext: { rendererCache },
 		});
+		const html = input.transformHtml ? input.transformHtml(viewRender.html) : viewRender.html;
+		return this.createHtmlResponse(html, input.ctx);
 	}
 	/**
@@ -377,26 +370,47 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 		ctx: RenderToResponseContext;
 		layout?: EcoComponent;
 	}): Promise<Response> {
-		return this.routeShellComposer.renderViewWithDocumentShell(input, {
-			hasForeignBoundaryDescendants: (component) => this.hasForeignBoundaryDescendants(component),
-			createHtmlResponse: (body, ctx) => this.createHtmlResponse(body, ctx),
-			renderComponentBoundary: (boundaryInput) => this.renderComponentBoundary(boundaryInput),
-			prepareViewDependencies: (view, layout) => this.prepareViewDependencies(view, layout),
-			getHtmlTemplate: () => this.getHtmlTemplate(),
-			resolveViewMetadata: (view, props) => this.resolveViewMetadata(view, props),
-			appendProcessedDependencies: (...assetGroups) => this.appendProcessedDependencies(...assetGroups),
-			finalizeResolvedHtml: (options) => this.finalizeResolvedHtml(options),
-			docType: this.DOC_TYPE,
+		const normalizedProps = (input.props ?? {}) as Record<string, unknown>;
+		if (input.ctx.partial) {
+			return this.renderPartialViewResponse(input);
+		}
+		await this.prepareViewDependencies(input.view, input.layout);
+		const HtmlTemplate = await this.getHtmlTemplate();
+		const metadata = await this.resolveViewMetadata(input.view, input.props);
+		const { documentHtml } = await this.composeDocumentShell({
+			primaryComponent: input.view as EcoComponent,
+			primaryProps: normalizedProps,
+			layout: input.layout
+				? {
+						component: input.layout,
+						props: {},
+					}
+				: undefined,
+			htmlTemplate: HtmlTemplate as EcoComponent,
+			documentProps: {
+				metadata,
+				pageProps: normalizedProps,
+			},
+		});
+		const html = await this.finalizeResolvedHtml({
+			html: `${this.DOC_TYPE}${documentHtml}`,
+			partial: false,
 		});
+		return this.createHtmlResponse(html, input.ctx);
 	}
 	/**
 	 * Renders a route page through optional layout and document shells.
 	 *
-	 * Route rendering and explicit view rendering now share the same boundary-owned
+	 * Route rendering and explicit view rendering now share the same renderer-owned
 	 * shell composition model. This helper composes page, layout, and html template
-	 * boundaries while threading one execution-scoped renderer cache through every
-	 * delegated boundary so foreign shell ownership remains stable and renderer
+	 * renders while threading one execution-scoped renderer cache through every
+	 * delegated foreign subtree so foreign shell ownership remains stable and renderer
 	 * initialization is reused inside the current request.
 	 *
 	 * @param input - Page, layout, document, and metadata inputs for the route render.
@@ -417,33 +431,77 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 		documentProps?: Record<string, unknown>;
 		transformDocumentHtml?: (html: string) => string;
 	}): Promise<string> {
-		return this.routeShellComposer.renderPageWithDocumentShell(input, {
-			hasForeignBoundaryDescendants: (component) => this.hasForeignBoundaryDescendants(component),
-			createHtmlResponse: (body, ctx) => this.createHtmlResponse(body, ctx),
-			renderComponentBoundary: (boundaryInput) => this.renderComponentBoundary(boundaryInput),
-			prepareViewDependencies: (view, layout) => this.prepareViewDependencies(view, layout),
-			getHtmlTemplate: () => this.getHtmlTemplate(),
-			resolveViewMetadata: (view, props) => this.resolveViewMetadata(view, props),
-			appendProcessedDependencies: (...assetGroups) => this.appendProcessedDependencies(...assetGroups),
-			finalizeResolvedHtml: (options) => this.finalizeResolvedHtml(options),
-			docType: this.DOC_TYPE,
+		const { documentHtml: composedDocumentHtml } = await this.composeDocumentShell({
+			primaryComponent: input.page.component,
+			primaryProps: input.page.props,
+			layout: input.layout,
+			htmlTemplate: input.htmlTemplate,
+			documentProps: {
+				metadata: input.metadata,
+				pageProps: input.pageProps,
+				...(input.documentProps ?? {}),
+			},
 		});
+		const documentHtml = input.transformDocumentHtml
+			? input.transformDocumentHtml(composedDocumentHtml)
+			: composedDocumentHtml;
+		return `${this.DOC_TYPE}${documentHtml}`;
+	}
+	private async composeDocumentShell(input: {
+		primaryComponent: EcoComponent;
+		primaryProps: Record<string, unknown>;
+		layout?: {
+			component: EcoComponent;
+			props?: Record<string, unknown>;
+		};
+		htmlTemplate: EcoComponent;
+		documentProps: Record<string, unknown>;
+	}): Promise<{ documentHtml: string }> {
+		const rendererCache = new Map<string, unknown>() as BaseIntegrationContext['rendererCache'];
+		const primaryRender = await this.renderComponentWithForeignChildren({
+			component: input.primaryComponent,
+			props: input.primaryProps,
+			integrationContext: { rendererCache },
+		});
+		const layoutRender = input.layout
+			? await this.renderComponentWithForeignChildren({
+					component: input.layout.component,
+					props: input.layout.props ?? {},
+					children: primaryRender.html,
+					integrationContext: { rendererCache },
+				})
+			: undefined;
+		const documentRender = await this.renderComponentWithForeignChildren({
+			component: input.htmlTemplate,
+			props: input.documentProps,
+			children: layoutRender?.html ?? primaryRender.html,
+			integrationContext: { rendererCache },
+		});
+		this.appendProcessedDependencies(primaryRender.assets, layoutRender?.assets, documentRender.assets);
+		return {
+			documentHtml: documentRender.html,
+		};
 	}
 	/**
-	 * Renders one string-first component boundary and collects its assets.
+	 * Renders one string-first component with serialized children and collects its assets.
 	 *
-	 * String-oriented integrations frequently share the same boundary contract:
+	 * String-oriented integrations frequently share the same component contract:
 	 * pass serialized children through props, coerce the render result to HTML, and
 	 * attach any component-scoped dependencies. This helper centralizes that flow
 	 * so integrations can opt into shared orchestration without repeating the same
-	 * boundary boilerplate.
+	 * string-render boilerplate.
 	 *
-	 * @param input - Boundary render input.
+	 * @param input - Component render input.
 	 * @param component - String-oriented component implementation to execute.
 	 * @returns Structured component render result for orchestration paths.
 	 */
-	protected async renderStringComponentBoundary(
+	protected async renderStringComponentWithSerializedChildren(
 		input: ComponentRenderInput,
 		component: (props: Record<string, unknown>) => Promise<EcoPagesElement> | EcoPagesElement,
 	): Promise<ComponentRenderResult> {
@@ -465,41 +523,18 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 		};
 	}
-	protected getBoundaryTokenPrefix(): string {
-		return `__${this.name}_boundary__`;
-	}
-	protected getBoundaryRuntimeContextKey(): string {
-		return `__${this.name}_boundary_runtime__`;
+	protected getForeignSubtreeTokenPrefix(): string {
+		return `__${this.name}_foreign_subtree__`;
 	}
-	protected getQueuedBoundaryRuntime<TContext extends QueuedBoundaryRuntimeContext>(
-		input: ComponentRenderInput,
-		runtimeContextKey = this.getBoundaryRuntimeContextKey(),
-	): TContext | undefined {
-		return this.queuedBoundaryRuntimeService.getRuntimeContext<TContext>(input, runtimeContextKey);
+	protected getForeignSubtreeResolutionContextKey(): string {
+		return `__${this.name}_foreign_subtree_runtime__`;
 	}
-	protected async resolveQueuedBoundaryTokens(
-		html: string,
-		queuedResolutionsByToken: Map<string, QueuedBoundaryResolution>,
-		resolveToken: (token: string) => Promise<string>,
-	): Promise<string> {
-		let resolvedHtml = html;
-		for (const token of queuedResolutionsByToken.keys()) {
-			if (!resolvedHtml.includes(token)) {
-				continue;
-			}
-			resolvedHtml = resolvedHtml.split(token).join(await resolveToken(token));
-		}
-		return resolvedHtml;
-	}
-	protected createQueuedBoundaryRuntime<TContext extends QueuedBoundaryRuntimeContext>(options: {
-		boundaryInput: ComponentRenderInput;
+	protected createQueuedForeignSubtreeExecutionRuntime<
+		TContext extends QueuedForeignSubtreeResolutionContext,
+	>(options: {
+		renderInput: ComponentRenderInput;
 		rendererCache: Map<string, IntegrationRenderer<any>>;
 		runtimeContextKey?: string;
 		tokenPrefix?: string;
@@ -507,80 +542,55 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 			integrationContext: BaseIntegrationContext & Record<string, unknown>,
 			rendererCache: Map<string, unknown>,
 		) => TContext;
-	}): ComponentBoundaryRuntime {
-		return this.queuedBoundaryRuntimeService.createRuntime<TContext>({
-			boundaryInput: options.boundaryInput,
-			rendererCache: options.rendererCache as Map<string, unknown>,
-			runtimeContextKey: options.runtimeContextKey ?? this.getBoundaryRuntimeContextKey(),
-			tokenPrefix: options.tokenPrefix ?? this.getBoundaryTokenPrefix(),
-			shouldQueueBoundary: (input) => this.shouldResolveBoundaryInOwningRenderer(input),
+	}): ForeignChildRuntime {
+		return this.foreignSubtreeExecutionService.createQueuedRuntime<TContext>({
+			renderInput: options.renderInput,
+			rendererCache: options.rendererCache,
+			runtimeContextKey: options.runtimeContextKey ?? this.getForeignSubtreeResolutionContextKey(),
+			tokenPrefix: options.tokenPrefix ?? this.getForeignSubtreeTokenPrefix(),
 			createRuntimeContext: options.createRuntimeContext,
 		});
 	}
-	protected async resolveRendererOwnedQueuedBoundaryHtml<TContext extends QueuedBoundaryRuntimeContext>(options: {
-		html: string;
-		runtimeContext?: TContext;
-		queueLabel: string;
-		renderQueuedChildren: (
-			children: unknown,
-			runtimeContext: TContext,
-			queuedResolutionsByToken: Map<string, QueuedBoundaryResolution>,
-			resolveToken: (token: string) => Promise<string>,
-		) => Promise<{ assets: ProcessedAsset[]; html?: string }>;
-	}): Promise<{ assets: ProcessedAsset[]; html: string }> {
-		return this.queuedBoundaryRuntimeService.resolveQueuedHtml({
-			html: options.html,
-			runtimeContext: options.runtimeContext,
-			queueLabel: options.queueLabel,
-			renderQueuedChildren: options.renderQueuedChildren,
-			resolveBoundary: (input, rendererCache) =>
-				this.resolveBoundaryPayloadInOwningRenderer(
-					input,
-					rendererCache as Map<string, IntegrationRenderer<any>>,
-				),
-			applyAttributesToFirstElement: (html, attributes) =>
-				this.htmlTransformer.applyAttributesToFirstElement(html, attributes),
-			dedupeProcessedAssets: (assets) => this.htmlTransformer.dedupeProcessedAssets(assets),
-		});
+	protected getQueuedForeignSubtreeResolutionContext<TContext extends QueuedForeignSubtreeResolutionContext>(
+		input: ComponentRenderInput,
+	): TContext | undefined {
+		return this.foreignSubtreeExecutionService.getQueuedRuntimeContext<TContext>(
+			input,
+			this.getForeignSubtreeResolutionContextKey(),
+		);
 	}
 	/**
 	 * Renders a string-first component, then resolves any queued foreign
 	 * boundaries before returning final component HTML.
 	 */
-	protected async renderStringComponentBoundaryWithQueuedForeignBoundaries(
+	protected async renderStringComponentWithQueuedForeignSubtrees(
 		input: ComponentRenderInput,
 		component: (props: Record<string, unknown>) => Promise<EcoPagesElement> | EcoPagesElement,
 	): Promise<ComponentRenderResult> {
-		const componentRender = await this.renderStringComponentBoundary(input, component);
-		const queuedBoundaryResolution = await this.resolveRendererOwnedQueuedBoundaryHtml({
+		const componentRender = await this.renderStringComponentWithSerializedChildren(input, component);
+		const queuedForeignSubtreeResolution = await this.foreignSubtreeExecutionService.resolveStringQueuedHtml({
+			currentIntegrationName: this.name,
+			renderInput: input,
 			html: componentRender.html,
-			runtimeContext: this.getQueuedBoundaryRuntime<QueuedBoundaryRuntimeContext>(input),
+			runtimeContextKey: this.getForeignSubtreeResolutionContextKey(),
 			queueLabel: 'String',
-			renderQueuedChildren: async (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => {
-				if (children === undefined) {
-					return { assets: [], html: undefined };
-				}
-				const html = await this.resolveQueuedBoundaryTokens(
-					typeof children === 'string' ? children : String(children ?? ''),
-					queuedResolutionsByToken,
-					resolveToken,
-				);
-				return { assets: [], html };
-			},
+			getOwningRenderer: (integrationName, rendererCache) =>
+				this.getIntegrationRendererForName(integrationName, rendererCache),
+			applyAttributesToFirstElement: (html, attributes) =>
+				this.htmlTransformer.applyAttributesToFirstElement(html, attributes),
+			dedupeProcessedAssets: (assets) => this.htmlTransformer.dedupeProcessedAssets(assets),
 		});
 		const mergedAssets = this.htmlTransformer.dedupeProcessedAssets([
 			...(componentRender.assets ?? []),
-			...queuedBoundaryResolution.assets,
+			...queuedForeignSubtreeResolution.assets,
 		]);
 		return {
 			...componentRender,
-			html: queuedBoundaryResolution.html,
-			rootTag: this.getRootTagName(queuedBoundaryResolution.html),
+			html: queuedForeignSubtreeResolution.html,
+			rootTag: this.getRootTagName(queuedForeignSubtreeResolution.html),
 			assets: mergedAssets.length > 0 ? mergedAssets : undefined,
 		};
 	}
@@ -601,16 +611,14 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 		this.appConfig = appConfig;
 		this.assetProcessingService = assetProcessingService;
 		this.htmlTransformer = new HtmlTransformerService();
-		this.pagePackagingService = new PagePackagingService();
 		this.resolvedIntegrationDependencies = resolvedIntegrationDependencies || [];
 		this.rendererModules = rendererModules ?? appConfig.runtime?.rendererModuleContext;
 		this.runtimeOrigin = runtimeOrigin;
 		this.dependencyResolverService = new DependencyResolverService(appConfig, assetProcessingService);
 		this.pageModuleLoaderService = new PageModuleLoaderService(appConfig, runtimeOrigin);
-		this.renderPreparationService = new RenderPreparationService(appConfig, assetProcessingService, {
-			pagePackagingService: this.pagePackagingService,
+		this.routeRenderOrchestrator = new RouteRenderOrchestrator(appConfig, assetProcessingService, {
+			ownershipValidationService: new OwnershipValidationService(appConfig),
 		});
-		this.renderExecutionService = new RenderExecutionService();
 	}
 	/**
@@ -648,45 +656,6 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 		}
 	}
-	/**
-	 * Returns the static props for the page.
-	 * It calls the provided getStaticProps function with the given options.
-	 *
-	 * @param getStaticProps - The function to get static props.
-	 * @param options - The options to pass to the getStaticProps function.
-	 * @returns The static props and metadata.
-	 */
-	protected async getStaticProps(
-		getStaticProps?: GetStaticProps<Record<string, unknown>>,
-		options?: Pick<RouteRendererOptions, 'params'>,
-	): Promise<{
-		props: Record<string, unknown>;
-		metadata?: PageMetadataProps;
-	}> {
-		return this.pageModuleLoaderService.getStaticPropsForPage({
-			getStaticProps,
-			params: options?.params,
-		});
-	}
-	/**
-	 * Returns the metadata properties for the page.
-	 * It calls the provided getMetadata function with the given context.
-	 *
-	 * @param getMetadata - The function to get metadata.
-	 * @param context - The context to pass to the getMetadata function.
-	 * @returns The metadata properties.
-	 */
-	protected async getMetadataProps(
-		getMetadata: GetMetadata | undefined,
-		{ props, params, query }: GetMetadataContext,
-	): Promise<PageMetadataProps> {
-		return this.pageModuleLoaderService.getMetadataPropsForPage({
-			getMetadata,
-			context: { props, params, query } as GetMetadataContext,
-		});
-	}
 	protected usesIntegrationPageImporter(_file: string): boolean {
 		return false;
 	}
@@ -815,6 +784,129 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 		return this.dependencyResolverService.processComponentDependencies(components, this.name);
 	}
+	/**
+	 * Builds the internal route-render adapter consumed by `RouteRenderOrchestrator`.
+	 *
+	 * The route orchestrator needs a narrow orchestration contract, but those hooks should
+	 * not become public API on the renderer base class. Keeping the adapter object
+	 * local to the execution path lets the orchestrator depend on one explicit seam while
+	 * subclasses continue to override protected renderer behavior directly.
+	 */
+	protected createRouteRenderOrchestratorAdapter(): RouteRenderOrchestratorAdapter<C> {
+		return {
+			name: this.name,
+			resolveRouteRenderInputs: (routeOptions) => this.resolveRouteRenderInputs(routeOptions),
+			resolveRouteAssets: (input) => this.resolveRouteAssets(input),
+			resolveRoutePageComponentRender: (input) => this.resolveRoutePageComponentRender(input),
+			renderRouteBody: (renderOptions) => this.renderRouteBody(renderOptions),
+			getRouteHtmlFinalization: (renderOptions) => this.getRouteHtmlFinalization(renderOptions),
+			transformRouteResponse: (response) => this.transformRouteResponse(response),
+		};
+	}
+	protected async resolveRouteRenderInputs(
+		routeOptions: RouteRendererOptions,
+	): Promise<RouteRenderOrchestratorResolvedInputs> {
+		const pageModule = await this.pageModuleLoaderService.resolvePageModule({
+			file: routeOptions.file,
+			importPageFileFn: (targetFile) => this.importPageFile(targetFile),
+		});
+		const { Page, integrationSpecificProps } = pageModule;
+		const HtmlTemplate = await this.getHtmlTemplate();
+		const Layout = Page.config?.layout;
+		const { props, metadata } = await this.pageModuleLoaderService.resolvePageData({
+			pageModule,
+			routeOptions,
+		});
+		return {
+			Page,
+			HtmlTemplate: HtmlTemplate as EcoComponent<HtmlTemplateProps>,
+			Layout,
+			props,
+			metadata,
+			integrationSpecificProps,
+		};
+	}
+	protected async resolveRouteAssets(input: {
+		routeOptions: RouteRendererOptions;
+		components: (EcoComponent | Partial<EcoComponent>)[];
+	}): Promise<{ resolvedDependencies: ProcessedAsset[]; pageBrowserGraph?: { assets: ProcessedAsset[] } }> {
+		return {
+			resolvedDependencies: await this.resolveDependencies(input.components),
+			pageBrowserGraph: await this.buildPageBrowserGraph(input.routeOptions.file),
+		};
+	}
+	protected async resolveRoutePageComponentRender(input: {
+		Page: EcoComponent;
+		Layout?: EcoComponent;
+		props: Record<string, unknown>;
+		routeOptions: RouteRendererOptions;
+	}): Promise<ComponentRenderResult | undefined> {
+		if (!this.shouldRenderPageComponent({ Page: input.Page, Layout: input.Layout, options: input.routeOptions })) {
+			return undefined;
+		}
+		return this.renderComponentWithForeignChildren({
+			component: input.Page,
+			props: {
+				...input.props,
+				params: input.routeOptions.params || {},
+				query: input.routeOptions.query || {},
+			},
+			integrationContext: {
+				componentInstanceId: 'eco-page-root',
+			},
+		});
+	}
+	protected async renderRouteBody(renderOptions: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody> {
+		return this.render(renderOptions);
+	}
+	protected getRouteHtmlFinalization(renderOptions: IntegrationRendererRenderOptions<C>): RouteHtmlFinalization {
+		const componentRootAttributes =
+			renderOptions.componentRender?.canAttachAttributes &&
+			renderOptions.componentRender.rootAttributes &&
+			Object.keys(renderOptions.componentRender.rootAttributes).length > 0
+				? (renderOptions.componentRender.rootAttributes as Record<string, string>)
+				: undefined;
+		const documentAttributes = this.getDocumentAttributes(renderOptions);
+		const hasStructuralFinalization =
+			(componentRootAttributes && Object.keys(componentRootAttributes).length > 0) ||
+			(documentAttributes && Object.keys(documentAttributes).length > 0);
+		if (!hasStructuralFinalization) {
+			return {};
+		}
+		return {
+			finalizeHtml: (html) => {
+				let renderedHtml = html;
+				if (componentRootAttributes) {
+					renderedHtml = this.htmlTransformer.applyAttributesToFirstBodyElement(
+						renderedHtml,
+						componentRootAttributes,
+					);
+				}
+				if (documentAttributes) {
+					renderedHtml = this.htmlTransformer.applyAttributesToHtmlElement(renderedHtml, documentAttributes);
+				}
+				return renderedHtml;
+			},
+		};
+	}
+	protected async transformRouteResponse(response: Response): Promise<RouteRendererBody> {
+		const transformedResponse = await this.htmlTransformer.transform(response);
+		return (transformedResponse.body ?? (await transformedResponse.text())) as RouteRendererBody;
+	}
 	/**
 	 * Prepares the render options for the integration renderer.
 	 * It imports the page file, collects dependencies, and prepares the render options.
@@ -822,27 +914,14 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 	 * @param options - The route renderer options.
 	 * @returns The prepared render options.
 	 */
-	protected async prepareRenderOptions(options: RouteRendererOptions): Promise<IntegrationRendererRenderOptions> {
-		const preparedOptions = await this.renderPreparationService.prepare(options, this.name, {
-			resolvePageModule: (file) => this.resolvePageModule(file),
-			getHtmlTemplate: () => this.getHtmlTemplate(),
-			resolvePageData: (pageModule, routeOptions) => this.resolvePageData(pageModule, routeOptions),
-			resolveDependencies: (components) => this.resolveDependencies(components),
-			buildRouteRenderAssets: (file) => this.buildRouteRenderAssets(file),
-			shouldRenderPageComponent: (input) => this.shouldRenderPageComponent(input),
-			renderPageComponent: ({ component, props }) =>
-				this.renderComponentBoundary({
-					component,
-					props,
-					integrationContext: {
-						componentInstanceId: 'eco-page-root',
-					},
-				}),
-		});
-		invariant(preparedOptions.pagePackage !== undefined, 'Expected render preparation to produce a page package');
-		this.htmlTransformer.setPagePackage(preparedOptions.pagePackage);
-		return preparedOptions;
+	protected async prepareRenderOptions(
+		options: RouteRendererOptions,
+		adapter = this.createRouteRenderOrchestratorAdapter(),
+	): Promise<IntegrationRendererRenderOptions<C>> {
+		const renderOptions = await this.routeRenderOrchestrator.prepareRenderOptions(options, adapter);
+		invariant(renderOptions.pagePackage !== undefined, 'Expected render preparation to produce a page package');
+		this.htmlTransformer.setPagePackage(renderOptions.pagePackage);
+		return renderOptions;
 	}
 	/**
@@ -861,47 +940,13 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 		return true;
 	}
-	/**
-	 * Resolves the page module and normalizes exports.
-	 */
-	protected async resolvePageModule(file: string): Promise<{
-		Page: EcoPageFile['default'] | EcoPageComponent<any>;
-		getStaticProps?: GetStaticProps<Record<string, unknown>>;
-		getMetadata?: GetMetadata;
-		integrationSpecificProps: Record<string, unknown>;
-	}> {
-		return this.pageModuleLoaderService.resolvePageModule({
-			file,
-			importPageFileFn: (targetFile) => this.importPageFile(targetFile),
-		});
-	}
-	/**
-	 * Resolves static props and metadata for the page.
-	 */
-	protected async resolvePageData(
-		pageModule: {
-			getStaticProps?: GetStaticProps<Record<string, unknown>>;
-			getMetadata?: GetMetadata;
-		},
-		options: RouteRendererOptions,
-	): Promise<{
-		props: Record<string, unknown>;
-		metadata: PageMetadataProps;
-	}> {
-		return this.pageModuleLoaderService.resolvePageData({
-			pageModule,
-			routeOptions: options,
-		});
-	}
 	/**
 	 * Executes the integration renderer with the provided options.
 	 *
 	 * Execution flow:
 	 * 1. Build normalized render options (`prepareRenderOptions`).
 	 * 2. Render the route body once.
-	 * 3. Reject unresolved route-level boundary artifacts.
+	 * 3. Reject unresolved route-level eco-marker artifacts.
 	 * 4. Optionally apply root attributes for page/component root boundaries.
 	 * 5. Run HTML transformer with final dependency set.
 	 *
@@ -913,27 +958,16 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 	 * @returns Rendered route body plus effective cache strategy.
 	 */
 	public async execute(options: RouteRendererOptions): Promise<RouteRenderResult> {
-		return this.renderExecutionService.execute(options, {
-			prepareRenderOptions: (routeOptions) =>
-				this.prepareRenderOptions(routeOptions) as Promise<IntegrationRendererRenderOptions<C>>,
-			render: (renderOptions) => this.render(renderOptions),
-			getDocumentAttributes: (renderOptions) => this.getDocumentAttributes(renderOptions),
-			applyAttributesToHtmlElement: (html, attributes) =>
-				this.htmlTransformer.applyAttributesToHtmlElement(html, attributes),
-			applyAttributesToFirstBodyElement: (html, attributes) =>
-				this.htmlTransformer.applyAttributesToFirstBodyElement(html, attributes),
-			transformResponse: async (response) => {
-				const transformedResponse = await this.htmlTransformer.transform(response);
-				return (transformedResponse.body ?? (await transformedResponse.text())) as RouteRendererBody;
-			},
-		});
+		const adapter = this.createRouteRenderOrchestratorAdapter();
+		const renderOptions = await this.prepareRenderOptions(options, adapter);
+		return this.routeRenderOrchestrator.executePrepared(renderOptions, adapter);
 	}
 	/**
 	 * Finalizes already-resolved HTML for explicit renderer-owned paths.
 	 *
 	 * This keeps document and root-attribute stamping plus HTML transformation
-	 * available after a renderer has completed nested boundary resolution without
+	 * available after a renderer has completed nested foreign-subtree resolution without
 	 * routing back through shared route execution.
 	 */
 	protected async finalizeResolvedHtml(options: {
@@ -992,12 +1026,12 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 	 * @returns Renderer for the requested integration.
 	 * @throws Error when no integration plugin matches `integrationName`.
 	 */
-	private getIntegrationRendererForName(
+	protected getIntegrationRendererForName(
 		integrationName: string,
-		cache: Map<string, IntegrationRenderer<any>>,
-	): IntegrationRenderer<any> {
+		cache: Map<string, ForeignSubtreeExecutionOwningRenderer>,
+	): ForeignSubtreeExecutionOwningRenderer {
 		if (cache.has(integrationName)) {
-			return cache.get(integrationName) as IntegrationRenderer<any>;
+			return cache.get(integrationName) as ForeignSubtreeExecutionOwningRenderer;
 		}
 		if (integrationName === this.name) {
@@ -1008,7 +1042,7 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 		const integrationPlugin = this.appConfig.integrations.find(
 			(integration) => integration.name === integrationName,
 		);
-		invariant(!!integrationPlugin, `[ecopages] Integration not found for boundary owner: ${integrationName}`);
+		invariant(!!integrationPlugin, `[ecopages] Integration not found for foreign owner: ${integrationName}`);
 		const renderer = integrationPlugin.initializeRenderer({
 			rendererModules: this.appConfig.runtime?.rendererModuleContext,
 		});
@@ -1025,95 +1059,38 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 	 */
 	abstract render(options: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody>;
-	protected async resolveBoundaryInOwningRenderer(
-		input: ComponentRenderInput,
-		rendererCache: Map<string, IntegrationRenderer<any>>,
-	): Promise<ComponentRenderResult | undefined> {
-		const boundaryOwner = this.getRegisteredBoundaryOwner(input.component);
-		if (!boundaryOwner) {
-			return undefined;
-		}
-		const owningRenderer = this.getIntegrationRendererForName(boundaryOwner, rendererCache);
-		if (owningRenderer === this || owningRenderer.name === this.name) {
-			return undefined;
-		}
-		return await owningRenderer.renderComponentBoundary(this.withBoundaryRendererCache(input, rendererCache));
-	}
-	protected async resolveBoundaryPayloadInOwningRenderer(
-		input: ComponentRenderInput,
-		rendererCache: Map<string, IntegrationRenderer<any>>,
-	): Promise<BoundaryRenderPayload | undefined> {
-		const boundaryOwner = this.getRegisteredBoundaryOwner(input.component);
-		if (!boundaryOwner) {
-			return undefined;
-		}
-		const owningRenderer = this.getIntegrationRendererForName(boundaryOwner, rendererCache);
-		if (owningRenderer === this || owningRenderer.name === this.name) {
-			return undefined;
-		}
-		return await owningRenderer.renderBoundary(this.withBoundaryRendererCache(input, rendererCache));
-	}
 	/**
-	 * Renders one component under this integration's boundary runtime and resolves
-	 * any nested foreign boundaries captured during that render.
+	 * Renders one component under this integration's foreign-child runtime and resolves
+	 * any nested foreign children captured during that render.
 	 *
 	 * Without this wrapper, a component tree with foreign-owned descendants would
-	 * render them with no active boundary runtime, which bypasses the owning
-	 * renderer's nested-boundary handoff.
+	 * render them with no active foreign-child runtime, which bypasses the owning
+	 * renderer's nested foreign-child handoff.
 	 */
-	async renderComponentBoundary(input: ComponentRenderInput): Promise<ComponentRenderResult> {
-		const rendererCache =
-			this.getBoundaryRendererCache(input.integrationContext) ?? new Map<string, IntegrationRenderer<any>>();
-		const delegatedBoundaryRender = await this.resolveBoundaryInOwningRenderer(input, rendererCache);
-		if (delegatedBoundaryRender) {
-			return delegatedBoundaryRender;
-		}
-		const hasForeignBoundaries = this.hasForeignBoundaryDescendants(input.component);
-		const activeRenderContext = getComponentRenderContext();
-		if (!hasForeignBoundaries) {
-			if (!activeRenderContext || activeRenderContext.currentIntegration === this.name) {
-				return this.normalizeComponentBoundaryRender(await this.renderComponent(input));
-			}
-			const sameIntegrationExecution = await runWithComponentRenderContext(
-				{
-					currentIntegration: this.name,
-				},
-				async () => this.renderComponent(input),
-			);
-			return this.normalizeComponentBoundaryRender(sameIntegrationExecution.value);
-		}
-		const execution = await runWithComponentRenderContext(
-			{
-				currentIntegration: this.name,
-				boundaryRuntime: this.createComponentBoundaryRuntime({
-					boundaryInput: input,
-					rendererCache,
+	async renderComponentWithForeignChildren(input: ComponentRenderInput): Promise<ComponentRenderResult> {
+		return await this.foreignSubtreeExecutionService.executeComponentRender({
+			currentIntegrationName: this.name,
+			input,
+			renderComponent: (renderInput) => this.renderComponent(renderInput),
+			normalizeComponentRenderOutput: (result) => this.normalizeComponentRenderOutput(result),
+			hasForeignChildDescendants: (component) => this.hasForeignChildDescendants(component),
+			createForeignChildRuntime: ({ renderInput, rendererCache }) =>
+				this.createForeignChildRuntime({
+					renderInput,
+					rendererCache: rendererCache as Map<string, IntegrationRenderer<any>>,
 				}),
-			},
-			async () => this.renderComponent(input),
-		);
-		return this.normalizeComponentBoundaryRender(execution.value);
+			getOwningRenderer: (integrationName, rendererCache) =>
+				this.getIntegrationRendererForName(integrationName, rendererCache),
+		});
 	}
 	/**
-	 * Compatibility boundary contract that exposes a narrower payload shape for
+	 * Compatibility foreign-subtree contract that exposes a narrower payload shape for
 	 * future route-composition work while preserving the current
-	 * `renderComponentBoundary()` runtime semantics.
+	 * `renderComponentWithForeignChildren()` runtime semantics.
 	 */
-	async renderBoundary(input: ComponentRenderInput): Promise<BoundaryRenderPayload> {
-		const result = await this.renderComponentBoundary(input);
+	async renderForeignSubtree(input: ComponentRenderInput): Promise<ForeignSubtreeRenderPayload> {
+		const result = await this.renderComponentWithForeignChildren(input);
 		return {
 			html: result.html,
@@ -1125,8 +1102,8 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 		};
 	}
-	private normalizeComponentBoundaryRender(result: ComponentRenderResult): ComponentRenderResult {
-		const normalizedHtml = this.normalizeBoundaryArtifactHtml(result.html);
+	private normalizeComponentRenderOutput(result: ComponentRenderResult): ComponentRenderResult {
+		const normalizedHtml = this.normalizeUnresolvedMarkerArtifactHtml(result.html);
 		return normalizedHtml === result.html
 			? result
@@ -1136,18 +1113,18 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 				};
 	}
-	protected normalizeBoundaryArtifactHtml(html: string): string {
-		return normalizeBoundaryArtifactHtml(html);
+	protected normalizeUnresolvedMarkerArtifactHtml(html: string): string {
+		return normalizeUnresolvedMarkerArtifactHtml(html);
 	}
 	/**
 	 * Returns whether the component dependency tree crosses into another
 	 * integration.
 	 *
-	 * This keeps boundary-runtime setup narrow: same-integration trees can render
+	 * This keeps foreign-child runtime setup narrow: same-integration trees can render
 	 * directly without paying the queue orchestration cost.
 	 */
-	protected hasForeignBoundaryDescendants(component: EcoComponent): boolean {
+	protected hasForeignChildDescendants(component: EcoComponent): boolean {
 		const stack = [component];
 		const seen = new Set<EcoComponent>();
@@ -1190,8 +1167,8 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 	 * Default behavior delegates to `renderToResponse` in partial mode and wraps
 	 * the resulting HTML into the `ComponentRenderResult` contract.
 	 *
-	 * In boundary resolution, this method is the integration-owned step that turns an
-	 * already-resolved deferred boundary into concrete HTML, assets, and optional
+	 * In foreign-subtree resolution, this method is the integration-owned step that turns an
+	 * already-resolved deferred foreign subtree into concrete HTML, assets, and optional
 	 * root attributes.
 	 *
 	 * Integrations can override this for richer behavior (asset emission,
@@ -1228,58 +1205,40 @@ export abstract class IntegrationRenderer<C = EcoPagesElement> {
 	}
 	/**
-	 * Method to build route render assets.
+	 * Builds the Page Browser Graph owned by this integration for one Page.
 	 * This method can be optionally overridden by the specific integration renderer.
 	 *
 	 * @param file - The file path to build assets for.
-	 * @returns The processed assets or undefined.
+	 * @returns The structured Page Browser Graph or undefined.
 	 */
-	protected buildRouteRenderAssets(_file: string): Promise<ProcessedAsset[]> | undefined {
+	protected async buildPageBrowserGraph(_file: string): Promise<{ assets: ProcessedAsset[] } | undefined> {
 		return undefined;
 	}
 	/**
-	 * Creates the per-render boundary runtime adopted by the shared component
+	 * Creates the per-render foreign-child runtime adopted by the shared component
 	 * render context.
 	 *
-	 * Real mixed-integration renderers should override this and keep foreign
-	 * boundary resolution inside their own renderer-owned queue. The base runtime
-	 * fails fast when a renderer crosses into a foreign owner without providing its
-	 * own handoff mechanism.
+	 * The default runtime queues delegated foreign subtrees inside the owning
+	 * renderer so string and markup renderers do not need to re-declare the same
+	 * handoff boilerplate. Override only when a renderer needs custom runtime
+	 * context or a different foreign-child execution strategy.
 	 */
-	protected createComponentBoundaryRuntime(_options: {
-		boundaryInput: ComponentRenderInput;
+	protected createForeignChildRuntime(options: {
+		renderInput: ComponentRenderInput;
 		rendererCache: Map<string, IntegrationRenderer<any>>;
-	}): ComponentBoundaryRuntime {
-		const decideBoundaryInterception = (input: BoundaryRenderDecisionInput) => {
-			if (!this.shouldResolveBoundaryInOwningRenderer(input)) {
-				return { kind: 'inline' as const };
-			}
-			throw new Error(
-				`[ecopages] ${this.name} renderer crossed into ${input.targetIntegration} without a renderer-owned boundary runtime. Override createComponentBoundaryRuntime() to resolve foreign boundaries inside the owning renderer.`,
-			);
-		};
-		const runtime: ComponentBoundaryRuntime = {
-			interceptBoundary: decideBoundaryInterception,
-			interceptBoundarySync: decideBoundaryInterception,
-		};
-		return runtime;
+	}): ForeignChildRuntime {
+		return this.createQueuedForeignSubtreeExecutionRuntime({
+			renderInput: options.renderInput,
+			rendererCache: options.rendererCache,
+		});
 	}
 	/**
-	 * Resolves whether a boundary should leave the current render pass and be
-	 * resolved by its owning renderer.
-	 *
-	 * Boundaries owned by the current integration always render inline. Foreign-
-	 * owned boundaries must be handed off by a renderer-owned runtime.
-	 *
-	 * @param input Boundary metadata for the active render pass.
-	 * @returns `true` when the boundary should leave the current pass; otherwise `false`.
+	 * Creates an explicit fail-fast runtime for tests or renderers that do not
+	 * support cross-integration foreign-child execution.
 	 */
-	protected shouldResolveBoundaryInOwningRenderer(input: BoundaryRenderDecisionInput): boolean {
-		return !!input.targetIntegration && input.targetIntegration !== input.currentIntegration;
+	protected createFailFastForeignChildRuntime(): ForeignChildRuntime {
+		return this.foreignSubtreeExecutionService.createFailFastRuntime(this.name);
 	}
 }