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

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

@@ -0,0 +1,206 @@
+import {
+  getComponentRenderContext,
+  runWithComponentRenderContext
+} from "./component-render-context.js";
+import {
+  QueuedForeignSubtreeResolutionService
+} from "./queued-foreign-subtree-resolution.service.js";
+class ForeignSubtreeExecutionService {
+  queuedForeignSubtreeResolutionService;
+  constructor(queuedForeignSubtreeResolutionService = new QueuedForeignSubtreeResolutionService()) {
+    this.queuedForeignSubtreeResolutionService = queuedForeignSubtreeResolutionService;
+  }
+  /**
+   * 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)) {
+        return { kind: "inline" };
+      }
+      throw new Error(
+        `[ecopages] ${rendererName} renderer crossed into ${input.targetIntegration} without a renderer-owned foreign-child runtime. Override createForeignChildRuntime() to resolve foreign children inside the owning renderer.`
+      );
+    };
+    return {
+      interceptForeignChild,
+      interceptForeignChildSync: interceptForeignChild
+    };
+  }
+  getQueuedRuntimeContext(input, runtimeContextKey) {
+    return this.queuedForeignSubtreeResolutionService.getRuntimeContext(input, runtimeContextKey);
+  }
+  createQueuedRuntime(options) {
+    return this.queuedForeignSubtreeResolutionService.createRuntime({
+      renderInput: options.renderInput,
+      rendererCache: options.rendererCache,
+      runtimeContextKey: options.runtimeContextKey,
+      tokenPrefix: options.tokenPrefix,
+      shouldQueueForeignChild: (input) => this.shouldDelegateForeignChild(input),
+      createRuntimeContext: options.createRuntimeContext
+    });
+  }
+  /**
+   * Resolves a string-first renderer HTML fragment that may contain queued Foreign Subtree tokens.
+   */
+  async resolveStringQueuedHtml(options) {
+    const runtimeContext = this.getQueuedRuntimeContext(options.renderInput, options.runtimeContextKey);
+    return this.resolveQueuedHtml({
+      currentIntegrationName: options.currentIntegrationName,
+      html: options.html,
+      runtimeContext,
+      queueLabel: options.queueLabel,
+      renderQueuedChildren: async (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => {
+        if (children === void 0) {
+          return { assets: [], html: void 0 };
+        }
+        const html = await this.resolveQueuedTokens(
+          typeof children === "string" ? children : String(children ?? ""),
+          queuedResolutionsByToken,
+          resolveToken
+        );
+        return { assets: [], html };
+      },
+      getOwningRenderer: options.getOwningRenderer,
+      applyAttributesToFirstElement: options.applyAttributesToFirstElement,
+      dedupeProcessedAssets: options.dedupeProcessedAssets
+    });
+  }
+  async resolveQueuedHtml(options) {
+    return this.queuedForeignSubtreeResolutionService.resolveQueuedHtml({
+      html: options.html,
+      runtimeContext: options.runtimeContext,
+      queueLabel: options.queueLabel,
+      renderQueuedChildren: options.renderQueuedChildren,
+      resolveForeignSubtree: (input, rendererCache) => this.resolveForeignSubtreeInOwningRenderer({
+        currentIntegrationName: options.currentIntegrationName,
+        input,
+        rendererCache,
+        getOwningRenderer: options.getOwningRenderer
+      }),
+      applyAttributesToFirstElement: options.applyAttributesToFirstElement,
+      dedupeProcessedAssets: options.dedupeProcessedAssets
+    });
+  }
+  /**
+   * Executes one component render with Foreign Child support under the current integration.
+   */
+  async executeComponentRender(options) {
+    const rendererCache = this.getRendererCache(options.input.integrationContext) ?? /* @__PURE__ */ new Map();
+    const delegatedForeignChildRender = await this.resolveForeignChildInOwningRenderer({
+      currentIntegrationName: options.currentIntegrationName,
+      input: options.input,
+      rendererCache,
+      getOwningRenderer: options.getOwningRenderer
+    });
+    if (delegatedForeignChildRender) {
+      return delegatedForeignChildRender;
+    }
+    const hasForeignChildren = options.hasForeignChildDescendants(options.input.component);
+    const activeRenderContext = getComponentRenderContext();
+    if (!hasForeignChildren) {
+      if (!activeRenderContext || activeRenderContext.currentIntegration === options.currentIntegrationName) {
+        return options.normalizeComponentRenderOutput(await options.renderComponent(options.input));
+      }
+      const sameIntegrationExecution = await runWithComponentRenderContext(
+        {
+          currentIntegration: options.currentIntegrationName
+        },
+        async () => options.renderComponent(options.input)
+      );
+      return options.normalizeComponentRenderOutput(sameIntegrationExecution.value);
+    }
+    const execution = await runWithComponentRenderContext(
+      {
+        currentIntegration: options.currentIntegrationName,
+        foreignChildRuntime: options.createForeignChildRuntime({
+          renderInput: options.input,
+          rendererCache
+        })
+      },
+      async () => options.renderComponent(options.input)
+    );
+    return options.normalizeComponentRenderOutput(execution.value);
+  }
+  getRendererCache(integrationContext) {
+    if (integrationContext?.rendererCache instanceof Map) {
+      return integrationContext.rendererCache;
+    }
+    return void 0;
+  }
+  withRendererCache(input, rendererCache) {
+    const integrationContext = input.integrationContext;
+    const sharedRendererCache = rendererCache;
+    return {
+      ...input,
+      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) {
+      return void 0;
+    }
+    return integrationName;
+  }
+  async resolveForeignChildInOwningRenderer(options) {
+    return await this.runInForeignOwningRenderer({
+      currentIntegrationName: options.currentIntegrationName,
+      input: options.input,
+      rendererCache: options.rendererCache,
+      getOwningRenderer: options.getOwningRenderer,
+      run: (owningRenderer, delegatedInput) => owningRenderer.renderComponentWithForeignChildren(delegatedInput)
+    });
+  }
+  async resolveForeignSubtreeInOwningRenderer(options) {
+    return await this.runInForeignOwningRenderer({
+      currentIntegrationName: options.currentIntegrationName,
+      input: options.input,
+      rendererCache: options.rendererCache,
+      getOwningRenderer: options.getOwningRenderer,
+      run: (owningRenderer, delegatedInput) => owningRenderer.renderForeignSubtree(delegatedInput)
+    });
+  }
+  async runInForeignOwningRenderer(options) {
+    const foreignOwnerIntegrationName = this.getForeignOwnerIntegrationName(
+      options.input.component,
+      options.currentIntegrationName
+    );
+    if (!foreignOwnerIntegrationName) {
+      return void 0;
+    }
+    const owningRenderer = options.getOwningRenderer(foreignOwnerIntegrationName, options.rendererCache);
+    if (owningRenderer.name === options.currentIntegrationName) {
+      return void 0;
+    }
+    return await options.run(owningRenderer, this.withRendererCache(options.input, options.rendererCache));
+  }
+  async resolveQueuedTokens(html, queuedResolutionsByToken, resolveToken) {
+    let resolvedHtml = html;
+    for (const token of queuedResolutionsByToken.keys()) {
+      if (!resolvedHtml.includes(token)) {
+        continue;
+      }
+      resolvedHtml = resolvedHtml.split(token).join(await resolveToken(token));
+    }
+    return resolvedHtml;
+  }
+}
+export {
+  ForeignSubtreeExecutionService
+};

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

@@ -4,22 +4,16 @@
  * @module
  */
 import type { EcoPagesAppConfig, IHmrManager } from '../../types/internal-types.js';
-import type { ComponentRenderInput, ComponentRenderResult, BoundaryRenderPayload, EcoComponent, EcoComponentDependencies, EcoPageComponent, EcoPageFile, EcoPagesElement, GetMetadata, GetMetadataContext, GetStaticProps, BaseIntegrationContext, HtmlTemplateProps, IntegrationRendererRenderOptions, PageMetadataProps, RouteRendererBody, RouteRendererOptions, RouteRenderResult } from '../../types/public-types.js';
+import type { ComponentRenderInput, ComponentRenderResult, ForeignSubtreeRenderPayload, EcoComponent, EcoComponentDependencies, EcoPageFile, EcoPagesElement, BaseIntegrationContext, HtmlTemplateProps, IntegrationRendererRenderOptions, 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 { HttpError } from '../../errors/http-error.js';
 import { DependencyResolverService } from '../page-loading/dependency-resolver.js';
 import { PageModuleLoaderService } from '../page-loading/page-module-loader.js';
-import { PagePackagingService } from './page-packaging.service.js';
-import { RenderExecutionService } from './render-execution.service.js';
-import { RenderPreparationService } from './render-preparation.service.js';
-import { RouteShellComposer } from './route-shell-composer.service.js';
-import type { ComponentBoundaryRuntime } from './component-render-context.js';
-import { QueuedBoundaryRuntimeService, type QueuedBoundaryResolution, type QueuedBoundaryRuntimeContext } from './queued-boundary-runtime.service.js';
-type BoundaryRenderDecisionInput = {
-    currentIntegration: string;
-    targetIntegration?: string;
-};
+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';
 /**
  * Controls how one route module is loaded outside the normal render path.
  *
@@ -56,11 +50,8 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
     protected runtimeOrigin: string;
     protected dependencyResolverService: DependencyResolverService;
     protected pageModuleLoaderService: PageModuleLoaderService;
-    protected renderPreparationService: RenderPreparationService;
-    protected renderExecutionService: RenderExecutionService;
-    protected pagePackagingService: PagePackagingService;
-    protected readonly routeShellComposer: RouteShellComposer;
-    protected readonly queuedBoundaryRuntimeService: QueuedBoundaryRuntimeService;
+    protected routeRenderOrchestrator: RouteRenderOrchestrator;
+    protected readonly foreignSubtreeExecutionService: ForeignSubtreeExecutionService;
     protected DOC_TYPE: string;
     /**
      * Loads one route module through the owning renderer's import path.
@@ -72,7 +63,7 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      */
     loadPageModule(file: string, options?: RouteModuleLoadOptions): Promise<EcoPageFile>;
     /**
-     * Reads the execution-scoped foreign renderer cache from one boundary input.
+     * 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
@@ -81,24 +72,24 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * stored on the renderer, which avoids leaking mutable integration state across
      * requests while still preventing redundant renderer initialization.
      *
-     * @param integrationContext - Optional boundary context carried with one render input.
+     * @param integrationContext - Optional render context carried with one render input.
      * @returns The current execution cache when present.
      */
-    private getBoundaryRendererCache;
-    private getRegisteredBoundaryOwner;
+    private getOwningRendererCache;
+    private getForeignOwnerIntegrationName;
     /**
-     * Attaches an execution-scoped foreign renderer cache to one boundary input.
+     * 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 boundary input contract.
+     * preserves renderer reuse without changing the public render input contract.
      * Existing integration-specific context is preserved and augmented.
      *
-     * @param input - Original boundary render input.
+     * @param input - Original render input.
      * @param rendererCache - Execution-scoped renderer cache to propagate.
-     * @returns Boundary input augmented with the shared renderer cache.
+     * @returns Render input augmented with the shared renderer cache.
      */
-    private withBoundaryRendererCache;
+    private withOwningRendererCache;
     protected getRendererModuleValue(key: string): unknown;
     protected getRendererModuleString(key: string): string | undefined;
     protected getRendererBootstrapDependencies(partial?: boolean): ProcessedAsset[];
@@ -136,7 +127,7 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * Merges component-scoped assets into the active HTML transformer state.
      *
      * Explicit page, layout, and document shell composition can produce assets at
-     * each boundary. This helper deduplicates those groups and folds them back into
+     * each foreign subtree. This helper deduplicates those groups and folds them back into
      * the transformer so downstream HTML finalization sees one canonical asset set.
      *
      * @param assetGroups - Optional groups of processed assets to merge.
@@ -160,7 +151,7 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      *
      * Same-integration views can optionally stream or render inline via the caller's
      * `renderInline()` hook. Once a view may cross integration boundaries, this
-     * helper routes the render through `renderComponentBoundary()` instead so mixed
+     * helper routes the render through `renderComponentWithForeignChildren()` instead so mixed
      * shells can reuse the execution-scoped renderer cache and resolve nested
      * foreign ownership before the partial response is returned.
      *
@@ -195,10 +186,10 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
     /**
      * Renders a route page through optional layout and document shells.
      *
-     * Route rendering and explicit view rendering now share the same boundary-owned
+     * Route rendering and explicit view rendering now share the same renderer-owned
      * shell composition model. This helper composes page, layout, and html template
-     * boundaries while threading one execution-scoped renderer cache through every
-     * delegated boundary so foreign shell ownership remains stable and renderer
+     * renders while threading one execution-scoped renderer cache through every
+     * delegated foreign subtree so foreign shell ownership remains stable and renderer
      * initialization is reused inside the current request.
      *
      * @param input - Page, layout, document, and metadata inputs for the route render.
@@ -219,48 +210,36 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
         documentProps?: Record<string, unknown>;
         transformDocumentHtml?: (html: string) => string;
     }): Promise<string>;
+    private composeDocumentShell;
     /**
-     * Renders one string-first component boundary and collects its assets.
+     * Renders one string-first component with serialized children and collects its assets.
      *
-     * String-oriented integrations frequently share the same boundary contract:
+     * 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
-     * boundary boilerplate.
+     * string-render boilerplate.
      *
-     * @param input - Boundary render input.
+     * @param input - Component render input.
      * @param component - String-oriented component implementation to execute.
      * @returns Structured component render result for orchestration paths.
      */
-    protected renderStringComponentBoundary(input: ComponentRenderInput, component: (props: Record<string, unknown>) => Promise<EcoPagesElement> | EcoPagesElement): Promise<ComponentRenderResult>;
-    protected getBoundaryTokenPrefix(): string;
-    protected getBoundaryRuntimeContextKey(): string;
-    protected getQueuedBoundaryRuntime<TContext extends QueuedBoundaryRuntimeContext>(input: ComponentRenderInput, runtimeContextKey?: string): TContext | undefined;
-    protected resolveQueuedBoundaryTokens(html: string, queuedResolutionsByToken: Map<string, QueuedBoundaryResolution>, resolveToken: (token: string) => Promise<string>): Promise<string>;
-    protected createQueuedBoundaryRuntime<TContext extends QueuedBoundaryRuntimeContext>(options: {
-        boundaryInput: ComponentRenderInput;
+    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;
-    }): ComponentBoundaryRuntime;
-    protected resolveRendererOwnedQueuedBoundaryHtml<TContext extends QueuedBoundaryRuntimeContext>(options: {
-        html: string;
-        runtimeContext?: TContext;
-        queueLabel: string;
-        renderQueuedChildren: (children: unknown, runtimeContext: TContext, queuedResolutionsByToken: Map<string, QueuedBoundaryResolution>, resolveToken: (token: string) => Promise<string>) => Promise<{
-            assets: ProcessedAsset[];
-            html?: string;
-        }>;
-    }): Promise<{
-        assets: ProcessedAsset[];
-        html: string;
-    }>;
+    }): 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.
      */
