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

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

@@ -1,644 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { eco } from '../../eco/eco.ts';
-import type { EcoPagesAppConfig } from '../../types/internal-types.ts';
-import type {
-	OwnershipPlan,
-	EcoComponent,
-	EcoPageComponent,
-	HtmlTemplateProps,
-	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 { 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[]>;
-	buildPageBrowserGraph: (file: string) => Promise<{ assets: ProcessedAsset[] } | 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,
-				}),
-			};
-		},
-		resolveRouteAssets: async ({ routeOptions, components }) => ({
-			resolvedDependencies: await input.resolveDependencies(components),
-			pageBrowserGraph: await input.buildPageBrowserGraph(routeOptions.file),
-		}),
-		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(),
-	};
-}
-
-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],
-				buildPageBrowserGraph: 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: [resolvedDependency, integrationDependency, pageDependency, componentAsset],
-			}),
-		);
-	});
-
-	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 () => [],
-				buildPageBrowserGraph: 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 () => [],
-				buildPageBrowserGraph: 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('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 () => [],
-				buildPageBrowserGraph: 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 () => [],
-				buildPageBrowserGraph: 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 () => [],
-				buildPageBrowserGraph: 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 () => [],
-					buildPageBrowserGraph: 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 () => [],
-				buildPageBrowserGraph: 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 () => [],
-				buildPageBrowserGraph: 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);
-	});
-});