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

package/src/plugins/processor.d.ts

@@ -1,9 +1,9 @@
-import type { EcoBuildPlugin } from '../build/build-types.js';
+import type { EcoBuildPlugin } from '../build/contracts/build-types.js';
 import type { EcoPagesAppConfig, IClientBridge } from '../types/internal-types.js';
 import { GENERATED_BASE_PATHS } from '../config/constants.js';
 import type { RuntimeCapabilityDeclaration } from './runtime-capability.js';
 export type { RuntimeCapabilityDeclaration, RuntimeCapabilityTag } from './runtime-capability.js';
-export type { EcoBuildLoader, EcoBuildOnLoadArgs, EcoBuildOnLoadResult, EcoBuildOnResolveArgs, EcoBuildOnResolveResult, EcoBuildPlugin, EcoBuildPluginBuilder, } from '../build/build-types.js';
+export type { EcoBuildLoader, EcoBuildOnLoadArgs, EcoBuildOnLoadResult, EcoBuildOnResolveArgs, EcoBuildOnResolveResult, EcoBuildPlugin, EcoBuildPluginBuilder, } from '../build/contracts/build-types.js';
 export declare const PROCESSOR_ERRORS: {
     readonly CACHE_DIRECTORY_NOT_SET: "Cache directory not set in context";
 };
