@ecopages/core 0.2.0-beta.3 → 0.2.0-beta.30

package/src/route-renderer/orchestration/{foreign-subtree-execution.service.js → foreign-child/foreign-subtree-execution.service.js}

@@ -2,17 +2,18 @@ import {
   getComponentRenderContext,
   runWithComponentRenderContext
 } from "./component-render-context.js";
-import {
-  QueuedForeignSubtreeResolutionService
-} from "./queued-foreign-subtree-resolution.service.js";
-function isMarkupNodeLike(value) {
-  return typeof value === "object" && value !== null && "nodeType" in value && typeof value.nodeType === "number" && (!("outerHTML" in value) || typeof value.outerHTML === "string");
+import { assertForeignChildrenNotOpaque, isMarkupNodeLike } from "./foreign-child-output.utils.js";
+function toForeignSubtreeRenderPayload(result) {
+  return {
+    html: result.html,
+    assets: result.assets ?? [],
+    rootTag: result.rootTag,
+    rootAttributes: result.rootAttributes,
+    attachmentPolicy: result.canAttachAttributes ? { kind: "first-element" } : { kind: "none" },
+    integrationName: result.integrationName
+  };
 }
 class ForeignSubtreeExecutionService {
-  queuedForeignSubtreeResolutionService;
-  constructor(queuedForeignSubtreeResolutionService = new QueuedForeignSubtreeResolutionService()) {
-    this.queuedForeignSubtreeResolutionService = queuedForeignSubtreeResolutionService;
-  }
   requiresForeignChildRuntime(input) {
     const children = input.children ?? input.props.children;
     if (children === void 0 || children === null) {
@@ -26,18 +27,9 @@ class ForeignSubtreeExecutionService {
     }
     return !isMarkupNodeLike(children);
   }
-  /**
-   * Returns whether the current render pass must hand the child off to a foreign owner.
-   */
   shouldDelegateForeignChild(input) {
     return !!input.targetIntegration && input.targetIntegration !== input.currentIntegration;
   }
-  /**
-   * Creates the base runtime used when a renderer has not supplied its own queueing runtime.
-   *
-   * The runtime allows same-integration children to continue inline and fails fast
-   * when execution crosses into a foreign owner without a renderer-owned handoff.
-   */
   createFailFastRuntime(rendererName) {
     const interceptForeignChild = (input) => {
       if (!this.shouldDelegateForeignChild(input)) {
@@ -56,10 +48,10 @@ class ForeignSubtreeExecutionService {
     };
   }
   getQueuedRuntimeContext(input, runtimeContextKey) {
-    return this.queuedForeignSubtreeResolutionService.getRuntimeContext(input, runtimeContextKey);
+    return this.getRuntimeContext(input, runtimeContextKey);
   }
   createQueuedRuntime(options) {
-    return this.queuedForeignSubtreeResolutionService.createRuntime({
+    return this.createQueueRuntime({
       renderInput: options.renderInput,
       rendererCache: options.rendererCache,
       runtimeContextKey: options.runtimeContextKey,
@@ -68,9 +60,45 @@ class ForeignSubtreeExecutionService {
       createRuntimeContext: options.createRuntimeContext
     });
   }
-  /**
-   * Resolves a string-first renderer HTML fragment that may contain queued Foreign Subtree tokens.
-   */
+  createQueueRuntime(options) {
+    const runtimeContext = this.ensureRuntimeContext(options);
+    const interceptForeignChild = (input) => {
+      if (!options.shouldQueueForeignChild(input)) {
+        return {
+          kind: "inline",
+          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);
+      runtimeContext.queuedResolutions.push({
+        token,
+        component: input.component,
+        props: { ...input.props },
+        componentInstanceId: runtimeContext.componentInstanceScope ? `${runtimeContext.componentInstanceScope}_n_${foreignSubtreeId}` : `n_${foreignSubtreeId}`
+      });
+      return {
+        kind: "resolved",
+        value: token
+      };
+    };
+    return {
+      interceptForeignChild,
+      interceptForeignChildSync: interceptForeignChild
+    };
+  }
+  getRuntimeContext(input, runtimeContextKey) {
+    const integrationContext = input.integrationContext;
+    const runtimeContext = integrationContext?.[runtimeContextKey];
+    if (typeof runtimeContext !== "object" || runtimeContext === null) {
+      return void 0;
+    }
+    return runtimeContext;
+  }
   async resolveStringQueuedHtml(options) {
     const runtimeContext = this.getQueuedRuntimeContext(options.renderInput, options.runtimeContextKey);
     return this.resolveQueuedHtml({
@@ -83,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
         );
@@ -98,7 +127,7 @@ class ForeignSubtreeExecutionService {
     });
   }
   async resolveQueuedHtml(options) {
-    return this.queuedForeignSubtreeResolutionService.resolveQueuedHtml({
+    return this.resolveQueuedForeignSubtreeTokens({
       html: options.html,
       runtimeContext: options.runtimeContext,
       queueLabel: options.queueLabel,
@@ -113,9 +142,93 @@ class ForeignSubtreeExecutionService {
       dedupeProcessedAssets: options.dedupeProcessedAssets
     });
   }
-  /**
-   * Executes one component render with Foreign Child support under the current integration.
-   */
+  async resolveQueuedForeignSubtreeTokens(options) {
+    if (!options.runtimeContext || options.runtimeContext.queuedResolutions.length === 0) {
+      return { assets: [], html: options.html };
+    }
+    const runtimeContext = options.runtimeContext;
+    const queuedResolutionsByToken = /* @__PURE__ */ new Map();
+    const resolvedHtmlByToken = /* @__PURE__ */ new Map();
+    const resolvingTokens = /* @__PURE__ */ new Set();
+    const collectedAssets = [];
+    const syncQueuedResolutions = () => {
+      for (const resolution of runtimeContext.queuedResolutions) {
+        if (!queuedResolutionsByToken.has(resolution.token)) {
+          queuedResolutionsByToken.set(resolution.token, resolution);
+        }
+      }
+    };
+    const resolveToken = async (token) => {
+      syncQueuedResolutions();
+      const cachedHtml = resolvedHtmlByToken.get(token);
+      if (cachedHtml) {
+        return cachedHtml;
+      }
+      const resolution = queuedResolutionsByToken.get(token);
+      if (!resolution) {
+        return token;
+      }
+      if (resolvingTokens.has(token)) {
+        throw new Error(
+          `[ecopages] ${options.queueLabel} foreign-subtree queue contains a cycle or unresolved dependency links.`
+        );
+      }
+      resolvingTokens.add(token);
+      try {
+        const renderedChildren = await options.renderQueuedChildren(
+          resolution.props.children,
+          runtimeContext,
+          queuedResolutionsByToken,
+          resolveToken
+        );
+        syncQueuedResolutions();
+        if (renderedChildren.assets.length > 0) {
+          collectedAssets.push(...renderedChildren.assets);
+        }
+        const foreignSubtreeRender = await options.resolveForeignSubtree(
+          {
+            component: resolution.component,
+            props: { ...resolution.props },
+            children: renderedChildren.html ?? renderedChildren.children,
+            integrationContext: {
+              rendererCache: runtimeContext.rendererCache,
+              componentInstanceId: resolution.componentInstanceId
+            }
+          },
+          runtimeContext.rendererCache
+        );
+        if (!foreignSubtreeRender) {
+          throw new Error(
+            `[ecopages] ${options.queueLabel} queued foreign subtree could not resolve its owning renderer.`
+          );
+        }
+        if ((foreignSubtreeRender.assets?.length ?? 0) > 0) {
+          collectedAssets.push(...foreignSubtreeRender.assets ?? []);
+        }
+        const resolvedHtml2 = foreignSubtreeRender.attachmentPolicy.kind === "first-element" && foreignSubtreeRender.rootAttributes ? options.applyAttributesToFirstElement(
+          foreignSubtreeRender.html,
+          foreignSubtreeRender.rootAttributes
+        ) : foreignSubtreeRender.html;
+        resolvedHtmlByToken.set(token, resolvedHtml2);
+        return resolvedHtml2;
+      } finally {
+        resolvingTokens.delete(token);
+      }
+    };
+    let resolvedHtml = options.html;
+    for (let index = 0; index < runtimeContext.queuedResolutions.length; index += 1) {
+      syncQueuedResolutions();
+      const resolution = runtimeContext.queuedResolutions[index];
+      if (!resolvedHtml.includes(resolution.token)) {
+        continue;
+      }
+      resolvedHtml = resolvedHtml.split(resolution.token).join(await resolveToken(resolution.token));
+    }
+    return {
+      assets: options.dedupeProcessedAssets(collectedAssets),
+      html: resolvedHtml
+    };
+  }
   async executeComponentRender(options) {
     const rendererCache = this.getRendererCache(options.input.integrationContext) ?? /* @__PURE__ */ new Map();
     const delegatedForeignChildRender = await this.resolveForeignChildInOwningRenderer({
@@ -167,12 +280,6 @@ class ForeignSubtreeExecutionService {
       integrationContext: integrationContext ? { ...integrationContext, rendererCache: sharedRendererCache } : { rendererCache: sharedRendererCache }
     };
   }
-  /**
-   * Returns the delegatable owning renderer integration for one component.
-   *
-   * The pseudo `html` integration marks document-shell ownership only and does
-   * not participate in component-level foreign subtree execution.
-   */
   getForeignOwnerIntegrationName(component, currentIntegrationName) {
     const integrationName = component.config?.integration ?? component.config?.__eco?.integration;
     if (!integrationName || integrationName === "html" || integrationName === currentIntegrationName) {
@@ -195,7 +302,7 @@ class ForeignSubtreeExecutionService {
       input: options.input,
       rendererCache: options.rendererCache,
       getOwningRenderer: options.getOwningRenderer,
-      run: (owningRenderer, delegatedInput) => owningRenderer.renderForeignSubtree(delegatedInput)
+      run: async (owningRenderer, delegatedInput) => toForeignSubtreeRenderPayload(await owningRenderer.renderComponentWithForeignChildren(delegatedInput))
     });
   }
   async runInForeignOwningRenderer(options) {
@@ -206,7 +313,7 @@ class ForeignSubtreeExecutionService {
     if (!foreignOwnerIntegrationName) {
       return void 0;
     }
-    const owningRenderer = options.getOwningRenderer(foreignOwnerIntegrationName, options.rendererCache);
+    const owningRenderer = await options.getOwningRenderer(foreignOwnerIntegrationName, options.rendererCache);
     if (owningRenderer.name === options.currentIntegrationName) {
       return void 0;
     }
@@ -227,7 +334,33 @@ class ForeignSubtreeExecutionService {
     }
     return resolvedHtml;
   }
+  createForeignSubtreeToken(tokenPrefix, runtimeContext, foreignSubtreeId) {
+    return `${tokenPrefix}${runtimeContext.componentInstanceScope ?? "root"}__${foreignSubtreeId}__`;
+  }
+  ensureRuntimeContext(options) {
+    let integrationContext;
+    if (typeof options.renderInput.integrationContext === "object" && options.renderInput.integrationContext !== null) {
+      integrationContext = options.renderInput.integrationContext;
+    } else {
+      integrationContext = {};
+    }
+    const existingRuntimeContext = integrationContext[options.runtimeContextKey];
+    if (typeof existingRuntimeContext !== "object" || existingRuntimeContext === null) {
+      integrationContext[options.runtimeContextKey] = options.createRuntimeContext?.(integrationContext, options.rendererCache) ?? {
+        rendererCache: options.rendererCache,
+        componentInstanceScope: integrationContext.componentInstanceId,
+        nextForeignSubtreeId: 0,
+        queuedResolutions: []
+      };
+    } else {
+      existingRuntimeContext.rendererCache = options.rendererCache;
+    }
+    integrationContext.rendererCache = options.rendererCache;
+    options.renderInput.integrationContext = integrationContext;
+    return integrationContext[options.runtimeContextKey];
+  }
 }
 export {
-  ForeignSubtreeExecutionService
+  ForeignSubtreeExecutionService,
+  toForeignSubtreeRenderPayload
 };

package/src/route-renderer/orchestration/foreign-child/owning-renderer-resolution.d.ts

@@ -0,0 +1,19 @@
+import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
+import type { ForeignSubtreeExecutionOwningRenderer } from './foreign-subtree-execution.service.js';
+export type OwningRendererResolutionInput = {
+    appConfig: EcoPagesAppConfig;
+    runtimeOrigin: string;
+    currentIntegrationName: string;
+    currentRenderer: ForeignSubtreeExecutionOwningRenderer;
+    integrationName: string;
+    cache: Map<string, ForeignSubtreeExecutionOwningRenderer>;
+};
+export declare function getForeignSubtreeTokenPrefix(integrationName: string): string;
+export declare function getForeignSubtreeResolutionContextKey(integrationName: string): string;
+/**
+ * Resolves an owning integration renderer for a foreign-child handoff.
+ *
+ * Reuses the execution-scoped cache, activates the target runtime when needed,
+ * and initializes the plugin renderer once per integration name.
+ */
+export declare function resolveOwningIntegrationRenderer(input: OwningRendererResolutionInput): Promise<ForeignSubtreeExecutionOwningRenderer>;

package/src/route-renderer/orchestration/foreign-child/owning-renderer-resolution.js

@@ -0,0 +1,35 @@
+import { ensureIntegrationRuntimeReady } from "../../../build/app-build-manifest-runtime.js";
+import { invariant } from "../../../utils/invariant.js";
+function getForeignSubtreeTokenPrefix(integrationName) {
+  return `__${integrationName}_foreign_subtree__`;
+}
+function getForeignSubtreeResolutionContextKey(integrationName) {
+  return `__${integrationName}_foreign_subtree_runtime__`;
+}
+async function resolveOwningIntegrationRenderer(input) {
+  const { integrationName, cache } = input;
+  if (cache.has(integrationName)) {
+    return cache.get(integrationName);
+  }
+  if (integrationName === input.currentIntegrationName) {
+    cache.set(integrationName, input.currentRenderer);
+    return input.currentRenderer;
+  }
+  await ensureIntegrationRuntimeReady({
+    appConfig: input.appConfig,
+    integrationName,
+    runtimeOrigin: input.runtimeOrigin
+  });
+  const integrationPlugin = input.appConfig.integrations.find((integration) => integration.name === integrationName);
+  invariant(!!integrationPlugin, `[ecopages] Integration not found for foreign owner: ${integrationName}`);
+  const renderer = integrationPlugin.initializeRenderer({
+    rendererModules: input.appConfig.runtime?.rendererModuleContext
+  });
+  cache.set(integrationName, renderer);
+  return renderer;
+}
+export {
+  getForeignSubtreeResolutionContextKey,
+  getForeignSubtreeTokenPrefix,
+  resolveOwningIntegrationRenderer
+};

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

@@ -4,17 +4,16 @@
  * @module
  */
 import type { EcoPagesAppConfig, IHmrManager } from '../../types/internal-types.js';
-import type { ComponentRenderInput, ComponentRenderResult, ForeignSubtreeRenderPayload, EcoComponent, EcoComponentDependencies, EcoPageFile, EcoPagesElement, BaseIntegrationContext, HtmlTemplateProps, IntegrationRendererRenderOptions, PageBrowserGraphContribution, PageBrowserGraphContributionContext, PageBrowserGraphResult, PageMetadataProps, RouteRendererBody, RouteRendererOptions, RouteRenderResult } from '../../types/public-types.js';
+import type { ComponentRenderInput, ComponentRenderResult, EcoComponent, EcoPageFile, EcoPagesElement, HtmlTemplateProps, IntegrationRendererRenderOptions, PageBrowserGraphContribution, PageBrowserGraphContributionContext, PageBrowserGraphResult, PageMetadataProps, 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';
 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 { type RouteHtmlFinalization, RouteRenderOrchestrator, type RouteRenderOrchestratorAdapter, type RouteRenderOrchestratorResolvedInputs } from './route-render-orchestrator.js';
-import type { ForeignChildRuntime } from './component-render-context.js';
-import { ForeignSubtreeExecutionService, type ForeignSubtreeExecutionOwningRenderer } from './foreign-subtree-execution.service.js';
-import { type QueuedForeignSubtreeResolutionContext } from './queued-foreign-subtree-resolution.service.js';
+import { RouteRenderOrchestrator, type RouteRenderOrchestratorAdapter, type RouteRenderOrchestratorResolvedInputs } from './route-pipeline/route-render-orchestrator.js';
+import type { ForeignChildRuntime } from './foreign-child/component-render-context.js';
+import { ForeignSubtreeExecutionService } from './foreign-child/foreign-subtree-execution.service.js';
 /**
  * Controls how one route module is loaded outside the normal render path.
  *
@@ -59,7 +58,23 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
     protected pageModuleLoaderService: PageModuleLoaderService;
     protected routeRenderOrchestrator: RouteRenderOrchestrator;
     protected readonly foreignSubtreeExecutionService: ForeignSubtreeExecutionService;
+    /**
+     * Serializes route and view renders that mutate `htmlTransformer` state.
+     *
+     * Integration renderers are cached per integration, so concurrent static builds
+     * and overlapping SSR requests must not share one transformer page package.
+     */
+    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.
      *
@@ -69,34 +84,6 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * with raw transpiler access.
      */
     loadPageModule(file: string, options?: RouteModuleLoadOptions): Promise<EcoPageFile>;
-    /**
-     * Reads the execution-scoped owning-renderer cache from one render input.
-     *
-     * Shared page/layout/document shell helpers pass one cache through
-     * `integrationContext` so repeated delegation to the same foreign integration
-     * can reuse a single initialized renderer instance during one render flow.
-     * The cache is deliberately scoped to the current render execution rather than
-     * stored on the renderer, which avoids leaking mutable integration state across
-     * requests while still preventing redundant renderer initialization.
-     *
-     * @param integrationContext - Optional render context carried with one render input.
-     * @returns The current execution cache when present.
-     */
-    private getOwningRendererCache;
-    private getForeignOwnerIntegrationName;
-    /**
-     * Attaches an execution-scoped owning-renderer cache to one render input.
-     *
-     * Foreign-owned page, layout, or document shells may delegate several times in
-     * the same render flow. Threading the cache through `integrationContext`
-     * preserves renderer reuse without changing the public render input contract.
-     * Existing integration-specific context is preserved and augmented.
-     *
-     * @param input - Original render input.
-     * @param rendererCache - Execution-scoped renderer cache to propagate.
-     * @returns Render input augmented with the shared renderer cache.
-     */
-    private withOwningRendererCache;
     protected getRendererModuleValue(key: string): unknown;
     protected getRendererModuleString(key: string): string | undefined;
     protected getRendererBootstrapDependencies(partial?: boolean): ProcessedAsset[];
@@ -131,7 +118,6 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      */
     protected prepareViewDependencies(view: EcoComponent, layout?: EcoComponent): Promise<ProcessedAsset[]>;
     protected resolvePageBrowserGraphForFile(filePath: string): Promise<PageBrowserGraphResult | undefined>;
-    protected mergePageBrowserGraphIntoPagePackage(pageBrowserGraph?: PageBrowserGraphResult): PageBrowserGraphResult | undefined;
     /**
      * Merges component-scoped assets into the active HTML transformer state.
      *
@@ -191,6 +177,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.
@@ -219,31 +206,7 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
         documentProps?: Record<string, unknown>;
         transformDocumentHtml?: (html: string) => string;
     }): Promise<string>;
-    private composeDocumentShell;
-    /**
-     * Renders one string-first component with serialized children and collects its assets.
-     *
-     * String-oriented integrations frequently share the same component contract:
-     * pass serialized children through props, coerce the render result to HTML, and
-     * attach any component-scoped dependencies. This helper centralizes that flow
-     * so integrations can opt into shared orchestration without repeating the same
-     * string-render boilerplate.
-     *
-     * @param input - Component render input.
-     * @param component - String-oriented component implementation to execute.
-     * @returns Structured component render result for orchestration paths.
-     */
     protected renderStringComponentWithSerializedChildren(input: ComponentRenderInput, component: (props: Record<string, unknown>) => Promise<EcoPagesElement> | EcoPagesElement): Promise<ComponentRenderResult>;
-    protected getForeignSubtreeTokenPrefix(): string;
-    protected getForeignSubtreeResolutionContextKey(): string;
-    protected createQueuedForeignSubtreeExecutionRuntime<TContext extends QueuedForeignSubtreeResolutionContext>(options: {
-        renderInput: ComponentRenderInput;
-        rendererCache: Map<string, IntegrationRenderer<any>>;
-        runtimeContextKey?: string;
-        tokenPrefix?: string;
-        createRuntimeContext?: (integrationContext: BaseIntegrationContext & Record<string, unknown>, rendererCache: Map<string, unknown>) => TContext;
-    }): ForeignChildRuntime;
-    protected getQueuedForeignSubtreeResolutionContext<TContext extends QueuedForeignSubtreeResolutionContext>(input: ComponentRenderInput): TContext | undefined;
     /**
      * Renders a string-first component, then resolves any queued foreign
      * boundaries before returning final component HTML.
@@ -256,16 +219,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.
@@ -293,27 +246,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.
@@ -343,15 +275,7 @@ 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 getRouteHtmlFinalization(renderOptions: IntegrationRendererRenderOptions<C>): RouteHtmlFinalization;
-    protected transformRouteResponse(response: Response, htmlContributions?: HtmlDocumentContribution[]): Promise<RouteRendererBody>;
     /**
      * Prepares the render options for the integration renderer.
      * It imports the page file, collects dependencies, and prepares the render options.
@@ -360,19 +284,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.
      *
@@ -380,7 +291,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,
@@ -391,21 +302,6 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * @returns Rendered route body plus effective cache strategy.
      */
     execute(options: RouteRendererOptions): Promise<RouteRenderResult>;
-    /**
-     * 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.
-     */
-    protected finalizeResolvedHtml(options: {
-        html: string;
-        partial?: boolean;
-        componentRootAttributes?: Record<string, string>;
-        documentAttributes?: Record<string, string>;
-        transformHtml?: boolean;
-        htmlContributions?: HtmlDocumentContribution[];
-    }): Promise<string>;
     /**
      * Returns document-level attributes to stamp onto the rendered `<html>` tag.
      *
@@ -413,6 +309,8 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * other runtime coordination markers without relying on script sniffing.
      */
     protected getDocumentAttributes(_renderOptions: IntegrationRendererRenderOptions<C>): Record<string, string> | undefined;
+    protected applyAttributesToFirstBodyElement(html: string, attributes: Record<string, string>): string;
+    protected applyAttributesToHtmlElement(html: string, attributes: Record<string, string>): string;
     /**
      * Returns declarative HTML fragments that core should inject into the final document.
      *
@@ -423,17 +321,6 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * response finalization logic.
      */
     protected getHtmlDocumentContributions(_options: HtmlDocumentContributionContext<C>): HtmlDocumentContribution[] | undefined;
-    /**
-     * 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`.
-     */
-    protected getIntegrationRendererForName(integrationName: string, cache: Map<string, ForeignSubtreeExecutionOwningRenderer>): ForeignSubtreeExecutionOwningRenderer;
     /**
      * Abstract method to render the integration-specific component.
      * This method should be implemented by the specific integration renderer.
@@ -451,12 +338,6 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * renderer's nested foreign-child handoff.
      */
     renderComponentWithForeignChildren(input: ComponentRenderInput): Promise<ComponentRenderResult>;
-    /**
-     * Compatibility foreign-subtree contract that exposes a narrower payload shape for
-     * future route-composition work while preserving the current
-     * `renderComponentWithForeignChildren()` runtime semantics.
-     */
-    renderForeignSubtree(input: ComponentRenderInput): Promise<ForeignSubtreeRenderPayload>;
     private normalizeComponentRenderOutput;
     protected normalizeUnresolvedMarkerArtifactHtml(html: string): string;
     /**