-    protected renderStringComponentBoundaryWithQueuedForeignBoundaries(input: ComponentRenderInput, component: (props: Record<string, unknown>) => Promise<EcoPagesElement> | EcoPagesElement): Promise<ComponentRenderResult>;
+    protected renderStringComponentWithQueuedForeignSubtrees(input: ComponentRenderInput, component: (props: Record<string, unknown>) => Promise<EcoPagesElement> | EcoPagesElement): Promise<ComponentRenderResult>;
     constructor({ appConfig, assetProcessingService, resolvedIntegrationDependencies, rendererModules, runtimeOrigin, }: {
         appConfig: EcoPagesAppConfig;
         assetProcessingService: AssetProcessingService;
@@ -285,27 +264,6 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * @returns The HTML template component.
      */
     protected getHtmlTemplate(): Promise<EcoComponent<HtmlTemplateProps>>;
-    /**
-     * Returns the static props for the page.
-     * It calls the provided getStaticProps function with the given options.
-     *
-     * @param getStaticProps - The function to get static props.
-     * @param options - The options to pass to the getStaticProps function.
-     * @returns The static props and metadata.
-     */
-    protected getStaticProps(getStaticProps?: GetStaticProps<Record<string, unknown>>, options?: Pick<RouteRendererOptions, 'params'>): Promise<{
-        props: Record<string, unknown>;
-        metadata?: PageMetadataProps;
-    }>;
-    /**
-     * Returns the metadata properties for the page.
-     * It calls the provided getMetadata function with the given context.
-     *
-     * @param getMetadata - The function to get metadata.
-     * @param context - The context to pass to the getMetadata function.
-     * @returns The metadata properties.
-     */
-    protected getMetadataProps(getMetadata: GetMetadata | undefined, { props, params, query }: GetMetadataContext): Promise<PageMetadataProps>;
     protected usesIntegrationPageImporter(_file: string): boolean;
     protected importIntegrationPageFile(_file: string, _options?: RouteModuleLoadOptions): Promise<EcoPageFile>;
     protected normalizeImportedPageFile<TPageModule extends EcoPageFile>(_file: string, pageModule: TPageModule): TPageModule;
@@ -361,6 +319,34 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * @param components - The components to collect dependencies from.
      */
     protected processComponentDependencies(components: (EcoComponent | Partial<EcoComponent>)[]): Promise<ProcessedAsset[]>;
+    /**
+     * Builds the internal route-render adapter consumed by `RouteRenderOrchestrator`.
+     *
+     * The route orchestrator needs a narrow orchestration contract, but those hooks should
+     * not become public API on the renderer base class. Keeping the adapter object
+     * local to the execution path lets the orchestrator depend on one explicit seam while
+     * subclasses continue to override protected renderer behavior directly.
+     */
+    protected createRouteRenderOrchestratorAdapter(): RouteRenderOrchestratorAdapter<C>;
+    protected resolveRouteRenderInputs(routeOptions: RouteRendererOptions): Promise<RouteRenderOrchestratorResolvedInputs>;
+    protected resolveRouteAssets(input: {
+        routeOptions: RouteRendererOptions;
+        components: (EcoComponent | Partial<EcoComponent>)[];
+    }): Promise<{
+        resolvedDependencies: ProcessedAsset[];
+        pageBrowserGraph?: {
+            assets: 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): Promise<RouteRendererBody>;
     /**
      * Prepares the render options for the integration renderer.
      * It imports the page file, collects dependencies, and prepares the render options.
@@ -368,7 +354,7 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * @param options - The route renderer options.
      * @returns The prepared render options.
      */
-    protected prepareRenderOptions(options: RouteRendererOptions): Promise<IntegrationRendererRenderOptions>;
+    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.
@@ -382,32 +368,13 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
         Layout?: EcoComponent;
         options: RouteRendererOptions;
     }): boolean;
-    /**
-     * Resolves the page module and normalizes exports.
-     */
-    protected resolvePageModule(file: string): Promise<{
-        Page: EcoPageFile['default'] | EcoPageComponent<any>;
-        getStaticProps?: GetStaticProps<Record<string, unknown>>;
-        getMetadata?: GetMetadata;
-        integrationSpecificProps: Record<string, unknown>;
-    }>;
-    /**
-     * Resolves static props and metadata for the page.
-     */
-    protected resolvePageData(pageModule: {
-        getStaticProps?: GetStaticProps<Record<string, unknown>>;
-        getMetadata?: GetMetadata;
-    }, options: RouteRendererOptions): Promise<{
-        props: Record<string, unknown>;
-        metadata: PageMetadataProps;
-    }>;
     /**
      * Executes the integration renderer with the provided options.
      *
      * Execution flow:
      * 1. Build normalized render options (`prepareRenderOptions`).
      * 2. Render the route body once.
-     * 3. Reject unresolved route-level boundary artifacts.
+     * 3. Reject unresolved route-level eco-marker artifacts.
      * 4. Optionally apply root attributes for page/component root boundaries.
      * 5. Run HTML transformer with final dependency set.
      *
@@ -423,7 +390,7 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * 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 boundary resolution without
+     * available after a renderer has completed nested foreign-subtree resolution without
      * routing back through shared route execution.
      */
     protected finalizeResolvedHtml(options: {
@@ -450,7 +417,7 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * @returns Renderer for the requested integration.
      * @throws Error when no integration plugin matches `integrationName`.
      */
-    private getIntegrationRendererForName;
+    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.
@@ -459,33 +426,31 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * @returns The rendered body.
      */
     abstract render(options: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody>;
-    protected resolveBoundaryInOwningRenderer(input: ComponentRenderInput, rendererCache: Map<string, IntegrationRenderer<any>>): Promise<ComponentRenderResult | undefined>;
-    protected resolveBoundaryPayloadInOwningRenderer(input: ComponentRenderInput, rendererCache: Map<string, IntegrationRenderer<any>>): Promise<BoundaryRenderPayload | undefined>;
     /**
-     * Renders one component under this integration's boundary runtime and resolves
-     * any nested foreign boundaries captured during that render.
+     * Renders one component under this integration's foreign-child runtime and resolves
+     * any nested foreign children captured during that render.
      *
      * Without this wrapper, a component tree with foreign-owned descendants would
-     * render them with no active boundary runtime, which bypasses the owning
-     * renderer's nested-boundary handoff.
+     * render them with no active foreign-child runtime, which bypasses the owning
+     * renderer's nested foreign-child handoff.
      */
-    renderComponentBoundary(input: ComponentRenderInput): Promise<ComponentRenderResult>;
+    renderComponentWithForeignChildren(input: ComponentRenderInput): Promise<ComponentRenderResult>;
     /**
-     * Compatibility boundary contract that exposes a narrower payload shape for
+     * Compatibility foreign-subtree contract that exposes a narrower payload shape for
      * future route-composition work while preserving the current
-     * `renderComponentBoundary()` runtime semantics.
+     * `renderComponentWithForeignChildren()` runtime semantics.
      */
-    renderBoundary(input: ComponentRenderInput): Promise<BoundaryRenderPayload>;
-    private normalizeComponentBoundaryRender;
-    protected normalizeBoundaryArtifactHtml(html: string): string;
+    renderForeignSubtree(input: ComponentRenderInput): Promise<ForeignSubtreeRenderPayload>;
+    private normalizeComponentRenderOutput;
+    protected normalizeUnresolvedMarkerArtifactHtml(html: string): string;
     /**
      * Returns whether the component dependency tree crosses into another
      * integration.
      *
-     * This keeps boundary-runtime setup narrow: same-integration trees can render
+     * This keeps foreign-child runtime setup narrow: same-integration trees can render
      * directly without paying the queue orchestration cost.
      */
-    protected hasForeignBoundaryDescendants(component: EcoComponent): boolean;
+    protected hasForeignChildDescendants(component: EcoComponent): boolean;
     /**
      * Render a view directly to a Response object.
      * Used for explicit routing where views are rendered from route handlers.
@@ -502,8 +467,8 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      * Default behavior delegates to `renderToResponse` in partial mode and wraps
      * the resulting HTML into the `ComponentRenderResult` contract.
      *
-     * In boundary resolution, this method is the integration-owned step that turns an
-     * already-resolved deferred boundary into concrete HTML, assets, and optional
+     * In foreign-subtree resolution, this method is the integration-owned step that turns an
+     * already-resolved deferred foreign subtree into concrete HTML, assets, and optional
      * root attributes.
      *
      * Integrations can override this for richer behavior (asset emission,
@@ -521,36 +486,31 @@ export declare abstract class IntegrationRenderer<C = EcoPagesElement> {
      */
     protected getRootTagName(html: string): string | undefined;
     /**
-     * Method to build route render assets.
+     * Builds the Page Browser Graph owned by this integration for one Page.
      * This method can be optionally overridden by the specific integration renderer.
      *
      * @param file - The file path to build assets for.
-     * @returns The processed assets or undefined.
+     * @returns The structured Page Browser Graph or undefined.
      */
-    protected buildRouteRenderAssets(_file: string): Promise<ProcessedAsset[]> | undefined;
+    protected buildPageBrowserGraph(_file: string): Promise<{
+        assets: ProcessedAsset[];
+    } | undefined>;
     /**
-     * Creates the per-render boundary runtime adopted by the shared component
+     * Creates the per-render foreign-child runtime adopted by the shared component
      * render context.
      *
-     * Real mixed-integration renderers should override this and keep foreign
-     * boundary resolution inside their own renderer-owned queue. The base runtime
-     * fails fast when a renderer crosses into a foreign owner without providing its
-     * own handoff mechanism.
+     * The default runtime queues delegated foreign subtrees inside the owning
+     * renderer so string and markup renderers do not need to re-declare the same
+     * handoff boilerplate. Override only when a renderer needs custom runtime
+     * context or a different foreign-child execution strategy.
      */
-    protected createComponentBoundaryRuntime(_options: {
-        boundaryInput: ComponentRenderInput;
+    protected createForeignChildRuntime(options: {
+        renderInput: ComponentRenderInput;
         rendererCache: Map<string, IntegrationRenderer<any>>;
-    }): ComponentBoundaryRuntime;
+    }): ForeignChildRuntime;
     /**
-     * Resolves whether a boundary should leave the current render pass and be
-     * resolved by its owning renderer.
-     *
-     * Boundaries owned by the current integration always render inline. Foreign-
-     * owned boundaries must be handed off by a renderer-owned runtime.
-     *
-     * @param input Boundary metadata for the active render pass.
-     * @returns `true` when the boundary should leave the current pass; otherwise `false`.
+     * Creates an explicit fail-fast runtime for tests or renderers that do not
+     * support cross-integration foreign-child execution.
      */
-    protected shouldResolveBoundaryInOwningRenderer(input: BoundaryRenderDecisionInput): boolean;
+    protected createFailFastForeignChildRuntime(): ForeignChildRuntime;
 }
-export {};