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

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

@@ -0,0 +1,289 @@
+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

@@ -0,0 +1,196 @@
+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

@@ -0,0 +1,182 @@
+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;
+	}
+}