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

package/src/route-renderer/orchestration/queued-boundary-runtime.service.ts

@@ -1,289 +0,0 @@
-import type { ProcessedAsset } from '../../services/assets/asset-processing-service/index.ts';
-import type {
-	BaseIntegrationContext,
-	BoundaryRenderPayload,
-	ComponentRenderInput,
-	EcoComponent,
-} from '../../types/public-types.ts';
-import type { ComponentBoundaryRuntime } from './component-render-context.ts';
-
-export type QueuedBoundaryDecisionInput = {
-	currentIntegration: string;
-	targetIntegration?: string;
-	component: EcoComponent;
-	props: Record<string, unknown>;
-};
-
-export type QueuedBoundaryResolution = {
-	token: string;
-	component: EcoComponent;
-	props: Record<string, unknown>;
-	componentInstanceId: string;
-};
-
-/**
- * Shared mutable state for one renderer-owned queued boundary runtime.
- *
- * Renderers that cannot resolve foreign boundaries inline can enqueue transport
- * tokens during their initial render, then resolve those tokens against the
- * owning renderer before returning final HTML.
- */
-export type QueuedBoundaryRuntimeContext = {
-	rendererCache: Map<string, unknown>;
-	componentInstanceScope?: string;
-	nextBoundaryId: number;
-	queuedResolutions: QueuedBoundaryResolution[];
-};
-
-type QueuedBoundaryIntegrationContext = BaseIntegrationContext & Record<string, unknown>;
-
-type QueuedBoundaryChildRenderResult = {
-	assets: ProcessedAsset[];
-	html?: string;
-};
-
-/**
- * Shared queue orchestration for renderer-owned boundary 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 `ComponentBoundaryRuntime` that enqueues foreign boundaries
- * - resolving queued tokens back through the owning renderer before final HTML
- *   leaves the current renderer
- *
- * Renderers still own framework-specific child rendering. This service only
- * handles queue bookkeeping, recursion, cycle detection, and asset merging.
- */
-export class QueuedBoundaryRuntimeService {
-	/**
-	 * Reads the queued boundary runtime state previously attached to one render.
-	 */
-	getRuntimeContext<TContext extends QueuedBoundaryRuntimeContext>(
-		input: ComponentRenderInput,
-		runtimeContextKey: string,
-	): TContext | undefined {
-		const integrationContext = input.integrationContext as QueuedBoundaryIntegrationContext | undefined;
-		const runtimeContext = integrationContext?.[runtimeContextKey];
-
-		if (typeof runtimeContext !== 'object' || runtimeContext === null) {
-			return undefined;
-		}
-
-		return runtimeContext as TContext;
-	}
-
-	/**
-	 * 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
-	 * a resolved transport token instead of rendering the foreign component inline.
-	 */
-	createRuntime<TContext extends QueuedBoundaryRuntimeContext>(options: {
-		boundaryInput: ComponentRenderInput;
-		rendererCache: Map<string, unknown>;
-		runtimeContextKey: string;
-		tokenPrefix: string;
-		shouldQueueBoundary: (input: QueuedBoundaryDecisionInput) => boolean;
-		createRuntimeContext?: (
-			integrationContext: QueuedBoundaryIntegrationContext,
-			rendererCache: Map<string, unknown>,
-		) => TContext;
-	}): ComponentBoundaryRuntime {
-		const runtimeContext = this.ensureRuntimeContext(options);
-
-		const interceptBoundary = (input: QueuedBoundaryDecisionInput) => {
-			if (!options.shouldQueueBoundary(input)) {
-				return { kind: 'inline' as const };
-			}
-
-			runtimeContext.nextBoundaryId += 1;
-			const boundaryId = runtimeContext.nextBoundaryId;
-			const token = this.createBoundaryToken(options.tokenPrefix, runtimeContext, boundaryId);
-			runtimeContext.queuedResolutions.push({
-				token,
-				component: input.component,
-				props: { ...input.props },
-				componentInstanceId: runtimeContext.componentInstanceScope
-					? `${runtimeContext.componentInstanceScope}_n_${boundaryId}`
-					: `n_${boundaryId}`,
-			});
-
-			return {
-				kind: 'resolved' as const,
-				value: token,
-			};
-		};
-
-		return {
-			interceptBoundary,
-			interceptBoundarySync: interceptBoundary,
-		};
-	}
-
-	/**
-	 * 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.
-	 */
-	async resolveQueuedHtml<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<QueuedBoundaryChildRenderResult>;
-		resolveBoundary: (
-			input: ComponentRenderInput,
-			rendererCache: Map<string, unknown>,
-		) => Promise<BoundaryRenderPayload | undefined>;
-		applyAttributesToFirstElement: (html: string, attributes: Record<string, string>) => string;
-		dedupeProcessedAssets: (assets: ProcessedAsset[]) => ProcessedAsset[];
-	}): Promise<{ assets: ProcessedAsset[]; html: string }> {
-		if (!options.runtimeContext || options.runtimeContext.queuedResolutions.length === 0) {
-			return { assets: [], html: options.html };
-		}
-
-		const runtimeContext = options.runtimeContext;
-		const queuedResolutionsByToken = new Map(
-			runtimeContext.queuedResolutions.map((resolution) => [resolution.token, resolution]),
-		);
-		const resolvedHtmlByToken = new Map<string, string>();
-		const resolvingTokens = new Set<string>();
-		const collectedAssets: ProcessedAsset[] = [];
-
-		const resolveToken = async (token: string): Promise<string> => {
-			const cachedHtml = resolvedHtmlByToken.get(token);
-			if (cachedHtml) {
-				return cachedHtml;
-			}
-
-			const resolution = queuedResolutionsByToken.get(token);
-			if (!resolution) {
-				return token;
-			}
-
-			if (resolvingTokens.has(token)) {
-				throw new Error(
-					`[ecopages] ${options.queueLabel} boundary queue contains a cycle or unresolved dependency links.`,
-				);
-			}
-
-			resolvingTokens.add(token);
-
-			try {
-				const renderedChildren = await options.renderQueuedChildren(
-					resolution.props.children,
-					runtimeContext,
-					queuedResolutionsByToken,
-					resolveToken,
-				);
-
-				if (renderedChildren.assets.length > 0) {
-					collectedAssets.push(...renderedChildren.assets);
-				}
-
-				const boundaryRender = await options.resolveBoundary(
-					{
-						component: resolution.component,
-						props: { ...resolution.props },
-						children: renderedChildren.html,
-						integrationContext: {
-							rendererCache: runtimeContext.rendererCache,
-							componentInstanceId: resolution.componentInstanceId,
-						},
-					},
-					runtimeContext.rendererCache,
-				);
-
-				if (!boundaryRender) {
-					throw new Error(
-						`[ecopages] ${options.queueLabel} queued boundary could not resolve its owning renderer.`,
-					);
-				}
-
-				if ((boundaryRender.assets?.length ?? 0) > 0) {
-					collectedAssets.push(...(boundaryRender.assets ?? []));
-				}
-
-				const resolvedHtml =
-					boundaryRender.attachmentPolicy.kind === 'first-element' && boundaryRender.rootAttributes
-						? options.applyAttributesToFirstElement(boundaryRender.html, boundaryRender.rootAttributes)
-						: boundaryRender.html;
-
-				resolvedHtmlByToken.set(token, resolvedHtml);
-				return resolvedHtml;
-			} finally {
-				resolvingTokens.delete(token);
-			}
-		};
-
-		let resolvedHtml = options.html;
-
-		for (const resolution of runtimeContext.queuedResolutions) {
-			if (!resolvedHtml.includes(resolution.token)) {
-				continue;
-			}
-
-			resolvedHtml = resolvedHtml.split(resolution.token).join(await resolveToken(resolution.token));
-		}
-
-		return {
-			assets: options.dedupeProcessedAssets(collectedAssets),
-			html: resolvedHtml,
-		};
-	}
-
-	private createBoundaryToken(
-		tokenPrefix: string,
-		runtimeContext: QueuedBoundaryRuntimeContext,
-		boundaryId: number,
-	): string {
-		return `${tokenPrefix}${runtimeContext.componentInstanceScope ?? 'root'}__${boundaryId}__`;
-	}
-
-	private ensureRuntimeContext<TContext extends QueuedBoundaryRuntimeContext>(options: {
-		boundaryInput: ComponentRenderInput;
-		rendererCache: Map<string, unknown>;
-		runtimeContextKey: string;
-		createRuntimeContext?: (
-			integrationContext: QueuedBoundaryIntegrationContext,
-			rendererCache: Map<string, unknown>,
-		) => TContext;
-	}): TContext {
-		let integrationContext: QueuedBoundaryIntegrationContext;
-		if (
-			typeof options.boundaryInput.integrationContext === 'object' &&
-			options.boundaryInput.integrationContext !== null
-		) {
-			integrationContext = options.boundaryInput.integrationContext as QueuedBoundaryIntegrationContext;
-		} else {
-			integrationContext = {};
-		}
-
-		const existingRuntimeContext = integrationContext[options.runtimeContextKey];
-		if (typeof existingRuntimeContext !== 'object' || existingRuntimeContext === null) {
-			integrationContext[options.runtimeContextKey] =
-				options.createRuntimeContext?.(integrationContext, options.rendererCache) ??
-				({
-					rendererCache: options.rendererCache,
-					componentInstanceScope: integrationContext.componentInstanceId,
-					nextBoundaryId: 0,
-					queuedResolutions: [],
-				} satisfies QueuedBoundaryRuntimeContext);
-		} else {
-			(existingRuntimeContext as QueuedBoundaryRuntimeContext).rendererCache = options.rendererCache;
-		}
-
-		integrationContext.rendererCache = options.rendererCache;
-		options.boundaryInput.integrationContext = integrationContext;
-
-		return integrationContext[options.runtimeContextKey] as TContext;
-	}
-}

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

