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

package/src/route-renderer/orchestration/route-pipeline/robots-meta.contribution.js

@@ -1,36 +1,43 @@
-import { escapeHtmlAttribute } from "../../../utils/html-escaping.js";
-function buildRobotsMetaContribution(metadata) {
-  const content = formatRobotsMetaContent(metadata.robots);
-  if (!content) {
-    return void 0;
-  }
-  return {
-    placement: "head-append",
-    html: `<meta name="robots" content="${escapeHtmlAttribute(content)}">`
-  };
+import { escapeHtmlAttribute } from '../../../utils/html-escaping.js';
+/**
+ * Builds a head contribution for non-default `metadata.robots` values.
+ *
+ * @remarks
+ * When `robots` is omitted or matches the default `index,follow` behaviour,
+ * no tag is emitted (Next.js parity). Otherwise a single
+ * `<meta name="robots" content="...">` contribution is returned.
+ */
+export function buildRobotsMetaContribution(metadata) {
+    const content = formatRobotsMetaContent(metadata.robots);
+    if (!content) {
+        return undefined;
+    }
+    return {
+        placement: 'head-append',
+        html: `<meta name="robots" content="${escapeHtmlAttribute(content)}">`,
+    };
 }
-function formatRobotsMetaContent(robots) {
-  if (!robots) {
-    return void 0;
-  }
-  const index = robots.index !== false;
-  const follow = robots.follow !== false;
-  const directives = [];
-  if (!index) {
-    directives.push("noindex");
-  }
-  if (!follow) {
-    directives.push("nofollow");
-  }
-  if (robots.nocache) {
-    directives.push("nocache");
-  }
-  if (directives.length === 0) {
-    return void 0;
-  }
-  return directives.join(", ");
+/**
+ * Formats robots directives for a meta tag, or `undefined` when defaults apply.
+ */
+export function formatRobotsMetaContent(robots) {
+    if (!robots) {
+        return undefined;
+    }
+    const index = robots.index !== false;
+    const follow = robots.follow !== false;
+    const directives = [];
+    if (!index) {
+        directives.push('noindex');
+    }
+    if (!follow) {
+        directives.push('nofollow');
+    }
+    if (robots.nocache) {
+        directives.push('nocache');
+    }
+    if (directives.length === 0) {
+        return undefined;
+    }
+    return directives.join(', ');
 }
-export {
-  buildRobotsMetaContribution,
-  formatRobotsMetaContent
-};

package/src/route-renderer/orchestration/route-pipeline/route-html-finalization.service.d.ts

@@ -1,7 +1,12 @@
 import type { HtmlDocumentContribution } from '../../../services/html/html-transformer.service.js';
 import type { IntegrationRendererRenderOptions } from '../../../types/public-types.js';
 import type { RouteHtmlFinalization } from './route-render-orchestrator.js';
+import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
 export type RouteHtmlFinalizationContext<C> = {
+    appConfig: EcoPagesAppConfig;
+    watch: boolean;
+    hostOwnsDevClient?: boolean;
+    integrationName: string;
     renderOptions: IntegrationRendererRenderOptions<C>;
     getDocumentAttributes: (renderOptions: IntegrationRendererRenderOptions<C>) => Record<string, string> | undefined;
     getHtmlDocumentContributions: (options: {

package/src/route-renderer/orchestration/route-pipeline/route-html-finalization.service.js

@@ -1,24 +1,44 @@
-import { buildRobotsMetaContribution } from "./robots-meta.contribution.js";
-function buildRouteHtmlFinalization(context) {
-  const { renderOptions } = context;
-  const documentAttributes = context.getDocumentAttributes(renderOptions);
-  const integrationContributions = context.getHtmlDocumentContributions({ renderOptions, partial: false }) ?? [];
-  const robotsContribution = buildRobotsMetaContribution(renderOptions.metadata ?? {});
-  const htmlContributions = robotsContribution ? [robotsContribution, ...integrationContributions] : integrationContributions;
-  const hasStructuralFinalization = documentAttributes && Object.keys(documentAttributes).length > 0;
-  if (!hasStructuralFinalization && htmlContributions.length === 0) {
-    return {};
-  }
-  return {
-    htmlContributions,
-    finalizeHtml: (html) => {
-      if (!documentAttributes || Object.keys(documentAttributes).length === 0) {
-        return html;
-      }
-      return context.applyAttributesToHtmlElement(html, documentAttributes);
+import { buildRobotsMetaContribution } from './robots-meta.contribution.js';
+import { DevToolbarHost } from '../../../dev-toolbar/dev-toolbar-host.js';
+/**
+ * Builds the structural HTML finalization plan for one prepared route render.
+ *
+ * @remarks
+ * Merges core robots meta contributions with integration-owned document
+ * contributions so page-level `metadata.robots` works across templates.
+ */
+export function buildRouteHtmlFinalization(context) {
+    const { renderOptions } = context;
+    const documentAttributes = context.getDocumentAttributes(renderOptions);
+    const integrationContributions = context.getHtmlDocumentContributions({ renderOptions, partial: false }) ?? [];
+    const robotsContribution = buildRobotsMetaContribution(renderOptions.metadata ?? {});
+    const devToolbarContribution = buildDevToolbarManifestContribution(context);
+    const htmlContributions = [
+        ...(robotsContribution ? [robotsContribution] : []),
+        ...(devToolbarContribution ? [devToolbarContribution] : []),
+        ...integrationContributions,
+    ];
+    const hasStructuralFinalization = documentAttributes && Object.keys(documentAttributes).length > 0;
+    if (!hasStructuralFinalization && htmlContributions.length === 0) {
+        return {};
     }
-  };
+    return {
+        htmlContributions,
+        finalizeHtml: (html) => {
+            if (!documentAttributes || Object.keys(documentAttributes).length === 0) {
+                return html;
+            }
+            return context.applyAttributesToHtmlElement(html, documentAttributes);
+        },
+    };
+}
+function buildDevToolbarManifestContribution(context) {
+    return DevToolbarHost.forApp(context.appConfig, {
+        watch: context.watch,
+        hostOwnsDevClient: context.hostOwnsDevClient,
+    }).buildRouteManifestContribution({
+        routeFile: context.renderOptions.file,
+        integrationName: context.integrationName,
+        pagePackage: context.renderOptions.pagePackage,
+    });
 }
-export {
-  buildRouteHtmlFinalization
-};

package/src/route-renderer/orchestration/route-pipeline/route-prepared-options.builder.js

@@ -1,49 +1,51 @@
-import { createPagePackage } from "../../../services/assets/asset-processing-service/index.js";
-import { dedupeProcessedAssets } from "../page-browser-graph/processed-asset-dedupe.js";
-import { createPageLocalsProxy } from "./route-prepared-options.utils.js";
-function buildPreparedRenderOptions(input) {
-  const { routeOptions, resolvedInputs, resolvedDependencies, allDependencies, pageBrowserGraph, appConfig } = input;
-  const { Page, HtmlTemplate, Layouts, Layout, layoutEntries, props, metadata, integrationSpecificProps } = resolvedInputs;
-  const dedupedDependencies = dedupeProcessedAssets(allDependencies);
-  const pagePackage = createPagePackage(dedupedDependencies, { pageBrowserGraph });
-  const resolvedProps = {
-    ...props,
-    ...routeOptions.props ?? {}
-  };
-  const pageProps = {
-    ...resolvedProps,
-    params: routeOptions.params || {},
-    query: routeOptions.query || {}
-  };
-  const cacheStrategy = Page.cache;
-  const defaultCacheStrategy = appConfig.cache?.defaultStrategy ?? "static";
-  const effectiveCacheStrategy = cacheStrategy ?? defaultCacheStrategy;
-  const localsAvailable = effectiveCacheStrategy === "dynamic" && routeOptions.locals !== void 0;
-  const pageLocals = localsAvailable ? routeOptions.locals : createPageLocalsProxy(routeOptions.file);
-  const locals = localsAvailable ? routeOptions.locals : void 0;
-  const preparedOptions = {
-    ...routeOptions,
-    resolvedDependencies,
-    pagePackage,
-    HtmlTemplate,
-    Layouts,
-    Layout,
-    layoutEntries,
-    props: resolvedProps,
-    Page,
-    metadata,
-    params: routeOptions.params || {},
-    query: routeOptions.query || {},
-    pageProps,
-    locals,
-    pageLocals,
-    cacheStrategy
-  };
-  return {
-    ...integrationSpecificProps,
-    ...preparedOptions
-  };
+import { createPagePackage } from '../../../services/assets/asset-processing-service/index.js';
+import { dedupeProcessedAssets } from '../page-browser-graph/processed-asset-dedupe.js';
+import { createPageLocalsProxy } from './route-prepared-options.utils.js';
+/**
+ * Assembles the final integration render options after route prep dependencies resolve.
+ */
+export function buildPreparedRenderOptions(input) {
+    const { routeOptions, resolvedInputs, resolvedDependencies, allDependencies, pageBrowserGraph, appConfig } = input;
+    const { Page, HtmlTemplate, Layouts, Layout, layoutEntries, props, metadata, integrationSpecificProps } = resolvedInputs;
+    const dedupedDependencies = dedupeProcessedAssets(allDependencies);
+    const pagePackage = createPagePackage(dedupedDependencies, { pageBrowserGraph });
+    const resolvedProps = {
+        ...props,
+        ...(routeOptions.props ?? {}),
+    };
+    const pageProps = {
+        ...resolvedProps,
+        params: routeOptions.params || {},
+        query: routeOptions.query || {},
+    };
+    const cacheStrategy = Page.cache;
+    const defaultCacheStrategy = appConfig.cache?.defaultStrategy ?? 'static';
+    const effectiveCacheStrategy = cacheStrategy ?? defaultCacheStrategy;
+    const localsAvailable = effectiveCacheStrategy === 'dynamic' && routeOptions.locals !== undefined;
+    const pageLocals = localsAvailable
+        ? routeOptions.locals
+        : createPageLocalsProxy(routeOptions.file);
+    const locals = localsAvailable ? routeOptions.locals : undefined;
+    const preparedOptions = {
+        ...routeOptions,
+        resolvedDependencies,
+        pagePackage,
+        HtmlTemplate: HtmlTemplate,
+        Layouts,
+        Layout,
+        layoutEntries,
+        props: resolvedProps,
+        Page: Page,
+        metadata,
+        params: routeOptions.params || {},
+        query: routeOptions.query || {},
+        pageProps,
+        locals,
+        pageLocals,
+        cacheStrategy,
+    };
+    return {
+        ...integrationSpecificProps,
+        ...preparedOptions,
+    };
 }
-export {
-  buildPreparedRenderOptions
-};

package/src/route-renderer/orchestration/route-pipeline/route-prepared-options.utils.js

@@ -1,33 +1,30 @@
-import { LocalsAccessError } from "../../../errors/locals-access-error.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.`;
-  return new Proxy(
-    {},
-    {
-      get: () => {
-        throw new LocalsAccessError(errorMessage);
-      },
-      set: () => {
-        throw new LocalsAccessError(errorMessage);
-      },
-      has: () => {
-        throw new LocalsAccessError(errorMessage);
-      },
-      ownKeys: () => {
-        throw new LocalsAccessError(errorMessage);
-      },
-      deleteProperty: () => {
-        throw new LocalsAccessError(errorMessage);
-      },
-      defineProperty: () => {
-        throw new LocalsAccessError(errorMessage);
-      },
-      getOwnPropertyDescriptor: () => {
-        throw new LocalsAccessError(errorMessage);
-      }
-    }
-  );
+import { LocalsAccessError } from '../../../errors/locals-access-error.js';
+/**
+ * Proxy that throws when dynamic route locals are accessed on non-dynamic pages.
+ */
+export 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.`;
+    return new Proxy({}, {
+        get: () => {
+            throw new LocalsAccessError(errorMessage);
+        },
+        set: () => {
+            throw new LocalsAccessError(errorMessage);
+        },
+        has: () => {
+            throw new LocalsAccessError(errorMessage);
+        },
+        ownKeys: () => {
+            throw new LocalsAccessError(errorMessage);
+        },
+        deleteProperty: () => {
+            throw new LocalsAccessError(errorMessage);
+        },
+        defineProperty: () => {
+            throw new LocalsAccessError(errorMessage);
+        },
+        getOwnPropertyDescriptor: () => {
+            throw new LocalsAccessError(errorMessage);
+        },
+    });
 }
-export {
-  createPageLocalsProxy
-};

package/src/route-renderer/orchestration/route-pipeline/route-render-orchestrator.js

@@ -1,162 +1,156 @@
-import { inspectUnresolvedMarkerArtifactHtml } from "./marker-artifact.utils.js";
-import {
-  OwnershipValidationService,
-  throwIfOwnershipInvalid
-} from "../ownership-graph/ownership-validation.service.js";
-import {
-  buildEagerSsrLazyAssetsFromGraph,
-  collectResolvedLazyTriggersFromGraph,
-  collectUsedIntegrationDependenciesFromGraph
-} from "../ownership-graph/component-graph-collectors.js";
-import { buildGlobalInjectorAssets } from "../page-browser-graph/global-injector-assets.service.js";
-import { PageBrowserGraphService } from "../page-browser-graph/page-browser-graph.service.js";
-import { buildPreparedRenderOptions } from "./route-prepared-options.builder.js";
-class RouteRenderOrchestrator {
-  appConfig;
-  assetProcessingService;
-  ownershipValidationService;
-  pageBrowserGraphService;
-  constructor(appConfig, assetProcessingService, dependencies = {}) {
-    this.appConfig = appConfig;
-    this.assetProcessingService = assetProcessingService;
-    this.ownershipValidationService = dependencies.ownershipValidationService ?? new OwnershipValidationService(appConfig);
-    this.pageBrowserGraphService = dependencies.pageBrowserGraphService ?? new PageBrowserGraphService(appConfig, assetProcessingService);
-  }
-  /**
-   * Builds normalized route render options before the integration render runs.
-   *
-   * This preparation step validates route-root ownership, resolves page data,
-   * collects processed assets, and produces the page package consumed by downstream
-   * HTML transformation.
-   */
-  async prepareRenderOptions(routeOptions, adapter) {
-    const resolvedInputs = await adapter.resolveRouteRenderInputs(routeOptions);
-    const { Page, HtmlTemplate, Layouts } = resolvedInputs;
-    const validationErrors = this.ownershipValidationService.validate({
-      currentIntegrationName: adapter.name,
-      roots: [
-        { component: HtmlTemplate, source: "html-template" },
-        ...Layouts.map((layout) => ({ component: layout, source: "layout" })),
-        { component: Page, source: "page" }
-      ]
-    });
-    throwIfOwnershipInvalid(validationErrors);
-    const componentsToResolve = [HtmlTemplate, ...Layouts, Page];
-    const [{ resolvedDependencies }, pageBrowserGraph] = await Promise.all([
-      adapter.resolveRouteDependencies({
-        components: componentsToResolve
-      }),
-      this.pageBrowserGraphService.resolvePageBrowserGraph({
-        routeFile: routeOptions.file,
-        integrationName: adapter.name,
-        collectContribution: async (routeFile) => await adapter.collectPageBrowserGraphContribution(routeFile)
-      })
-    ]);
-    const allDependencies = [
-      ...resolvedDependencies,
-      ...collectUsedIntegrationDependenciesFromGraph(this.appConfig, componentsToResolve, adapter.name)
-    ];
-    const triggers = collectResolvedLazyTriggersFromGraph(componentsToResolve, adapter.name);
-    const [globalAssets, eagerSsrLazyAssets] = await Promise.all([
-      triggers.length > 0 ? buildGlobalInjectorAssets(this.appConfig, this.assetProcessingService, triggers, adapter.name) : Promise.resolve([]),
-      buildEagerSsrLazyAssetsFromGraph(this.assetProcessingService, componentsToResolve, adapter.name)
-    ]);
-    allDependencies.push(...globalAssets, ...eagerSsrLazyAssets);
-    return buildPreparedRenderOptions({
-      routeOptions,
-      resolvedInputs,
-      resolvedDependencies,
-      allDependencies,
-      pageBrowserGraph,
-      appConfig: this.appConfig
-    });
-  }
-  async resolveDeclaredPageBrowserGraph(input) {
-    return await this.pageBrowserGraphService.resolvePageBrowserGraph(input);
-  }
-  /**
-   * 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()."
-      );
+import { inspectUnresolvedMarkerArtifactHtml } from './marker-artifact.utils.js';
+import { OwnershipValidationService, throwIfOwnershipInvalid, } from '../ownership-graph/ownership-validation.service.js';
+import { buildEagerSsrLazyAssetsFromGraph, collectResolvedLazyTriggersFromGraph, collectUsedIntegrationDependenciesFromGraph, } from '../ownership-graph/component-graph-collectors.js';
+import { buildGlobalInjectorAssets } from '../page-browser-graph/global-injector-assets.service.js';
+import { PageBrowserGraphService } from '../page-browser-graph/page-browser-graph.service.js';
+import { buildPreparedRenderOptions } from './route-prepared-options.builder.js';
+/**
+ * Owns one route render from normalized module loading through final HTML output.
+ *
+ * This orchestrator keeps route rendering as one app-scoped unit while still
+ * delegating integration-specific behavior through the adapter seam. It owns
+ * route-root validation, dependency aggregation, page package creation, and the
+ * final HTML/body handling that happens after the integration render returns.
+ */
+export class RouteRenderOrchestrator {
+    appConfig;
+    assetProcessingService;
+    ownershipValidationService;
+    pageBrowserGraphService;
+    constructor(appConfig, assetProcessingService, dependencies = {}) {
+        this.appConfig = appConfig;
+        this.assetProcessingService = assetProcessingService;
+        this.ownershipValidationService =
+            dependencies.ownershipValidationService ?? new OwnershipValidationService(appConfig);
+        this.pageBrowserGraphService =
+            dependencies.pageBrowserGraphService ?? new PageBrowserGraphService(appConfig, assetProcessingService);
     }
-    const canReuseCapturedBody = !hasUnresolvedMarkerHtml && htmlFinalization.finalizeHtml === void 0;
-    if (canReuseCapturedBody) {
-      const body2 = await adapter.transformRouteResponse(
-        new Response(renderExecution.body, {
-          headers: {
-            "Content-Type": "text/html"
-          }
-        }),
-        htmlFinalization.htmlContributions,
-        renderOptions.pagePackage
-      );
-      return {
-        body: body2,
-        cacheStrategy: renderOptions.cacheStrategy
-      };
+    /**
+     * Builds normalized route render options before the integration render runs.
+     *
+     * This preparation step validates route-root ownership, resolves page data,
+     * collects processed assets, and produces the page package consumed by downstream
+     * HTML transformation.
+     */
+    async prepareRenderOptions(routeOptions, adapter) {
+        const resolvedInputs = await adapter.resolveRouteRenderInputs(routeOptions);
+        const { Page, HtmlTemplate, Layouts } = resolvedInputs;
+        const validationErrors = this.ownershipValidationService.validate({
+            currentIntegrationName: adapter.name,
+            roots: [
+                { component: HtmlTemplate, source: 'html-template' },
+                ...Layouts.map((layout) => ({ component: layout, source: 'layout' })),
+                { component: Page, source: 'page' },
+            ],
+        });
+        throwIfOwnershipInvalid(validationErrors);
+        const componentsToResolve = [HtmlTemplate, ...Layouts, Page];
+        const [{ resolvedDependencies }, pageBrowserGraph] = await Promise.all([
+            adapter.resolveRouteDependencies({
+                components: componentsToResolve,
+            }),
+            this.pageBrowserGraphService.resolvePageBrowserGraph({
+                routeFile: routeOptions.file,
+                integrationName: adapter.name,
+                collectContribution: async (routeFile) => await adapter.collectPageBrowserGraphContribution(routeFile),
+            }),
+        ]);
+        const allDependencies = [
+            ...resolvedDependencies,
+            ...collectUsedIntegrationDependenciesFromGraph(this.appConfig, componentsToResolve, adapter.name),
+        ];
+        const triggers = collectResolvedLazyTriggersFromGraph(componentsToResolve, adapter.name);
+        const [globalAssets, eagerSsrLazyAssets] = await Promise.all([
+            triggers.length > 0
+                ? buildGlobalInjectorAssets(this.appConfig, this.assetProcessingService, triggers, adapter.name)
+                : Promise.resolve([]),
+            buildEagerSsrLazyAssetsFromGraph(this.assetProcessingService, componentsToResolve, adapter.name),
+        ]);
+        allDependencies.push(...globalAssets, ...eagerSsrLazyAssets);
+        return buildPreparedRenderOptions({
+            routeOptions,
+            resolvedInputs,
+            resolvedDependencies,
+            allDependencies,
+            pageBrowserGraph,
+            appConfig: this.appConfig,
+        });
     }
-    const finalization = htmlFinalization.finalizeHtml ? htmlFinalization.finalizeHtml(unresolvedArtifactInspection.normalizedHtml) : unresolvedArtifactInspection.normalizedHtml;
-    const body = await adapter.transformRouteResponse(
-      new Response(finalization, {
-        headers: {
-          "Content-Type": "text/html"
+    async resolveDeclaredPageBrowserGraph(input) {
+        return await this.pageBrowserGraphService.resolvePageBrowserGraph(input);
+    }
+    /**
+     * 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().');
         }
-      }),
-      htmlFinalization.htmlContributions,
-      renderOptions.pagePackage
-    );
-    return {
-      body,
-      cacheStrategy: renderOptions.cacheStrategy
-    };
-  }
-  async captureRenderedBody(body) {
-    const response = new Response(body);
-    if (typeof body === "string") {
-      return {
-        body,
-        html: await response.text()
-      };
+        const canReuseCapturedBody = !hasUnresolvedMarkerHtml && htmlFinalization.finalizeHtml === undefined;
+        if (canReuseCapturedBody) {
+            const body = await adapter.transformRouteResponse(new Response(renderExecution.body, {
+                headers: {
+                    'Content-Type': 'text/html',
+                },
+            }), htmlFinalization.htmlContributions, renderOptions.pagePackage);
+            return {
+                body,
+                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',
+            },
+        }), htmlFinalization.htmlContributions, renderOptions.pagePackage);
+        return {
+            body,
+            cacheStrategy: renderOptions.cacheStrategy,
+        };
     }
-    if (!response.body) {
-      return {
-        body,
-        html: await response.text()
-      };
+    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(),
+        };
     }
-    const [capturedBody, replayBody] = response.body.tee();
-    return {
-      body: replayBody,
-      html: await new Response(capturedBody).text()
-    };
-  }
 }
-export {
-  RouteRenderOrchestrator
-};