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

package/src/route-renderer/orchestration/{render-preparation.service.js → route-render-orchestrator.js}

@@ -1,12 +1,14 @@
 import { createRequire } from "node:module";
 import path from "node:path";
 import {
-  AssetFactory
+  AssetFactory,
+  createPagePackage
 } from "../../services/assets/asset-processing-service/index.js";
 import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../../eco/global-injector-map.js";
 import { LocalsAccessError } from "../../errors/locals-access-error.js";
-import { BoundaryPlanningService } from "./boundary-planning.service.js";
-import { PagePackagingService } from "./page-packaging.service.js";
+import { inspectUnresolvedMarkerArtifactHtml } from "./render-output.utils.js";
+import { OwnershipValidationService } from "./ownership-validation.service.js";
+import { OwnershipPlanningService } from "./ownership-planning.service.js";
 import { dedupeProcessedAssets } from "./processed-asset-dedupe.js";
 function createPageLocalsProxy(filePath) {
   const errorMessage = `[ecopages] Request locals are only available during request-time rendering with cache: 'dynamic'. Page: ${filePath}. If you meant to use locals here, set cache: 'dynamic' and provide locals from route middleware/handlers.`;
@@ -37,83 +39,74 @@ function createPageLocalsProxy(filePath) {
     }
   );
 }
