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

package/src/types/public-types.d.ts

@@ -2,7 +2,7 @@ import type { Readable } from 'node:stream';
 import type { ApiResponseBuilder } from '../adapters/shared/api-response.js';
 import type { BuildExecutor } from '../build/build-adapter.js';
 import type { EcoBuildPlugin } from '../build/build-types.js';
-import type { ComponentBoundaryRuntime } from '../route-renderer/orchestration/component-render-context.js';
+import type { ForeignChildRuntime } from '../route-renderer/orchestration/component-render-context.js';
 import type { EcoPageComponent } from '../eco/eco.types.js';
 import type { EcoPagesAppConfig } from './internal-types.js';
 import type { HmrStrategy } from '../hmr/hmr-strategy.js';
@@ -14,7 +14,7 @@ export type { EcoPagesAppConfig } from './internal-types.js';
 export type { EcoPageComponent } from '../eco/eco.types.js';
 export type { ProcessedAsset } from '../services/assets/asset-processing-service/assets.types.js';
 import type { StandardSchema, StandardSchemaResult, StandardSchemaSuccessResult, StandardSchemaFailureResult, StandardSchemaIssue, InferOutput } from '../services/validation/standard-schema.types.js';
-export type { StandardSchema, StandardSchemaResult, StandardSchemaSuccessResult, StandardSchemaFailureResult, StandardSchemaIssue, InferOutput, ComponentBoundaryRuntime, };
+export type { StandardSchema, StandardSchemaResult, StandardSchemaSuccessResult, StandardSchemaFailureResult, StandardSchemaIssue, InferOutput, ForeignChildRuntime, };
 export type InteractionEventsString = ScriptsInjectorInteractionEventsString;
 export type DependencyLazyTrigger = {
     'on:idle': true;
@@ -94,10 +94,6 @@ export interface DefaultHmrContext {
      * Map of registered entrypoints to their output URLs.
      */
     getWatchedFiles(): Map<string, string>;
-    /**
-     * Map of bare specifiers to runtime URLs for browser import resolution.
-     */
-    getSpecifierMap(): Map<string, string>;
     /**
      * Directory where HMR bundles are written.
      */
@@ -188,15 +184,6 @@ export interface IHmrManager {
      * script bundling path.
      */
     registerScriptEntrypoint(entrypointPath: string): Promise<string>;
-    /**
-     * Registers mappings from bare specifiers to runtime URLs.
-     *
-     * @remarks
-     * This is the shared registration seam for integration-owned runtime alias
-     * maps. The registry may later back a broader import-map-style facility, but
-     * the mappings themselves remain integration-owned.
-     */
-    registerSpecifierMap(map: Record<string, string>): void;
     /**
      * Registers a custom HMR strategy.
      */
@@ -225,10 +212,6 @@ export interface IHmrManager {
      * Gets the map of watched files.
      */
     getWatchedFiles(): Map<string, string>;
-    /**
-     * Gets the registered bare-specifier map.
-     */
-    getSpecifierMap(): Map<string, string>;
     /**
      * Gets the HMR dist directory.
      */
@@ -679,7 +662,7 @@ export type IntegrationRendererRenderOptions<C = EcoPagesElement> = RouteRendere
     pageProps?: Record<string, unknown>;
     cacheStrategy?: CacheStrategy;
     pageLocals?: RequestLocals;
-    boundaryPlan?: BoundaryPlan;
+    ownershipPlan?: OwnershipPlan;
 };
 /**
  * Structured page asset package produced after dependency resolution.
@@ -718,51 +701,65 @@ export interface PagePackageResult {
      */
     dynamicChunks: ProcessedAsset[];
 }
-export type BoundaryValidationErrorCode = 'UNKNOWN_INTEGRATION_OWNER' | 'MISSING_COMPONENT_METADATA';
-export interface BoundaryValidationError {
-    code: BoundaryValidationErrorCode;
+/**
+ * Page-scoped browser output planned before final HTML packaging.
+ *
+ * The initial seam keeps the graph payload intentionally small: integrations
+ * return the processed assets that belong to the Page browser graph, while the
+ * surrounding route pipeline remains free to evolve toward richer entry/lazy/
+ * shared chunk structure later.
+ */
+export interface PageBrowserGraphResult {
+    /**
+     * Processed assets owned by the current Page browser graph.
+     */
+    assets: ProcessedAsset[];
+}
+export type OwnershipValidationErrorCode = 'UNKNOWN_INTEGRATION_OWNER' | 'MISSING_COMPONENT_METADATA';
+export interface OwnershipValidationError {
+    code: OwnershipValidationErrorCode;
     message: string;
     componentId?: string;
     componentFile?: string;
     integrationName?: string;
 }
-export type BoundaryPlanNodeSource = 'route' | 'page' | 'layout' | 'html-template' | 'dependency';
-export interface BoundaryOwnership {
+export type OwnershipPlanNodeSource = 'route' | 'page' | 'layout' | 'html-template' | 'dependency';
+export interface IntegrationOwnership {
     integrationName: string;
     componentId: string;
     componentFile?: string;
     isPageEntry: boolean;
     isForeignToParent: boolean;
 }
-export interface BoundaryPlanNode {
+export interface OwnershipPlanNode {
     id: string;
-    source: BoundaryPlanNodeSource;
-    ownership: BoundaryOwnership;
-    children: BoundaryPlanNode[];
+    source: OwnershipPlanNodeSource;
+    ownership: IntegrationOwnership;
+    children: OwnershipPlanNode[];
     declaredDependenciesValid: boolean;
 }
-export interface BoundaryPlan {
-    root: BoundaryPlanNode;
+export interface OwnershipPlan {
+    root: OwnershipPlanNode;
     rendererNames: string[];
     foreignEdgeCount: number;
     hasValidationErrors: boolean;
-    validationErrors: BoundaryValidationError[];
+    validationErrors: OwnershipValidationError[];
 }
-export type BoundaryAttachmentPolicy = {
+export type ForeignSubtreeAttachmentPolicy = {
     kind: 'none';
 } | {
     kind: 'first-element';
 };
-export interface BoundaryRenderPayload {
+export interface ForeignSubtreeRenderPayload {
     html: string;
     assets: ProcessedAsset[];
     rootTag?: string;
     rootAttributes?: Record<string, string>;
-    attachmentPolicy: BoundaryAttachmentPolicy;
+    attachmentPolicy: ForeignSubtreeAttachmentPolicy;
     integrationName: string;
 }
 /**
- * Shared execution-scoped context threaded through component boundary renders.
+ * Shared execution-scoped context threaded through foreign-child renders.
  *
  * Integrations can extend this with renderer-local runtime keys, but the cache
  * and optional component instance identity are shared across all renderers.
@@ -1016,6 +1013,15 @@ export interface ApiHandlerContext<TRequest extends Request = Request, TServer =
      */
     headers?: unknown;
 }
+/**
+ * Context available to file-route page middleware.
+ *
+ * Page middleware can mutate locals, short-circuit the request, and use the
+ * response helpers, but final document rendering stays owned by the page route
+ * execution path.
+ */
+export interface FileRouteMiddlewareContext<TRequest extends Request = Request, TServer = any> extends Omit<ApiHandlerContext<TRequest, TServer>, 'render' | 'renderPartial'> {
+}
 /**
  * Next function for middleware chain.
  * Call to continue to the next middleware or final handler.
@@ -1051,6 +1057,10 @@ export type MiddlewareNext = () => Promise<Response>;
  * ```
  */
 export type Middleware<TRequest extends Request = Request, TServer = any, TContext extends ApiHandlerContext<TRequest, TServer> = ApiHandlerContext<TRequest, TServer>> = (context: TContext, next: MiddlewareNext) => Promise<Response> | Response;
+/**
+ * Middleware contract for file-based page routes.
+ */
+export type FileRouteMiddleware<TRequest extends Request = Request, TServer = any, TContext extends FileRouteMiddlewareContext<TRequest, TServer> = FileRouteMiddlewareContext<TRequest, TServer>> = (context: TContext, next: MiddlewareNext) => Promise<Response> | Response;
 /**
  * Helper type for defining middleware with extended context.
  * Automatically infers TRequest and TServer from the provided context type.

package/src/watchers/project-watcher.test-helpers.js

@@ -10,23 +10,23 @@ const createMockHmrManager = () => ({
   }),
   registerEntrypoint: vi.fn(async () => ""),
   registerScriptEntrypoint: vi.fn(async () => ""),
-  registerSpecifierMap: vi.fn(() => {
-  }),
   registerStrategy: vi.fn(() => {
   }),
   isEnabled: vi.fn(() => true),
   getOutputUrl: vi.fn(() => void 0),
   getWatchedFiles: vi.fn(() => /* @__PURE__ */ new Map()),
-  getSpecifierMap: vi.fn(() => /* @__PURE__ */ new Map()),
   getDistDir: vi.fn(() => ""),
   getPlugins: vi.fn(() => []),
   getDefaultContext: vi.fn(() => ({
     getWatchedFiles: () => /* @__PURE__ */ new Map(),
-    getSpecifierMap: () => /* @__PURE__ */ new Map(),
     getDistDir: () => "",
     getPlugins: () => [],
     getSrcDir: () => "",
-    getLayoutsDir: () => ""
+    getLayoutsDir: () => "",
+    getPagesDir: () => "",
+    getBuildExecutor: () => ({ build: vi.fn(async () => ({ success: true, logs: [], outputs: [] })) }),
+    getBrowserBundleService: () => ({ bundle: vi.fn(async () => ({ success: true, logs: [], outputs: [] })) }),
+    importServerModule: vi.fn(async () => ({}))
   }))
 });
 const createMockBridge = () => ({

package/src/route-renderer/orchestration/boundary-planning.service.d.ts

@@ -1,25 +0,0 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-import type { BoundaryPlan, EcoComponent } from '../../types/public-types.js';
-type BoundaryPlanBuildInput = {
-    routeFile: string;
-    currentIntegrationName: string;
-    HtmlTemplate: EcoComponent;
-    Layout?: EcoComponent;
-    Page: EcoComponent;
-};
-/**
- * Builds a declared ownership plan from the component dependency graph.
- *
- * The plan is intentionally conservative: it reflects declared component
- * dependencies available during render preparation and records diagnostics for
- * foreign ownership edges that cannot be validated against registered
- * integrations or stable component metadata.
- */
-export declare class BoundaryPlanningService {
-    private readonly appConfig;
-    private nextSyntheticId;
-    constructor(appConfig: EcoPagesAppConfig);
-    buildPlan(input: BoundaryPlanBuildInput): BoundaryPlan;
-    private isRegisteredIntegration;
-}
-export {};

package/src/route-renderer/orchestration/boundary-planning.service.js

@@ -1,97 +0,0 @@
-class BoundaryPlanningService {
-  appConfig;
-  nextSyntheticId = 0;
-  constructor(appConfig) {
-    this.appConfig = appConfig;
-  }
-  buildPlan(input) {
-    this.nextSyntheticId = 0;
-    const validationErrors = [];
-    const rendererNames = /* @__PURE__ */ new Set([input.currentIntegrationName]);
-    let foreignEdgeCount = 0;
-    const buildNode = (component, source, parentIntegrationName, lineage) => {
-      const integrationName = component.config?.integration ?? component.config?.__eco?.integration ?? parentIntegrationName;
-      const componentMeta = component.config?.__eco;
-      const isForeignToParent = integrationName !== parentIntegrationName;
-      const componentId = componentMeta?.id ?? componentMeta?.file ?? `${source}:${this.nextSyntheticId += 1}`;
-      rendererNames.add(integrationName);
-      if (isForeignToParent) {
-        foreignEdgeCount += 1;
-        if (!componentMeta) {
-          validationErrors.push({
-            code: "MISSING_COMPONENT_METADATA",
-            message: `[ecopages] Foreign boundary "${componentId}" must provide stable __eco metadata so ownership diagnostics stay actionable. Declared dependencies must include all possible foreign children.`,
-            componentId,
-            integrationName
-          });
-        }
-        if (!this.isRegisteredIntegration(integrationName, input.currentIntegrationName)) {
-          validationErrors.push({
-            code: "UNKNOWN_INTEGRATION_OWNER",
-            message: `[ecopages] Foreign boundary "${componentId}" references unknown integration owner "${integrationName}". Declared dependencies must include all possible foreign children and those integrations must be registered.`,
-            componentId,
-            componentFile: componentMeta?.file,
-            integrationName
-          });
-        }
-      }
-      const nextLineage = new Set(lineage);
-      nextLineage.add(component);
-      const children = (component.config?.dependencies?.components ?? []).flatMap((child) => {
-        if (!child || nextLineage.has(child)) {
-          return [];
-        }
-        return [buildNode(child, "dependency", integrationName, nextLineage)];
-      });
-      return {
-        id: componentId,
-        source,
-        ownership: {
-          integrationName,
-          componentId,
-          componentFile: componentMeta?.file,
-          isPageEntry: source === "page",
-          isForeignToParent
-        },
-        children,
-        declaredDependenciesValid: true
-      };
-    };
-    const roots = [
-      { component: input.HtmlTemplate, source: "html-template" },
-      ...input.Layout ? [{ component: input.Layout, source: "layout" }] : [],
-      { component: input.Page, source: "page" }
-    ];
-    const root = {
-      id: `route:${input.routeFile}`,
-      source: "route",
-      ownership: {
-        integrationName: input.currentIntegrationName,
-        componentId: `route:${input.routeFile}`,
-        componentFile: input.routeFile,
-        isPageEntry: false,
-        isForeignToParent: false
-      },
-      children: roots.map(
-        ({ component, source }) => buildNode(component, source, input.currentIntegrationName, /* @__PURE__ */ new Set())
-      ),
-      declaredDependenciesValid: validationErrors.length === 0
-    };
-    return {
-      root,
-      rendererNames: Array.from(rendererNames),
-      foreignEdgeCount,
-      hasValidationErrors: validationErrors.length > 0,
-      validationErrors
-    };
-  }
-  isRegisteredIntegration(integrationName, currentIntegrationName) {
-    if (integrationName === currentIntegrationName) {
-      return true;
-    }
-    return this.appConfig.integrations.some((integration) => integration.name === integrationName);
-  }
-}
-export {
-  BoundaryPlanningService
-};

package/src/route-renderer/orchestration/page-packaging.service.d.ts

@@ -1,16 +0,0 @@
-import type { ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
-import type { PagePackageResult } from '../../types/public-types.js';
-/**
- * Creates the structured page package consumed by final HTML injection.
- *
- * This first pass is intentionally behavior-preserving. It establishes the
- * packaging seam while forwarding the current flat processed asset list.
- */
-export declare class PagePackagingService {
-    /**
-     * Partitions processed assets into the page-level groups used during final
-     * HTML injection and post-processing.
-     */
-    createPagePackage(assets: ProcessedAsset[]): PagePackageResult;
-    private shouldIncludeInHtml;
-}

package/src/route-renderer/orchestration/page-packaging.service.js

@@ -1,66 +0,0 @@
-class PagePackagingService {
-  /**
-   * Partitions processed assets into the page-level groups used during final
-   * HTML injection and post-processing.
-   */
-  createPagePackage(assets) {
-    const inlineAssets = [];
-    const separateAssets = [];
-    const dynamicChunks = [];
-    let pageScript;
-    let pageStylesheet;
-    for (const asset of assets) {
-      if (asset.inline) {
-        inlineAssets.push(asset);
-        continue;
-      }
-      if (asset.packageRole === "dynamic-chunk") {
-        dynamicChunks.push(asset);
-        continue;
-      }
-      if (!pageScript && asset.packageRole === "page-script") {
-        pageScript = asset;
-        continue;
-      }
-      if (!pageStylesheet && asset.packageRole === "page-style") {
-        pageStylesheet = asset;
-        continue;
-      }
-      if (asset.packageRole === "keep-separate" || asset.packageRole === "runtime") {
-        separateAssets.push(asset);
-        continue;
-      }
-      if (!pageScript && asset.kind === "script" && !asset.excludeFromHtml) {
-        pageScript = asset;
-        continue;
-      }
-      if (!pageStylesheet && asset.kind === "stylesheet") {
-        pageStylesheet = asset;
-        continue;
-      }
-      separateAssets.push(asset);
-    }
-    const htmlAssets = assets.filter((asset) => this.shouldIncludeInHtml(asset));
-    return {
-      assets,
-      htmlAssets,
-      pageScript,
-      pageStylesheet,
-      inlineAssets,
-      separateAssets,
-      dynamicChunks
-    };
-  }
-  shouldIncludeInHtml(asset) {
-    if (asset.excludeFromHtml) {
-      return false;
-    }
-    if (asset.packageRole === "runtime") {
-      return false;
-    }
-    return true;
-  }
-}
-export {
-  PagePackagingService
-};

package/src/route-renderer/orchestration/queued-boundary-runtime.service.d.ts

@@ -1,89 +0,0 @@
-import type { ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
-import type { BaseIntegrationContext, BoundaryRenderPayload, ComponentRenderInput, EcoComponent } from '../../types/public-types.js';
-import type { ComponentBoundaryRuntime } from './component-render-context.js';
-export type QueuedBoundaryDecisionInput = {
-    currentIntegration: string;
-    targetIntegration?: string;
-    component: EcoComponent;
-    props: Record<string, unknown>;
-};
-export type QueuedBoundaryResolution = {
-    token: string;
-    component: EcoComponent;
-    props: Record<string, unknown>;
-    componentInstanceId: string;
-};
-/**
- * Shared mutable state for one renderer-owned queued boundary runtime.
- *
- * Renderers that cannot resolve foreign boundaries inline can enqueue transport
- * tokens during their initial render, then resolve those tokens against the
- * owning renderer before returning final HTML.
- */
-export type QueuedBoundaryRuntimeContext = {
-    rendererCache: Map<string, unknown>;
-    componentInstanceScope?: string;
-    nextBoundaryId: number;
-    queuedResolutions: QueuedBoundaryResolution[];
-};
-type QueuedBoundaryIntegrationContext = BaseIntegrationContext & Record<string, unknown>;
-type QueuedBoundaryChildRenderResult = {
-    assets: ProcessedAsset[];
-    html?: string;
-};
-/**
- * Shared queue orchestration for renderer-owned boundary runtimes that emit
- * temporary transport tokens during one render pass.
- *
- * The service keeps three responsibilities in one place:
- * - storing per-render queue state on the active integration context
- * - creating a `ComponentBoundaryRuntime` that enqueues foreign boundaries
- * - resolving queued tokens back through the owning renderer before final HTML
- *   leaves the current renderer
- *
- * Renderers still own framework-specific child rendering. This service only
- * handles queue bookkeeping, recursion, cycle detection, and asset merging.
- */
-export declare class QueuedBoundaryRuntimeService {
-    /**
-     * Reads the queued boundary runtime state previously attached to one render.
-     */
-    getRuntimeContext<TContext extends QueuedBoundaryRuntimeContext>(input: ComponentRenderInput, runtimeContextKey: string): TContext | undefined;
-    /**
-     * Creates the runtime hook used by `runWithComponentRenderContext()` for one
-     * renderer-owned queue.
-     *
-     * When the renderer decides a boundary must be handed off, the runtime returns
-     * a resolved transport token instead of rendering the foreign component inline.
-     */
-    createRuntime<TContext extends QueuedBoundaryRuntimeContext>(options: {
-        boundaryInput: ComponentRenderInput;
-        rendererCache: Map<string, unknown>;
-        runtimeContextKey: string;
-        tokenPrefix: string;
-        shouldQueueBoundary: (input: QueuedBoundaryDecisionInput) => boolean;
-        createRuntimeContext?: (integrationContext: QueuedBoundaryIntegrationContext, rendererCache: Map<string, unknown>) => TContext;
-    }): ComponentBoundaryRuntime;
-    /**
-     * Resolves every queued transport token in one renderer-owned HTML fragment.
-     *
-     * The caller supplies framework-specific child rendering, while this service
-     * handles recursive token replacement, cycle detection, root-attribute
-     * application, and merged asset collection.
-     */
-    resolveQueuedHtml<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<QueuedBoundaryChildRenderResult>;
-        resolveBoundary: (input: ComponentRenderInput, rendererCache: Map<string, unknown>) => Promise<BoundaryRenderPayload | undefined>;
-        applyAttributesToFirstElement: (html: string, attributes: Record<string, string>) => string;
-        dedupeProcessedAssets: (assets: ProcessedAsset[]) => ProcessedAsset[];
-    }): Promise<{
-        assets: ProcessedAsset[];
-        html: string;
-    }>;
-    private createBoundaryToken;
-    private ensureRuntimeContext;
-}
-export {};

package/src/route-renderer/orchestration/render-execution.service.d.ts

@@ -1,43 +0,0 @@
-import type { IntegrationRendererRenderOptions, RouteRendererBody, RouteRendererOptions, RouteRenderResult } from '../../types/public-types.js';
-export interface CapturedHtmlRenderResult {
-    body: RouteRendererBody;
-    html: string;
-}
-export interface FinalizeHtmlRenderOptions {
-    html: string;
-    componentRootAttributes?: Record<string, string>;
-    documentAttributes?: Record<string, string>;
-}
-export interface RenderExecutionCallbacks<C> {
-    prepareRenderOptions(options: RouteRendererOptions): Promise<IntegrationRendererRenderOptions<C>>;
-    render(renderOptions: IntegrationRendererRenderOptions<C>): Promise<RouteRendererBody>;
-    getDocumentAttributes(renderOptions: IntegrationRendererRenderOptions<C>): Record<string, string> | undefined;
-    applyAttributesToHtmlElement(html: string, attributes: Record<string, string>): string;
-    applyAttributesToFirstBodyElement(html: string, attributes: Record<string, string>): string;
-    transformResponse(response: Response): Promise<RouteRendererBody>;
-}
-/**
- * Executes the main post-preparation rendering flow for integration renderers.
- *
- * This service owns the orchestration that happens after normalized render
- * options have been prepared: one render pass, unresolved boundary-marker
- * enforcement, root-attribute application, and final HTML transformation into
- * a response body stream.
- */
-export declare class RenderExecutionService {
-    captureHtmlRender(render: () => Promise<RouteRendererBody>): Promise<CapturedHtmlRenderResult>;
-    /**
-     * Executes one integration render pass and returns the final route render
-     * result.
-     *
-     * @typeParam C Integration render output element type.
-     * @param options Route-level render options.
-     * @param currentIntegrationName Active integration name for this render pass.
-     * @param callbacks Renderer-specific hooks required during execution.
-     * @returns Final route render output with body and cache strategy.
-     */
-    execute<C = unknown>(options: RouteRendererOptions, callbacks: RenderExecutionCallbacks<C>): Promise<RouteRenderResult>;
-    private captureRenderedBody;
-    finalizeHtmlRender(options: FinalizeHtmlRenderOptions, callbacks: Pick<RenderExecutionCallbacks<unknown>, 'applyAttributesToHtmlElement' | 'applyAttributesToFirstBodyElement'>): Promise<string>;
-    private applyFinalHtmlAttributes;
-}

package/src/route-renderer/orchestration/render-execution.service.js

@@ -1,106 +0,0 @@
-import { inspectBoundaryArtifactHtml } from "./render-output.utils.js";
-class RenderExecutionService {
-  async captureHtmlRender(render) {
-    const renderedBody = await render();
-    const capturedRender = await this.captureRenderedBody(renderedBody);
-    return {
-      body: capturedRender.body,
-      html: capturedRender.html
-    };
-  }
-  /**
-   * Executes one integration render pass and returns the final route render
-   * result.
-   *
-   * @typeParam C Integration render output element type.
-   * @param options Route-level render options.
-   * @param currentIntegrationName Active integration name for this render pass.
-   * @param callbacks Renderer-specific hooks required during execution.
-   * @returns Final route render output with body and cache strategy.
-   */
-  async execute(options, callbacks) {
-    const renderOptions = await callbacks.prepareRenderOptions(options);
-    const shouldApplyComponentRootAttributes = renderOptions.componentRender?.canAttachAttributes && renderOptions.componentRender.rootAttributes && Object.keys(renderOptions.componentRender.rootAttributes).length > 0;
-    const renderExecution = await this.captureHtmlRender(async () => callbacks.render(renderOptions));
-    const boundaryArtifacts = inspectBoundaryArtifactHtml(renderExecution.html);
-    const documentAttributes = callbacks.getDocumentAttributes(renderOptions);
-    const hasBoundaryMarkerHtml = boundaryArtifacts.hasUnresolvedBoundaryArtifacts;
-    if (hasBoundaryMarkerHtml) {
-      throw new Error(
-        "[ecopages] Route render returned unresolved boundary artifact HTML. Full-route unresolved-boundary fallback has been removed; resolve mixed boundaries inside renderComponentBoundary()."
-      );
-    }
-    const canReuseCapturedBody = !hasBoundaryMarkerHtml && !shouldApplyComponentRootAttributes && !(documentAttributes && Object.keys(documentAttributes).length > 0);
-    if (canReuseCapturedBody) {
-      const body2 = await callbacks.transformResponse(
-        new Response(renderExecution.body, {
-          headers: {
-            "Content-Type": "text/html"
-          }
-        })
-      );
-      return {
-        body: body2,
-        cacheStrategy: renderOptions.cacheStrategy
-      };
-    }
-    const finalization = await this.finalizeHtmlRender(
-      {
-        html: boundaryArtifacts.normalizedHtml,
-        componentRootAttributes: shouldApplyComponentRootAttributes ? renderOptions.componentRender?.rootAttributes : void 0,
-        documentAttributes
-      },
-      {
-        applyAttributesToHtmlElement: callbacks.applyAttributesToHtmlElement,
-        applyAttributesToFirstBodyElement: callbacks.applyAttributesToFirstBodyElement
-      }
-    );
-    const body = await callbacks.transformResponse(
-      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()
-    };
-  }
-  async finalizeHtmlRender(options, callbacks) {
-    return this.applyFinalHtmlAttributes(options.html, options, callbacks);
-  }
-  applyFinalHtmlAttributes(html, options, callbacks) {
-    let renderedHtml = html;
-    if (options.componentRootAttributes && Object.keys(options.componentRootAttributes).length > 0) {
-      renderedHtml = callbacks.applyAttributesToFirstBodyElement(renderedHtml, options.componentRootAttributes);
-    }
-    if (options.documentAttributes && Object.keys(options.documentAttributes).length > 0) {
-      renderedHtml = callbacks.applyAttributesToHtmlElement(renderedHtml, options.documentAttributes);
-    }
-    return renderedHtml;
-  }
-}
-export {
-  RenderExecutionService
-};