npm - @ecopages/react - Versions diffs - 0.2.0-alpha.12 → 0.2.0-alpha.14 - Mend

@ecopages/react 0.2.0-alpha.12 → 0.2.0-alpha.14

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 (7) hide show

package/CHANGELOG.md CHANGED Viewed

@@ -8,11 +8,7 @@ All notable changes to `@ecopages/react` are documented here.
 ### Bug Fixes
-- Fixed development hydration, router HMR ownership, and page bootstraps across Bun, Vite, and Nitro flows.
-- Fixed React page and MDX module loading to use host-provided loaders on Vite or Nitro and a lightweight browser `eco` shim in preview and build output.
-- Fixed React Fast Refresh to keep React-owned island entrypoints on the React HMR path while ignoring non-React watched script entrypoints.
-- Fixed `renderDocument` to prepend `<!DOCTYPE html>` for both React-managed and non-React HTML templates, matching the behavior of all other integrations.
-- Fixed React island asset generation to share both bundled component modules and hydration bootstraps across repeated island instances of the same component.
+- Fixed React hydration, Fast Refresh, module loading, doctype handling, island asset reuse, and mixed-renderer boundary resolution across Bun, Vite, and Nitro flows.
 ### Features
@@ -22,10 +18,12 @@ All notable changes to `@ecopages/react` are documented here.
 - Consolidated React bundling, hydration, and runtime state behind shared service boundaries and `window.__ECO_PAGES__`.
+### Documentation
+- Updated the README to document React-owned mixed boundaries and React MDX setup.
 ---
 ## Migration Notes
-- The React integration now requires explicit client boundary declarations for client-rendered components.
 - React MDX support is built in and no longer requires installing `@ecopages/mdx` just to enable React MDX routes.
-- The internal service layer is not part of the public API and may change between releases.

package/README.md CHANGED Viewed