@@ -1,196 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { getComponentRenderContext } from './component-render-context.ts';
-import type {
-	EcoComponent,
-	IntegrationRendererRenderOptions,
-	RouteRendererBody,
-	RouteRendererOptions,
-} from '../../types/public-types.ts';
-import { RenderExecutionService } from './render-execution.service.ts';
-
-describe('RenderExecutionService', () => {
-	it('captures streamed render bodies before final HTML handling', async () => {
-		const service = new RenderExecutionService();
-		const encoder = new TextEncoder();
-
-		const result = await service.captureHtmlRender(
-			async () =>
-				new ReadableStream({
-					start(controller) {
-						controller.enqueue(encoder.encode('<html><body><main>Streamed</main></body></html>'));
-						controller.close();
-					},
-				}) as unknown as BodyInit,
-		);
-
-		expect(result.body).toBeInstanceOf(ReadableStream);
-		expect(result.html).toContain('<main>Streamed</main>');
-	});
-
-	it('preserves streamed bodies when no boundary resolution or attribute stamping is required', async () => {
-		const service = new RenderExecutionService();
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<Record<string, unknown>>;
-		const Page = (() => '<main>Page</main>') as EcoComponent<Record<string, unknown>>;
-		const encoder = new TextEncoder();
-
-		const result = await service.execute(
-			{
-				file: '/app/pages/index.tsx',
-				params: {},
-				query: {},
-			} as unknown as RouteRendererOptions,
-			{
-				prepareRenderOptions: async () =>
-					({
-						HtmlTemplate,
-						Page,
-						cacheStrategy: { revalidate: 60 },
-					}) as unknown as IntegrationRendererRenderOptions<unknown>,
-				render: async () =>
-					new ReadableStream({
-						start(controller) {
-							controller.enqueue(encoder.encode('<html><body><main>Streamed</main></body></html>'));
-							controller.close();
-						},
-					}) as unknown as BodyInit,
-				getDocumentAttributes: () => undefined,
-				applyAttributesToHtmlElement: (html) => html,
-				applyAttributesToFirstBodyElement: (html) => html,
-				transformResponse: async (response) => response.body as RouteRendererBody,
-			},
-		);
-
-		expect(result.cacheStrategy).toEqual({ revalidate: 60 });
-		expect(result.body).toBeInstanceOf(ReadableStream);
-		expect(await new Response(result.body as BodyInit).text()).toContain('<main>Streamed</main>');
-	});
-
-	it('applies root and document attributes to fully resolved route HTML', async () => {
-		const service = new RenderExecutionService();
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<Record<string, unknown>>;
-		const Page = (() => '<main>Page</main>') as EcoComponent<Record<string, unknown>>;
-
-		const result = await service.execute(
-			{
-				file: '/app/pages/index.tsx',
-				params: {},
-				query: {},
-			} as unknown as RouteRendererOptions,
-			{
-				prepareRenderOptions: async () =>
-					({
-						HtmlTemplate,
-						Page,
-						cacheStrategy: { revalidate: 60 },
-						componentRender: {
-							canAttachAttributes: true,
-							rootAttributes: { 'data-eco-component-id': 'eco-page-root' },
-						},
-					}) as unknown as IntegrationRendererRenderOptions<unknown>,
-				render: async () => '<html><body><main>Resolved</main></body></html>',
-				getDocumentAttributes: () => ({ 'data-eco-document-owner': 'react-router' }),
-				applyAttributesToHtmlElement: (html, attributes) =>
-					html.replace('<html', `<html data-eco-document-owner="${attributes['data-eco-document-owner']}"`),
-				applyAttributesToFirstBodyElement: (html, attributes) =>
-					html.replace('<main', `<main data-eco-component-id="${attributes['data-eco-component-id']}"`),
-				transformResponse: async (response) => await response.text(),
-			},
-		);
-
-		expect(result.cacheStrategy).toEqual({ revalidate: 60 });
-		expect(result.body).toContain('<html data-eco-document-owner="react-router"><body>');
-		expect(result.body).toContain('<main data-eco-component-id="eco-page-root">Resolved</main>');
-	});
-
-	it('throws when route HTML contains escaped unresolved boundary artifacts', async () => {
-		const service = new RenderExecutionService();
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<Record<string, unknown>>;
-		const Page = (() => '<main>Page</main>') as EcoComponent<Record<string, unknown>>;
-
-		await expect(
-			service.execute(
-				{
-					file: '/app/pages/index.tsx',
-					params: {},
-					query: {},
-				} as unknown as RouteRendererOptions,
-				{
-					prepareRenderOptions: async () =>
-						({
-							HtmlTemplate,
-							Page,
-							cacheStrategy: 'dynamic',
-						}) as unknown as IntegrationRendererRenderOptions<unknown>,
-					render: async () =>
-						'<html><body>&amp;lt;eco-marker data-eco-node-id=&quot;n_2&quot; data-eco-component-ref=&quot;page-component&quot; data-eco-props-ref=&quot;p_2&quot;&amp;gt;&amp;lt;/eco-marker&amp;gt;</body></html>',
-					getDocumentAttributes: () => undefined,
-					applyAttributesToHtmlElement: (html) => html,
-					applyAttributesToFirstBodyElement: (html) => html,
-					transformResponse: async (response) => await response.text(),
-				},
-			),
-		).rejects.toThrow('Full-route unresolved-boundary fallback has been removed');
-	});
-
-	it('renders routes with no active component render context', async () => {
-		const service = new RenderExecutionService();
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<Record<string, unknown>>;
-		const Page = (() => '<main>Page</main>') as EcoComponent<Record<string, unknown>>;
-
-		const result = await service.execute(
-			{
-				file: '/app/pages/index.tsx',
-				params: {},
-				query: {},
-			} as unknown as RouteRendererOptions,
-			{
-				prepareRenderOptions: async () =>
-					({
-						HtmlTemplate,
-						Page,
-						cacheStrategy: 'dynamic',
-					}) as unknown as IntegrationRendererRenderOptions<unknown>,
-				render: async () => {
-					expect(getComponentRenderContext()).toBeUndefined();
-					return '<html><body><main>Plain render</main></body></html>';
-				},
-				getDocumentAttributes: () => undefined,
-				applyAttributesToHtmlElement: (html) => html,
-				applyAttributesToFirstBodyElement: (html) => html,
-				transformResponse: async (response) => await response.text(),
-			},
-		);
-
-		expect(result.body).toContain('<main>Plain render</main>');
-	});
-
-	it('throws when route HTML returns unresolved boundary artifact HTML', async () => {
-		const service = new RenderExecutionService();
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<Record<string, unknown>>;
-		const Page = (() => '<main>Page</main>') as EcoComponent<Record<string, unknown>>;
-
-		await expect(
-			service.execute(
-				{
-					file: '/app/pages/index.tsx',
-					params: {},
-					query: {},
-				} as unknown as RouteRendererOptions,
-				{
-					prepareRenderOptions: async () =>
-						({
-							HtmlTemplate,
-							Page,
-							cacheStrategy: 'dynamic',
-						}) as unknown as IntegrationRendererRenderOptions<unknown>,
-					render: async () =>
-						'<html><body><eco-marker data-eco-node-id="n_1" data-eco-component-ref="unexpected-marker" data-eco-props-ref="p_1"></eco-marker></body></html>',
-					getDocumentAttributes: () => undefined,
-					applyAttributesToHtmlElement: (html) => html,
-					applyAttributesToFirstBodyElement: (html) => html,
-					transformResponse: async (response) => await response.text(),
-				},
-			),
-		).rejects.toThrow('Full-route unresolved-boundary fallback has been removed');
-	});
-});

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

