@ecopages/core 0.2.0-alpha.23 → 0.2.0-alpha.24

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/queued-boundary-runtime.service.js

@@ -1,155 +0,0 @@
-class QueuedBoundaryRuntimeService {
-  /**
-   * Reads the queued boundary runtime state previously attached to one render.
-   */
-  getRuntimeContext(input, runtimeContextKey) {
-    const integrationContext = input.integrationContext;
-    const runtimeContext = integrationContext?.[runtimeContextKey];
-    if (typeof runtimeContext !== "object" || runtimeContext === null) {
-      return void 0;
-    }
-    return runtimeContext;
-  }
-  /**
-   * 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(options) {
-    const runtimeContext = this.ensureRuntimeContext(options);
-    const interceptBoundary = (input) => {
-      if (!options.shouldQueueBoundary(input)) {
-        return { kind: "inline" };
-      }
-      runtimeContext.nextBoundaryId += 1;
-      const boundaryId = runtimeContext.nextBoundaryId;
-      const token = this.createBoundaryToken(options.tokenPrefix, runtimeContext, boundaryId);
-      runtimeContext.queuedResolutions.push({
-        token,
-        component: input.component,
-        props: { ...input.props },
-        componentInstanceId: runtimeContext.componentInstanceScope ? `${runtimeContext.componentInstanceScope}_n_${boundaryId}` : `n_${boundaryId}`
-      });
-      return {
-        kind: "resolved",
-        value: token
-      };
-    };
-    return {
-      interceptBoundary,
-      interceptBoundarySync: interceptBoundary
-    };
-  }
-  /**
-   * 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.
-   */
-  async resolveQueuedHtml(options) {
-    if (!options.runtimeContext || options.runtimeContext.queuedResolutions.length === 0) {
-      return { assets: [], html: options.html };
-    }
-    const runtimeContext = options.runtimeContext;
-    const queuedResolutionsByToken = new Map(
-      runtimeContext.queuedResolutions.map((resolution) => [resolution.token, resolution])
-    );
-    const resolvedHtmlByToken = /* @__PURE__ */ new Map();
-    const resolvingTokens = /* @__PURE__ */ new Set();
-    const collectedAssets = [];
-    const resolveToken = async (token) => {
-      const cachedHtml = resolvedHtmlByToken.get(token);
-      if (cachedHtml) {
-        return cachedHtml;
-      }
-      const resolution = queuedResolutionsByToken.get(token);
-      if (!resolution) {
-        return token;
-      }
-      if (resolvingTokens.has(token)) {
-        throw new Error(
-          `[ecopages] ${options.queueLabel} boundary queue contains a cycle or unresolved dependency links.`
-        );
-      }
-      resolvingTokens.add(token);
-      try {
-        const renderedChildren = await options.renderQueuedChildren(
-          resolution.props.children,
-          runtimeContext,
-          queuedResolutionsByToken,
-          resolveToken
-        );
-        if (renderedChildren.assets.length > 0) {
-          collectedAssets.push(...renderedChildren.assets);
-        }
-        const boundaryRender = await options.resolveBoundary(
-          {
-            component: resolution.component,
-            props: { ...resolution.props },
-            children: renderedChildren.html,
-            integrationContext: {
-              rendererCache: runtimeContext.rendererCache,
-              componentInstanceId: resolution.componentInstanceId
-            }
-          },
-          runtimeContext.rendererCache
-        );
-        if (!boundaryRender) {
-          throw new Error(
-            `[ecopages] ${options.queueLabel} queued boundary could not resolve its owning renderer.`
-          );
-        }
-        if ((boundaryRender.assets?.length ?? 0) > 0) {
-          collectedAssets.push(...boundaryRender.assets ?? []);
-        }
-        const resolvedHtml2 = boundaryRender.attachmentPolicy.kind === "first-element" && boundaryRender.rootAttributes ? options.applyAttributesToFirstElement(boundaryRender.html, boundaryRender.rootAttributes) : boundaryRender.html;
-        resolvedHtmlByToken.set(token, resolvedHtml2);
-        return resolvedHtml2;
-      } finally {
-        resolvingTokens.delete(token);
-      }
-    };
-    let resolvedHtml = options.html;
-    for (const resolution of runtimeContext.queuedResolutions) {
-      if (!resolvedHtml.includes(resolution.token)) {
-        continue;
-      }
-      resolvedHtml = resolvedHtml.split(resolution.token).join(await resolveToken(resolution.token));
-    }
-    return {
-      assets: options.dedupeProcessedAssets(collectedAssets),
-      html: resolvedHtml
-    };
-  }
-  createBoundaryToken(tokenPrefix, runtimeContext, boundaryId) {
-    return `${tokenPrefix}${runtimeContext.componentInstanceScope ?? "root"}__${boundaryId}__`;
-  }
-  ensureRuntimeContext(options) {
-    let integrationContext;
-    if (typeof options.boundaryInput.integrationContext === "object" && options.boundaryInput.integrationContext !== null) {
-      integrationContext = options.boundaryInput.integrationContext;
-    } else {
-      integrationContext = {};
-    }
-    const existingRuntimeContext = integrationContext[options.runtimeContextKey];
-    if (typeof existingRuntimeContext !== "object" || existingRuntimeContext === null) {
-      integrationContext[options.runtimeContextKey] = options.createRuntimeContext?.(integrationContext, options.rendererCache) ?? {
-        rendererCache: options.rendererCache,
-        componentInstanceScope: integrationContext.componentInstanceId,
-        nextBoundaryId: 0,
-        queuedResolutions: []
-      };
-    } else {
-      existingRuntimeContext.rendererCache = options.rendererCache;
-    }
-    integrationContext.rendererCache = options.rendererCache;
-    options.boundaryInput.integrationContext = integrationContext;
-    return integrationContext[options.runtimeContextKey];
-  }
-}
-export {
-  QueuedBoundaryRuntimeService
-};

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
-};