@@ -57,10 +57,17 @@ export interface ProcessorContext {
     cache?: string;
 }
 /**
- * Interface for processor build plugins
- * This is used to pass plugins to the build process directly from the processor
- * For instance it can become very handy when dealing with virtual modules that needs to be recognized by the bundler
- * i.e. @ecopages/image-processor
+ * Base class for content and asset processors that contribute build plugins.
+ *
+ * @remarks
+ * Processors declare plugins through two getters that map to
+ * {@link AppBuildManifest} buckets (names differ from integrations):
+ *
+ * - `plugins` → `runtimePlugins` (server **and** browser builds)
+ * - `buildPlugins` → `browserBundlePlugins` (browser bundles only)
+ *
+ * Virtual modules that must resolve during route-module transpile belong in
+ * `plugins`. Browser-only bundler hooks belong in `buildPlugins`.
  */
 export declare abstract class Processor<TOptions = Record<string, unknown>> {
     readonly name: string;
@@ -69,9 +76,22 @@ export declare abstract class Processor<TOptions = Record<string, unknown>> {
     protected watchConfig?: ProcessorWatchConfig;
     protected capabilities: ProcessorAssetCapability[];
     readonly runtimeCapability?: RuntimeCapabilityDeclaration;
-    /** Plugins that are only used during the build process */
+    /**
+     * Browser-bundle-only plugins.
+     *
+     * @remarks
+     * Maps to {@link AppBuildManifest.browserBundlePlugins}. Integrations name the
+     * same bucket `browserBuildPlugins`.
+     */
     abstract buildPlugins?: EcoBuildPlugin[];
-    /** Plugins that are used during runtime for file processing */
+    /**
+     * Shared build plugins for server-oriented and browser-oriented work.
+     *
+     * @remarks
+     * Maps to {@link AppBuildManifest.runtimePlugins}. Despite the name, these are
+     * bundler plugins—not dev-server file processors. Runtime-only setup stays in
+     * {@link setup}.
+     */
     abstract plugins?: EcoBuildPlugin[];
     constructor(config: ProcessorConfig<TOptions>);
     setContext(appConfig: EcoPagesAppConfig): void;

package/src/plugins/source-transform.d.ts

@@ -1,4 +1,4 @@
-import type { EcoBuildPlugin } from '../build/build-types.js';
+import type { EcoBuildPlugin } from '../build/contracts/build-types.js';
 import type { EcoPagesAppConfig } from '../types/internal-types.js';
 export interface EcoSourceTransformResult {
     code: string;

package/src/route-renderer/GRAPH.md

@@ -42,23 +42,17 @@ flowchart TD
   C --> D[ownershipValidationService.validate]
   D --> E[resolvePageData]
   E --> F[ownershipValidationService.validate + throwIfOwnershipInvalid]
-  F --> G[resolveDependencies]
-  G --> H[buildPageBrowserGraph]
-  H --> I{shouldRenderPageComponent?}
-  I -- Yes --> J[renderPageComponent]
-  I -- No --> K[skip page-root render]
-  J --> L[merge component assets]
-  K --> L
-  L --> M[collect injector and eager SSR lazy assets]
-  M --> N[build pagePackage and prepared render options]
-  N --> O[callbacks.render]
-  O --> P[capture rendered body as html]
-  P --> Q[inspect unresolved marker artifacts]
-  Q --> R{unresolved eco-marker remains?}
-  R -- Yes --> S[throw unresolved artifact error]
-  R -- No --> T[stamp root or document attributes when needed]
-  T --> U[htmlTransformer transform]
-  U --> V[final body and cache strategy]
+  F --> G[resolveDependencies + buildPageBrowserGraph]
+  G --> H[collect injector and eager SSR lazy assets]
+  H --> I[build pagePackage and prepared render options]
+  I --> J[IntegrationRenderer.render via document shell]
+  J --> K[capture rendered body as html]
+  K --> L[inspect unresolved marker artifacts]
+  L --> M{unresolved eco-marker remains?}
+  M -- Yes --> N[throw unresolved artifact error]
+  M -- No --> O[stamp document attributes when needed]
+  O --> P[htmlTransformer transform]
+  P --> Q[final body and cache strategy]
 ```
 
 ## 3) Mixed-Integration Render Model
@@ -124,7 +118,7 @@ The most useful reading order is:
 2. `orchestration/route-render-orchestrator.ts`
 3. `orchestration/integration-renderer.ts`
 4. `orchestration/ownership-validation.service.ts`
-5. `orchestration/ownership-planning.service.ts`
+5. `orchestration/component-graph.ts`
 6. `orchestration/component-render-context.ts`
 7. `orchestration/foreign-subtree-execution.service.ts`
 8. `page-loading/page-module-loader.ts`
@@ -137,7 +131,7 @@ The most useful reading order is:
 - `packages/core/src/route-renderer/orchestration/route-render-orchestrator.ts`
 - `packages/core/src/route-renderer/orchestration/integration-renderer.ts`
 - `packages/core/src/route-renderer/orchestration/ownership-validation.service.ts`
-- `packages/core/src/route-renderer/orchestration/ownership-planning.service.ts`
+- `packages/core/src/route-renderer/orchestration/component-graph.ts`
 - `packages/core/src/route-renderer/orchestration/component-render-context.ts`
 - `packages/core/src/route-renderer/orchestration/foreign-subtree-execution.service.ts`
 - `packages/core/src/route-renderer/page-loading/page-module-loader.ts`

package/src/route-renderer/README.md

@@ -72,7 +72,7 @@ The route-render contract is:
 3. `RouteRenderOrchestrator.prepareRenderOptions()` loads the page module, validates ownership (fail-fast), resolves page data, resolves dependencies, and builds the page browser graph.
 4. The integration renderer performs page, layout, and document-shell rendering. When it encounters a foreign child, it delegates that child back to the owning renderer.
 5. If a renderer needs queued handoff, it emits internal foreign-subtree tokens and resolves them before returning final HTML.
-6. `RouteRenderOrchestrator.executePrepared()` captures the final body, rejects unresolved `<eco-marker>` artifacts, stamps root or document attributes when needed, and runs the HTML transformer.
+6. `RouteRenderOrchestrator.executePrepared()` captures the final body, rejects unresolved `<eco-marker>` artifacts, stamps document attributes when needed, and runs the HTML transformer.
 
 Important:
 

package/src/route-renderer/orchestration/component-render-context.d.ts

@@ -2,16 +2,16 @@ import type { EcoComponent } from '../../types/public-types.js';
 /**
  * Result returned by a renderer-owned foreign-child runtime.
  *
- * `inline` keeps rendering inside the current integration. `resolved` returns a
- * renderer-owned value immediately, which can be final HTML or a renderer-local
- * transport token for later queue resolution.
+ * `inline` keeps rendering inside the current integration. `resolved.value` is
+ * the queue transport token string allocated by `createQueuedRuntime`; callers
+ * must not treat arbitrary objects as resolved output.
  */
 export type ForeignChildInterceptionResult = {
     kind: 'inline';
     props?: Record<string, unknown>;
 } | {
     kind: 'resolved';
-    value: unknown;
+    value: string;
 } | undefined;
 /**
  * Foreign-child metadata passed into the active renderer-owned runtime.

package/src/route-renderer/orchestration/foreign-subtree-execution.service.js

@@ -2,7 +2,7 @@ import {
   getComponentRenderContext,
   runWithComponentRenderContext
 } from "./component-render-context.js";
-import { isMarkupNodeLike } from "./render-output.utils.js";
+import { assertForeignChildrenNotOpaque, isMarkupNodeLike } from "./render-output.utils.js";
 function toForeignSubtreeRenderPayload(result) {
   return {
     html: result.html,
@@ -69,6 +69,9 @@ class ForeignSubtreeExecutionService {
           props: { ...input.props }
         };
       }
+      if ("children" in input.props) {
+        assertForeignChildrenNotOpaque(input.props.children, "foreign-subtree queue");
+      }
       runtimeContext.nextForeignSubtreeId += 1;
       const foreignSubtreeId = runtimeContext.nextForeignSubtreeId;
       const token = this.createForeignSubtreeToken(options.tokenPrefix, runtimeContext, foreignSubtreeId);
@@ -108,10 +111,11 @@ class ForeignSubtreeExecutionService {
           return { assets: [], html: void 0 };
         }
         if (typeof children !== "string" && !isMarkupNodeLike(children)) {
+          assertForeignChildrenNotOpaque(children, options.queueLabel);
           return { assets: [], children };
         }
         const html = await this.resolveQueuedTokens(
-          typeof children === "string" ? children : children.outerHTML ?? String(children ?? ""),
+          typeof children === "string" ? children : children.outerHTML ?? "",
           queuedResolutionsByToken,
           resolveToken
         );

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

@@ -4,7 +4,7 @@
  * @module
  */
 import type { EcoPagesAppConfig, IHmrManager } from '../../types/internal-types.js';
-import type { ComponentRenderInput, ComponentRenderResult, EcoComponent, EcoComponentDependencies, EcoPageFile, EcoPagesElement, BaseIntegrationContext, HtmlTemplateProps, IntegrationRendererRenderOptions, PageBrowserGraphContribution, PageBrowserGraphContributionContext, PageBrowserGraphResult, PageMetadataProps, PagePackageResult, RouteRendererBody, RouteRendererOptions, RouteRenderResult } from '../../types/public-types.js';
+import type { ComponentRenderInput, ComponentRenderResult, EcoComponent, EcoPageFile, EcoPagesElement, BaseIntegrationContext, HtmlTemplateProps, IntegrationRendererRenderOptions, PageBrowserGraphContribution, PageBrowserGraphContributionContext, PageBrowserGraphResult, PageMetadataProps, PagePackageResult, RouteRendererBody, RouteRendererOptions, RouteRenderResult } from '../../types/public-types.js';
 import { type AssetProcessingService, type ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
 import { HtmlTransformerService } from '../../services/html/html-transformer.service.js';
 import type { HtmlDocumentContribution } from '../../services/html/html-transformer.service.js';
@@ -67,6 +67,14 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
     private renderExclusiveChain;
     protected DOC_TYPE: string;
     private runRenderExclusive;
+    /**
+     * Activates the owning integration runtime on first render or graph use.
+     */
+    protected ensureIntegrationRuntimeActivated(): Promise<void>;
+    /**
+     * Prebuilds the production Page Browser Graph for one route file.
+     */
+    prebuildProductionPageBrowserGraph(routeFile: string): Promise<void>;
     /**
      * Loads one route module through the owning renderer's import path.
      *
@@ -170,6 +178,7 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
         props: P;
         ctx: RenderToResponseContext;
         layout?: EcoComponent;
+        transformDocumentHtml?: (html: string) => string;
     }): Promise<Response>;
     /**
      * Renders a route page through optional layout and document shells.
@@ -225,16 +234,6 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
         rendererModules?: unknown;
         runtimeOrigin: string;
     });
-    /**
-     * Returns the HTML path from the provided file path.
-     * It extracts the path relative to the pages directory and removes the 'index' part if present.
-     *
-     * @param file - The file path to extract the HTML path from.
-     * @returns The extracted HTML path.
-     */
-    protected getHtmlPath({ file }: {
-        file: string;
-    }): string;
     /**
      * Returns the HTML template component.
      * It imports the HTML template from the specified path in the app configuration.
@@ -262,27 +261,6 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * @returns The resolved dependency path.
      */
     protected resolveDependencyPath(componentDir: string, pathUrl: string): string;
-    /**
-     * Extracts the dependencies from the provided component configuration.
-     * It resolves the paths for scripts and stylesheets based on the component directory.
-     *
-     * @param componentDir - The component directory path.
-     * @param scripts - The scripts to extract.
-     * @param stylesheets - The stylesheets to extract.
-     * @returns The extracted dependencies.
-     */
-    protected extractDependencies({ componentDir, scripts, stylesheets, }: {
-        componentDir: string;
-    } & EcoComponentDependencies): EcoComponentDependencies;
-    /**
-     * Resolves lazy script paths to public asset URLs.
-     * Converts source paths to their final bundled output paths.
-     *
-     * @param componentDir - The component directory path.
-     * @param scripts - The lazy script paths to resolve.
-     * @returns Comma-separated string of resolved public script paths.
-     */
-    protected resolveLazyScripts(componentDir: string, scripts: string[]): string;
     /**
      * Collects the dependencies for the provided components.
      * Combines component-specific dependencies with global integration dependencies.
@@ -312,12 +290,6 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
     }): Promise<{
         resolvedDependencies: ProcessedAsset[];
     }>;
-    protected resolveRoutePageComponentRender(input: {
-        Page: EcoComponent;
-        Layout?: EcoComponent;
-        props: Record<string, unknown>;
-        routeOptions: RouteRendererOptions;
-    }): Promise<ComponentRenderResult | undefined>;
     protected renderRouteBody(renderOptions: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody>;
     protected transformRouteResponse(response: Response, htmlContributions?: HtmlDocumentContribution[], pagePackage?: PagePackageResult): Promise<RouteRendererBody>;
     /**
@@ -328,19 +300,6 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * @returns The prepared render options.
      */
     protected prepareRenderOptions(options: RouteRendererOptions, adapter?: RouteRenderOrchestratorAdapter<C>): Promise<IntegrationRendererRenderOptions<C>>;
-    /**
-     * Controls whether the page root should be rendered through `renderComponent()`
-     * during route option preparation in component-capable modes.
-     *
-     * Integrations that already own page-level hydration (for example router-driven
-     * React rendering) can override this and return `false` to avoid duplicate root
-     * mount assets and competing hydration entrypoints.
-     */
-    protected shouldRenderPageComponent(_input: {
-        Page: EcoComponent;
-        Layout?: EcoComponent;
-        options: RouteRendererOptions;
-    }): boolean;
     /**
      * Executes the integration renderer with the provided options.
      *
@@ -348,7 +307,7 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * 1. Build normalized render options (`prepareRenderOptions`).
      * 2. Render the route body once.
      * 3. Reject unresolved route-level eco-marker artifacts.
-     * 4. Optionally apply root attributes for page/component root boundaries.
+     * 4. Optionally apply document attributes for integration-owned document boundaries.
      * 5. Run HTML transformer with final dependency set.
      *
      * Stream-safety note: the first render result is normalized to a string once,

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

@@ -14,6 +14,7 @@ import {
 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";
 import {
   ForeignSubtreeExecutionService
 } from "./foreign-subtree-execution.service.js";
@@ -45,13 +46,33 @@ class IntegrationRenderer {
   renderExclusiveChain = Promise.resolve();
   DOC_TYPE = "<!DOCTYPE html>";
   runRenderExclusive(operation) {
-    const run = this.renderExclusiveChain.then(operation, operation);
+    const run = this.renderExclusiveChain.then(async () => {
+      await this.ensureIntegrationRuntimeActivated();
+      return operation();
+    });
     this.renderExclusiveChain = run.then(
       () => void 0,
       () => void 0
     );
     return run;
   }
+  /**
+   * Activates the owning integration runtime on first render or graph use.
+   */
+  async ensureIntegrationRuntimeActivated() {
+    await ensureIntegrationRuntimeReady({
+      appConfig: this.appConfig,
+      integrationName: this.name,
+      runtimeOrigin: this.runtimeOrigin
+    });
+  }
+  /**
+   * Prebuilds the production Page Browser Graph for one route file.
+   */
+  async prebuildProductionPageBrowserGraph(routeFile) {
+    await this.ensureIntegrationRuntimeActivated();
+    await this.resolvePageBrowserGraphForFile(routeFile);
+  }
   /**
    * Loads one route module through the owning renderer's import path.
    *
@@ -281,9 +302,13 @@ class IntegrationRenderer {
    * @returns HTML response for the explicit view render.
    */
   async renderViewWithDocumentShell(input) {
+    await this.ensureIntegrationRuntimeActivated();
     const normalizedProps = input.props ?? {};
     if (input.ctx.partial) {
-      return this.renderPartialViewResponse(input);
+      return this.renderPartialViewResponse({
+        ...input,
+        transformHtml: input.transformDocumentHtml
+      });
     }
     await this.prepareViewDependencies(input.view, input.layout);
     const HtmlTemplate = await this.getHtmlTemplate();
@@ -307,8 +332,9 @@ class IntegrationRenderer {
         }
       }
     );
+    const transformedDocumentHtml = input.transformDocumentHtml ? input.transformDocumentHtml(documentHtml) : documentHtml;
     const html = await this.finalizeResolvedHtml({
-      html: `${this.DOC_TYPE}${documentHtml}`,
+      html: `${this.DOC_TYPE}${transformedDocumentHtml}`,
       partial: false
     });
     return this.createHtmlResponse(html, input.ctx);
@@ -346,7 +372,14 @@ class IntegrationRenderer {
     }
     const props = serializedChildren === void 0 ? input.props : { ...input.props, children: serializedChildren };
     const content = await component(props);
-    const html = String(content);
+    if (typeof content !== "string") {
+      const componentFile = input.component.config?.__eco?.file ?? "unknown component";
+      const contentTag = Object.prototype.toString.call(content);
+      throw new TypeError(
+        `[ecopages] ${this.name} renderer expected a string render result for ${componentFile}, received ${contentTag}.`
+      );
+    }
+    const html = content;
     const assets = input.component.config?.dependencies && typeof this.assetProcessingService?.processDependencies === "function" ? await this.processComponentDependencies([input.component]) : void 0;
     return {
       html,
@@ -435,23 +468,6 @@ class IntegrationRenderer {
       ownershipValidationService: new OwnershipValidationService(appConfig)
     });
   }
-  /**
-   * Returns the HTML path from the provided file path.
-   * It extracts the path relative to the pages directory and removes the 'index' part if present.
-   *
-   * @param file - The file path to extract the HTML path from.
-   * @returns The extracted HTML path.
-   */
-  getHtmlPath({ file }) {
-    const pagesDir = this.appConfig.absolutePaths.pagesDir;
-    const pagesIndex = file.indexOf(pagesDir);
-    if (pagesIndex === -1) return file;
-    const startIndex = file.indexOf(pagesDir) + pagesDir.length;
-    const endIndex = file.lastIndexOf("/");
-    const path = file.substring(startIndex, endIndex);
-    if (path === "/index") return "";
-    return path;
-  }
   /**
    * Returns the HTML template component.
    * It imports the HTML template from the specified path in the app configuration.
@@ -505,46 +521,6 @@ class IntegrationRenderer {
   resolveDependencyPath(componentDir, pathUrl) {
     return this.dependencyResolverService.resolveDependencyPath(componentDir, pathUrl);
   }
-  /**
-   * Extracts the dependencies from the provided component configuration.
-   * It resolves the paths for scripts and stylesheets based on the component directory.
-   *
-   * @param componentDir - The component directory path.
-   * @param scripts - The scripts to extract.
-   * @param stylesheets - The stylesheets to extract.
-   * @returns The extracted dependencies.
-   */
-  extractDependencies({
-    componentDir,
-    scripts,
-    stylesheets
-  }) {
-    const scriptsPaths = [
-      ...new Set(
-        (scripts ?? []).filter((script) => typeof script === "string" ? true : !script.lazy).map((script) => typeof script === "string" ? script : script.src).filter((script) => Boolean(script)).map((script) => this.resolveDependencyPath(componentDir, script))
-      )
-    ];
-    const stylesheetsPaths = [
-      ...new Set(
-        (stylesheets ?? []).map((style) => typeof style === "string" ? style : style.src).filter((style) => Boolean(style)).map((style) => this.resolveDependencyPath(componentDir, style))
-      )
-    ];
-    return {
-      scripts: scriptsPaths,
-      stylesheets: stylesheetsPaths
-    };
-  }
-  /**
-   * Resolves lazy script paths to public asset URLs.
-   * Converts source paths to their final bundled output paths.
-   *
-   * @param componentDir - The component directory path.
-   * @param scripts - The lazy script paths to resolve.
-   * @returns Comma-separated string of resolved public script paths.
-   */
-  resolveLazyScripts(componentDir, scripts) {
-    return this.dependencyResolverService.resolveLazyScripts(componentDir, scripts);
-  }
   /**
    * Collects the dependencies for the provided components.
    * Combines component-specific dependencies with global integration dependencies.
@@ -579,11 +555,9 @@ class IntegrationRenderer {
       resolveRouteDependencies: (input) => this.resolveRouteDependencies(input),
       importPageFile: (file) => this.importPageFile(file),
       collectPageBrowserGraphContribution: (context) => this.collectPageBrowserGraphContribution(context),
-      resolveRoutePageComponentRender: (input) => this.resolveRoutePageComponentRender(input),
       renderRouteBody: (renderOptions) => this.renderRouteBody(renderOptions),
       getDocumentAttributes: (renderOptions) => this.getDocumentAttributes(renderOptions),
       getHtmlDocumentContributions: (options) => this.getHtmlDocumentContributions(options),
-      applyAttributesToFirstBodyElement: (html, attributes) => this.applyAttributesToFirstBodyElement(html, attributes),
       applyAttributesToHtmlElement: (html, attributes) => this.applyAttributesToHtmlElement(html, attributes),
       transformRouteResponse: (response, htmlContributions, pagePackage) => this.transformRouteResponse(response, htmlContributions, pagePackage)
     });
@@ -617,22 +591,6 @@ class IntegrationRenderer {
       resolvedDependencies: await this.resolveDependencies(input.components)
     };
   }
-  async resolveRoutePageComponentRender(input) {
-    if (!this.shouldRenderPageComponent({ Page: input.Page, Layout: input.Layout, options: input.routeOptions })) {
-      return void 0;
-    }
-    return this.renderComponentWithForeignChildren({
-      component: input.Page,
-      props: {
-        ...input.props,
-        params: input.routeOptions.params || {},
-        query: input.routeOptions.query || {}
-      },
-      integrationContext: {
-        componentInstanceId: "eco-page-root"
-      }
-    });
-  }
   async renderRouteBody(renderOptions) {
     return this.render(renderOptions);
   }
@@ -658,17 +616,6 @@ class IntegrationRenderer {
     this.htmlTransformer.setPagePackage(renderOptions.pagePackage);
     return renderOptions;
   }
-  /**
-   * Controls whether the page root should be rendered through `renderComponent()`
-   * during route option preparation in component-capable modes.
-   *
-   * Integrations that already own page-level hydration (for example router-driven
-   * React rendering) can override this and return `false` to avoid duplicate root
-   * mount assets and competing hydration entrypoints.
-   */
-  shouldRenderPageComponent(_input) {
-    return true;
-  }
   /**
    * Executes the integration renderer with the provided options.
    *
@@ -676,7 +623,7 @@ class IntegrationRenderer {
    * 1. Build normalized render options (`prepareRenderOptions`).
    * 2. Render the route body once.
    * 3. Reject unresolved route-level eco-marker artifacts.
-   * 4. Optionally apply root attributes for page/component root boundaries.
+   * 4. Optionally apply document attributes for integration-owned document boundaries.
    * 5. Run HTML transformer with final dependency set.
    *
    * Stream-safety note: the first render result is normalized to a string once,

package/src/route-renderer/orchestration/integration-route-render-adapter.d.ts

@@ -1,6 +1,6 @@
 import type { ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
 import type { HtmlDocumentContribution } from '../../services/html/html-transformer.service.js';
-import type { ComponentRenderResult, EcoComponent, EcoPageFile, IntegrationRendererRenderOptions, PageBrowserGraphContribution, PageBrowserGraphContributionContext, PagePackageResult, RouteRendererBody, RouteRendererOptions } from '../../types/public-types.js';
+import type { EcoComponent, EcoPageFile, IntegrationRendererRenderOptions, PageBrowserGraphContribution, PageBrowserGraphContributionContext, PagePackageResult, RouteRendererBody, RouteRendererOptions } from '../../types/public-types.js';
 import type { RouteHtmlFinalization, RouteRenderOrchestratorAdapter, RouteRenderOrchestratorResolvedInputs } from './route-render-orchestrator.js';
 /**
  * Host surface required to build the orchestrator adapter for one integration renderer.
@@ -15,19 +15,12 @@ export type IntegrationRouteRenderAdapterHost<C> = {
     }>;
     importPageFile(file: string): Promise<EcoPageFile>;
     collectPageBrowserGraphContribution(context: PageBrowserGraphContributionContext): Promise<PageBrowserGraphContribution | undefined>;
-    resolveRoutePageComponentRender(input: {
-        Page: EcoComponent;
-        Layout?: EcoComponent;
-        props: Record<string, unknown>;
-        routeOptions: RouteRendererOptions;
-    }): Promise<ComponentRenderResult | undefined>;
     renderRouteBody(renderOptions: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody>;
     getDocumentAttributes(renderOptions: IntegrationRendererRenderOptions<C>): Record<string, string> | undefined;
     getHtmlDocumentContributions(options: {
         renderOptions: IntegrationRendererRenderOptions<C>;
         partial: boolean;
     }): HtmlDocumentContribution[] | undefined;
-    applyAttributesToFirstBodyElement(html: string, attributes: Record<string, string>): string;
     applyAttributesToHtmlElement(html: string, attributes: Record<string, string>): string;
     transformRouteResponse(response: Response, htmlContributions?: HtmlDocumentContribution[], pagePackage?: PagePackageResult): Promise<RouteRendererBody>;
 };

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

@@ -10,13 +10,11 @@ function createIntegrationRouteRenderAdapter(host) {
       (file) => host.importPageFile(file),
       (context) => host.collectPageBrowserGraphContribution(context)
     ),
-    resolveRoutePageComponentRender: (input) => host.resolveRoutePageComponentRender(input),
     renderRouteBody: (renderOptions) => host.renderRouteBody(renderOptions),
     getRouteHtmlFinalization: (renderOptions) => buildRouteHtmlFinalization({
       renderOptions,
       getDocumentAttributes: (options) => host.getDocumentAttributes(options),
       getHtmlDocumentContributions: (options) => host.getHtmlDocumentContributions(options),
-      applyAttributesToFirstBodyElement: (html, attributes) => host.applyAttributesToFirstBodyElement(html, attributes),
       applyAttributesToHtmlElement: (html, attributes) => host.applyAttributesToHtmlElement(html, attributes)
     }),
     transformRouteResponse: (response, htmlContributions, pagePackage) => host.transformRouteResponse(response, htmlContributions, pagePackage)