@@ -1,182 +0,0 @@
-import { inspectBoundaryArtifactHtml } from './render-output.utils.ts';
-import type {
-	IntegrationRendererRenderOptions,
-	RouteRendererBody,
-	RouteRendererOptions,
-	RouteRenderResult,
-} from '../../types/public-types.ts';
-
-export interface CapturedHtmlRenderResult {
-	body: RouteRendererBody;
-	html: string;
-}
-
-export interface FinalizeHtmlRenderOptions {
-	html: string;
-	componentRootAttributes?: Record<string, string>;
-	documentAttributes?: Record<string, string>;
-}
-
-export interface RenderExecutionCallbacks<C> {
-	prepareRenderOptions(options: RouteRendererOptions): Promise<IntegrationRendererRenderOptions<C>>;
-	render(renderOptions: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody>;
-	getDocumentAttributes(renderOptions: IntegrationRendererRenderOptions<C>): Record<string, string> | undefined;
-	applyAttributesToHtmlElement(html: string, attributes: Record<string, string>): string;
-	applyAttributesToFirstBodyElement(html: string, attributes: Record<string, string>): string;
-	transformResponse(response: Response): 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: one render pass, unresolved boundary-marker
- * enforcement, root-attribute application, and final HTML transformation into
- * a response body stream.
- */
-export class RenderExecutionService {
-	async captureHtmlRender(render: () => Promise<RouteRendererBody>): Promise<CapturedHtmlRenderResult> {
-		const renderedBody = await render();
-		const capturedRender = await this.captureRenderedBody(renderedBody);
-
-		return {
-			body: capturedRender.body,
-			html: capturedRender.html,
-		};
-	}
-
-	/**
-	 * Executes 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,
-		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 this.captureHtmlRender(async () => callbacks.render(renderOptions));
-		const boundaryArtifacts = inspectBoundaryArtifactHtml(renderExecution.html);
-		const documentAttributes = callbacks.getDocumentAttributes(renderOptions);
-		const hasBoundaryMarkerHtml = boundaryArtifacts.hasUnresolvedBoundaryArtifacts;
-
-		if (hasBoundaryMarkerHtml) {
-			throw new Error(
-				'[ecopages] Route render returned unresolved boundary artifact HTML. Full-route unresolved-boundary fallback has been removed; resolve mixed boundaries inside renderComponentBoundary().',
-			);
-		}
-
-		const canReuseCapturedBody =
-			!hasBoundaryMarkerHtml &&
-			!shouldApplyComponentRootAttributes &&
-			!(documentAttributes && Object.keys(documentAttributes).length > 0);
-
-		if (canReuseCapturedBody) {
-			const body = await callbacks.transformResponse(
-				new Response(renderExecution.body as BodyInit, {
-					headers: {
-						'Content-Type': 'text/html',
-					},
-				}),
-			);
-
-			return {
-				body,
-				cacheStrategy: renderOptions.cacheStrategy,
-			};
-		}
-
-		const finalization = await this.finalizeHtmlRender(
-			{
-				html: boundaryArtifacts.normalizedHtml,
-				componentRootAttributes: shouldApplyComponentRootAttributes
-					? (renderOptions.componentRender?.rootAttributes as Record<string, string>)
-					: undefined,
-				documentAttributes,
-			},
-			{
-				applyAttributesToHtmlElement: callbacks.applyAttributesToHtmlElement,
-				applyAttributesToFirstBodyElement: callbacks.applyAttributesToFirstBodyElement,
-			},
-		);
-
-		const body = await callbacks.transformResponse(
-			new Response(finalization, {
-				headers: {
-					'Content-Type': 'text/html',
-				},
-			}),
-		);
-
-		return {
-			body,
-			cacheStrategy: renderOptions.cacheStrategy,
-		};
-	}
-
-	private async captureRenderedBody(body: RouteRendererBody): Promise<{ body: RouteRendererBody; html: string }> {
-		const response = new Response(body as BodyInit);
-
-		if (typeof body === 'string') {
-			return {
-				body,
-				html: await response.text(),
-			};
-		}
-
-		if (!response.body) {
-			return {
-				body,
-				html: await response.text(),
-			};
-		}
-
-		const [capturedBody, replayBody] = response.body.tee();
-
-		return {
-			body: replayBody,
-			html: await new Response(capturedBody).text(),
-		};
-	}
-
-	async finalizeHtmlRender(
-		options: FinalizeHtmlRenderOptions,
-		callbacks: Pick<
-			RenderExecutionCallbacks<unknown>,
-			'applyAttributesToHtmlElement' | 'applyAttributesToFirstBodyElement'
-		>,
-	): Promise<string> {
-		return this.applyFinalHtmlAttributes(options.html, options, callbacks);
-	}
-
-	private applyFinalHtmlAttributes(
-		html: string,
-		options: FinalizeHtmlRenderOptions,
-		callbacks: Pick<
-			RenderExecutionCallbacks<unknown>,
-			'applyAttributesToHtmlElement' | 'applyAttributesToFirstBodyElement'
-		>,
-	): string {
-		let renderedHtml = html;
-
-		if (options.componentRootAttributes && Object.keys(options.componentRootAttributes).length > 0) {
-			renderedHtml = callbacks.applyAttributesToFirstBodyElement(renderedHtml, options.componentRootAttributes);
-		}
-
-		if (options.documentAttributes && Object.keys(options.documentAttributes).length > 0) {
-			renderedHtml = callbacks.applyAttributesToHtmlElement(renderedHtml, options.documentAttributes);
-		}
-
-		return renderedHtml;
-	}
-}