@ecopages/core 0.2.0-beta.27 → 0.2.0-beta.29

package/src/route-renderer/orchestration/integration-renderer.js

@@ -6,25 +6,31 @@ import { invariant } from "../../utils/invariant.js";
 import { HttpError } from "../../errors/http-error.js";
 import { DependencyResolverService } from "../page-loading/dependency-resolver.js";
 import { PageModuleLoaderService } from "../page-loading/page-module-loader.js";
-import { OwnershipValidationService } from "./ownership-validation.service.js";
-import { hasForeignChildDescendantsInGraph } from "./component-graph-collectors.js";
+import { OwnershipValidationService } from "./ownership-graph/ownership-validation.service.js";
+import { hasForeignChildDescendantsInGraph } from "./ownership-graph/component-graph-collectors.js";
 import {
   RouteRenderOrchestrator
-} from "./route-render-orchestrator.js";
-import { createIntegrationRouteRenderAdapter } from "./integration-route-render-adapter.js";
-import { loadPageBrowserGraphContribution } from "./page-browser-graph-contribution.loader.js";
-import { normalizeUnresolvedMarkerArtifactHtml, isMarkupNodeLike } from "./render-output.utils.js";
-import { ensureIntegrationRuntimeReady } from "../../build/app-build-manifest-runtime.js";
+} from "./route-pipeline/route-render-orchestrator.js";
+import { createIntegrationRouteRenderAdapter } from "./route-pipeline/integration-route-render-adapter.js";
+import { loadPageBrowserGraphContribution } from "./page-browser-graph/page-browser-graph-contribution.loader.js";
+import { normalizeUnresolvedMarkerArtifactHtml } from "./route-pipeline/marker-artifact.utils.js";
+import { isMarkupNodeLike } from "./foreign-child/foreign-child-output.utils.js";
 import {
-  ForeignSubtreeExecutionService
-} from "./foreign-subtree-execution.service.js";
-import { buildProcessedAssetDedupeKey } from "./processed-asset-dedupe.js";
+  getForeignSubtreeResolutionContextKey,
+  getForeignSubtreeTokenPrefix,
+  resolveOwningIntegrationRenderer
+} from "./foreign-child/owning-renderer-resolution.js";
+import { ensureIntegrationRuntimeReady } from "../../build/app-build-manifest-runtime.js";
+import { ForeignSubtreeExecutionService } from "./foreign-child/foreign-subtree-execution.service.js";
 import {
-  applyDocumentShellAttributeStamping,
   composeDocumentShell,
+  finalizeDocumentShellHtml,
   renderPageDocumentShell
-} from "./document-shell-render.service.js";
-import { resolveInnermostPageLayout, resolvePageLayoutComponents } from "./layout-shell-props.service.js";
+} from "./document-shell/document-shell-render.service.js";
+import {
+  resolveInnermostPageLayout,
+  resolvePageLayoutComponents
+} from "./document-shell/layout-shell-props.service.js";
 class IntegrationRenderer {
   appConfig;
   assetProcessingService;
@@ -186,36 +192,6 @@ class IntegrationRenderer {
       )
     });
   }