@@ -60,6 +60,16 @@ const config = await new ConfigBuilder()
 export default config;
 ```
+## Mixed Rendering
+The React integration can participate in mixed-renderer apps in three ways:
+- React can own the page or view directly.
+- React can render nested component boundaries inside pages owned by another integration.
+- React can render through non-React page, layout, or document shells when those shell components return strings.
+When a non-React render pass enters a React-owned boundary, Ecopages hands that boundary back to the React renderer. When React renders through a non-React shell, that shell must serialize to HTML so React can insert the result into the final response without escaping it.
 ## Server and Client Graph Contract
 The React integration supports Node.js modules and server-only code **only on the server execution graph**.

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@ecopages/react",
-  "version": "0.2.0-alpha.12",
+  "version": "0.2.0-alpha.14",
   "description": "React integration for Ecopages",
   "keywords": [
     "ecopages",
@@ -53,14 +53,14 @@
     "directory": "packages/integrations/react"
   },
   "peerDependencies": {
-    "@ecopages/core": "0.2.0-alpha.12",
+    "@ecopages/core": "0.2.0-alpha.14",
     "@types/react": "^19",
     "@types/react-dom": "^19",
     "react": "^19",
     "react-dom": "^19"
   },
   "dependencies": {
-    "@ecopages/file-system": "0.2.0-alpha.12",
+    "@ecopages/file-system": "0.2.0-alpha.14",
     "@ecopages/logger": "^0.2.3",
     "@mdx-js/esbuild": "^3.0.1",
     "@mdx-js/mdx": "^3.1.0",

package/src/react-renderer.d.ts CHANGED Viewed

@@ -77,7 +77,7 @@ export declare class ReactRenderer extends IntegrationRenderer<ReactNode> {
      *
      * React pages embedded in a non-React HTML shell still need to expose the same
      * page-data contract as fully React-owned documents so navigation and hydration
-     * can read one marker consistently.
+     * can read one shared document payload consistently.
      */
     private buildRouterPageDataScript;
     private getRouterDocumentAttributes;
@@ -111,14 +111,6 @@ export declare class ReactRenderer extends IntegrationRenderer<ReactNode> {
      * HTML transformer state.
      */
     private appendHydrationAssetsForFile;
-    /**
-     * Resolves metadata for direct `renderToResponse()` calls.
-     *
-     * View rendering bypasses the normal route-file pipeline, so metadata has to be
-     * evaluated here from either the component-level generator or the application
-     * default.
-     */
-    private resolveViewMetadata;
     /**
      * Renders a non-React layout or HTML template and enforces that mixed shells
      * return serialized HTML.
@@ -128,35 +120,23 @@ export declare class ReactRenderer extends IntegrationRenderer<ReactNode> {
      */
     private renderNonReactShellComponent;
     /**
-     * Renders one React component boundary for marker-graph orchestration.
+     * Renders one React component boundary while preserving already-resolved child HTML.
      *
-     * When the marker resolver has already resolved child HTML for this boundary,
-     * the child payload must remain raw SSR output rather than a React string
-     * child, otherwise React would escape it. This helper renders a unique token
-     * through React and swaps that token back to the resolved HTML afterward.
+     * When nested boundary resolution has already produced child HTML for this
+     * boundary, the child payload must remain raw SSR output rather than a React
+     * string child, otherwise React would escape it. This helper renders a unique
+     * token through React and swaps that token back to the resolved HTML
+     * afterward.
      *
-     * @param input Component render input reconstructed from marker metadata.
+     * @param input Component render input for the current boundary.
      * @param context React-specific render context for stable token generation.
      * @returns Serialized component HTML with resolved child markup preserved.
      */
     private renderComponentHtml;
+    private restoreRuntimeChildHtml;
+    private renderQueuedChildrenToHtml;
+    private resolveQueuedBoundaryHtml;
     private buildHydrationProps;
-    /**
-     * Produces the page body before the final HTML template is applied.
-     *
-     * This method owns the React/non-React layout split. React-managed layouts stay
-     * as React elements so they can stream normally; non-React layouts are rendered
-     * to HTML first and then passed through as serialized content.
-     */
-    private composePageContent;
-    /**
-     * Wraps composed page content in the final document template.
-     *
-     * React-owned HTML templates stream directly. Non-React templates receive
-     * pre-rendered page HTML plus the canonical React page-data payload so the
-     * client runtime can recover page data after cross-integration handoff.
-     */
-    private renderDocument;
     /**
      * Renders a React component for component-level orchestration.
      *
@@ -172,6 +152,10 @@ export declare class ReactRenderer extends IntegrationRenderer<ReactNode> {
      * deterministic mount target per component instance.
      */
     renderComponent(input: ComponentRenderInput): Promise<ComponentRenderResult>;
+    protected createComponentBoundaryRuntime(options: {
+        boundaryInput: ComponentRenderInput;
+        rendererCache: Map<string, IntegrationRenderer<any>>;
+    }): import("@ecopages/core").ComponentBoundaryRuntime;
     /**
      * Checks if the given file path corresponds to an MDX file based on configured extensions.
      * @param filePath - The file path to check

package/src/react-renderer.js CHANGED Viewed

@@ -6,32 +6,14 @@ import { rapidhash } from "@ecopages/core/hash";
 import { AssetFactory } from "@ecopages/core/services/asset-processing-service";
 import { ECO_DOCUMENT_OWNER_ATTRIBUTE } from "@ecopages/core/router/navigation-coordinator";
 import path from "node:path";
-import { createElement } from "react";
+import { createElement, Fragment } from "react";
 import { renderToReadableStream, renderToString } from "react-dom/server";
 import { PLUGIN_NAME } from "./react.plugin.js";
 import { hasSingleRootElement } from "./utils/html-boundary.js";
 import { ReactBundleService } from "./services/react-bundle.service.js";
 import { ReactHmrPageMetadataCache } from "./services/react-hmr-page-metadata-cache.js";
 import { ReactPageModuleService } from "./services/react-page-module.service.js";
-import {
-  getReactIslandComponentKey,
-  ReactHydrationAssetService
-} from "./services/react-hydration-asset.service.js";
-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 restoreEscapedComponentMarkers(html) {
-  return html.replace(
-    /&(?:amp;)?lt;eco-marker\b[\s\S]*?&(?:amp;)?gt;&(?:amp;)?lt;\/eco-marker&(?:amp;)?gt;/g,
-    (marker) => decodeHtmlEntities(marker)
-  );
-}
+import { getReactIslandComponentKey, ReactHydrationAssetService } from "./services/react-hydration-asset.service.js";
 class ReactRenderError extends Error {
   constructor(message) {
     super(message);
@@ -124,7 +106,7 @@ class ReactRenderer extends IntegrationRenderer {
    *
    * React pages embedded in a non-React HTML shell still need to expose the same
    * page-data contract as fully React-owned documents so navigation and hydration
-   * can read one marker consistently.
+   * can read one shared document payload consistently.
    */
   buildRouterPageDataScript(pageProps) {
     const safeJson = JSON.stringify(pageProps || {}).replace(/</g, "\\u003c");
@@ -183,25 +165,7 @@ class ReactRenderer extends IntegrationRenderer {
       return;
     }
     const hydrationAssets = await this.buildRouteRenderAssets(filePath);
-    this.htmlTransformer.setProcessedDependencies([
-      ...this.htmlTransformer.getProcessedDependencies(),
-      ...hydrationAssets
-    ]);
-  }
-  /**
-   * Resolves metadata for direct `renderToResponse()` calls.
-   *
-   * View rendering bypasses the normal route-file pipeline, so metadata has to be
-   * evaluated here from either the component-level generator or the application
-   * default.
-   */
-  async resolveViewMetadata(view, props) {
-    return view.metadata ? await view.metadata({
-      params: {},
-      query: {},
-      props,
-      appConfig: this.appConfig
-    }) : this.appConfig.defaultMetadata;
+    this.appendProcessedDependencies(hydrationAssets);
   }
   /**
    * Renders a non-React layout or HTML template and enforces that mixed shells
@@ -218,100 +182,77 @@ class ReactRenderer extends IntegrationRenderer {
     throw new ReactRenderError(`${label} must return a string when used as a mixed shell for React pages.`);
   }
   /**
-   * Renders one React component boundary for marker-graph orchestration.
+   * Renders one React component boundary while preserving already-resolved child HTML.
    *
-   * When the marker resolver has already resolved child HTML for this boundary,
-   * the child payload must remain raw SSR output rather than a React string
-   * child, otherwise React would escape it. This helper renders a unique token
-   * through React and swaps that token back to the resolved HTML afterward.
+   * When nested boundary resolution has already produced child HTML for this
+   * boundary, the child payload must remain raw SSR output rather than a React
+   * string child, otherwise React would escape it. This helper renders a unique
+   * token through React and swaps that token back to the resolved HTML
+   * afterward.
    *
-   * @param input Component render input reconstructed from marker metadata.
+   * @param input Component render input for the current boundary.
    * @param context React-specific render context for stable token generation.
    * @returns Serialized component HTML with resolved child markup preserved.
    */
-  renderComponentHtml(input, context) {
+  renderComponentHtml(input, context, runtimeContext) {
     if (input.children === void 0) {
-      return restoreEscapedComponentMarkers(
+      return this.normalizeBoundaryArtifactHtml(
         renderToString(createElement(this.asReactComponent(input.component), input.props))
       );
     }
     const resolvedChildHtml = typeof input.children === "string" ? input.children : String(input.children ?? "");
     const rawChildrenToken = `__ECO_RAW_HTML_CHILD_${context.componentInstanceId ?? "component"}__`;
+    if (runtimeContext) {
+      runtimeContext.rawChildrenToken = rawChildrenToken;
+      runtimeContext.rawChildrenHtml = resolvedChildHtml;
+    }
     const html = renderToString(
       createElement(this.asReactComponent(input.component), input.props, rawChildrenToken)
     );
-    return restoreEscapedComponentMarkers(html.split(rawChildrenToken).join(resolvedChildHtml));
+    return this.normalizeBoundaryArtifactHtml(html.split(rawChildrenToken).join(resolvedChildHtml));
   }
-  buildHydrationProps(props) {
-    if (!props || !Object.prototype.hasOwnProperty.call(props, "locals")) {
-      return props ?? {};
+  restoreRuntimeChildHtml(html, runtimeContext) {
+    if (!runtimeContext?.rawChildrenToken || runtimeContext.rawChildrenHtml === void 0) {
+      return html;
     }
-    const { locals: _locals, ...hydrationProps } = props;
-    return hydrationProps;
+    return html.split(runtimeContext.rawChildrenToken).join(runtimeContext.rawChildrenHtml);
   }
-  /**
-   * Produces the page body before the final HTML template is applied.
-   *
-   * This method owns the React/non-React layout split. React-managed layouts stay
-   * as React elements so they can stream normally; non-React layouts are rendered
-   * to HTML first and then passed through as serialized content.
-   */
-  async composePageContent(options) {
-    const pageElement = createElement(options.Page, options.pageProps);
-    const pageHtml = restoreEscapedComponentMarkers(renderToString(pageElement));
-    const layoutProps = options.locals ? { locals: options.locals } : {};
-    if (!options.Layout) {
-      return { contentNode: pageElement, contentHtml: pageHtml };
-    }
-    if (this.isReactManagedComponent(options.Layout)) {
-      const layoutElement = createElement(this.asReactComponent(options.Layout), layoutProps, pageElement);
-      return {
-        contentNode: layoutElement,
-        contentHtml: restoreEscapedComponentMarkers(renderToString(layoutElement))
-      };
+  async renderQueuedChildrenToHtml(children, runtimeContext, queuedResolutionsByToken, resolveToken) {
+    if (children === void 0) {
+      return void 0;
     }
-    const layoutHtml = await this.renderNonReactShellComponent(
-      this.asNonReactShellComponent(options.Layout),
-      { ...layoutProps, children: pageHtml },
-      "Layout"
+    let html = this.normalizeBoundaryArtifactHtml(
+      renderToString(createElement(Fragment, null, children))
     );
-    return { contentNode: layoutHtml, contentHtml: layoutHtml };
+    html = this.restoreRuntimeChildHtml(html, runtimeContext);
+    html = await this.resolveQueuedBoundaryTokens(html, queuedResolutionsByToken, resolveToken);
+    return html;
   }
-  /**
-   * Wraps composed page content in the final document template.
-   *
-   * React-owned HTML templates stream directly. Non-React templates receive
-   * pre-rendered page HTML plus the canonical React page-data payload so the
-   * client runtime can recover page data after cross-integration handoff.
-   */
-  async renderDocument(options) {
-    if (this.isReactManagedComponent(options.HtmlTemplate)) {
-      const rawChildrenToken = "__ECO_RAW_HTML_DOCUMENT_CHILD__";
-      const html = restoreEscapedComponentMarkers(
-        renderToString(
-          createElement(
-            this.asReactComponent(options.HtmlTemplate),
-            {
-              metadata: options.metadata,
-              pageProps: options.pageProps
-            },
-            rawChildrenToken
-          )
-        )
-      );
-      return this.DOC_TYPE + html.split(rawChildrenToken).join(options.contentHtml);
+  async resolveQueuedBoundaryHtml(html, runtimeContext) {
+    return this.resolveRendererOwnedQueuedBoundaryHtml({
+      html,
+      runtimeContext,
+      queueLabel: "React",
+      renderQueuedChildren: async (children, currentRuntimeContext, queuedResolutionsByToken, resolveToken) => {
+        const renderedHtml = await this.renderQueuedChildrenToHtml(
+          children,
+          currentRuntimeContext,
+          queuedResolutionsByToken,
+          resolveToken
+        );
+        return {
+          assets: [],
+          html: renderedHtml
+        };
+      }
+    });
+  }
+  buildHydrationProps(props) {
+    if (!props || !Object.prototype.hasOwnProperty.call(props, "locals")) {
+      return props ?? {};
     }
-    const headContent = ReactRenderer.routerAdapter ? this.buildRouterPageDataScript(options.pageProps) : void 0;
-    return this.DOC_TYPE + await this.renderNonReactShellComponent(
-      this.asNonReactShellComponent(options.HtmlTemplate),
-      {
-        metadata: options.metadata,
-        pageProps: options.pageProps,
-        children: options.contentHtml,
-        headContent
-      },
-      "HtmlTemplate"
-    );
+    const { locals: _locals, ...hydrationProps } = props;
+    return hydrationProps;
   }
   /**
    * Renders a React component for component-level orchestration.
@@ -328,10 +269,42 @@ class ReactRenderer extends IntegrationRenderer {
    * deterministic mount target per component instance.
    */
   async renderComponent(input) {
+    const runtimeContext = this.getQueuedBoundaryRuntime(input);
+    if (!this.isReactManagedComponent(input.component)) {
+      let props = input.props;
+      if (input.children !== void 0) {
+        props = {
+          ...input.props,
+          children: typeof input.children === "string" ? input.children : String(input.children ?? "")
+        };
+      }
+      const html2 = await this.renderNonReactShellComponent(
+        this.asNonReactShellComponent(input.component),
+        props,
+        "Component"
+      );
+      const hasDependencies = Boolean(input.component.config?.dependencies);
+      const canResolveAssets = typeof this.assetProcessingService?.processDependencies === "function";
+      const assets2 = hasDependencies && canResolveAssets ? await this.processComponentDependencies([input.component]) : void 0;
+      const queuedBoundaryResolution2 = await this.resolveQueuedBoundaryHtml(html2, runtimeContext);
+      const mergedAssets2 = this.htmlTransformer.dedupeProcessedAssets([
+        ...assets2 ?? [],
+        ...queuedBoundaryResolution2.assets
+      ]);
+      return {
+        html: queuedBoundaryResolution2.html,
+        canAttachAttributes: true,
+        rootTag: this.getRootTagName(queuedBoundaryResolution2.html),
+        integrationName: this.name,
+        assets: mergedAssets2.length > 0 ? mergedAssets2 : void 0
+      };
+    }
     const componentConfig = input.component.config;
     const context = input.integrationContext ?? {};
     const hasResolvedChildHtml = input.children !== void 0;
-    let html = this.renderComponentHtml(input, context);
+    let html = this.renderComponentHtml(input, context, runtimeContext);
+    const queuedBoundaryResolution = await this.resolveQueuedBoundaryHtml(html, runtimeContext);
+    html = queuedBoundaryResolution.html;
     let canAttachAttributes = hasSingleRootElement(html);
     let rootTag = this.getRootTagName(html);
     const componentFile = componentConfig?.__eco?.file;
@@ -339,25 +312,40 @@ class ReactRenderer extends IntegrationRenderer {
     let assets;
     if (canAttachAttributes && componentFile && context.componentInstanceId && this.assetProcessingService && !hasResolvedChildHtml) {
       const componentInstanceId = context.componentInstanceId;
-      assets = await this.hydrationAssetService.buildComponentRenderAssets(
-        componentFile,
-        componentConfig
-      );
+      assets = await this.hydrationAssetService.buildComponentRenderAssets(componentFile, componentConfig);
       rootAttributes = {
         "data-eco-component-id": componentInstanceId,
         "data-eco-component-key": getReactIslandComponentKey(componentFile, componentConfig),
         "data-eco-props": btoa(JSON.stringify(this.buildHydrationProps(input.props)))
       };
     }
+    const mergedAssets = this.htmlTransformer.dedupeProcessedAssets([
+      ...assets ?? [],
+      ...queuedBoundaryResolution.assets
+    ]);
     return {
       html,
       canAttachAttributes,
       rootTag,
       integrationName: this.name,
       rootAttributes,
-      assets
+      assets: mergedAssets.length > 0 ? mergedAssets : void 0
     };
   }
+  createComponentBoundaryRuntime(options) {
+    return this.createQueuedBoundaryRuntime({
+      boundaryInput: options.boundaryInput,
+      rendererCache: options.rendererCache,
+      createRuntimeContext: (integrationContext, rendererCache) => ({
+        rendererCache,
+        componentInstanceScope: integrationContext.componentInstanceId,
+        nextBoundaryId: 0,
+        queuedResolutions: [],
+        rawChildrenToken: void 0,
+        rawChildrenHtml: void 0
+      })
+    });
+  }
   /**
    * Checks if the given file path corresponds to an MDX file based on configured extensions.
    * @param filePath - The file path to check
@@ -543,18 +531,19 @@ class ReactRenderer extends IntegrationRenderer {
         query,
         safeLocals
       });
-      const { contentNode, contentHtml } = await this.composePageContent({
-        Page: this.asReactComponent(Page),
-        Layout,
-        pageProps: { params, query, ...props, locals: pageLocals },
-        locals
-      });
-      return await this.renderDocument({
-        HtmlTemplate,
+      return await this.renderPageWithDocumentShell({
+        page: {
+          component: Page,
+          props: { params, query, ...props, locals: pageLocals }
+        },
+        layout: Layout ? {
+          component: Layout,
+          props: locals ? { locals } : {}
+        } : void 0,
+        htmlTemplate: HtmlTemplate,
         metadata,
         pageProps: allPageProps,
-        contentNode,
-        contentHtml
+        documentProps: !this.isReactManagedComponent(HtmlTemplate) && ReactRenderer.routerAdapter ? { headContent: this.buildRouterPageDataScript(allPageProps) } : void 0
       });
     } catch (error) {
       throw this.createRenderError("Failed to render component", error);
@@ -617,38 +606,41 @@ class ReactRenderer extends IntegrationRenderer {
       const ViewComponent = this.asReactComponent(view);
       const normalizedProps = props ?? {};
       if (ctx.partial) {
-        const stream = await renderToReadableStream(createElement(ViewComponent, normalizedProps));
-        return this.createHtmlResponse(stream, ctx);
+        return this.renderPartialViewResponse({
+          view,
+          props,
+          ctx,
+          renderInline: async () => await renderToReadableStream(createElement(ViewComponent, normalizedProps))
+        });
       }
       const HtmlTemplate = await this.getHtmlTemplate();
       const metadata = await this.resolveViewMetadata(view, props);
       await this.prepareViewDependencies(view, Layout);
       await this.appendHydrationAssetsForFile(viewConfig?.__eco?.file);
-      const { contentNode, contentHtml } = await this.composePageContent({
-        Page: ViewComponent,
-        Layout,
-        pageProps: normalizedProps
+      const viewRender = await this.renderComponentBoundary({
+        component: view,
+        props: normalizedProps
       });
-      const body = await this.renderDocument({
-        HtmlTemplate,
-        metadata,
-        pageProps: normalizedProps,
-        contentNode,
-        contentHtml
+      const layoutRender = Layout ? await this.renderComponentBoundary({
+        component: Layout,
+        props: {},
+        children: viewRender.html
+      }) : void 0;
+      const documentRender = await this.renderComponentBoundary({
+        component: HtmlTemplate,
+        props: {
+          metadata,
+          pageProps: normalizedProps,
+          ...!this.isReactManagedComponent(HtmlTemplate) && ReactRenderer.routerAdapter ? { headContent: this.buildRouterPageDataScript(normalizedProps) } : {}
+        },
+        children: layoutRender?.html ?? viewRender.html
+      });
+      this.appendProcessedDependencies(viewRender.assets, layoutRender?.assets, documentRender.assets);
+      const transformedHtml = await this.finalizeResolvedHtml({
+        html: `${this.DOC_TYPE}${documentRender.html}`,
+        partial: false,
+        documentAttributes: this.getRouterDocumentAttributes()
       });
-      const transformedResponse = await this.htmlTransformer.transform(
-        new Response(body, {
-          headers: { "Content-Type": "text/html" }
-        })
-      );
-      let transformedHtml = await transformedResponse.text();
-      const documentAttributes = this.getRouterDocumentAttributes();
-      if (documentAttributes) {
-        transformedHtml = this.htmlTransformer.applyAttributesToHtmlElement(
-          transformedHtml,
-          documentAttributes
-        );
-      }
       return this.createHtmlResponse(transformedHtml, ctx);
     } catch (error) {
       throw this.createRenderError("Failed to render view", error);

package/src/react.plugin.d.ts CHANGED Viewed

@@ -10,7 +10,6 @@ import type { CompileOptions } from '@mdx-js/mdx';
 import type React from 'react';
 import { ReactRenderer } from './react-renderer.js';
 import type { ReactRouterAdapter } from './router-adapter.js';
-import type { ComponentBoundaryPolicyInput } from '@ecopages/core/plugins/integration-plugin';
 /**
  * MDX configuration options for the React plugin
  */
@@ -139,17 +138,6 @@ export declare class ReactPlugin extends IntegrationPlugin<React.JSX.Element> {
      */
     getHmrStrategy(): HmrStrategy | undefined;
     getRuntimeSpecifierMap(): Record<string, string>;
-    /**
-     * Declares React's boundary deferral rule for cross-integration rendering.
-     *
-     * React defers when a render pass owned by another integration enters a React
-     * component boundary. That boundary is then resolved later through the marker
-     * graph stage using the React renderer.
-     *
-     * @param input Boundary metadata for the active render pass.
-     * @returns `true` when the boundary should be deferred into the marker pass.
-     */
-    shouldDeferComponentBoundary(input: ComponentBoundaryPolicyInput): boolean;
 }
 /**
  * Factory function to create a React plugin instance

package/src/react.plugin.js CHANGED Viewed

@@ -135,19 +135,6 @@ class ReactPlugin extends IntegrationPlugin {
   getRuntimeSpecifierMap() {
     return this.runtimeBundleService.getSpecifierMap();
   }
-  /**
-   * Declares React's boundary deferral rule for cross-integration rendering.
-   *
-   * React defers when a render pass owned by another integration enters a React
-   * component boundary. That boundary is then resolved later through the marker
-   * graph stage using the React renderer.
-   *
-   * @param input Boundary metadata for the active render pass.
-   * @returns `true` when the boundary should be deferred into the marker pass.
-   */
-  shouldDeferComponentBoundary(input) {
-    return input.targetIntegration === this.name && input.currentIntegration !== this.name;
-  }
 }
 function reactPlugin(options) {
   return new ReactPlugin(options);