npm - @ecopages/core - Versions diffs - 0.2.0-alpha.11 → 0.2.0-alpha.13 - Mend

@ecopages/core 0.2.0-alpha.11 → 0.2.0-alpha.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (57) hide show

package/src/route-renderer/orchestration/integration-renderer.js CHANGED Viewed

@@ -6,10 +6,13 @@ import { HttpError } from "../../errors/http-error.js";
 import { LocalsAccessError } from "../../errors/locals-access-error.js";
 import { DependencyResolverService } from "../page-loading/dependency-resolver.js";
 import { PageModuleLoaderService } from "../page-loading/page-module-loader.js";
-import { MarkerGraphResolver } from "../component-graph/marker-graph-resolver.js";
 import { RenderExecutionService } from "./render-execution.service.js";
 import { RenderPreparationService } from "./render-preparation.service.js";
-import { runWithComponentRenderContext } from "../../eco/component-render-context.js";
+import { normalizeBoundaryArtifactHtml } from "./render-output.utils.js";
+import { getComponentRenderContext, runWithComponentRenderContext } from "./component-render-context.js";
+import {
+  QueuedBoundaryRuntimeService
+} from "./queued-boundary-runtime.service.js";
 function createLocalsProxy(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(
@@ -49,10 +52,55 @@ class IntegrationRenderer {
   runtimeOrigin;
   dependencyResolverService;
   pageModuleLoaderService;
-  markerGraphResolver;
   renderPreparationService;
   renderExecutionService;
+  queuedBoundaryRuntimeService = new QueuedBoundaryRuntimeService();
   DOC_TYPE = "<!DOCTYPE html>";
+  /**
+   * Reads the execution-scoped foreign renderer cache from one boundary input.
+   *
+   * Shared page/layout/document shell helpers pass one cache through
+   * `integrationContext` so repeated delegation to the same foreign integration
+   * can reuse a single initialized renderer instance during one render flow.
+   * The cache is deliberately scoped to the current render execution rather than
+   * stored on the renderer, which avoids leaking mutable integration state across
+   * requests while still preventing redundant renderer initialization.
+   *
+   * @param integrationContext - Optional boundary context carried with one render input.
+   * @returns The current execution cache when present.
+   */
+  getBoundaryRendererCache(integrationContext) {
+    if (typeof integrationContext === "object" && integrationContext !== null && "rendererCache" in integrationContext && integrationContext.rendererCache instanceof Map) {
+      return integrationContext.rendererCache;
+    }
+    return void 0;
+  }
+  getRegisteredBoundaryOwner(component) {
+    const integrationName = component.config?.integration ?? component.config?.__eco?.integration;
+    if (!integrationName || integrationName === this.name) {
+      return void 0;
+    }
+    return this.appConfig.integrations.some((integration) => integration.name === integrationName) ? integrationName : void 0;
+  }
+  /**
+   * Attaches an execution-scoped foreign renderer cache to one boundary input.
+   *
+   * Foreign-owned page, layout, or document shells may delegate several times in
+   * the same render flow. Threading the cache through `integrationContext`
+   * preserves renderer reuse without changing the public boundary input contract.
+   * Existing integration-specific context is preserved and augmented.
+   *
+   * @param input - Original boundary render input.
+   * @param rendererCache - Execution-scoped renderer cache to propagate.
+   * @returns Boundary input augmented with the shared renderer cache.
+   */
+  withBoundaryRendererCache(input, rendererCache) {
+    const integrationContext = input.integrationContext;
+    return {
+      ...input,
+      integrationContext: typeof integrationContext === "object" && integrationContext !== null ? { ...integrationContext, rendererCache } : { rendererCache }
+    };
+  }
   getRendererModuleValue(key) {
     if (!this.rendererModules || typeof this.rendererModules !== "object") {
       return void 0;
@@ -143,6 +191,265 @@ class IntegrationRenderer {
     this.htmlTransformer.setProcessedDependencies(resolvedDependencies);
     return resolvedDependencies;
   }
+  /**
+   * Merges component-scoped assets into the active HTML transformer state.
+   *
+   * Explicit page, layout, and document shell composition can produce assets at
+   * each boundary. This helper deduplicates those groups and folds them back into
+   * the transformer so downstream HTML finalization sees one canonical asset set.
+   *
+   * @param assetGroups - Optional groups of processed assets to merge.
+   * @returns The deduplicated asset subset contributed by this merge operation.
+   */
+  appendProcessedDependencies(...assetGroups) {
+    const nextDependencies = this.htmlTransformer.dedupeProcessedAssets(
+      assetGroups.flatMap((assets) => assets ?? [])
+    );
+    if (nextDependencies.length === 0) {
+      return nextDependencies;
+    }
+    this.htmlTransformer.setProcessedDependencies(
+      this.htmlTransformer.dedupeProcessedAssets([
+        ...this.htmlTransformer.getProcessedDependencies(),
+        ...nextDependencies
+      ])
+    );
+    return nextDependencies;
+  }
+  /**
+   * Resolves metadata for explicit view rendering.
+   *
+   * When a view declares a `metadata()` function, that contract owns the final
+   * metadata for the explicit render. Otherwise the app-level default metadata is
+   * reused so explicit routes and page-module routes share the same fallback.
+   *
+   * @param view - View component being rendered.
+   * @param props - Props passed to the view.
+   * @returns Resolved metadata for the final document shell.
+   */
+  async resolveViewMetadata(view, props) {
+    return view.metadata ? await view.metadata({
+      params: {},
+      query: {},
+      props,
+      appConfig: this.appConfig
+    }) : this.appConfig.defaultMetadata;
+  }
+  /**
+   * Renders one explicit view response in partial mode.
+   *
+   * Same-integration views can optionally stream or render inline via the caller's
+   * `renderInline()` hook. Once a view may cross integration boundaries, this
+   * helper routes the render through `renderComponentBoundary()` instead so mixed
+   * shells can reuse the execution-scoped renderer cache and resolve nested
+   * foreign ownership before the partial response is returned.
+   *
+   * @param input - View render options for the partial response.
+   * @returns HTML response for the partial render.
+   */
+  async renderPartialViewResponse(input) {
+    if (input.renderInline && !this.hasForeignBoundaryDescendants(input.view)) {
+      return this.createHtmlResponse(await input.renderInline(), input.ctx);
+    }
+    const rendererCache = /* @__PURE__ */ new Map();
+    const viewRender = await this.renderComponentBoundary({
+      component: input.view,
+      props: input.props ?? {},
+      integrationContext: { rendererCache }
+    });
+    const html = input.transformHtml ? input.transformHtml(viewRender.html) : viewRender.html;
+    return this.createHtmlResponse(html, input.ctx);
+  }
+  /**
+   * Renders an explicit view through optional layout and document shells.
+   *
+   * This helper is the shared explicit-route path for string-oriented and mixed
+   * integrations. It prepares view dependencies, resolves metadata, and composes
+   * view, layout, and html template boundaries with one execution-scoped renderer
+   * cache so repeated foreign shell delegation can reuse initialized renderers
+   * during the same render flow.
+   *
+   * @param input - View, props, and optional layout metadata for the render.
+   * @returns HTML response for the explicit view render.
+   */
+  async renderViewWithDocumentShell(input) {
+    const normalizedProps = input.props ?? {};
+    if (input.ctx.partial) {
+      return this.renderPartialViewResponse({
+        view: input.view,
+        props: input.props,
+        ctx: input.ctx
+      });
+    }
+    await this.prepareViewDependencies(input.view, input.layout);
+    const HtmlTemplate = await this.getHtmlTemplate();
+    const metadata = await this.resolveViewMetadata(input.view, input.props);
+    const rendererCache = /* @__PURE__ */ new Map();
+    const viewRender = await this.renderComponentBoundary({
+      component: input.view,
+      props: normalizedProps,
+      integrationContext: { rendererCache }
+    });
+    const layoutRender = input.layout ? await this.renderComponentBoundary({
+      component: input.layout,
+      props: {},
+      children: viewRender.html,
+      integrationContext: { rendererCache }
+    }) : void 0;
+    const documentRender = await this.renderComponentBoundary({
+      component: HtmlTemplate,
+      props: {
+        metadata,
+        pageProps: normalizedProps
+      },
+      children: layoutRender?.html ?? viewRender.html,
+      integrationContext: { rendererCache }
+    });
+    this.appendProcessedDependencies(viewRender.assets, layoutRender?.assets, documentRender.assets);
+    const html = await this.finalizeResolvedHtml({
+      html: `${this.DOC_TYPE}${documentRender.html}`,
+      partial: false
+    });
+    return this.createHtmlResponse(html, input.ctx);
+  }
+  /**
+   * Renders a route page through optional layout and document shells.
+   *
+   * Route rendering and explicit view rendering now share the same boundary-owned
+   * shell composition model. This helper composes page, layout, and html template
+   * boundaries while threading one execution-scoped renderer cache through every
+   * delegated boundary so foreign shell ownership remains stable and renderer
+   * initialization is reused inside the current request.
+   *
+   * @param input - Page, layout, document, and metadata inputs for the route render.
+   * @returns Final serialized document HTML including the doctype prefix.
+   */
+  async renderPageWithDocumentShell(input) {
+    const rendererCache = /* @__PURE__ */ new Map();
+    const pageRender = await this.renderComponentBoundary({
+      component: input.page.component,
+      props: input.page.props,
+      integrationContext: { rendererCache }
+    });
+    const layoutRender = input.layout ? await this.renderComponentBoundary({
+      component: input.layout.component,
+      props: input.layout.props ?? {},
+      children: pageRender.html,
+      integrationContext: { rendererCache }
+    }) : void 0;
+    const documentRender = await this.renderComponentBoundary({
+      component: input.htmlTemplate,
+      props: {
+        metadata: input.metadata,
+        pageProps: input.pageProps,
+        ...input.documentProps ?? {}
+      },
+      children: layoutRender?.html ?? pageRender.html,
+      integrationContext: { rendererCache }
+    });
+    this.appendProcessedDependencies(pageRender.assets, layoutRender?.assets, documentRender.assets);
+    const documentHtml = input.transformDocumentHtml ? input.transformDocumentHtml(documentRender.html) : documentRender.html;
+    return `${this.DOC_TYPE}${documentHtml}`;
+  }
+  /**
+   * Renders one string-first component boundary and collects its assets.
+   *
+   * String-oriented integrations frequently share the same boundary contract:
+   * pass serialized children through props, coerce the render result to HTML, and
+   * attach any component-scoped dependencies. This helper centralizes that flow
+   * so integrations can opt into shared orchestration without repeating the same
+   * boundary boilerplate.
+   *
+   * @param input - Boundary render input.
+   * @param component - String-oriented component implementation to execute.
+   * @returns Structured component render result for orchestration paths.
+   */
+  async renderStringComponentBoundary(input, component) {
+    const props = input.children === void 0 ? input.props : { ...input.props, children: input.children };
+    const content = await component(props);
+    const html = String(content);
+    const assets = input.component.config?.dependencies && typeof this.assetProcessingService?.processDependencies === "function" ? await this.processComponentDependencies([input.component]) : void 0;
+    return {
+      html,
+      canAttachAttributes: true,
+      rootTag: this.getRootTagName(html),
+      integrationName: this.name,
+      assets
+    };
+  }
+  getBoundaryTokenPrefix() {
+    return `__${this.name}_boundary__`;
+  }
+  getBoundaryRuntimeContextKey() {
+    return `__${this.name}_boundary_runtime__`;
+  }
+  getQueuedBoundaryRuntime(input, runtimeContextKey = this.getBoundaryRuntimeContextKey()) {
+    return this.queuedBoundaryRuntimeService.getRuntimeContext(input, runtimeContextKey);
+  }
+  async resolveQueuedBoundaryTokens(html, queuedResolutionsByToken, resolveToken) {
+    let resolvedHtml = html;
+    for (const token of queuedResolutionsByToken.keys()) {
+      if (!resolvedHtml.includes(token)) {
+        continue;
+      }
+      resolvedHtml = resolvedHtml.split(token).join(await resolveToken(token));
+    }
+    return resolvedHtml;
+  }
+  createQueuedBoundaryRuntime(options) {
+    return this.queuedBoundaryRuntimeService.createRuntime({
+      boundaryInput: options.boundaryInput,
+      rendererCache: options.rendererCache,
+      runtimeContextKey: options.runtimeContextKey ?? this.getBoundaryRuntimeContextKey(),
+      tokenPrefix: options.tokenPrefix ?? this.getBoundaryTokenPrefix(),
+      shouldQueueBoundary: (input) => this.shouldResolveBoundaryInOwningRenderer(input),
+      createRuntimeContext: options.createRuntimeContext
+    });
+  }
+  async resolveRendererOwnedQueuedBoundaryHtml(options) {
+    return this.queuedBoundaryRuntimeService.resolveQueuedHtml({
+      html: options.html,
+      runtimeContext: options.runtimeContext,
+      queueLabel: options.queueLabel,
+      renderQueuedChildren: options.renderQueuedChildren,
+      resolveBoundary: (input, rendererCache) => this.resolveBoundaryInOwningRenderer(input, rendererCache),
+      applyAttributesToFirstElement: (html, attributes) => this.htmlTransformer.applyAttributesToFirstElement(html, attributes),
+      dedupeProcessedAssets: (assets) => this.htmlTransformer.dedupeProcessedAssets(assets)
+    });
+  }
+  /**
+   * Renders a string-first component, then resolves any queued foreign
+   * boundaries before returning final component HTML.
+   */
+  async renderStringComponentBoundaryWithQueuedForeignBoundaries(input, component) {
+    const componentRender = await this.renderStringComponentBoundary(input, component);
+    const queuedBoundaryResolution = await this.resolveRendererOwnedQueuedBoundaryHtml({
+      html: componentRender.html,
+      runtimeContext: this.getQueuedBoundaryRuntime(input),
+      queueLabel: "String",
+      renderQueuedChildren: async (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => {
+        if (children === void 0) {
+          return { assets: [], html: void 0 };
+        }
+        const html = await this.resolveQueuedBoundaryTokens(
+          typeof children === "string" ? children : String(children ?? ""),
+          queuedResolutionsByToken,
+          resolveToken
+        );
+        return { assets: [], html };
+      }
+    });
+    const mergedAssets = this.htmlTransformer.dedupeProcessedAssets([
+      ...componentRender.assets ?? [],
+      ...queuedBoundaryResolution.assets
+    ]);
+    return {
+      ...componentRender,
+      html: queuedBoundaryResolution.html,
+      rootTag: this.getRootTagName(queuedBoundaryResolution.html),
+      assets: mergedAssets.length > 0 ? mergedAssets : void 0
+    };
+  }
   constructor({
     appConfig,
     assetProcessingService,
@@ -158,7 +465,6 @@ class IntegrationRenderer {
     this.runtimeOrigin = runtimeOrigin;
     this.dependencyResolverService = new DependencyResolverService(appConfig, assetProcessingService);
     this.pageModuleLoaderService = new PageModuleLoaderService(appConfig, runtimeOrigin);
-    this.markerGraphResolver = new MarkerGraphResolver();
     this.renderPreparationService = new RenderPreparationService(appConfig, assetProcessingService);
     this.renderExecutionService = new RenderExecutionService();
   }
@@ -328,14 +634,13 @@ class IntegrationRenderer {
       resolveDependencies: (components) => this.resolveDependencies(components),
       buildRouteRenderAssets: (file) => this.buildRouteRenderAssets(file),
       shouldRenderPageComponent: (input) => this.shouldRenderPageComponent(input),
-      renderPageComponent: ({ component, props }) => this.renderComponent({
+      renderPageComponent: ({ component, props }) => this.renderComponentBoundary({
         component,
         props,
         integrationContext: {
           componentInstanceId: "eco-page-root"
         }
       }),
-      getComponentRenderBoundaryContext: () => this.getComponentRenderBoundaryContext(),
       setProcessedDependencies: (dependencies) => this.htmlTransformer.setProcessedDependencies(dependencies),
       dedupeProcessedAssets: (assets) => this.htmlTransformer.dedupeProcessedAssets(assets),
       createPageLocalsProxy: (filePath) => createLocalsProxy(filePath)
@@ -375,11 +680,10 @@ class IntegrationRenderer {
    *
    * Execution flow:
    * 1. Build normalized render options (`prepareRenderOptions`).
-   * 2. Render once inside component render context to capture marker graph refs.
-   * 3. Merge captured refs with optional explicit page-module graph context.
-   * 4. Resolve any `eco-marker` graph bottom-up and merge produced assets.
-   * 5. Optionally apply root attributes for page/component root boundaries.
-   * 6. Run HTML transformer with final dependency set.
+   * 2. Render the route body once.
+   * 3. Reject unresolved route-level boundary artifacts.
+   * 4. Optionally apply root attributes for page/component root boundaries.
+   * 5. Run HTML transformer with final dependency set.
    *
    * Stream-safety note: the first render result is normalized to a string once,
    * then the pipeline continues with that immutable HTML value to avoid disturbed
@@ -389,85 +693,41 @@ class IntegrationRenderer {
    * @returns Rendered route body plus effective cache strategy.
    */
   async execute(options) {
-    return this.renderExecutionService.execute(options, this.name, {
+    return this.renderExecutionService.execute(options, {
       prepareRenderOptions: (routeOptions) => this.prepareRenderOptions(routeOptions),
       render: (renderOptions) => this.render(renderOptions),
-      getComponentRenderBoundaryContext: () => this.getComponentRenderBoundaryContext(),
-      resolveMarkerGraphHtml: (input) => this.resolveMarkerGraphHtml({
-        html: input.html,
-        componentsToResolve: input.componentsToResolve,
-        graphContext: input.graphContext
-      }),
       getDocumentAttributes: (renderOptions) => this.getDocumentAttributes(renderOptions),
-      dedupeProcessedAssets: (assets) => this.htmlTransformer.dedupeProcessedAssets(assets),
-      getProcessedDependencies: () => this.htmlTransformer.getProcessedDependencies(),
-      setProcessedDependencies: (dependencies) => this.htmlTransformer.setProcessedDependencies(dependencies),
       applyAttributesToHtmlElement: (html, attributes) => this.htmlTransformer.applyAttributesToHtmlElement(html, attributes),
       applyAttributesToFirstBodyElement: (html, attributes) => this.htmlTransformer.applyAttributesToFirstBodyElement(html, attributes),
       transformResponse: async (response) => {
         const transformedResponse = await this.htmlTransformer.transform(response);
-        return transformedResponse.body;
+        return transformedResponse.body ?? await transformedResponse.text();
       }
     });
   }
   /**
-   * Captures a render pass as immutable HTML along with the graph context needed
-   * for deferred marker resolution.
+   * Finalizes already-resolved HTML for explicit renderer-owned paths.
    *
-   * This is the shared entry point for direct `renderToResponse()` flows that
-   * need the same component graph capture semantics as route execution without
-   * going through `prepareRenderOptions()`.
-   */
-  async captureHtmlRender(render) {
-    return this.renderExecutionService.captureHtmlRender(
-      this.name,
-      this.getComponentRenderBoundaryContext(),
-      render
-    );
-  }
-  /**
-   * Finalizes previously captured HTML by resolving deferred markers, merging
-   * any emitted assets, stamping optional attributes, and optionally running the
-   * HTML transformer for full-document flows.
+   * This keeps document and root-attribute stamping plus HTML transformation
+   * available after a renderer has completed nested boundary resolution without
+   * routing back through shared route execution.
    */
-  async finalizeCapturedHtmlRender(options) {
+  async finalizeResolvedHtml(options) {
     const rendererBootstrapDependencies = this.getRendererBootstrapDependencies(options.partial);
-    if (rendererBootstrapDependencies.length > 0) {
-      this.htmlTransformer.setProcessedDependencies(
-        this.htmlTransformer.dedupeProcessedAssets([
-          ...this.htmlTransformer.getProcessedDependencies(),
-          ...rendererBootstrapDependencies
-        ])
-      );
+    this.appendProcessedDependencies(rendererBootstrapDependencies);
+    let html = options.html;
+    if (options.componentRootAttributes && Object.keys(options.componentRootAttributes).length > 0) {
+      html = this.htmlTransformer.applyAttributesToFirstBodyElement(html, options.componentRootAttributes);
+    }
+    if (options.documentAttributes && Object.keys(options.documentAttributes).length > 0) {
+      html = this.htmlTransformer.applyAttributesToHtmlElement(html, options.documentAttributes);
     }
-    const finalization = await this.renderExecutionService.finalizeHtmlRender(
-      {
-        html: options.html,
-        graphContext: options.graphContext,
-        componentsToResolve: options.componentsToResolve,
-        componentRootAttributes: options.componentRootAttributes,
-        documentAttributes: options.documentAttributes,
-        mergeAssets: options.mergeAssets ?? !options.partial
-      },
-      {
-        resolveMarkerGraphHtml: (input) => this.resolveMarkerGraphHtml({
-          html: input.html,
-          componentsToResolve: input.componentsToResolve,
-          graphContext: input.graphContext
-        }),
-        dedupeProcessedAssets: (assets) => this.htmlTransformer.dedupeProcessedAssets(assets),
-        getProcessedDependencies: () => this.htmlTransformer.getProcessedDependencies(),
-        setProcessedDependencies: (dependencies) => this.htmlTransformer.setProcessedDependencies(dependencies),
-        applyAttributesToHtmlElement: (html, attributes) => this.htmlTransformer.applyAttributesToHtmlElement(html, attributes),
-        applyAttributesToFirstBodyElement: (html, attributes) => this.htmlTransformer.applyAttributesToFirstBodyElement(html, attributes)
-      }
-    );
     const shouldTransform = options.transformHtml ?? !options.partial;
     if (!shouldTransform) {
-      return finalization.html;
+      return html;
     }
     const transformedResponse = await this.htmlTransformer.transform(
-      new Response(finalization.html, {
+      new Response(html, {
         headers: { "Content-Type": "text/html" }
       })
     );
@@ -482,40 +742,6 @@ class IntegrationRenderer {
   getDocumentAttributes(_renderOptions) {
     return void 0;
   }
-  /**
-   * Resolves all `eco-marker` placeholders in rendered HTML using integration
-   * dispatch and bottom-up graph execution.
-   *
-   * Responsibility split:
-   * - core decodes markers into component refs, props, slot children, and target
-   *   integration dispatch
-   * - the selected integration renderer performs the actual component render via
-   *   `renderComponent()`
-   *
-   * Resolver callback behavior per marker:
-   * - resolve component definition by `componentRef`
-   * - resolve serialized props by `propsRef`
-   * - stitch resolved child HTML when `slotRef` is present
-   * - dispatch to target integration `renderComponent`
-   * - collect produced assets and apply root attributes when attachable
-   *
-   * @param options.html HTML that may still contain marker tokens.
-   * @param options.componentsToResolve Component set used to build component ref registry.
-   * @param options.graphContext Props/slot linkage captured during render.
-   * @returns Resolved HTML plus any component-scoped assets produced while resolving nodes.
-   * @throws Error when marker component refs or props refs cannot be resolved.
-   */
-  async resolveMarkerGraphHtml(options) {
-    const integrationRendererCache = /* @__PURE__ */ new Map();
-    return this.markerGraphResolver.resolve({
-      html: options.html,
-      componentsToResolve: options.componentsToResolve,
-      graphContext: options.graphContext,
-      instanceIdScope: options.instanceIdScope,
-      resolveRenderer: (integrationName) => this.getIntegrationRendererForName(integrationName, integrationRendererCache),
-      applyAttributesToFirstElement: (html, attributes) => this.htmlTransformer.applyAttributesToFirstElement(html, attributes)
-    });
-  }
   /**
    * Returns a renderer instance for a given integration name.
    *
@@ -537,57 +763,80 @@ class IntegrationRenderer {
     const integrationPlugin = this.appConfig.integrations.find(
       (integration) => integration.name === integrationName
     );
-    invariant(!!integrationPlugin, `[ecopages] Integration not found for marker: ${integrationName}`);
+    invariant(!!integrationPlugin, `[ecopages] Integration not found for boundary owner: ${integrationName}`);
     const renderer = integrationPlugin.initializeRenderer({
       rendererModules: this.appConfig.runtime?.rendererModuleContext
     });
     cache.set(integrationName, renderer);
     return renderer;
   }
+  async resolveBoundaryInOwningRenderer(input, rendererCache) {
+    const boundaryOwner = this.getRegisteredBoundaryOwner(input.component);
+    if (!boundaryOwner) {
+      return void 0;
+    }
+    return await this.getIntegrationRendererForName(boundaryOwner, rendererCache).renderComponentBoundary(
+      this.withBoundaryRendererCache(input, rendererCache)
+    );
+  }
   /**
-   * Renders one deferred marker-graph node under this integration's boundary
-   * context so nested cross-integration children can continue to defer while the
-   * graph is being resolved bottom-up.
+   * Renders one component under this integration's boundary runtime and resolves
+   * any nested foreign boundaries captured during that render.
    *
-   * Without this wrapper, resolving a deferred React or Kita node would render
-   * any nested foreign components with no active render context, causing them to
-   * fall back to inline escaped HTML instead of emitting the next marker layer.
+   * Without this wrapper, a component tree with foreign-owned descendants would
+   * render them with no active boundary runtime, which bypasses the owning
+   * renderer's nested-boundary handoff.
    */
-  async renderComponentForMarkerGraph(input) {
-    if (!this.shouldWrapMarkerGraphComponent(input.component)) {
-      return this.renderComponent(input);
+  async renderComponentBoundary(input) {
+    const rendererCache = this.getBoundaryRendererCache(input.integrationContext) ?? /* @__PURE__ */ new Map();
+    const delegatedBoundaryRender = await this.resolveBoundaryInOwningRenderer(input, rendererCache);
+    if (delegatedBoundaryRender) {
+      return delegatedBoundaryRender;
+    }
+    const hasForeignBoundaries = this.hasForeignBoundaryDescendants(input.component);
+    const activeRenderContext = getComponentRenderContext();
+    if (!hasForeignBoundaries) {
+      if (!activeRenderContext || activeRenderContext.currentIntegration === this.name) {
+        return this.normalizeComponentBoundaryRender(await this.renderComponent(input));
+      }
+      const sameIntegrationExecution = await runWithComponentRenderContext(
+        {
+          currentIntegration: this.name
+        },
+        async () => this.renderComponent(input)
+      );
+      return this.normalizeComponentBoundaryRender(sameIntegrationExecution.value);
     }
     const execution = await runWithComponentRenderContext(
       {
         currentIntegration: this.name,
-        boundaryContext: this.getComponentRenderBoundaryContext()
+        boundaryRuntime: this.createComponentBoundaryRuntime({
+          boundaryInput: input,
+          rendererCache
+        })
       },
       async () => this.renderComponent(input)
     );
-    if (!execution.value.html.includes("<eco-marker")) {
-      return execution.value;
-    }
-    const hasCapturedNestedGraph = Object.keys(execution.graphContext.propsByRef ?? {}).length > 0 || Object.keys(execution.graphContext.slotChildrenByRef ?? {}).length > 0;
-    if (!hasCapturedNestedGraph) {
-      return execution.value;
-    }
-    const parentInstanceId = input.integrationContext?.componentInstanceId;
-    const nestedResolution = await this.resolveMarkerGraphHtml({
-      html: execution.value.html,
-      componentsToResolve: [input.component],
-      graphContext: execution.graphContext,
-      instanceIdScope: parentInstanceId
-    });
-    return {
-      ...execution.value,
-      html: nestedResolution.html,
-      assets: this.htmlTransformer.dedupeProcessedAssets([
-        ...execution.value.assets ?? [],
-        ...nestedResolution.assets
-      ])
+    return this.normalizeComponentBoundaryRender(execution.value);
+  }
+  normalizeComponentBoundaryRender(result) {
+    const normalizedHtml = this.normalizeBoundaryArtifactHtml(result.html);
+    return normalizedHtml === result.html ? result : {
+      ...result,
+      html: normalizedHtml
     };
   }
-  shouldWrapMarkerGraphComponent(component) {
+  normalizeBoundaryArtifactHtml(html) {
+    return normalizeBoundaryArtifactHtml(html);
+  }
+  /**
+   * Returns whether the component dependency tree crosses into another
+   * integration.
+   *
+   * This keeps boundary-runtime setup narrow: same-integration trees can render
+   * directly without paying the queue orchestration cost.
+   */
+  hasForeignBoundaryDescendants(component) {
     const stack = [component];
     const seen = /* @__PURE__ */ new Set();
     while (stack.length > 0) {
@@ -610,7 +859,7 @@ class IntegrationRenderer {
    * Default behavior delegates to `renderToResponse` in partial mode and wraps
    * the resulting HTML into the `ComponentRenderResult` contract.
    *
-   * In marker resolution, this method is the integration-owned step that turns an
+   * In boundary resolution, this method is the integration-owned step that turns an
    * already-resolved deferred boundary into concrete HTML, assets, and optional
    * root attributes.
    *
@@ -618,7 +867,7 @@ class IntegrationRenderer {
    * root attributes, integration-specific hydration metadata).
    *
    * @param input Component render request.
-   * @returns Structured render result used by marker/page orchestration.
+   * @returns Structured render result used by component/page orchestration.
    */
   async renderComponent(input) {
     const response = await this.renderToResponse(
@@ -655,46 +904,41 @@ class IntegrationRenderer {
     return void 0;
   }
   /**
-   * Builds the narrow boundary policy facade injected into component render
-   * context for this render pass.
-   *
-   * `eco.component()` consumes this facade without knowing about integration
-   * registries or plugin instances.
+   * Creates the per-render boundary runtime adopted by the shared component
+   * render context.
    *
-   * @returns Boundary policy context for the active integration renderer.
+   * Real mixed-integration renderers should override this and keep foreign
+   * boundary resolution inside their own renderer-owned queue. The base runtime
+   * fails fast when a renderer crosses into a foreign owner without providing its
+   * own handoff mechanism.
    */
-  getComponentRenderBoundaryContext() {
-    return {
-      decideBoundaryRender: (input) => this.shouldDeferComponentBoundary(input) ? "defer" : "inline"
+  createComponentBoundaryRuntime(_options) {
+    const decideBoundaryInterception = (input) => {
+      if (!this.shouldResolveBoundaryInOwningRenderer(input)) {
+        return { kind: "inline" };
+      }
+      throw new Error(
+        `[ecopages] ${this.name} renderer crossed into ${input.targetIntegration} without a renderer-owned boundary runtime. Override createComponentBoundaryRuntime() to resolve foreign boundaries inside the owning renderer.`
+      );
+    };
+    const runtime = {
+      interceptBoundary: decideBoundaryInterception,
+      interceptBoundarySync: decideBoundaryInterception
     };
+    return runtime;
   }
   /**
-   * Resolves whether a component boundary should be deferred by consulting the
-   * target integration plugin.
+   * Resolves whether a boundary should leave the current render pass and be
+   * resolved by its owning renderer.
    *
-   * Boundaries targeting the current integration always render inline. Cross-
-   * integration boundaries delegate the decision to the target integration's
-   * `shouldDeferComponentBoundary()` policy.
+   * Boundaries owned by the current integration always render inline. Foreign-
+   * owned boundaries must be handed off by a renderer-owned runtime.
    *
    * @param input Boundary metadata for the active render pass.
-   * @returns `true` when the boundary should emit a marker; otherwise `false`.
+   * @returns `true` when the boundary should leave the current pass; otherwise `false`.
    */
-  shouldDeferComponentBoundary(input) {
-    if (!input.targetIntegration || input.targetIntegration === input.currentIntegration) {
-      return false;
-    }
-    const targetIntegration = this.appConfig.integrations.find(
-      (integration) => integration.name === input.targetIntegration
-    );
-    invariant(
-      !!targetIntegration,
-      `[ecopages] Integration not found for component boundary: ${input.targetIntegration}`
-    );
-    return targetIntegration.shouldDeferComponentBoundary({
-      currentIntegration: input.currentIntegration,
-      targetIntegration: input.targetIntegration,
-      component: input.component
-    });
+  shouldResolveBoundaryInOwningRenderer(input) {
+    return !!input.targetIntegration && input.targetIntegration !== input.currentIntegration;
   }
 }
 export {