-  mergePageBrowserGraphIntoPagePackage(pageBrowserGraph) {
-    if (!pageBrowserGraph) {
-      return void 0;
-    }
-    const currentPagePackage = this.htmlTransformer.getPagePackage();
-    const mergedPageBrowserGraph = currentPagePackage?.pageBrowserGraph ? {
-      entryAssets: this.htmlTransformer.dedupeProcessedAssets([
-        ...currentPagePackage.pageBrowserGraph.entryAssets,
-        ...pageBrowserGraph.entryAssets
-      ]),
-      chunkAssets: this.htmlTransformer.dedupeProcessedAssets([
-        ...currentPagePackage.pageBrowserGraph.chunkAssets,
-        ...pageBrowserGraph.chunkAssets
-      ])
-    } : pageBrowserGraph;
-    const pageBrowserGraphAssetKeys = new Set(
-      [...mergedPageBrowserGraph.entryAssets, ...mergedPageBrowserGraph.chunkAssets].map(
-        (asset) => buildProcessedAssetDedupeKey(asset)
-      )
-    );
-    const baseAssets = currentPagePackage ? currentPagePackage.assets.filter(
-      (asset) => !pageBrowserGraphAssetKeys.has(buildProcessedAssetDedupeKey(asset))
-    ) : this.htmlTransformer.getProcessedDependencies();
-    this.htmlTransformer.setPagePackage(
-      createPagePackage(this.htmlTransformer.dedupeProcessedAssets(baseAssets), {
-        pageBrowserGraph: mergedPageBrowserGraph
-      })
-    );
-    return mergedPageBrowserGraph;
-  }
   /**
    * Merges component-scoped assets into the active HTML transformer state.
    *
@@ -333,9 +309,11 @@ class IntegrationRenderer {
       }
     );
     const transformedDocumentHtml = input.transformDocumentHtml ? input.transformDocumentHtml(documentHtml) : documentHtml;
-    const html = await this.finalizeResolvedHtml({
+    this.appendProcessedDependencies(this.getRendererBootstrapDependencies(false));
+    const html = await finalizeDocumentShellHtml(this.htmlTransformer, {
       html: `${this.DOC_TYPE}${transformedDocumentHtml}`,
-      partial: false
+      partial: false,
+      htmlContributions: this.getHtmlDocumentContributions({ partial: false })
     });
     return this.createHtmlResponse(html, input.ctx);
   }
@@ -389,39 +367,6 @@ class IntegrationRenderer {
       assets
     };
   }
-  getForeignSubtreeTokenPrefix() {
-    return `__${this.name}_foreign_subtree__`;
-  }
-  getForeignSubtreeResolutionContextKey() {
-    return `__${this.name}_foreign_subtree_runtime__`;
-  }
-  createQueuedForeignSubtreeExecutionRuntime(options) {
-    return this.foreignSubtreeExecutionService.createQueuedRuntime({
-      renderInput: options.renderInput,
-      rendererCache: options.rendererCache,
-      runtimeContextKey: options.runtimeContextKey ?? this.getForeignSubtreeResolutionContextKey(),
-      tokenPrefix: options.tokenPrefix ?? this.getForeignSubtreeTokenPrefix(),
-      createRuntimeContext: options.createRuntimeContext
-    });
-  }
-  getQueuedForeignSubtreeResolutionContext(input) {
-    return this.foreignSubtreeExecutionService.getQueuedRuntimeContext(
-      input,
-      this.getForeignSubtreeResolutionContextKey()
-    );
-  }
-  async resolveQueuedForeignSubtreeHtml(html, runtimeContext, renderQueuedChildren, queueLabel = this.name) {
-    return this.foreignSubtreeExecutionService.resolveQueuedHtml({
-      currentIntegrationName: this.name,
-      html,
-      runtimeContext,
-      queueLabel,
-      getOwningRenderer: (integrationName, rendererCache) => this.getIntegrationRendererForName(integrationName, rendererCache),
-      applyAttributesToFirstElement: (resolvedHtml, attributes) => this.htmlTransformer.applyAttributesToFirstElement(resolvedHtml, attributes),
-      dedupeProcessedAssets: (assets) => this.htmlTransformer.dedupeProcessedAssets(assets),
-      renderQueuedChildren
-    });
-  }
   /**
    * Renders a string-first component, then resolves any queued foreign
    * boundaries before returning final component HTML.
@@ -432,9 +377,16 @@ class IntegrationRenderer {
       currentIntegrationName: this.name,
       renderInput: input,
       html: componentRender.html,
-      runtimeContextKey: this.getForeignSubtreeResolutionContextKey(),
+      runtimeContextKey: getForeignSubtreeResolutionContextKey(this.name),
       queueLabel: "String",
-      getOwningRenderer: (integrationName, rendererCache) => this.getIntegrationRendererForName(integrationName, rendererCache),
+      getOwningRenderer: (integrationName, rendererCache) => resolveOwningIntegrationRenderer({
+        appConfig: this.appConfig,
+        runtimeOrigin: this.runtimeOrigin,
+        currentIntegrationName: this.name,
+        currentRenderer: this,
+        integrationName,
+        cache: rendererCache
+      }),
       applyAttributesToFirstElement: (html, attributes) => this.htmlTransformer.applyAttributesToFirstElement(html, attributes),
       dedupeProcessedAssets: (assets) => this.htmlTransformer.dedupeProcessedAssets(assets)
     });
@@ -559,7 +511,15 @@ class IntegrationRenderer {
       getDocumentAttributes: (renderOptions) => this.getDocumentAttributes(renderOptions),
       getHtmlDocumentContributions: (options) => this.getHtmlDocumentContributions(options),
       applyAttributesToHtmlElement: (html, attributes) => this.applyAttributesToHtmlElement(html, attributes),
-      transformRouteResponse: (response, htmlContributions, pagePackage) => this.transformRouteResponse(response, htmlContributions, pagePackage)
+      transformRouteResponse: async (response, htmlContributions, pagePackage) => {
+        const resolvedPagePackage = this.htmlTransformer.getPagePackage() ?? pagePackage;
+        const transformedResponse = await this.htmlTransformer.transform(
+          response,
+          htmlContributions,
+          resolvedPagePackage
+        );
+        return transformedResponse.body ?? await transformedResponse.text();
+      }
     });
   }
   async resolveRouteRenderInputs(routeOptions) {
@@ -594,15 +554,6 @@ class IntegrationRenderer {
   async renderRouteBody(renderOptions) {
     return this.render(renderOptions);
   }
-  async transformRouteResponse(response, htmlContributions, pagePackage) {
-    const resolvedPagePackage = this.htmlTransformer.getPagePackage() ?? pagePackage;
-    const transformedResponse = await this.htmlTransformer.transform(
-      response,
-      htmlContributions,
-      resolvedPagePackage
-    );
-    return transformedResponse.body ?? await transformedResponse.text();
-  }
   /**
    * Prepares the render options for the integration renderer.
    * It imports the page file, collects dependencies, and prepares the render options.
@@ -641,42 +592,6 @@ class IntegrationRenderer {
       return this.routeRenderOrchestrator.executePrepared(renderOptions, adapter);
     });
   }
-  /**
-   * Finalizes already-resolved HTML for explicit renderer-owned paths.
-   *
-   * This keeps document and root-attribute stamping plus HTML transformation
-   * available after a renderer has completed nested foreign-subtree resolution without
-   * routing back through shared route execution.
-   */
-  async finalizeResolvedHtml(options) {
-    const rendererBootstrapDependencies = this.getRendererBootstrapDependencies(options.partial);
-    this.appendProcessedDependencies(rendererBootstrapDependencies);
-    let html = applyDocumentShellAttributeStamping(
-      options.html,
-      {
-        applyAttributesToFirstBodyElement: (nextHtml, attributes) => this.htmlTransformer.applyAttributesToFirstBodyElement(nextHtml, attributes),
-        applyAttributesToHtmlElement: (nextHtml, attributes) => this.htmlTransformer.applyAttributesToHtmlElement(nextHtml, attributes)
-      },
-      {
-        componentRootAttributes: options.componentRootAttributes,
-        documentAttributes: options.documentAttributes
-      }
-    );
-    const shouldTransform = options.transformHtml ?? !options.partial;
-    if (!shouldTransform) {
-      return html;
-    }
-    const htmlContributions = options.htmlContributions ?? this.getHtmlDocumentContributions({
-      partial: options.partial
-    });
-    const transformedResponse = await this.htmlTransformer.transform(
-      new Response(html, {
-        headers: { "Content-Type": "text/html" }
-      }),
-      htmlContributions
-    );
-    return await transformedResponse.text();
-  }
   /**
    * Returns document-level attributes to stamp onto the rendered `<html>` tag.
    *
@@ -704,34 +619,6 @@ class IntegrationRenderer {
   getHtmlDocumentContributions(_options) {
     return void 0;
   }
-  /**
-   * Returns a renderer instance for a given integration name.
-   *
-   * Uses a per-execution cache to avoid repeated renderer initialization.
-   *
-   * @param integrationName Target integration name.
-   * @param cache Render-pass renderer cache.
-   * @returns Renderer for the requested integration.
-   * @throws Error when no integration plugin matches `integrationName`.
-   */
-  getIntegrationRendererForName(integrationName, cache) {
-    if (cache.has(integrationName)) {
-      return cache.get(integrationName);
-    }
-    if (integrationName === this.name) {
-      cache.set(integrationName, this);
-      return this;
-    }
-    const integrationPlugin = this.appConfig.integrations.find(
-      (integration) => integration.name === integrationName
-    );
-    invariant(!!integrationPlugin, `[ecopages] Integration not found for foreign owner: ${integrationName}`);
-    const renderer = integrationPlugin.initializeRenderer({
-      rendererModules: this.appConfig.runtime?.rendererModuleContext
-    });
-    cache.set(integrationName, renderer);
-    return renderer;
-  }
   /**
    * Renders one component under this integration's foreign-child runtime and resolves
    * any nested foreign children captured during that render.
@@ -751,7 +638,14 @@ class IntegrationRenderer {
         renderInput,
         rendererCache
       }),
-      getOwningRenderer: (integrationName, rendererCache) => this.getIntegrationRendererForName(integrationName, rendererCache)
+      getOwningRenderer: (integrationName, rendererCache) => resolveOwningIntegrationRenderer({
+        appConfig: this.appConfig,
+        runtimeOrigin: this.runtimeOrigin,
+        currentIntegrationName: this.name,
+        currentRenderer: this,
+        integrationName,
+        cache: rendererCache
+      })
     });
   }
   normalizeComponentRenderOutput(result) {
@@ -838,9 +732,11 @@ class IntegrationRenderer {
    * context or a different foreign-child execution strategy.
    */
   createForeignChildRuntime(options) {
-    return this.createQueuedForeignSubtreeExecutionRuntime({
+    return this.foreignSubtreeExecutionService.createQueuedRuntime({
       renderInput: options.renderInput,
-      rendererCache: options.rendererCache
+      rendererCache: options.rendererCache,
+      runtimeContextKey: getForeignSubtreeResolutionContextKey(this.name),
+      tokenPrefix: getForeignSubtreeTokenPrefix(this.name)
     });
   }
   /**

package/src/route-renderer/orchestration/integration-renderer.test-fixtures.d.ts

@@ -0,0 +1,75 @@
+import { IntegrationRenderer, type HtmlDocumentContribution, type RenderToResponseContext } from './integration-renderer.js';
+import { getComponentRenderContext, type ForeignChildRuntime } from './foreign-child/component-render-context.js';
+import type { EcoPagesAppConfig } from '../../types/internal-types.js';
+import type { AssetProcessingService, ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
+import type { ComponentRenderInput, ComponentRenderResult, EcoPagesElement, IntegrationRendererRenderOptions, EcoPageFile, RouteRendererBody, RouteRendererOptions, EcoComponent, HtmlTemplateProps } from '../../types/public-types.js';
+import type { PagePackageResult } from '../../types/public-types.js';
+export declare function createUnresolvedMarkerArtifact(nodeId: string, componentRef: string, propsRef: string): string;
+export declare function createMockIntegrationPlugin(plugin: {
+    name: string;
+} & Record<string, unknown>): EcoPagesAppConfig['integrations'][number];
+export declare const testAppConfig: EcoPagesAppConfig;
+export declare const testAssetService: AssetProcessingService;
+/**
+ * Concrete implementation with ed file loading for testing purposes.
+ */
+export declare class TestIntegrationRenderer extends IntegrationRenderer<EcoPagesElement> {
+    name: string;
+    ForeignChildRuntimeCreationCount: number;
+    ForeignChildRenderCount: number;
+    UseFailFastForeignChildRuntime: boolean;
+    PageModule: EcoPageFile | null;
+    HtmlTemplate: EcoComponent<HtmlTemplateProps> | null;
+    RenderedBody: RouteRendererBody;
+    RenderBodyFactory: ((context: ReturnType<typeof getComponentRenderContext>) => RouteRendererBody | Promise<RouteRendererBody>) | null;
+    MockComponentRenderResult: ComponentRenderResult | null;
+    ImportedFiles: string[];
+    HtmlContributions: HtmlDocumentContribution[];
+    render(_options: IntegrationRendererRenderOptions<EcoPagesElement>): Promise<RouteRendererBody>;
+    renderComponent(_input: ComponentRenderInput): Promise<ComponentRenderResult>;
+    renderComponentWithForeignChildren(input: ComponentRenderInput): Promise<ComponentRenderResult>;
+    renderToResponse<P>(view: EcoComponent<P>, props: P, ctx: RenderToResponseContext): Promise<Response>;
+    protected importPageFile(_file: string): Promise<EcoPageFile>;
+    protected getHtmlTemplate(): Promise<EcoComponent<HtmlTemplateProps>>;
+    protected resolveDependencies(_components: (EcoComponent | Partial<EcoComponent>)[]): Promise<ProcessedAsset[]>;
+    testPrepareRenderOptions(options: RouteRendererOptions): Promise<IntegrationRendererRenderOptions<EcoPagesElement>>;
+    testShouldDelegateForeignChild(input: {
+        currentIntegration: string;
+        targetIntegration?: string;
+    }): boolean;
+    testHasForeignChildDescendants(component: EcoComponent): boolean;
+    testGetHtmlTemplate(): Promise<import("../../index.browser.js").EcoFunctionComponent<HtmlTemplateProps<EcoPagesElement>, any>>;
+    testBaseGetHtmlTemplate(): Promise<import("../../index.browser.js").EcoFunctionComponent<HtmlTemplateProps<EcoPagesElement>, any>>;
+    testGetRendererBootstrapDependencies(partial?: boolean): ProcessedAsset[];
+    testFinalizeDocumentShellHtml(options: {
+        html: string;
+        partial?: boolean;
+        htmlContributions?: HtmlDocumentContribution[];
+    }): Promise<string>;
+    testTransformRouteResponse(response: Response, htmlContributions?: HtmlDocumentContribution[], pagePackage?: PagePackageResult): Promise<RouteRendererBody>;
+    appendTestProcessedDependencies(assets: ProcessedAsset[]): ProcessedAsset[];
+    setTestPagePackage(pagePackage: PagePackageResult): void;
+    getTestPagePackage(): PagePackageResult | undefined;
+    getTestProcessedDependencies(): ProcessedAsset[];
+    testRenderPartialViewResponse<P>(input: {
+        view: EcoComponent<P>;
+        props: P;
+        ctx?: RenderToResponseContext;
+        renderInline?: () => Promise<BodyInit>;
+        transformHtml?: (html: string) => string;
+    }): Promise<Response>;
+    testRenderViewWithDocumentShell<P>(input: {
+        view: EcoComponent<P>;
+        props: P;
+        ctx?: RenderToResponseContext;
+        layout?: EcoComponent;
+    }): Promise<Response>;
+    testRenderForeignSubtree(input: ComponentRenderInput): Promise<import("../../index.browser.js").ForeignSubtreeRenderPayload>;
+    protected createForeignChildRuntime(options: {
+        renderInput: ComponentRenderInput;
+        rendererCache: Map<string, IntegrationRenderer<any>>;
+    }): ForeignChildRuntime;
+    protected getHtmlDocumentContributions(_options?: {
+        partial?: boolean;
+    }): HtmlDocumentContribution[] | undefined;
+}

package/src/route-renderer/orchestration/integration-renderer.test-fixtures.js

@@ -0,0 +1,177 @@
+import { vi } from "vitest";
+import { resolveInnermostPageLayout } from "./document-shell/layout-shell-props.service.js";
+import { finalizeDocumentShellHtml } from "./document-shell/document-shell-render.service.js";
+import {
+  IntegrationRenderer
+} from "./integration-renderer.js";
+import { getComponentRenderContext } from "./foreign-child/component-render-context.js";
+import { toForeignSubtreeRenderPayload } from "./foreign-child/foreign-subtree-execution.service.js";
+function createUnresolvedMarkerArtifact(nodeId, componentRef, propsRef) {
+  return `<eco-marker data-eco-node-id="${nodeId}" data-eco-component-ref="${componentRef}" data-eco-props-ref="${propsRef}"></eco-marker>`;
+}
+function createMockIntegrationPlugin(plugin) {
+  return {
+    setConfig: vi.fn(),
+    setRuntimeOrigin: vi.fn(),
+    setup: vi.fn(async () => {
+    }),
+    ...plugin
+  };
+}
+const testAppConfig = {
+  absolutePaths: {
+    pagesDir: "/app/pages",
+    htmlTemplatePath: "/app/index.ghtml.ts"
+  },
+  integrations: [],
+  defaultMetadata: {
+    title: "Default Title",
+    description: "Default Description"
+  },
+  srcDir: "/app"
+};
+const testAssetService = {
+  processDependencies: vi.fn(() => Promise.resolve([]))
+};
+class TestIntegrationRenderer extends IntegrationRenderer {
+  name = "test-renderer";
+  ForeignChildRuntimeCreationCount = 0;
+  ForeignChildRenderCount = 0;
+  UseFailFastForeignChildRuntime = false;
+  PageModule = null;
+  HtmlTemplate = null;
+  RenderedBody = "<html><body>Test Page</body></html>";
+  RenderBodyFactory = null;
+  MockComponentRenderResult = null;
+  ImportedFiles = [];
+  HtmlContributions = [];
+  async render(_options) {
+    if (this.RenderBodyFactory) {
+      return await this.RenderBodyFactory(getComponentRenderContext());
+    }
+    return this.RenderedBody;
+  }
+  async renderComponent(_input) {
+    if (this.MockComponentRenderResult) {
+      return this.MockComponentRenderResult;
+    }
+    return super.renderComponent(_input);
+  }
+  async renderComponentWithForeignChildren(input) {
+    this.ForeignChildRenderCount += 1;
+    return await super.renderComponentWithForeignChildren(input);
+  }
+  async renderToResponse(view, props, ctx) {
+    const viewFn = view;
+    const content = viewFn(props);
+    let body;
+    if (ctx.partial) {
+      body = content;
+    } else {
+      const Layout = resolveInnermostPageLayout(view.config?.layouts);
+      const children = Layout ? Layout({ children: content }) : content;
+      body = `<!DOCTYPE html><html><body>${children}</body></html>`;
+    }
+    const headers = new Headers({ "Content-Type": "text/html; charset=utf-8" });
+    if (ctx.headers) {
+      for (const [key, value] of Object.entries(ctx.headers)) {
+        headers.set(key, value);
+      }
+    }
+    return new Response(body, {
+      status: ctx.status ?? 200,
+      headers
+    });
+  }
+  async importPageFile(_file) {
+    this.ImportedFiles.push(_file);
+    if (!this.PageModule) throw new Error("Mock page module not set");
+    return this.PageModule;
+  }
+  async getHtmlTemplate() {
+    if (!this.HtmlTemplate) throw new Error("Mock HTML template not set");
+    return this.HtmlTemplate;
+  }
+  async resolveDependencies(_components) {
+    return [];
+  }
+  async testPrepareRenderOptions(options) {
+    return this.prepareRenderOptions(options);
+  }
+  testShouldDelegateForeignChild(input) {
+    return this.foreignSubtreeExecutionService.shouldDelegateForeignChild(input);
+  }
+  testHasForeignChildDescendants(component) {
+    return this.hasForeignChildDescendants(component);
+  }
+  async testGetHtmlTemplate() {
+    return this.getHtmlTemplate();
+  }
+  async testBaseGetHtmlTemplate() {
+    return super.getHtmlTemplate();
+  }
+  testGetRendererBootstrapDependencies(partial = false) {
+    return this.getRendererBootstrapDependencies(partial);
+  }
+  async testFinalizeDocumentShellHtml(options) {
+    this.appendProcessedDependencies(this.getRendererBootstrapDependencies(options.partial));
+    return finalizeDocumentShellHtml(this.htmlTransformer, {
+      html: options.html,
+      partial: options.partial,
+      htmlContributions: options.htmlContributions ?? this.getHtmlDocumentContributions({ partial: options.partial ?? false })
+    });
+  }
+  async testTransformRouteResponse(response, htmlContributions, pagePackage) {
+    const adapter = this.createRouteRenderOrchestratorAdapter();
+    return adapter.transformRouteResponse(response, htmlContributions, pagePackage);
+  }
+  appendTestProcessedDependencies(assets) {
+    return this.appendProcessedDependencies(assets);
+  }
+  setTestPagePackage(pagePackage) {
+    this.htmlTransformer.setPagePackage(pagePackage);
+  }
+  getTestPagePackage() {
+    return this.htmlTransformer.getPagePackage();
+  }
+  getTestProcessedDependencies() {
+    return this.htmlTransformer.getProcessedDependencies();
+  }
+  async testRenderPartialViewResponse(input) {
+    return this.renderPartialViewResponse({
+      view: input.view,
+      props: input.props,
+      ctx: input.ctx ?? { partial: true },
+      renderInline: input.renderInline,
+      transformHtml: input.transformHtml
+    });
+  }
+  async testRenderViewWithDocumentShell(input) {
+    return this.renderViewWithDocumentShell({
+      view: input.view,
+      props: input.props,
+      ctx: input.ctx ?? {},
+      layout: input.layout
+    });
+  }
+  async testRenderForeignSubtree(input) {
+    return toForeignSubtreeRenderPayload(await this.renderComponentWithForeignChildren(input));
+  }
+  createForeignChildRuntime(options) {
+    this.ForeignChildRuntimeCreationCount += 1;
+    if (this.UseFailFastForeignChildRuntime) {
+      return this.createFailFastForeignChildRuntime();
+    }
+    return super.createForeignChildRuntime(options);
+  }
+  getHtmlDocumentContributions(_options) {
+    return this.HtmlContributions;
+  }
+}
+export {
+  TestIntegrationRenderer,
+  createMockIntegrationPlugin,
+  createUnresolvedMarkerArtifact,
+  testAppConfig,
+  testAssetService
+};

package/src/route-renderer/orchestration/{component-graph-collectors.d.ts → ownership-graph/component-graph-collectors.d.ts}

@@ -1,7 +1,7 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-import type { EcoComponent, ResolvedLazyTrigger } from '../../types/public-types.js';
-import type { AssetDefinition } from '../../services/assets/asset-processing-service/index.js';
-import type { AssetProcessingService, ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
+import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
+import type { EcoComponent, ResolvedLazyTrigger } from '../../../types/public-types.js';
+import type { AssetDefinition } from '../../../services/assets/asset-processing-service/index.js';
+import type { AssetProcessingService, ProcessedAsset } from '../../../services/assets/asset-processing-service/index.js';
 export declare function collectIntegrationNamesFromGraph(components: (EcoComponent | Partial<EcoComponent>)[], currentIntegrationName: string): Set<string>;
 export declare function collectResolvedLazyTriggersFromGraph(components: (EcoComponent | Partial<EcoComponent>)[], currentIntegrationName: string): ResolvedLazyTrigger[];
 export declare function hasForeignChildDescendantsInGraph(component: EcoComponent, currentIntegrationName: string): boolean;

package/src/route-renderer/orchestration/{component-graph-collectors.js → ownership-graph/component-graph-collectors.js}

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
+import { AssetFactory } from "../../../services/assets/asset-processing-service/index.js";
 import { walkComponentGraph } from "./component-graph.js";
 function toGraphRoots(components) {
   return components.filter(Boolean).map((component) => ({ component }));

package/src/route-renderer/orchestration/{component-graph.d.ts → ownership-graph/component-graph.d.ts}

@@ -1,4 +1,4 @@
-import type { EcoComponent, OwnershipPlanNodeSource } from '../../types/public-types.js';
+import type { EcoComponent, OwnershipPlanNodeSource } from '../../../types/public-types.js';
 export type DeclaredOwnershipRoot = {
     component: EcoComponent;
     source: Extract<OwnershipPlanNodeSource, 'page' | 'layout' | 'html-template'>;
@@ -32,5 +32,3 @@ export declare function mapComponentGraph<T>(input: {
     currentIntegrationName: string;
     mapNode: (node: DeclaredOwnershipNodeInput, children: T[]) => T;
 }): T[];
-/** @deprecated Use `mapComponentGraph` from `component-graph.ts`. */
-export declare const mapDeclaredOwnershipGraph: typeof mapComponentGraph;

package/src/route-renderer/orchestration/{component-graph.js → ownership-graph/component-graph.js}

@@ -90,9 +90,7 @@ function mapComponentGraph(input) {
     ({ component, source }) => mapComponent(component, source, input.currentIntegrationName, /* @__PURE__ */ new Set())
   );
 }
-const mapDeclaredOwnershipGraph = mapComponentGraph;
 export {
   mapComponentGraph,
-  mapDeclaredOwnershipGraph,
   walkComponentGraph
 };

package/src/route-renderer/orchestration/{ownership-validation.service.d.ts → ownership-graph/ownership-validation.service.d.ts}

@@ -1,5 +1,5 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-import type { OwnershipPlanNodeSource, OwnershipValidationError, EcoComponent } from '../../types/public-types.js';
+import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
+import type { OwnershipPlanNodeSource, OwnershipValidationError, EcoComponent } from '../../../types/public-types.js';
 type OwnershipValidationInput = {
     currentIntegrationName: string;
     roots: Array<{

package/src/route-renderer/orchestration/{ownership-validation.service.js → ownership-graph/ownership-validation.service.js}

@@ -1,6 +1,5 @@
-import { assertEcoDeclaredComponent } from "../../eco/eco-declared-component.js";
-import { mapDeclaredOwnershipGraph } from "./declared-ownership-graph.js";
-import { walkComponentGraph } from "./component-graph.js";
+import { assertEcoDeclaredComponent } from "../../../eco/eco-declared-component.js";
+import { mapComponentGraph, walkComponentGraph } from "./component-graph.js";
 class OwnershipValidationService {
   appConfig;
   /**
@@ -14,7 +13,7 @@ class OwnershipValidationService {
    */
   validate(input) {
     this.assertDeclaredComponentDependencies(input);
-    return mapDeclaredOwnershipGraph({
+    return mapComponentGraph({
       roots: input.roots,
       currentIntegrationName: input.currentIntegrationName,
       mapNode: ({ component, integrationName, componentId, isForeignToParent }, children) => {

package/src/route-renderer/orchestration/{global-injector-assets.service.d.ts → page-browser-graph/global-injector-assets.service.d.ts}

@@ -1,6 +1,6 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-import type { ResolvedLazyTrigger } from '../../types/public-types.js';
-import { type AssetProcessingService, type ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
+import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
+import type { ResolvedLazyTrigger } from '../../../types/public-types.js';
+import { type AssetProcessingService, type ProcessedAsset } from '../../../services/assets/asset-processing-service/index.js';
 /**
  * Builds processed global-injector map and bootstrap assets for resolved lazy triggers.
  */

package/src/route-renderer/orchestration/{global-injector-assets.service.js → page-browser-graph/global-injector-assets.service.js}

@@ -2,8 +2,8 @@ import { createRequire } from "node:module";
 import path from "node:path";
 import {
   AssetFactory
-} from "../../services/assets/asset-processing-service/index.js";
-import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../../eco/global-injector-map.js";
+} from "../../../services/assets/asset-processing-service/index.js";
+import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../../../eco/global-injector-map.js";
 async function buildGlobalInjectorAssets(appConfig, assetProcessingService, triggers, currentIntegrationName) {
   const appProjectDir = appConfig.rootDir ?? appConfig.absolutePaths?.projectDir ?? process.cwd();
   const appPackageRequire = createRequire(path.join(appProjectDir, "package.json"));

package/src/route-renderer/orchestration/{page-browser-graph-contribution.loader.d.ts → page-browser-graph/page-browser-graph-contribution.loader.d.ts}

@@ -1,4 +1,4 @@
-import type { EcoPageFile, PageBrowserGraphContribution, PageBrowserGraphContributionContext } from '../../types/public-types.js';
+import type { EcoPageFile, PageBrowserGraphContribution, PageBrowserGraphContributionContext } from '../../../types/public-types.js';
 /**
  * Loads a page module once and collects declarative browser-graph requirements.
  *

package/src/route-renderer/orchestration/page-browser-graph/page-browser-graph-merge.utils.d.ts

@@ -0,0 +1,12 @@
+import { type ProcessedAsset } from '../../../services/assets/asset-processing-service/index.js';
+import type { PageBrowserGraphResult, PagePackageResult } from '../../../types/public-types.js';
+/**
+ * Merges a page browser graph into an existing page package (or processed dependencies).
+ *
+ * Deduplicates entry/chunk assets against the existing package and rebuilds the
+ * package so downstream HTML finalization sees one canonical graph.
+ */
+export declare function mergePageBrowserGraph(currentPagePackage: PagePackageResult | undefined, processedDependencies: ProcessedAsset[], pageBrowserGraph: PageBrowserGraphResult): {
+    pagePackage: PagePackageResult;
+    mergedGraph: PageBrowserGraphResult;
+};