package/src/route-renderer/orchestration/render-output.utils.d.ts

@@ -1,46 +0,0 @@
-import type { EcoComponent } from '../../types/public-types.js';
-/**
- * Returns `true` when `value` is a thenable (Promise-like) object.
- *
- * Used to transparently handle both synchronous and asynchronous component
- * render results without requiring every caller to branch on `instanceof Promise`.
- *
- * @typeParam T Expected resolved type of the thenable.
- */
-export declare function isThenable<T>(value: unknown): value is PromiseLike<T>;
-/**
- * Injects `data-eco-trigger` into the first real HTML element opening tag of
- * a component's rendered output string.
- *
- * The scan skips over leading whitespace, HTML comments (`<!-- -->`), CDATA
- * sections, and doctype declarations so that the attribute is always placed on
- * the first actual element — not spurious markup that can precede it.
- *
- * The insertion point is the end of the element's tag name, before any existing
- * attributes or the closing `>`, which produces output like:
- *
- * ```html
- * <my-element data-eco-trigger="eco-trigger-abc123" class="foo">…</my-element>
- * ```
- *
- * When no eligible opening tag is found the original string is returned
- * unchanged so callers never receive a broken fragment.
- *
- * @param content Rendered HTML string (or any value coercible to string).
- * @param triggerId Stable trigger identifier produced by `buildResolvedLazyTriggers`.
- */
-export declare function addTriggerAttribute(content: unknown, triggerId: string): string;
-/**
- * Wraps rendered component output in a `<scripts-injector>` element that
- * carries an inline injector map for the legacy (non-global-injector) path.
- *
- * @param content Rendered component HTML.
- * @param lazyGroups Resolved lazy script groups attached to the component config.
- */
-export declare function wrapWithScriptsInjector(content: unknown, lazyGroups: NonNullable<EcoComponent['config']>['_resolvedLazyScripts']): string;
-export declare function decodeHtmlEntities(value: string): string;
-export declare function normalizeBoundaryArtifactHtml(html: string): string;
-export declare function inspectBoundaryArtifactHtml(html: string): {
-    hasUnresolvedBoundaryArtifacts: boolean;
-    normalizedHtml: string;
-};

package/src/route-renderer/orchestration/render-output.utils.js