-class RenderPreparationService {
+class RouteRenderOrchestrator {
   appConfig;
   assetProcessingService;
-  boundaryPlanningService;
-  pagePackagingService;
-  /**
-   * Creates the render-preparation orchestrator for one app instance.
-   *
-   * @remarks
-   * The service is app-scoped because it depends on finalized config defaults and
-   * the app-owned asset-processing pipeline while remaining renderer-agnostic.
-   */
+  ownershipPlanningService;
+  ownershipValidationService;
   constructor(appConfig, assetProcessingService, dependencies = {}) {
     this.appConfig = appConfig;
     this.assetProcessingService = assetProcessingService;
-    this.boundaryPlanningService = dependencies.boundaryPlanningService ?? new BoundaryPlanningService(appConfig);
-    this.pagePackagingService = dependencies.pagePackagingService ?? new PagePackagingService();
+    this.ownershipPlanningService = dependencies.ownershipPlanningService ?? new OwnershipPlanningService();
+    this.ownershipValidationService = dependencies.ownershipValidationService ?? new OwnershipValidationService(appConfig);
   }
   /**
-   * Builds the final render options object used by the integration-specific
-   * renderer.
-   *
-   * The returned object contains normalized page data, processed dependency
-   * state, component render artifacts, and the locals contract expected by the
-   * rest of the pipeline.
+   * Builds normalized route render options before the integration render runs.
    *
-   * @typeParam C Integration render output element type.
-   * @param routeOptions Route-level render inputs.
-   * @param currentIntegrationName Active integration name for this preparation pass.
-   * @param callbacks Renderer-specific hooks used during preparation.
-   * @returns Normalized render options.
+   * This preparation step validates route-root ownership, resolves page data,
+   * collects processed assets, captures optional page-root render metadata, and
+   * produces the page package consumed by downstream HTML transformation.
    */
-  async prepare(routeOptions, currentIntegrationName, callbacks) {
-    const pageModule = await callbacks.resolvePageModule(routeOptions.file);
-    const { Page, integrationSpecificProps } = pageModule;
-    const HtmlTemplate = await callbacks.getHtmlTemplate();
-    const { props, metadata } = await callbacks.resolvePageData(pageModule, routeOptions);
-    const Layout = Page.config?.layout;
-    const boundaryPlan = this.boundaryPlanningService.buildPlan({
+  async prepareRenderOptions(routeOptions, adapter) {
+    const resolvedInputs = await adapter.resolveRouteRenderInputs(routeOptions);
+    const { Page, HtmlTemplate, Layout, props, metadata, integrationSpecificProps } = resolvedInputs;
+    const validationErrors = this.ownershipValidationService.validate({
+      currentIntegrationName: adapter.name,
+      roots: [
+        { component: HtmlTemplate, source: "html-template" },
+        ...Layout ? [{ component: Layout, source: "layout" }] : [],
+        { component: Page, source: "page" }
+      ]
+    });
+    const ownershipPlan = this.ownershipPlanningService.buildPlan({
       routeFile: routeOptions.file,
-      currentIntegrationName,
+      currentIntegrationName: adapter.name,
       HtmlTemplate,
       Layout,
-      Page
+      Page,
+      validationErrors
     });
     const componentsToResolve = Layout ? [HtmlTemplate, Layout, Page] : [HtmlTemplate, Page];
-    const resolvedDependencies = await callbacks.resolveDependencies(componentsToResolve);
-    const usedIntegrationDependencies = this.collectUsedIntegrationDependencies(
-      componentsToResolve,
-      currentIntegrationName
-    );
-    const pageDeps = await callbacks.buildRouteRenderAssets(routeOptions.file) || [];
-    const allDependencies = [...resolvedDependencies, ...usedIntegrationDependencies, ...pageDeps];
-    let componentRender;
-    if (callbacks.shouldRenderPageComponent({ Page, Layout, options: routeOptions })) {
-      const pageRootRender = await this.renderPageRoot({
-        Page,
-        props,
-        routeOptions,
-        callbacks
-      });
-      componentRender = pageRootRender.componentRender;
-      if (componentRender.assets?.length) {
-        allDependencies.push(...componentRender.assets);
-      }
+    const { resolvedDependencies, pageBrowserGraph } = await adapter.resolveRouteAssets({
+      routeOptions,
+      components: componentsToResolve
+    });
+    const usedIntegrationDependencies = this.collectUsedIntegrationDependencies(componentsToResolve, adapter.name);
+    const allDependencies = [
+      ...resolvedDependencies,
+      ...usedIntegrationDependencies,
+      ...pageBrowserGraph?.assets ?? []
+    ];
+    const componentRender = await adapter.resolveRoutePageComponentRender({
+      Page,
+      Layout,
+      props,
+      routeOptions
+    });
+    if (componentRender?.assets?.length) {
+      allDependencies.push(...componentRender.assets);
     }
     const triggers = this.collectResolvedTriggers(componentsToResolve);
     if (triggers.length > 0) {
-      const globalAssets = await this.buildGlobalInjectorAssets(triggers, currentIntegrationName);
+      const globalAssets = await this.buildGlobalInjectorAssets(triggers, adapter.name);
       allDependencies.push(...globalAssets);
     }
-    const eagerSsrLazyAssets = await this.buildEagerSsrLazyAssets(componentsToResolve, currentIntegrationName);
+    const eagerSsrLazyAssets = await this.buildEagerSsrLazyAssets(componentsToResolve, adapter.name);
     if (eagerSsrLazyAssets.length > 0) {
       allDependencies.push(...eagerSsrLazyAssets);
     }
     const dedupedDependencies = dedupeProcessedAssets(allDependencies);
-    const pagePackage = this.pagePackagingService.createPagePackage(dedupedDependencies);
+    const pagePackage = createPagePackage(dedupedDependencies);
     const pageProps = {
       ...props,
       params: routeOptions.params || {},
@@ -141,7 +134,7 @@ class RenderPreparationService {
       locals,
       pageLocals,
       cacheStrategy,
-      boundaryPlan
+      ownershipPlan
     };
     return {
       ...integrationSpecificProps,
@@ -149,15 +142,83 @@ class RenderPreparationService {
     };
   }
   /**
-   * Collects resolved lazy trigger metadata from the component tree.
-   *
-   * Traversal is depth-first and deduplicated by component identity so shared
-   * component dependencies do not emit duplicate trigger sets.
-   *
-   * @param components Root component set.
-   * @param seen Internal visited set for shared graphs.
-   * @returns All resolved lazy triggers reachable from the root set.
+   * Captures one route render body as HTML while preserving a replayable body value.
+   */
+  async captureHtmlRender(render) {
+    const renderedBody = await render();
+    const capturedRender = await this.captureRenderedBody(renderedBody);
+    return {
+      body: capturedRender.body,
+      html: capturedRender.html
+    };
+  }
+  /**
+   * Executes the full route-render flow and returns the final body plus cache strategy.
    */
+  async execute(options, adapter) {
+    const renderOptions = await this.prepareRenderOptions(options, adapter);
+    return this.executePrepared(renderOptions, adapter);
+  }
+  /**
+   * Executes the route-render finalization path for already prepared render options.
+   */
+  async executePrepared(renderOptions, adapter) {
+    const renderExecution = await this.captureHtmlRender(async () => adapter.renderRouteBody(renderOptions));
+    const unresolvedArtifactInspection = inspectUnresolvedMarkerArtifactHtml(renderExecution.html);
+    const htmlFinalization = adapter.getRouteHtmlFinalization(renderOptions);
+    const hasUnresolvedMarkerHtml = unresolvedArtifactInspection.hasUnresolvedMarkerArtifacts;
+    if (hasUnresolvedMarkerHtml) {
+      throw new Error(
+        "[ecopages] Route render returned unresolved eco-marker artifact HTML. Full-route unresolved-marker fallback has been removed; resolve mixed foreign children inside renderComponentWithForeignChildren()."
+      );
+    }
+    const canReuseCapturedBody = !hasUnresolvedMarkerHtml && htmlFinalization.finalizeHtml === void 0;
+    if (canReuseCapturedBody) {
+      const body2 = await adapter.transformRouteResponse(
+        new Response(renderExecution.body, {
+          headers: {
+            "Content-Type": "text/html"
+          }
+        })
+      );
+      return {
+        body: body2,
+        cacheStrategy: renderOptions.cacheStrategy
+      };
+    }
+    const finalization = htmlFinalization.finalizeHtml ? htmlFinalization.finalizeHtml(unresolvedArtifactInspection.normalizedHtml) : unresolvedArtifactInspection.normalizedHtml;
+    const body = await adapter.transformRouteResponse(
+      new Response(finalization, {
+        headers: {
+          "Content-Type": "text/html"
+        }
+      })
+    );
+    return {
+      body,
+      cacheStrategy: renderOptions.cacheStrategy
+    };
+  }
+  async captureRenderedBody(body) {
+    const response = new Response(body);
+    if (typeof body === "string") {
+      return {
+        body,
+        html: await response.text()
+      };
+    }
+    if (!response.body) {
+      return {
+        body,
+        html: await response.text()
+      };
+    }
+    const [capturedBody, replayBody] = response.body.tee();
+    return {
+      body: replayBody,
+      html: await new Response(capturedBody).text()
+    };
+  }
   collectResolvedTriggers(components, seen = /* @__PURE__ */ new Set()) {
     const triggers = [];
     for (const comp of components) {
@@ -180,13 +241,6 @@ class RenderPreparationService {
     }
     return triggers;
   }
-  /**
-   * Collects global integration dependencies used by nested components belonging
-   * to integrations other than the current renderer.
-   *
-   * @param components Root component set.
-   * @returns Processed integration dependencies contributed by nested integrations.
-   */
   collectUsedIntegrationDependencies(components, currentIntegrationName) {
     const integrationNames = this.collectIntegrationNames(components);
     const dependencies = [];
@@ -204,13 +258,6 @@ class RenderPreparationService {
     }
     return dependencies;
   }
-  /**
-   * Discovers integration names referenced by the component dependency graph.
-   *
-   * @param components Root component set.
-   * @param seen Internal visited set for shared graphs.
-   * @returns Set of integration names found in the graph.
-   */
   collectIntegrationNames(components, seen = /* @__PURE__ */ new Set()) {
     const integrationNames = /* @__PURE__ */ new Set();
     for (const comp of components) {
@@ -236,32 +283,6 @@ class RenderPreparationService {
     }
     return integrationNames;
   }
-  /**
-   * Renders the page root through the component-level render contract so any
-   * integration-specific assets and root attributes are available before the main
-   * document render.
-   *
-   * @param input Page root render inputs.
-   * @returns Structured component render result.
-   */
-  async renderPageRoot(input) {
-    return {
-      componentRender: await input.callbacks.renderPageComponent({
-        component: input.Page,
-        props: {
-          ...input.props,
-          params: input.routeOptions.params || {},
-          query: input.routeOptions.query || {}
-        }
-      })
-    };
-  }
-  /**
-   * Builds the runtime assets needed to bootstrap global lazy trigger execution.
-   *
-   * @param triggers Fully resolved lazy trigger definitions.
-   * @returns Processed assets that should be merged into the final dependency set.
-   */
   async buildGlobalInjectorAssets(triggers, currentIntegrationName) {
     const globalInjectorImportPath = createRequire(import.meta.url).resolve("@ecopages/scripts-injector/global");
     const mapScript = AssetFactory.createInlineContentScript({
@@ -280,7 +301,10 @@ class RenderPreparationService {
       packageRole: "keep-separate",
       bundle: true
     });
-    return this.assetProcessingService.processDependencies([mapScript, bootstrapInlineScript], currentIntegrationName);
+    return this.assetProcessingService.processDependencies(
+      [mapScript, bootstrapInlineScript],
+      currentIntegrationName
+    );
   }
   async buildEagerSsrLazyAssets(components, currentIntegrationName) {
     const dependencies = this.collectEagerSsrLazyDependencies(components);
@@ -360,5 +384,5 @@ class RenderPreparationService {
   }
 }
 export {
-  RenderPreparationService
+  RouteRenderOrchestrator
 };

package/src/route-renderer/page-loading/component-dependency-collection.js

@@ -32,7 +32,14 @@ function resolveDependencyPath(componentDir, pathUrl) {
   return path.join(componentDir, pathUrl);
 }
 function collectComponentDependencies(options) {
-  const { components, integrationName, resolveLazyScripts, createEcopagesJsxLazyEntryName, isEcopagesJsxIntegration, errors } = options;
+  const {
+    components,
+    integrationName,
+    resolveLazyScripts,
+    createEcopagesJsxLazyEntryName,
+    isEcopagesJsxIntegration,
+    errors
+  } = options;
   const dependencies = [];
   const lazyScriptsByConfig = /* @__PURE__ */ new Map();
   const lazyDependencyKeys = /* @__PURE__ */ new Set();

package/src/route-renderer/page-loading/dependency-resolver.js

@@ -1,11 +1,9 @@
 import path from "node:path";
 import { rapidhash } from "../../utils/hash.js";
 import { AssetFactory } from "../../services/assets/asset-processing-service/index.js";
-import {
-  buildResolvedLazyTriggers
-} from "./lazy-trigger-planning.js";
+import { buildResolvedLazyTriggers } from "./lazy-trigger-planning.js";
 import { collectComponentDependencies } from "./component-dependency-collection.js";
-import { createUnifiedPageDependencies } from "./page-dependency-bundling.js";
+import { packagePageDependencies } from "./page-dependency-bundling.js";
 const DEPENDENCY_ERRORS = {
   INVALID_STYLESHEET_ENTRY: "Invalid stylesheet dependency entry: expected src or content",
   INVALID_SCRIPT_ENTRY: "Invalid script dependency entry: expected src or content",
@@ -77,12 +75,12 @@ class DependencyResolverService {
         lazyScriptMissingSrc: DEPENDENCY_ERRORS.LAZY_SCRIPT_MISSING_SRC
       }
     });
-    const unifiedDependencies = createUnifiedPageDependencies(dependencies, integrationName);
-    const hasLazyDependencies = unifiedDependencies.some(
+    const packagedDependencies = packagePageDependencies(dependencies, integrationName);
+    const hasLazyDependencies = packagedDependencies.some(
       (dep) => dep.kind === "script" && dep.excludeFromHtml === true
     );
     const processedDependencies = await this.assetProcessingService.processDependencies(
-      unifiedDependencies,
+      packagedDependencies,
       integrationName
     );
     const lazyKeyToOutputUrl = /* @__PURE__ */ new Map();

package/src/route-renderer/page-loading/page-dependency-bundling.d.ts

@@ -10,4 +10,4 @@ export declare function shouldBundlePageDependencies(integrationName: string): b
  * Only assets with the default attribute shape and without explicit packaging roles are
  * collapsed so integration-specific or lazy behavior keeps its existing ownership model.
  */
-export declare function createUnifiedPageDependencies(dependencies: AssetDefinition[], integrationName: string): AssetDefinition[];
+export declare function packagePageDependencies(dependencies: AssetDefinition[], integrationName: string): AssetDefinition[];

package/src/route-renderer/page-loading/page-dependency-bundling.js

@@ -16,7 +16,7 @@ function normalizeCssReferenceToken(token) {
   return token.trim().replace(/^['"]|['"]$/g, "");
 }
 function isSafeBundledStylesheetContent(content) {
-  for (const match of content.matchAll(/@import\s+(?:url\()?['"]?([^'"\)\s]+)['"]?\)?/g)) {
+  for (const match of content.matchAll(/@import\s+(?:url\()?['"]?([^'")\s]+)['"]?\)?/g)) {
     const reference = normalizeCssReferenceToken(match[1] ?? "");
     if (reference && !isSafeBundledStylesheetReference(reference)) {
       return false;
@@ -39,11 +39,12 @@ function isBundleableFileScriptAsset(dependency) {
 function shouldBundlePageDependencies(integrationName) {
   return integrationName === "react" || integrationName === "ecopages-jsx";
 }
-function createUnifiedPageDependencies(dependencies, integrationName) {
-  if (!shouldBundlePageDependencies(integrationName)) {
-    return dependencies;
-  }
+function createPageDependencyPackagingPlan(dependencies, integrationName) {
+  const shouldBundleDependencies = process.env.NODE_ENV === "production";
   const bundleableStyles = dependencies.filter((dependency) => {
+    if (!shouldBundleDependencies) {
+      return false;
+    }
     if (dependency.kind !== "stylesheet" || dependency.inline || dependency.position === "body") {
       return false;
     }
@@ -59,57 +60,78 @@ function createUnifiedPageDependencies(dependencies, integrationName) {
     return isSafeBundledStylesheetContent(readFileSync(dependency.filepath, "utf8"));
   }).filter(isBundleableFileStylesheetAsset);
   const bundleableScripts = dependencies.filter((dependency) => {
+    if (!shouldBundleDependencies) {
+      return false;
+    }
     return dependency.kind === "script" && dependency.source === "file" && !dependency.inline && !dependency.excludeFromHtml && dependency.position !== "body" && !dependency.packageRole && dependency.bundle !== false && hasOnlyExpectedAttributes(dependency.attributes, { type: "module", defer: "" }) && existsSync(dependency.filepath);
   }).filter(isBundleableFileScriptAsset);
   const bundledStylesheet = bundleableStyles.length > 1 ? AssetFactory.createContentStylesheet({
     content: bundleableStyles.map((dependency) => readFileSync(dependency.filepath, "utf8")).join("\n"),
     position: "head",
     attributes: { rel: "stylesheet" },
-    packageRole: "page-style"
+    packageRole: "page-style",
+    bundledSourceFilepaths: bundleableStyles.map((dependency) => dependency.filepath)
   }) : void 0;
-  const bundleableStyleFilepaths = new Set(bundleableStyles.map((dependency) => dependency.filepath));
   const pageScriptImports = [...new Set(bundleableScripts.map((dependency) => dependency.filepath))];
-  const bundleableScriptFilepaths = new Set(pageScriptImports);
   const shouldBundlePageScript = pageScriptImports.length > 0 && bundleableScripts.length > 1;
   const bundledScript = shouldBundlePageScript ? AssetFactory.createContentScript({
     name: `${integrationName}-page-${rapidhash(pageScriptImports.join("|")).toString(16)}`,
     content: pageScriptImports.map((filepath) => `import ${JSON.stringify(filepath)};`).join("\n"),
     position: "head",
     attributes: { type: "module", defer: "" },
-    packageRole: "page-script"
+    packageRole: "page-script",
+    bundledSourceFilepaths: pageScriptImports
   }) : void 0;
   if (!bundledStylesheet && !bundledScript) {
-    return dependencies;
+    return void 0;
   }
+  return {
+    bundledStylesheet,
+    bundledScript,
+    bundleableStyleFilepaths: new Set(bundleableStyles.map((dependency) => dependency.filepath)),
+    bundleableScriptFilepaths: new Set(pageScriptImports)
+  };
+}
+function applyPageDependencyPackagingPlan(dependencies, plan) {
   const unifiedDependencies = [];
   let insertedStylesheet = false;
   let insertedScript = false;
   for (const dependency of dependencies) {
-    if (bundledStylesheet && dependency.kind === "stylesheet" && dependency.source === "file" && bundleableStyleFilepaths.has(dependency.filepath)) {
+    if (plan.bundledStylesheet && dependency.kind === "stylesheet" && dependency.source === "file" && plan.bundleableStyleFilepaths.has(dependency.filepath)) {
       if (!insertedStylesheet) {
-        unifiedDependencies.push(bundledStylesheet);
+        unifiedDependencies.push(plan.bundledStylesheet);
         insertedStylesheet = true;
       }
       continue;
     }
-    if (bundledScript && dependency.kind === "script" && dependency.source === "file" && bundleableScriptFilepaths.has(dependency.filepath)) {
+    if (plan.bundledScript && dependency.kind === "script" && dependency.source === "file" && plan.bundleableScriptFilepaths.has(dependency.filepath)) {
       if (!insertedScript) {
-        unifiedDependencies.push(bundledScript);
+        unifiedDependencies.push(plan.bundledScript);
         insertedScript = true;
       }
       continue;
     }
     unifiedDependencies.push(dependency);
   }
-  if (bundledScript && !insertedScript) {
-    unifiedDependencies.push(bundledScript);
+  if (plan.bundledScript && !insertedScript) {
+    unifiedDependencies.push(plan.bundledScript);
   }
-  if (bundledStylesheet && !insertedStylesheet) {
-    unifiedDependencies.push(bundledStylesheet);
+  if (plan.bundledStylesheet && !insertedStylesheet) {
+    unifiedDependencies.push(plan.bundledStylesheet);
   }
   return unifiedDependencies;
 }
+function packagePageDependencies(dependencies, integrationName) {
+  if (!shouldBundlePageDependencies(integrationName)) {
+    return dependencies;
+  }
+  const plan = createPageDependencyPackagingPlan(dependencies, integrationName);
+  if (!plan) {
+    return dependencies;
+  }
+  return applyPageDependencyPackagingPlan(dependencies, plan);
+}
 export {
-  createUnifiedPageDependencies,
+  packagePageDependencies,
   shouldBundlePageDependencies
 };

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

@@ -1,30 +1,33 @@
 import type { EcoPagesAppConfig } from '../types/internal-types.js';
-import type { IntegrationPlugin } from '../plugins/integration-plugin.js';
-import type { EcoPageFile, RouteRenderResult, RouteRendererOptions } from '../types/public-types.js';
-import type { IntegrationRenderer, RouteModuleLoadOptions } from './orchestration/integration-renderer.js';
+import type { AnyIntegrationPlugin } from '../plugins/integration-plugin.js';
+import type { IntegrationRenderer } from './orchestration/integration-renderer.js';
 /**
- * Thin wrapper around one initialized integration renderer.
+ * Narrow route-render contract exposed to higher-level routing code.
  *
  * @remarks
- * This type exists so higher-level routing code can ask for a route renderer
- * without depending on the full integration plugin lifecycle. It delegates all
- * real work to the integration-specific renderer selected by the factory.
+ * Higher-level routing code only needs request execution and page-module
+ * loading. Returning this narrowed shape avoids a dedicated wrapper class while
+ * still keeping callers off the full integration renderer surface.
  */
-export declare class RouteRenderer {
-    private renderer;
-    /**
-     * Creates a route renderer bound to one integration renderer instance.
-     */
-    constructor(renderer: IntegrationRenderer);
-    /**
-     * Executes the render pipeline for one matched route.
-     */
-    createRoute(options: RouteRendererOptions): Promise<RouteRenderResult>;
-    /**
-     * Loads the route module through the owning integration renderer.
-     */
-    loadPageModule(filePath: string, options?: RouteModuleLoadOptions): Promise<EcoPageFile>;
+export type PageRouteRenderer = Pick<IntegrationRenderer<unknown>, 'execute' | 'loadPageModule'>;
+/**
+ * Narrow explicit-view render contract exposed to static route handling.
+ *
+ * @remarks
+ * Explicit static routes only need `renderToResponse()`, so the factory can
+ * hide the broader integration renderer surface there as well.
+ */
+export type ExplicitViewRenderer = Pick<IntegrationRenderer<unknown>, 'renderToResponse'>;
+export interface PageRendererResolver {
+    getPageRenderer(filePath: string): PageRouteRenderer;
 }
+export interface ExplicitViewRendererResolver {
+    getExplicitViewRenderer(integrationName: string): ExplicitViewRenderer | null;
+}
+/**
+ * Combined renderer-factory contract used by static generation.
+ */
+export type StaticGenerationRendererResolver = PageRendererResolver & ExplicitViewRendererResolver;
 /**
  * Selects and caches integration renderers for route files and explicit views.
  *
@@ -49,16 +52,15 @@ export declare class RouteRendererFactory {
     /**
      * Returns a route renderer for the supplied route file.
      */
-    createRenderer(filePath: string): RouteRenderer;
+    getPageRenderer(filePath: string): PageRouteRenderer;
     /**
-     * Get an integration renderer by its name.
-     * Used for explicit routing where views specify their integration via __eco.integration.
+     * Returns a renderer for an explicit view integration.
      */
-    getRendererByIntegration(integrationName: string): IntegrationRenderer | null;
+    getExplicitViewRenderer(integrationName: string): ExplicitViewRenderer | null;
     /**
      * Resolves the integration plugin that owns a given route file.
      */
-    getIntegrationPlugin(filePath: string): IntegrationPlugin;
+    getIntegrationPlugin(filePath: string): AnyIntegrationPlugin;
     /**
      * Returns the cached renderer engine for the file's owning integration,
      * creating it on first use.

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

@@ -1,26 +1,5 @@
 import { invariant } from "../utils/invariant.js";
 import { PathUtils } from "../utils/path-utils.module.js";
-class RouteRenderer {
-  renderer;
-  /**
-   * Creates a route renderer bound to one integration renderer instance.
-   */
-  constructor(renderer) {
-    this.renderer = renderer;
-  }
-  /**
-   * Executes the render pipeline for one matched route.
-   */
-  async createRoute(options) {
-    return this.renderer.execute(options);
-  }
-  /**
-   * Loads the route module through the owning integration renderer.
-   */
-  async loadPageModule(filePath, options) {
-    return this.renderer.loadPageModule(filePath, options);
-  }
-}
 class RouteRendererFactory {
   appConfig;
   runtimeOrigin;
@@ -41,16 +20,15 @@ class RouteRendererFactory {
   /**
    * Returns a route renderer for the supplied route file.
    */
-  createRenderer(filePath) {
+  getPageRenderer(filePath) {
     const integrationRenderer = this.getRouteRendererEngine(filePath);
     invariant(!!integrationRenderer, `No integration renderer found for file: ${filePath}`);
-    return new RouteRenderer(integrationRenderer);
+    return integrationRenderer;
   }
   /**
-   * Get an integration renderer by its name.
-   * Used for explicit routing where views specify their integration via __eco.integration.
+   * Returns a renderer for an explicit view integration.
    */
-  getRendererByIntegration(integrationName) {
+  getExplicitViewRenderer(integrationName) {
     const integrationPlugin = this.appConfig.integrations.find((plugin) => plugin.name === integrationName);
     if (!integrationPlugin) {
       return null;
@@ -98,6 +76,5 @@ class RouteRendererFactory {
   }
 }
 export {
-  RouteRenderer,
   RouteRendererFactory
 };