@ecopages/core 0.2.0-alpha.54 → 0.2.0-alpha.55

package/src/route-renderer/orchestration/route-render-orchestrator.prepare-render-options.test.ts

@@ -1,1365 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { fileSystem } from '@ecopages/file-system';
-import { eco } from '../../eco/eco.ts';
-import type { EcoPagesAppConfig } from '../../types/internal-types.ts';
-import type {
-	OwnershipPlan,
-	EcoComponent,
-	EcoPageComponent,
-	HtmlTemplateProps,
-	PageBrowserGraphContribution,
-	PageMetadataProps,
-	RouteRendererOptions,
-} from '../../types/public-types.ts';
-import { LocalsAccessError } from '../../errors/locals-access-error.ts';
-import { OwnershipPlanningService } from './ownership-planning.service.ts';
-import type {
-	AssetDefinition,
-	AssetProcessingService,
-	ProcessedAsset,
-} from '../../services/assets/asset-processing-service/index.ts';
-import type { GroupedScriptBundle } from '../../services/assets/asset-processing-service/assets.types.ts';
-import { OwnershipValidationService } from './ownership-validation.service.ts';
-import { type RouteRenderOrchestratorAdapter, RouteRenderOrchestrator } from './route-render-orchestrator.ts';
-
-declare module '../../types/public-types.ts' {
-	interface RequestLocals {
-		user?: string;
-		guarded?: boolean;
-	}
-}
-
-function createFlowAdapter<C>(input: {
-	resolvePageModule: (file: string) => Promise<{
-		Page: EcoPageComponent<any> | EcoComponent;
-		getStaticProps?: unknown;
-		getMetadata?: unknown;
-		integrationSpecificProps: Record<string, unknown>;
-	}>;
-	getHtmlTemplate: () => Promise<EcoComponent<HtmlTemplateProps>>;
-	resolvePageData: (
-		pageModule: {
-			getStaticProps?: unknown;
-			getMetadata?: unknown;
-		},
-		routeOptions: RouteRendererOptions,
-	) => Promise<{ props: Record<string, unknown>; metadata: PageMetadataProps }>;
-	resolveDependencies: (components: (EcoComponent | Partial<EcoComponent>)[]) => Promise<ProcessedAsset[]>;
-	collectPageBrowserGraphContribution: (routeFile: string) => Promise<PageBrowserGraphContribution | undefined>;
-	shouldRenderPageComponent: (input: {
-		Page: EcoComponent;
-		Layout?: EcoComponent;
-		options: RouteRendererOptions;
-	}) => boolean;
-	renderPageComponent: (input: {
-		Page: EcoComponent;
-		Layout?: EcoComponent;
-		props: Record<string, unknown>;
-		routeOptions: RouteRendererOptions;
-	}) => Promise<any>;
-}): RouteRenderOrchestratorAdapter<C> {
-	return {
-		name: 'ghtml',
-		resolveRouteRenderInputs: async (routeOptions) => {
-			const pageModule = await input.resolvePageModule(routeOptions.file);
-			const HtmlTemplate = await input.getHtmlTemplate();
-			const Layout = pageModule.Page.config?.layout;
-			const { props, metadata } = await input.resolvePageData(pageModule, routeOptions);
-
-			return {
-				Page: pageModule.Page,
-				HtmlTemplate,
-				Layout,
-				props,
-				metadata,
-				integrationSpecificProps: pageModule.integrationSpecificProps,
-				shouldRenderPageComponent: input.shouldRenderPageComponent({
-					Page: pageModule.Page as EcoComponent,
-					Layout,
-					options: routeOptions,
-				}),
-			};
-		},
-		resolveRouteDependencies: async ({ components }) => ({
-			resolvedDependencies: await input.resolveDependencies(components),
-		}),
-		collectPageBrowserGraphContribution: async (routeFile) =>
-			await input.collectPageBrowserGraphContribution(routeFile),
-		resolveRoutePageComponentRender: async (renderInput) => {
-			if (
-				!input.shouldRenderPageComponent({
-					Page: renderInput.Page,
-					Layout: renderInput.Layout,
-					options: renderInput.routeOptions,
-				})
-			) {
-				return undefined;
-			}
-
-			return await input.renderPageComponent(renderInput);
-		},
-		renderRouteBody: async () => '',
-		getRouteHtmlFinalization: () => ({}),
-		transformRouteResponse: async (response) => await response.text(),
-	};
-}
-
-function createProcessedGroupedScriptAsset(groupedBundle: GroupedScriptBundle, srcUrl: string): ProcessedAsset {
-	return {
-		kind: 'script',
-		srcUrl,
-		position: 'head',
-		packageRole: 'page-script',
-		groupedBundle,
-	};
-}
-
-function isGroupedContentScriptDependency(asset: AssetDefinition): asset is Extract<
-	AssetDefinition,
-	{ kind: 'script'; source: 'content' }
-> & {
-	groupedBundle: GroupedScriptBundle;
-} {
-	return asset.kind === 'script' && asset.source === 'content' && Boolean(asset.groupedBundle);
-}
-
-function createGroupedPageScriptDependency(
-	content: string,
-	name: string,
-	groupedBundle: GroupedScriptBundle,
-): Extract<AssetDefinition, { kind: 'script'; source: 'content' }> {
-	return {
-		kind: 'script',
-		source: 'content',
-		content,
-		name,
-		packageRole: 'page-script',
-		groupedBundle,
-	};
-}
-
-describe('RouteRenderOrchestrator prepareRenderOptions', () => {
-	it('should prepare dynamic render options and merge renderer-owned assets', async () => {
-		const integrationDependency = {
-			kind: 'script',
-			srcUrl: '/assets/react-runtime.js',
-			position: 'head',
-		} as ProcessedAsset;
-		const componentAsset = {
-			kind: 'script',
-			srcUrl: '/assets/page-root.js',
-			position: 'head',
-		} as ProcessedAsset;
-		const resolvedDependency = {
-			kind: 'stylesheet',
-			srcUrl: '/assets/page.css',
-			position: 'head',
-		} as ProcessedAsset;
-		const pageDependency = {
-			kind: 'script',
-			srcUrl: '/assets/page-entry.js',
-			position: 'head',
-		} as ProcessedAsset;
-		const assetProcessingService = {
-			processDependencies: vi.fn(async () => []),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [
-				{
-					name: 'react',
-					initializeRenderer: vi.fn(),
-					getResolvedIntegrationDependencies: () => [integrationDependency],
-				},
-			],
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Nested = (() => '<aside>Nested</aside>') as EcoComponent<Record<string, unknown>>;
-		Nested.config = {
-			integration: 'react',
-			__eco: { id: 'nested', file: '/app/components/nested.tsx', integration: 'react' },
-		};
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		Page.cache = 'dynamic';
-		Page.config = {
-			dependencies: {
-				components: [Nested],
-			},
-		};
-		const routeOptions = {
-			file: '/app/pages/index.tsx',
-			params: { slug: 'hello' },
-			query: { preview: '1' },
-			locals: { user: 'andee' },
-		} as unknown as RouteRendererOptions;
-		const result = await flow.prepareRenderOptions(
-			routeOptions,
-			createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: { layoutMode: 'full' },
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: { title: 'Hello' },
-					metadata: { title: 'Hello', description: 'Hello description' },
-				}),
-				resolveDependencies: async () => [resolvedDependency],
-				collectPageBrowserGraphContribution: async () => ({ assets: [pageDependency] }),
-				shouldRenderPageComponent: () => true,
-				renderPageComponent: async () => ({
-					html: '<main>Page</main>',
-					canAttachAttributes: true,
-					rootTag: 'main',
-					integrationName: 'ghtml',
-					assets: [componentAsset],
-				}),
-			}),
-		);
-
-		expect(result.locals).toEqual({ user: 'andee' });
-		expect(result.pageLocals).toEqual({ user: 'andee' });
-		expect(result.pageProps).toEqual({ title: 'Hello', params: { slug: 'hello' }, query: { preview: '1' } });
-		expect((result as typeof result & { layoutMode?: string }).layoutMode).toBe('full');
-		expect(result.componentRender?.assets).toEqual([componentAsset]);
-		expect(result.pagePackage).toEqual(
-			expect.objectContaining({
-				assets: expect.arrayContaining([
-					resolvedDependency,
-					integrationDependency,
-					pageDependency,
-					componentAsset,
-				]),
-				pageBrowserGraph: {
-					entryAssets: [pageDependency],
-					chunkAssets: [],
-				},
-			}),
-		);
-	});
-
-	it('renders page-root output directly during preparation', async () => {
-		const assetProcessingService = {
-			processDependencies: vi.fn(async () => []),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [],
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const DeferredChild = eco.component<{}, string>({
-			integration: 'react',
-			render: () => '<span>Deferred</span>',
-		});
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-
-		const result = await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Page', description: 'Page description' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution: async () => ({ assets: [] }),
-				shouldRenderPageComponent: () => true,
-				renderPageComponent: async () => ({
-					html: DeferredChild({}),
-					canAttachAttributes: true,
-					rootTag: 'span',
-					integrationName: 'ghtml',
-				}),
-			}),
-		);
-
-		expect(result.componentRender).toEqual(
-			expect.objectContaining({
-				canAttachAttributes: true,
-				rootTag: 'span',
-				integrationName: 'ghtml',
-			}),
-		);
-		expect(result.componentRender?.html).toBe('<span>Deferred</span>');
-	});
-
-	it('inlines the global injector bootstrap when resolved lazy triggers are present', async () => {
-		const processDependencies = vi.fn<AssetProcessingService['processDependencies']>().mockImplementation(
-			async (dependencies) =>
-				dependencies.map((dependency) => ({
-					kind: dependency.kind,
-					position: dependency.position,
-					attributes: dependency.attributes,
-					content: dependency.source === 'content' ? dependency.content : undefined,
-					inline: dependency.inline,
-					packageRole: dependency.packageRole,
-				})) as ProcessedAsset[],
-		);
-		const assetProcessingService = {
-			processDependencies,
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [],
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		Page.config = {
-			_resolvedLazyTriggers: [
-				{
-					triggerId: 'eco-trigger-theme-toggle',
-					rules: [{ 'on:interaction': { value: 'click', scripts: ['/assets/lazy-theme-toggle.js'] } }],
-				},
-			],
-		};
-
-		await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Page', description: 'Page description' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution: async () => ({ assets: [] }),
-				shouldRenderPageComponent: () => false,
-				renderPageComponent: vi.fn(),
-			}),
-		);
-
-		expect(processDependencies).toHaveBeenCalledOnce();
-		expect(processDependencies).toHaveBeenCalledWith(
-			expect.arrayContaining([
-				expect.objectContaining({
-					name: 'ecopages-global-injector-bootstrap',
-					inline: true,
-					bundle: true,
-					attributes: { type: 'module' },
-				}),
-			]),
-			'ghtml',
-		);
-	});
-
-	it('caches page browser graph resolution across repeated route preparation when HMR is disabled', async () => {
-		const pageBrowserAsset = {
-			kind: 'script',
-			srcUrl: '/assets/page.js',
-			position: 'head',
-		} as ProcessedAsset;
-		const collectPageBrowserGraphContribution = vi.fn(
-			async (): Promise<PageBrowserGraphContribution> => ({
-				dependencies: [
-					{
-						kind: 'script',
-						source: 'content',
-						content: 'console.log("page")',
-						name: 'page',
-						attributes: { type: 'module' },
-					},
-				],
-			}),
-		);
-		const processDependencies = vi.fn(async () => [pageBrowserAsset]);
-		const assetProcessingService = {
-			processDependencies,
-			getHmrManager: vi.fn(() => ({ isEnabled: () => false })),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [],
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-
-		const adapter = createFlowAdapter({
-			resolvePageModule: async () => ({
-				Page,
-				integrationSpecificProps: {},
-			}),
-			getHtmlTemplate: async () => HtmlTemplate,
-			resolvePageData: async () => ({
-				props: {},
-				metadata: { title: 'Page', description: 'Page description' },
-			}),
-			resolveDependencies: async () => [],
-			collectPageBrowserGraphContribution,
-			shouldRenderPageComponent: () => false,
-			renderPageComponent: vi.fn(),
-		});
-
-		await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			adapter,
-		);
-		await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			adapter,
-		);
-
-		expect(collectPageBrowserGraphContribution).toHaveBeenCalledOnce();
-		expect(processDependencies).toHaveBeenCalledOnce();
-	});
-
-	it('bypasses the page browser graph cache when HMR is enabled', async () => {
-		const pageBrowserAsset = {
-			kind: 'script',
-			srcUrl: '/assets/page.js',
-			position: 'head',
-		} as ProcessedAsset;
-		const collectPageBrowserGraphContribution = vi.fn(
-			async (): Promise<PageBrowserGraphContribution> => ({
-				dependencies: [
-					{
-						kind: 'script',
-						source: 'content',
-						content: 'console.log("page")',
-						name: 'page',
-						attributes: { type: 'module' },
-					},
-				],
-			}),
-		);
-		const processDependencies = vi.fn(async () => [pageBrowserAsset]);
-		const assetProcessingService = {
-			processDependencies,
-			getHmrManager: vi.fn(() => ({ isEnabled: () => true })),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [],
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-
-		const adapter = createFlowAdapter({
-			resolvePageModule: async () => ({
-				Page,
-				integrationSpecificProps: {},
-			}),
-			getHtmlTemplate: async () => HtmlTemplate,
-			resolvePageData: async () => ({
-				props: {},
-				metadata: { title: 'Page', description: 'Page description' },
-			}),
-			resolveDependencies: async () => [],
-			collectPageBrowserGraphContribution,
-			shouldRenderPageComponent: () => false,
-			renderPageComponent: vi.fn(),
-		});
-
-		await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			adapter,
-		);
-		await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			adapter,
-		);
-
-		expect(collectPageBrowserGraphContribution).toHaveBeenCalledTimes(2);
-		expect(processDependencies).toHaveBeenCalledTimes(2);
-	});
-
-	it('threads the structured page browser graph through the returned page package', async () => {
-		const entryAsset = {
-			kind: 'script',
-			srcUrl: '/assets/page.js',
-			position: 'head',
-			packageRole: 'page-script',
-		} as ProcessedAsset;
-		const chunkAsset = {
-			kind: 'script',
-			srcUrl: '/assets/page.chunk.js',
-			position: 'body',
-			packageRole: 'dynamic-chunk',
-		} as ProcessedAsset;
-		const processDependencies = vi.fn(async () => [entryAsset]);
-		const assetProcessingService = {
-			processDependencies,
-			getHmrManager: vi.fn(() => ({ isEnabled: () => false })),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [],
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-
-		const result = await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Page', description: 'Page description' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution: async () => ({
-					dependencies: [
-						{
-							kind: 'script',
-							source: 'content',
-							content: 'console.log("page")',
-							name: 'page',
-							attributes: { type: 'module' },
-						},
-					],
-					assets: [chunkAsset],
-				}),
-				shouldRenderPageComponent: () => false,
-				renderPageComponent: vi.fn(),
-			}),
-		);
-
-		expect(result.pagePackage).toEqual(
-			expect.objectContaining({
-				pageBrowserGraph: {
-					entryAssets: [entryAsset],
-					chunkAssets: [chunkAsset],
-				},
-				dynamicChunks: [chunkAsset],
-				assets: [entryAsset, chunkAsset],
-			}),
-		);
-	});
-
-	it('reuses one grouped page-browser build across sibling routes for the same integration', async () => {
-		vi.spyOn(fileSystem, 'glob').mockResolvedValue(['index.tsx', 'dashboard.tsx']);
-		const processDependencies = vi.fn(async (dependencies: AssetDefinition[], key: string) => {
-			if (key === 'react:grouped-page-browser-graph') {
-				return dependencies
-					.filter(isGroupedContentScriptDependency)
-					.map((dependency, index) =>
-						createProcessedGroupedScriptAsset(
-							dependency.groupedBundle,
-							`/assets/grouped-${dependency.groupedBundle.entryName}-${index}.js`,
-						),
-					);
-			}
-
-			return [];
-		});
-		const assetProcessingService = {
-			processDependencies,
-			getHmrManager: vi.fn(() => ({ isEnabled: () => false })),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [
-				{
-					name: 'react',
-					extensions: ['.tsx'],
-					initializeRenderer: vi.fn(),
-					getResolvedIntegrationDependencies: () => [],
-				},
-			],
-			absolutePaths: {
-				pagesDir: '/app/pages',
-			},
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		const groupedDependencyByRoute = new Map<
-			string,
-			Extract<AssetDefinition, { kind: 'script'; source: 'content' }>
-		>([
-			[
-				'/app/pages/index.tsx',
-				createGroupedPageScriptDependency('console.log("index")', 'index-entry', {
-					id: 'react-router-pages',
-					entryName: 'index',
-				}),
-			],
-			[
-				'/app/pages/dashboard.tsx',
-				createGroupedPageScriptDependency('console.log("dashboard")', 'dashboard-entry', {
-					id: 'react-router-pages',
-					entryName: 'dashboard',
-				}),
-			],
-		]);
-		const collectPageBrowserGraphContribution = vi.fn(
-			async (routeFile: string): Promise<PageBrowserGraphContribution> => ({
-				dependencies: [groupedDependencyByRoute.get(routeFile)!],
-			}),
-		);
-		const createReactFlowAdapter = () => ({
-			...createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Page', description: 'Page description' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution,
-				shouldRenderPageComponent: () => false,
-				renderPageComponent: vi.fn(),
-			}),
-			name: 'react' as const,
-		});
-
-		const firstResult = await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createReactFlowAdapter(),
-		);
-
-		const secondResult = await flow.prepareRenderOptions(
-			{ file: '/app/pages/dashboard.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createReactFlowAdapter(),
-		);
-
-		expect(processDependencies).toHaveBeenCalledTimes(1);
-		expect(processDependencies.mock.calls[0]?.[1]).toBe('react:grouped-page-browser-graph');
-		expect(collectPageBrowserGraphContribution).toHaveBeenCalledWith('/app/pages/dashboard.tsx');
-		expect(firstResult.pagePackage?.pageBrowserGraph?.entryAssets).toEqual([
-			expect.objectContaining({ groupedBundle: { id: 'react-router-pages', entryName: 'index' } }),
-		]);
-		expect(secondResult.pagePackage?.pageBrowserGraph?.entryAssets).toEqual([
-			expect.objectContaining({ groupedBundle: { id: 'react-router-pages', entryName: 'dashboard' } }),
-		]);
-	});
-
-	it('keeps rendering the current route when a sibling grouped contribution fails', async () => {
-		vi.spyOn(fileSystem, 'glob').mockResolvedValue(['index.tsx', 'broken.tsx']);
-		const processDependencies = vi.fn(async (dependencies: AssetDefinition[], key: string) => {
-			if (key === 'react:grouped-page-browser-graph') {
-				return dependencies
-					.filter(isGroupedContentScriptDependency)
-					.map((dependency) =>
-						createProcessedGroupedScriptAsset(
-							dependency.groupedBundle,
-							`/assets/${dependency.groupedBundle.entryName}.js`,
-						),
-					);
-			}
-
-			return [];
-		});
-		const assetProcessingService = {
-			processDependencies,
-			getHmrManager: vi.fn(() => ({ isEnabled: () => false })),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [
-				{
-					name: 'react',
-					extensions: ['.tsx'],
-					initializeRenderer: vi.fn(),
-					getResolvedIntegrationDependencies: () => [],
-				},
-			],
-			absolutePaths: {
-				pagesDir: '/app/pages',
-			},
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		const collectPageBrowserGraphContribution = vi.fn(
-			async (routeFile: string): Promise<PageBrowserGraphContribution> => {
-				if (routeFile === '/app/pages/broken.tsx') {
-					throw new Error('broken sibling');
-				}
-
-				return {
-					dependencies: [
-						createGroupedPageScriptDependency('console.log("index")', 'index-entry', {
-							id: 'react-router-pages',
-							entryName: 'index',
-						}),
-					],
-				};
-			},
-		);
-		const createReactFlowAdapter = () => ({
-			...createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Page', description: 'Page description' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution,
-				shouldRenderPageComponent: () => false,
-				renderPageComponent: vi.fn(),
-			}),
-			name: 'react' as const,
-		});
-
-		const result = await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createReactFlowAdapter(),
-		);
-
-		expect(result.pagePackage?.pageBrowserGraph?.entryAssets).toEqual([
-			expect.objectContaining({
-				srcUrl: '/assets/index.js',
-				groupedBundle: { id: 'react-router-pages', entryName: 'index' },
-			}),
-		]);
-		expect(processDependencies).toHaveBeenCalledTimes(1);
-		expect(collectPageBrowserGraphContribution).toHaveBeenCalledWith('/app/pages/index.tsx');
-		expect(collectPageBrowserGraphContribution).toHaveBeenCalledWith('/app/pages/broken.tsx');
-	});
-
-	it('does not cache grouped page-browser assets when a sibling contribution fails', async () => {
-		vi.spyOn(fileSystem, 'glob').mockResolvedValue(['index.tsx', 'dashboard.tsx', 'broken.tsx']);
-		const processDependencies = vi.fn(async (dependencies: AssetDefinition[], key: string) => {
-			if (key === 'react:grouped-page-browser-graph') {
-				return dependencies
-					.filter(isGroupedContentScriptDependency)
-					.map((dependency) =>
-						createProcessedGroupedScriptAsset(
-							dependency.groupedBundle,
-							`/assets/${dependency.groupedBundle.entryName}.js`,
-						),
-					);
-			}
-
-			return [];
-		});
-		const assetProcessingService = {
-			processDependencies,
-			getHmrManager: vi.fn(() => ({ isEnabled: () => false })),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [
-				{
-					name: 'react',
-					extensions: ['.tsx'],
-					initializeRenderer: vi.fn(),
-					getResolvedIntegrationDependencies: () => [],
-				},
-			],
-			absolutePaths: {
-				pagesDir: '/app/pages',
-			},
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		const groupedDependencyByRoute = new Map<
-			string,
-			Extract<AssetDefinition, { kind: 'script'; source: 'content' }>
-		>([
-			[
-				'/app/pages/index.tsx',
-				createGroupedPageScriptDependency('console.log("index")', 'index-entry', {
-					id: 'react-router-pages',
-					entryName: 'index',
-				}),
-			],
-			[
-				'/app/pages/dashboard.tsx',
-				createGroupedPageScriptDependency('console.log("dashboard")', 'dashboard-entry', {
-					id: 'react-router-pages',
-					entryName: 'dashboard',
-				}),
-			],
-		]);
-		const collectPageBrowserGraphContribution = vi.fn(
-			async (routeFile: string): Promise<PageBrowserGraphContribution> => {
-				if (routeFile === '/app/pages/broken.tsx') {
-					throw new Error('broken sibling');
-				}
-
-				return {
-					dependencies: [groupedDependencyByRoute.get(routeFile)!],
-				};
-			},
-		);
-		const createReactFlowAdapter = () => ({
-			...createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Page', description: 'Page description' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution,
-				shouldRenderPageComponent: () => false,
-				renderPageComponent: vi.fn(),
-			}),
-			name: 'react' as const,
-		});
-
-		await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createReactFlowAdapter(),
-		);
-
-		await flow.prepareRenderOptions(
-			{ file: '/app/pages/dashboard.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createReactFlowAdapter(),
-		);
-
-		expect(processDependencies).toHaveBeenCalledTimes(2);
-	});
-
-	it('keeps grouped page-browser assets scoped by bundle id when routes reuse the same entry name', async () => {
-		vi.spyOn(fileSystem, 'glob').mockResolvedValue(['marketing.tsx', 'docs.tsx']);
-		const processDependencies = vi.fn(async (dependencies: AssetDefinition[], key: string) => {
-			if (key === 'react:grouped-page-browser-graph') {
-				return dependencies
-					.filter(isGroupedContentScriptDependency)
-					.map((dependency) =>
-						createProcessedGroupedScriptAsset(
-							dependency.groupedBundle,
-							`/assets/${dependency.groupedBundle.id}-${dependency.groupedBundle.entryName}.js`,
-						),
-					);
-			}
-
-			return [];
-		});
-		const assetProcessingService = {
-			processDependencies,
-			getHmrManager: vi.fn(() => ({ isEnabled: () => false })),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [
-				{
-					name: 'react',
-					extensions: ['.tsx'],
-					initializeRenderer: vi.fn(),
-					getResolvedIntegrationDependencies: () => [],
-				},
-			],
-			absolutePaths: {
-				pagesDir: '/app/pages',
-			},
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		const groupedDependencyByRoute = new Map<
-			string,
-			Extract<AssetDefinition, { kind: 'script'; source: 'content' }>
-		>([
-			[
-				'/app/pages/marketing.tsx',
-				createGroupedPageScriptDependency('console.log("marketing")', 'marketing-entry', {
-					id: 'marketing-layout',
-					entryName: 'index',
-				}),
-			],
-			[
-				'/app/pages/docs.tsx',
-				createGroupedPageScriptDependency('console.log("docs")', 'docs-entry', {
-					id: 'docs-layout',
-					entryName: 'index',
-				}),
-			],
-		]);
-		const collectPageBrowserGraphContribution = vi.fn(
-			async (routeFile: string): Promise<PageBrowserGraphContribution> => ({
-				dependencies: [groupedDependencyByRoute.get(routeFile)!],
-			}),
-		);
-		const createReactFlowAdapter = () => ({
-			...createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Page', description: 'Page description' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution,
-				shouldRenderPageComponent: () => false,
-				renderPageComponent: vi.fn(),
-			}),
-			name: 'react' as const,
-		});
-
-		const marketingResult = await flow.prepareRenderOptions(
-			{ file: '/app/pages/marketing.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createReactFlowAdapter(),
-		);
-
-		const docsResult = await flow.prepareRenderOptions(
-			{ file: '/app/pages/docs.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createReactFlowAdapter(),
-		);
-
-		expect(marketingResult.pagePackage?.pageBrowserGraph?.entryAssets).toEqual([
-			expect.objectContaining({
-				srcUrl: '/assets/marketing-layout-index.js',
-				groupedBundle: { id: 'marketing-layout', entryName: 'index' },
-			}),
-		]);
-		expect(docsResult.pagePackage?.pageBrowserGraph?.entryAssets).toEqual([
-			expect.objectContaining({
-				srcUrl: '/assets/docs-layout-index.js',
-				groupedBundle: { id: 'docs-layout', entryName: 'index' },
-			}),
-		]);
-	});
-
-	it('rebuilds grouped page-browser assets on each request when HMR is enabled', async () => {
-		vi.spyOn(fileSystem, 'glob').mockResolvedValue(['index.tsx', 'dashboard.tsx']);
-		let groupedVersion = 1;
-		const processDependencies = vi.fn(async (dependencies: AssetDefinition[], key: string) => {
-			if (key === 'react:grouped-page-browser-graph') {
-				return dependencies
-					.filter(isGroupedContentScriptDependency)
-					.map((dependency) =>
-						createProcessedGroupedScriptAsset(
-							dependency.groupedBundle,
-							`/assets/${dependency.groupedBundle.entryName}-v${groupedVersion}.js`,
-						),
-					);
-			}
-
-			return [];
-		});
-		const assetProcessingService = {
-			processDependencies,
-			getHmrManager: vi.fn(() => ({ isEnabled: () => true })),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [
-				{
-					name: 'react',
-					extensions: ['.tsx'],
-					initializeRenderer: vi.fn(),
-					getResolvedIntegrationDependencies: () => [],
-				},
-			],
-			absolutePaths: {
-				pagesDir: '/app/pages',
-			},
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		const collectPageBrowserGraphContribution = vi.fn(
-			async (routeFile: string): Promise<PageBrowserGraphContribution> => ({
-				dependencies: [
-					createGroupedPageScriptDependency(
-						`console.log("${routeFile}-v${groupedVersion}")`,
-						`${routeFile}-entry`,
-						{
-							id: 'react-router-pages',
-							entryName: routeFile.includes('dashboard') ? 'dashboard' : 'index',
-						},
-					),
-				],
-			}),
-		);
-		const createReactFlowAdapter = () => ({
-			...createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Page', description: 'Page description' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution,
-				shouldRenderPageComponent: () => false,
-				renderPageComponent: vi.fn(),
-			}),
-			name: 'react' as const,
-		});
-
-		const firstResult = await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createReactFlowAdapter(),
-		);
-
-		groupedVersion = 2;
-
-		const secondResult = await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createReactFlowAdapter(),
-		);
-
-		expect(firstResult.pagePackage?.pageBrowserGraph?.entryAssets).toEqual([
-			expect.objectContaining({ srcUrl: '/assets/index-v1.js' }),
-		]);
-		expect(secondResult.pagePackage?.pageBrowserGraph?.entryAssets).toEqual([
-			expect.objectContaining({ srcUrl: '/assets/index-v2.js' }),
-		]);
-		expect(processDependencies).toHaveBeenCalledTimes(2);
-	});
-
-	it('should guard page locals for static pages and skip page-root rendering when disabled', async () => {
-		const assetProcessingService = {
-			processDependencies: vi.fn(async () => []),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [],
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		const renderPageComponent = vi.fn();
-
-		const result = await flow.prepareRenderOptions(
-			{
-				file: '/app/pages/index.tsx',
-				params: {},
-				query: {},
-				locals: { hidden: true },
-			} as unknown as RouteRendererOptions,
-			createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Static page', description: 'Static page description' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution: async () => ({ assets: [] }),
-				shouldRenderPageComponent: () => false,
-				renderPageComponent,
-			}),
-		);
-
-		expect(result.locals).toBeUndefined();
-		expect(() => Reflect.get(result.pageLocals as object, 'guarded')).toThrow(LocalsAccessError);
-		expect(result.componentRender).toBeUndefined();
-		expect(renderPageComponent).not.toHaveBeenCalled();
-	});
-
-	it('eagerly emits lazy SSR component scripts for shared non-owning routes', async () => {
-		const eagerSsrLazyAsset = {
-			kind: 'script',
-			srcUrl: '/assets/components/lit-counter.script.js',
-			position: 'head',
-			packageRole: 'dynamic-chunk',
-		} as ProcessedAsset;
-		const processDependencies = vi.fn(async (dependencies: AssetDefinition[]) => {
-			const hasEagerSsrLazyDependency = dependencies.some((dependency) => {
-				if (dependency.kind !== 'script' || dependency.source !== 'file') {
-					return false;
-				}
-
-				return String(dependency.filepath).endsWith('/lit-counter.script.ts');
-			});
-
-			return hasEagerSsrLazyDependency ? [eagerSsrLazyAsset] : [];
-		});
-		const assetProcessingService = {
-			processDependencies,
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [],
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const LitCounter = (() => '<lit-counter count="0"></lit-counter>') as unknown as EcoComponent<object>;
-		LitCounter.config = {
-			__eco: { id: 'lit-counter', file: '/app/components/lit-counter.lit.tsx', integration: 'lit' },
-			dependencies: {
-				scripts: [{ src: './lit-counter.script.ts', lazy: { 'on:interaction': 'click' }, ssr: true }],
-			},
-		};
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		Page.config = {
-			dependencies: {
-				components: [LitCounter],
-			},
-		};
-
-		await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Static page', description: 'Static page description' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution: async () => ({ assets: [] }),
-				shouldRenderPageComponent: () => false,
-				renderPageComponent: vi.fn(),
-			}),
-		);
-
-		expect(processDependencies).toHaveBeenCalledOnce();
-		expect(processDependencies).toHaveBeenCalledWith(
-			[
-				expect.objectContaining({
-					kind: 'script',
-					source: 'file',
-					filepath: '/app/components/lit-counter.script.ts',
-					packageRole: 'dynamic-chunk',
-				}),
-			],
-			'ghtml:ssr-lazy',
-		);
-	});
-
-	it('exposes eager lazy SSR assets through the returned page package', async () => {
-		const eagerSsrLazyAsset = {
-			kind: 'script',
-			srcUrl: '/assets/components/lit-counter.script.js',
-			position: 'head',
-			packageRole: 'dynamic-chunk',
-		} as ProcessedAsset;
-		const assetProcessingService = {
-			processDependencies: vi.fn(async (dependencies: AssetDefinition[]) => {
-				const hasEagerSsrLazyDependency = dependencies.some((dependency) => {
-					if (dependency.kind !== 'script' || dependency.source !== 'file') {
-						return false;
-					}
-
-					return String(dependency.filepath).endsWith('/lit-counter.script.ts');
-				});
-
-				return hasEagerSsrLazyDependency ? [eagerSsrLazyAsset] : [];
-			}),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [],
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const LitCounter = (() => '<lit-counter count="0"></lit-counter>') as unknown as EcoComponent<object>;
-		LitCounter.config = {
-			__eco: { id: 'lit-counter', file: '/app/components/lit-counter.lit.tsx', integration: 'lit' },
-			dependencies: {
-				scripts: [{ src: './lit-counter.script.ts', lazy: { 'on:interaction': 'click' }, ssr: true }],
-			},
-		};
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		Page.config = {
-			dependencies: {
-				components: [LitCounter],
-			},
-		};
-
-		const result = await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Static page', description: 'Static page description' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution: async () => ({ assets: [] }),
-				shouldRenderPageComponent: () => false,
-				renderPageComponent: vi.fn(),
-			}),
-		);
-
-		expect(result.pagePackage).toEqual(
-			expect.objectContaining({
-				dynamicChunks: [eagerSsrLazyAsset],
-			}),
-		);
-	});
-
-	it('skips undefined component entries while collecting integration dependencies and triggers', async () => {
-		const integrationDependency = {
-			kind: 'script',
-			srcUrl: '/assets/react-runtime.js',
-			position: 'head',
-		} as ProcessedAsset;
-		const assetProcessingService = {
-			processDependencies: vi.fn(async () => []),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [
-				{
-					name: 'react',
-					initializeRenderer: vi.fn(),
-					getResolvedIntegrationDependencies: () => [integrationDependency],
-				},
-			],
-		} as unknown as EcoPagesAppConfig;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService);
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Nested = (() => '<aside>Nested</aside>') as EcoComponent<Record<string, unknown>>;
-		Nested.config = {
-			integration: 'react',
-			__eco: { id: 'nested', file: '/app/components/nested.tsx', integration: 'react' },
-		};
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-		Page.config = {
-			dependencies: {
-				components: [undefined, Nested] as unknown as EcoComponent[],
-			},
-		};
-		await expect(
-			flow.prepareRenderOptions(
-				{ file: '/app/pages/404.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-				createFlowAdapter({
-					resolvePageModule: async () => ({
-						Page,
-						integrationSpecificProps: {},
-					}),
-					getHtmlTemplate: async () => HtmlTemplate,
-					resolvePageData: async () => ({
-						props: {},
-						metadata: { title: '404', description: 'Not found' },
-					}),
-					resolveDependencies: async () => [],
-					collectPageBrowserGraphContribution: async () => ({ assets: [] }),
-					shouldRenderPageComponent: () => false,
-					renderPageComponent: vi.fn(),
-				}),
-			),
-		).resolves.toEqual(
-			expect.objectContaining({
-				Page,
-			}),
-		);
-
-		const result = await flow.prepareRenderOptions(
-			{ file: '/app/pages/404.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: '404', description: 'Not found' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution: async () => ({ assets: [] }),
-				shouldRenderPageComponent: () => false,
-				renderPageComponent: vi.fn(),
-			}),
-		);
-
-		expect(result.pagePackage).toEqual(
-			expect.objectContaining({
-				assets: [integrationDependency],
-			}),
-		);
-	});
-
-	it('uses an injected ownership planning service when provided', async () => {
-		const assetProcessingService = {
-			processDependencies: vi.fn(async () => []),
-		} as unknown as AssetProcessingService;
-		const appConfig = {
-			cache: { defaultStrategy: 'static' },
-			integrations: [],
-		} as unknown as EcoPagesAppConfig;
-		const ownershipPlan = {
-			root: {
-				id: 'route:/app/pages/index.tsx',
-				source: 'route',
-				ownership: {
-					integrationName: 'ghtml',
-					componentId: 'route:/app/pages/index.tsx',
-					componentFile: '/app/pages/index.tsx',
-					isPageEntry: false,
-					isForeignToParent: false,
-				},
-				children: [],
-				declaredDependenciesValid: true,
-			},
-			rendererNames: ['ghtml'],
-			foreignEdgeCount: 0,
-			hasValidationErrors: false,
-			validationErrors: [],
-		} satisfies OwnershipPlan;
-		const injectedOwnershipPlanningService = {
-			buildPlan: vi.fn(() => ownershipPlan),
-		} as unknown as OwnershipPlanningService;
-		const injectedOwnershipValidationService = {
-			validate: vi.fn(() => []),
-		} as unknown as OwnershipValidationService;
-		const flow = new RouteRenderOrchestrator(appConfig, assetProcessingService, {
-			ownershipPlanningService: injectedOwnershipPlanningService,
-			ownershipValidationService: injectedOwnershipValidationService,
-		});
-		const HtmlTemplate = (() => '<html></html>') as EcoComponent<HtmlTemplateProps>;
-		const Page = (() => '<main>Page</main>') as unknown as EcoPageComponent<any>;
-
-		const result = await flow.prepareRenderOptions(
-			{ file: '/app/pages/index.tsx', params: {}, query: {} } as unknown as RouteRendererOptions,
-			createFlowAdapter({
-				resolvePageModule: async () => ({
-					Page,
-					integrationSpecificProps: {},
-				}),
-				getHtmlTemplate: async () => HtmlTemplate,
-				resolvePageData: async () => ({
-					props: {},
-					metadata: { title: 'Page', description: 'Page description' },
-				}),
-				resolveDependencies: async () => [],
-				collectPageBrowserGraphContribution: async () => ({ assets: [] }),
-				shouldRenderPageComponent: () => false,
-				renderPageComponent: vi.fn(),
-			}),
-		);
-
-		expect(injectedOwnershipPlanningService.buildPlan).toHaveBeenCalledWith({
-			routeFile: '/app/pages/index.tsx',
-			currentIntegrationName: 'ghtml',
-			HtmlTemplate,
-			Layout: undefined,
-			Page,
-			validationErrors: [],
-		});
-		expect(result.ownershipPlan).toBe(ownershipPlan);
-	});
-});