@@ -1,65 +0,0 @@
-import { buildInjectorMapScript } from "../../eco/lazy-injector-map.js";
-function isThenable(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function addTriggerAttribute(content, triggerId) {
-  const str = String(content);
-  let i = 0;
-  while (i < str.length) {
-    if (str[i] !== "<") {
-      i++;
-      continue;
-    }
-    const next = str[i + 1];
-    if (next === "!" || next === "?") {
-      const end = str.indexOf(">", i);
-      if (end === -1) break;
-      i = end + 1;
-      continue;
-    }
-    if (next && /[a-zA-Z]/.test(next)) {
-      const tagSlice = str.slice(i + 1);
-      const nameEnd = tagSlice.search(/[\s/>]/);
-      if (nameEnd === -1) break;
-      const insertAt = i + 1 + nameEnd;
-      return `${str.slice(0, insertAt)} data-eco-trigger="${triggerId}"${str.slice(insertAt)}`;
-    }
-    break;
-  }
-  return str;
-}
-function wrapWithScriptsInjector(content, lazyGroups) {
-  const wrappedContent = String(content);
-  const injectorMapScript = buildInjectorMapScript(lazyGroups ?? []);
-  return `<scripts-injector><script type="ecopages/injector-map">${injectorMapScript}<\/script>${wrappedContent}<\/scripts-injector>`;
-}
-function decodeHtmlEntities(value) {
-  let decoded = value;
-  let previous;
-  do {
-    previous = decoded;
-    decoded = decoded.replaceAll("&quot;", '"').replaceAll("&#39;", "'").replaceAll("&#x27;", "'").replaceAll("&lt;", "<").replaceAll("&gt;", ">").replaceAll("&amp;", "&");
-  } while (decoded !== previous);
-  return decoded;
-}
-function normalizeBoundaryArtifactHtml(html) {
-  return html.replace(
-    /&(?:amp;)?lt;eco-marker\b[\s\S]*?&(?:amp;)?gt;&(?:amp;)?lt;\/eco-marker&(?:amp;)?gt;/g,
-    (marker) => decodeHtmlEntities(marker)
-  );
-}
-function inspectBoundaryArtifactHtml(html) {
-  const normalizedHtml = normalizeBoundaryArtifactHtml(html);
-  return {
-    normalizedHtml,
-    hasUnresolvedBoundaryArtifacts: normalizedHtml.includes("<eco-marker")
-  };
-}
-export {
-  addTriggerAttribute,
-  decodeHtmlEntities,
-  inspectBoundaryArtifactHtml,
-  isThenable,
-  normalizeBoundaryArtifactHtml,
-  wrapWithScriptsInjector
-};

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

@@ -1,120 +0,0 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-import type { ComponentRenderResult, EcoComponent, EcoPageComponent, EcoPageFile, EcoPagesElement, GetMetadata, GetStaticProps, HtmlTemplateProps, IntegrationRendererRenderOptions, PageMetadataProps, RouteRendererOptions } from '../../types/public-types.js';
-import { type AssetProcessingService, type ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
-import { BoundaryPlanningService } from './boundary-planning.service.js';
-type ResolvedPageModule = {
-    Page: EcoPageFile['default'] | EcoPageComponent<any>;
-    getStaticProps?: GetStaticProps<Record<string, unknown>>;
-    getMetadata?: GetMetadata;
-    integrationSpecificProps: Record<string, unknown>;
-};
-export interface RenderPreparationCallbacks {
-    resolvePageModule(file: string): Promise<ResolvedPageModule>;
-    getHtmlTemplate(): Promise<EcoComponent<HtmlTemplateProps>>;
-    resolvePageData(pageModule: {
-        getStaticProps?: GetStaticProps<Record<string, unknown>>;
-        getMetadata?: GetMetadata;
-    }, routeOptions: RouteRendererOptions): Promise<{
-        props: Record<string, unknown>;
-        metadata: PageMetadataProps;
-    }>;
-    resolveDependencies(components: (EcoComponent | Partial<EcoComponent>)[]): Promise<ProcessedAsset[]>;
-    buildRouteRenderAssets(file: string): Promise<ProcessedAsset[]> | undefined;
-    shouldRenderPageComponent(input: {
-        Page: EcoComponent;
-        Layout?: EcoComponent;
-        options: RouteRendererOptions;
-    }): boolean;
-    renderPageComponent(input: {
-        component: EcoComponent;
-        props: Record<string, unknown>;
-    }): Promise<ComponentRenderResult>;
-    setProcessedDependencies(dependencies: ProcessedAsset[]): void;
-    dedupeProcessedAssets(assets: ProcessedAsset[]): ProcessedAsset[];
-    createPageLocalsProxy(filePath: string): RouteRendererOptions['locals'];
-}
-export interface RenderPreparationServiceDependencies {
-    boundaryPlanningService?: BoundaryPlanningService;
-}
-/**
- * Prepares the normalized render inputs consumed by `IntegrationRenderer.execute()`.
- *
- * This service owns the orchestration that happens before the main HTML render:
- * page module resolution, data loading, dependency aggregation, page-root
- * component artifact capture, lazy trigger bootstrap generation, and request
- * locals policy.
- */
-export declare class RenderPreparationService {
-    private appConfig;
-    private assetProcessingService;
-    private readonly boundaryPlanningService;
-    /**
-     * 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.
-     */
-    constructor(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService, dependencies?: RenderPreparationServiceDependencies);
-    /**
-     * 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.
-     *
-     * @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.
-     */
-    prepare<C = EcoPagesElement>(routeOptions: RouteRendererOptions, currentIntegrationName: string, callbacks: RenderPreparationCallbacks): Promise<IntegrationRendererRenderOptions<C>>;
-    /**
-     * 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.
-     */
-    private collectResolvedTriggers;
-    /**
-     * 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.
-     */
-    private collectUsedIntegrationDependencies;
-    /**
-     * 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.
-     */
-    private collectIntegrationNames;
-    /**
-     * 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.
-     */
-    private renderPageRoot;
-    /**
-     * 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.
-     */
-    private buildGlobalInjectorAssets;
-    private buildEagerSsrLazyAssets;
-    private collectEagerSsrLazyDependencies;
-}
-export {};