@ecopages/ecopages-jsx 0.2.0-alpha.25 → 0.2.0-alpha.27

package/CHANGELOG.md

@@ -8,25 +8,29 @@
 
 ### Bug Fixes
 
+- Moved Ecopages JSX intrinsic custom-element asset bookkeeping into the active JSX SSR render scope and reinstalls the Radiant light-DOM shim whenever SSR runtime setup reruns so nested renders stay aligned with the current server render contract.
+- Fixed intrinsic custom-element SSR asset hooks to fall back cleanly when they run after the active JSX render frame has already unwound, avoiding spurious server warnings during docs renders.
 - Fixed lazy Ecopages JSX custom-element dependencies to stay as standalone assets instead of being folded into page-owned bundles, restoring trigger-driven loading for docs components like `theme-toggle`.
 - Fixed Ecopages JSX page-owned browser bundles to inline their JSX and Radiant runtime imports while skipping separate intrinsic custom-element script tags when the current component tree already imports those scripts.
 - Fixed intrinsic custom-element script suppression to honor dependency-declared script ownership instead of relying only on source import scanning.
+- Fixed Radiant custom-element SSR bridging so `prop:` values like array props render through the server host bridge without requiring wrapper-level attribute serialization fallbacks.
 - Aligned the Ecopages JSX browser runtime bundle with the upstream `@ecopages/jsx` runtime shipped by current alpha releases.
 - Aligned Ecopages JSX peer dependency ranges with the current `@ecopages/jsx` and `@ecopages/radiant` alpha releases.
 - Aligned Radiant SSR and hydration wiring with the public `@ecopages/radiant/server/render-component` and `@ecopages/radiant/client/hydrator` entrypoints so JSX apps install an explicit client hydrator bootstrap instead of relying on implicit side effects.
 - Updated the Ecopages JSX Radiant browser runtime for the `RadiantElement` and `RadiantController` API surface and switched the explicit hydrator bootstrap to `@ecopages/radiant/client/install-hydrator`.
 - Fixed Radiant SSR page inspection to install the light-DOM shim before JSX page modules are imported outside the normal render pass.
 - Restored direct `EcopagesJsxPlugin` construction so the exported class still accepts the public plugin options shape.
-- Fixed intrinsic custom-element asset discovery so Ecopages JSX registers scripts declared with decorator and function-call `customElement(...)` syntax.
-- Fixed the Ecopages JSX browser runtime import map so browser builds no longer expose `@ecopages/jsx/server` through the shared JSX vendor bundle.
+- Aligned Ecopages JSX intrinsic custom-element loading with explicit `dependencies.scripts` ownership instead of implicit tag-to-script discovery.
+- Removed implicit JSX integration-generated intrinsic custom-element browser entries so client custom-element loading now follows the normal asset pipeline.
 - Fixed the Ecopages JSX browser runtime bundle so Radiant custom-element scripts no longer fail on a duplicate `jsxDEV` export cycle.
-- Fixed Ecopages JSX boundary payload compatibility coverage and removed the plugin/renderer integration-name import cycle.
+- Fixed Ecopages JSX foreign-subtree payload compatibility coverage and removed the plugin/renderer integration-name import cycle.
 
 ### Refactoring
 
-- Removed the JSX browser import-map asset and folded the Radiant install-hydrator entry into the emitted Radiant vendor bundle.
+- Removed the shared JSX runtime bundle service and browser import-map asset in favor of per-script browser entries that prepend `@ecopages/radiant/client/install-hydrator` only when Radiant SSR is enabled.
 - Replaced Ecopages JSX renderer static and post-construction configuration with instance-owned renderer wiring and extracted shared plugin and renderer types into a dedicated module.
+- Extracted JSX renderer SSR asset-frame scope handling into a dedicated render-session module.
 
 ### Tests
 
-- Added renderer-level coverage for the boundary payload compatibility contract.
+- Added renderer-level coverage for the foreign-subtree payload compatibility contract.

package/README.md

@@ -5,10 +5,10 @@ Integration plugin for [@ecopages/jsx](https://www.npmjs.com/package/@ecopages/j
 ## Installation
 
 ```bash
-bun add @ecopages/ecopages-jsx @ecopages/radiant
+bun add @ecopages/ecopages-jsx @ecopages/jsx @ecopages/radiant
 ```
 
-`@ecopages/radiant` is a required peer dependency for this package.
+`@ecopages/jsx` and `@ecopages/radiant` are required peer dependencies for this package.
 
 ## Usage
 
@@ -62,6 +62,15 @@ Set `radiant: false` when your JSX pages do not need Radiant SSR or the Radiant
 
 The plugin bootstrap is intentionally explicit rather than depending on custom-element modules to install the Radiant hydrator opportunistically.
 
+For server-side custom-element examples, prefer explicit SSR modes over the older boolean-only contract.
+
+```ts
+new MyElement().renderHostToString({ mode: 'plain' });
+new MyElement().renderHostToString({ mode: 'hydrate' });
+```
+
+The legacy `hydrate: true` option remains compatible, but `mode` is the current SSR contract. Registered intrinsic tags that contain a dash are SSR candidates, and framework-specific host rendering should be adapted through the server custom-element render hook instead of hardcoding framework branches into JSX page code.
+
 ## MDX Support
 
 Enable MDX to treat `.mdx` files as JSX routes compiled against the `@ecopages/jsx` runtime.
@@ -86,7 +95,7 @@ export default config;
 
 ## Mixed Rendering
 
-Ecopages JSX can own the outer page shell or just the nested boundary. When another integration reaches a JSX-owned boundary, Ecopages hands that boundary back to the JSX renderer so it can serialize the correct output before the outer renderer resumes.
+Ecopages JSX can own the outer page shell or just a nested foreign subtree. When another integration reaches a JSX-owned foreign child, Ecopages hands that foreign subtree back to the JSX renderer so it can serialize the correct output before the outer renderer resumes.
 
 Important:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecopages/ecopages-jsx",
-  "version": "0.2.0-alpha.25",
+  "version": "0.2.0-alpha.27",
   "description": "JSX integration plugin for Ecopages",
   "keywords": [
     "ecopages",
@@ -21,8 +21,8 @@
     "vfile": "^6.0.3"
   },
   "peerDependencies": {
-    "@ecopages/core": "0.2.0-alpha.25",
-    "@ecopages/jsx": "0.3.0-alpha.10",
-    "@ecopages/radiant": "0.3.0-alpha.10"
+    "@ecopages/core": "0.2.0-alpha.27",
+    "@ecopages/jsx": "0.3.0-alpha.13",
+    "@ecopages/radiant": "0.3.0-alpha.13"
   }
 }

package/src/ecopages-jsx-mdx.d.ts

@@ -0,0 +1,21 @@
+import type { CompileOptions } from '@mdx-js/mdx';
+import type { EcoComponent, EcoComponentConfig, EcoFunctionComponent, EcoPageFile, GetMetadata } from '@ecopages/core';
+import type { EcoBuildPlugin } from '@ecopages/core/plugins/integration-plugin';
+import type { JsxRenderable } from '@ecopages/jsx';
+import type { EcopagesJsxMdxCompileOptions, EcopagesJsxMdxOptions } from './ecopages-jsx.types.js';
+export type ResolvedMdxCompileOptions = EcopagesJsxMdxCompileOptions & Pick<CompileOptions, 'jsxImportSource' | 'jsxRuntime'>;
+export type AsyncEcoComponent<P = Record<string, unknown>, R = JsxRenderable> = EcoFunctionComponent<P, R | Promise<R>>;
+export type EcopagesJsxMdxPageModule = EcoPageFile<{
+    config?: EcoComponentConfig;
+    layout?: EcoComponent;
+    getMetadata?: GetMetadata;
+}>;
+export declare const createMdxExtensionFilter: (extensions: string[], options?: {
+    allowQueryString?: boolean;
+}) => RegExp;
+export declare const appendMdxExtensions: (target: string[], mdxExtensions: string[]) => void;
+export declare const resolveMdxCompilerOptions: (mdxOptions: EcopagesJsxMdxOptions) => ResolvedMdxCompileOptions;
+export declare const createMdxLoaderPlugin: (compilerOptions: ResolvedMdxCompileOptions, extensions: string[]) => EcoBuildPlugin;
+export declare const registerBunMdxPlugin: (compilerOptions: ResolvedMdxCompileOptions, extensions: string[]) => Promise<void>;
+export declare const isMdxFile: (filePath: string, extensions: string[]) => boolean;
+export declare const normalizeMdxPageModule: (file: string, module: EcopagesJsxMdxPageModule) => EcopagesJsxMdxPageModule;

package/src/ecopages-jsx-mdx.js

@@ -0,0 +1,113 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { rapidhash } from "@ecopages/core/hash";
+import { VFile } from "vfile";
+import { ECOPAGES_JSX_PLUGIN_NAME } from "./ecopages-jsx.constants.js";
+const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const mergePluginLists = (...lists) => {
+  const merged = lists.flatMap((list) => list ? [...list] : []);
+  return merged.length > 0 ? merged : void 0;
+};
+const createMdxExtensionFilter = (extensions, options) => {
+  const escaped = extensions.map(escapeRegex);
+  const suffix = options?.allowQueryString ? "(\\?.*)?$" : "$";
+  return new RegExp(`(${escaped.join("|")})${suffix}`);
+};
+const appendMdxExtensions = (target, mdxExtensions) => {
+  for (const ext of mdxExtensions) {
+    if (!target.includes(ext)) {
+      target.push(ext);
+    }
+  }
+};
+const resolveMdxCompilerOptions = (mdxOptions) => {
+  const { compilerOptions, remarkPlugins, rehypePlugins, recmaPlugins } = mdxOptions;
+  const resolved = {
+    format: "detect",
+    outputFormat: "program",
+    ...compilerOptions,
+    jsxImportSource: "@ecopages/jsx",
+    jsxRuntime: "automatic",
+    development: process.env.NODE_ENV === "development"
+  };
+  const mergedRemark = mergePluginLists(compilerOptions?.remarkPlugins, remarkPlugins);
+  const mergedRehype = mergePluginLists(compilerOptions?.rehypePlugins, rehypePlugins);
+  const mergedRecma = mergePluginLists(compilerOptions?.recmaPlugins, recmaPlugins);
+  if (mergedRemark) resolved.remarkPlugins = mergedRemark;
+  if (mergedRehype) resolved.rehypePlugins = mergedRehype;
+  if (mergedRecma) resolved.recmaPlugins = mergedRecma;
+  return resolved;
+};
+const createMdxLoaderPlugin = (compilerOptions, extensions) => {
+  const filter = createMdxExtensionFilter(extensions, { allowQueryString: true });
+  return {
+    name: "ecopages-jsx-mdx-loader",
+    setup(build) {
+      build.onLoad({ filter }, async (args) => {
+        const { compile } = await import("@mdx-js/mdx");
+        const filePath = args.path.includes("?") ? args.path.split("?")[0] : args.path;
+        const source = await readFile(filePath, "utf-8");
+        const compiled = await compile(new VFile({ value: source, path: filePath }), compilerOptions);
+        return {
+          contents: String(compiled.value),
+          loader: "js",
+          resolveDir: path.dirname(filePath)
+        };
+      });
+    }
+  };
+};
+const registerBunMdxPlugin = async (compilerOptions, extensions) => {
+  if (typeof Bun === "undefined") {
+    return;
+  }
+  const filter = createMdxExtensionFilter(extensions);
+  Bun.plugin({
+    name: "ecopages-jsx-mdx",
+    setup(build) {
+      build.onLoad({ filter }, async (args) => {
+        const { compile } = await import("@mdx-js/mdx");
+        const source = await readFile(args.path, "utf-8");
+        const compiled = await compile(new VFile({ value: source, path: args.path }), compilerOptions);
+        return { contents: String(compiled.value), loader: "js" };
+      });
+    }
+  });
+};
+const isMdxFile = (filePath, extensions) => {
+  return extensions.some((ext) => filePath.endsWith(ext));
+};
+const normalizeMdxPageModule = (file, module) => {
+  if (typeof module.default !== "function") {
+    throw new TypeError("MDX file must export a callable default component.");
+  }
+  const Page = module.default;
+  const normalizedConfig = {
+    ...module.config ?? Page.config ?? {},
+    ...module.layout ? { layout: module.layout } : {},
+    __eco: module.config?.__eco ?? Page.config?.__eco ?? {
+      id: String(rapidhash(file)),
+      file,
+      integration: ECOPAGES_JSX_PLUGIN_NAME
+    }
+  };
+  const wrappedPage = async (props) => await Page(props);
+  wrappedPage.config = normalizedConfig;
+  if (module.getMetadata ?? Page.metadata) {
+    wrappedPage.metadata = module.getMetadata ?? Page.metadata;
+  }
+  return {
+    ...module,
+    default: wrappedPage,
+    config: normalizedConfig
+  };
+};
+export {
+  appendMdxExtensions,
+  createMdxExtensionFilter,
+  createMdxLoaderPlugin,
+  isMdxFile,
+  normalizeMdxPageModule,
+  registerBunMdxPlugin,
+  resolveMdxCompilerOptions
+};

package/src/ecopages-jsx-radiant-ssr-policy.d.ts

@@ -0,0 +1,33 @@
+import { createMarkupNodeLike } from '@ecopages/jsx';
+/**
+ * Owns optional Radiant SSR runtime installation for the JSX integration.
+ *
+ * @remarks
+ * Radiant's server bridge and light-DOM shim are loaded lazily because most JSX
+ * renders do not need them. Once enabled, the resolved runtime modules are
+ * cached statically so repeated page and component renders do not keep paying
+ * module-resolution or shim-installation costs.
+ */
+export declare class EcopagesJsxRadiantSsrPolicy {
+    private static runtimeModules;
+    private static runtimeModulesPromise;
+    private readonly enabled;
+    constructor(enabled: boolean);
+    /**
+     * Ensures the Radiant SSR runtime is installed before a render needs it.
+     */
+    prepareRuntime(): Promise<void>;
+    /**
+     * Runs one render inside Radiant's server runtime when the policy is enabled.
+     */
+    withRuntime<T>(render: () => T): Promise<T>;
+    /**
+     * Converts one Radiant custom-element instance into trusted SSR markup.
+     *
+     * @remarks
+     * The returned node-like wrapper lets the JSX server renderer preserve the
+     * generated host HTML without escaping it back into plain text.
+     */
+    renderIntrinsicElementMarkup(instance: unknown): ReturnType<typeof createMarkupNodeLike> | undefined;
+    private ensureRuntimeInstalled;
+}

package/src/ecopages-jsx-radiant-ssr-policy.js

@@ -0,0 +1,80 @@
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { createMarkupNodeLike } from "@ecopages/jsx";
+import { isServerRenderHydrationActive } from "@ecopages/jsx/server";
+class EcopagesJsxRadiantSsrPolicy {
+  static runtimeModules;
+  static runtimeModulesPromise;
+  enabled;
+  constructor(enabled) {
+    this.enabled = enabled;
+  }
+  /**
+   * Ensures the Radiant SSR runtime is installed before a render needs it.
+   */
+  async prepareRuntime() {
+    if (!this.enabled) {
+      return;
+    }
+    await this.ensureRuntimeInstalled();
+  }
+  /**
+   * Runs one render inside Radiant's server runtime when the policy is enabled.
+   */
+  async withRuntime(render) {
+    if (!this.enabled) {
+      return render();
+    }
+    const runtimeModules = await EcopagesJsxRadiantSsrPolicy.runtimeModulesPromise;
+    if (!runtimeModules) {
+      return render();
+    }
+    return runtimeModules.withServerRadiantElementSsrRuntime(render);
+  }
+  /**
+   * Converts one Radiant custom-element instance into trusted SSR markup.
+   *
+   * @remarks
+   * The returned node-like wrapper lets the JSX server renderer preserve the
+   * generated host HTML without escaping it back into plain text.
+   */
+  renderIntrinsicElementMarkup(instance) {
+    const renderBridge = EcopagesJsxRadiantSsrPolicy.runtimeModules?.resolveRadiantElementRenderBridge(instance);
+    if (!renderBridge) {
+      return void 0;
+    }
+    return createMarkupNodeLike(
+      renderBridge.renderHostToString({
+        mode: isServerRenderHydrationActive() ? "hydrate" : "plain"
+      })
+    );
+  }
+  async ensureRuntimeInstalled() {
+    if (!EcopagesJsxRadiantSsrPolicy.runtimeModulesPromise) {
+      const radiantLightDomShimEntry = fileURLToPath(
+        import.meta.resolve("@ecopages/radiant/server/light-dom-shim")
+      );
+      const radiantPackageRoot = path.dirname(path.dirname(path.dirname(radiantLightDomShimEntry)));
+      const radiantElementSsrRuntimeModuleUrl = pathToFileURL(
+        path.join(radiantPackageRoot, "dist/server/radiant-element-ssr-bridge.js")
+      ).href;
+      EcopagesJsxRadiantSsrPolicy.runtimeModulesPromise = Promise.all([
+        import(radiantElementSsrRuntimeModuleUrl),
+        import("@ecopages/radiant/server/light-dom-shim")
+      ]).then(([radiantElementSsrRuntimeModule, lightDomShimModule2]) => {
+        const modules = {
+          installLightDomShim: lightDomShimModule2.installLightDomShim,
+          resolveRadiantElementRenderBridge: radiantElementSsrRuntimeModule.resolveRadiantElementRenderBridge,
+          withServerRadiantElementSsrRuntime: radiantElementSsrRuntimeModule.withServerRadiantElementSsrRuntime
+        };
+        EcopagesJsxRadiantSsrPolicy.runtimeModules = modules;
+        return modules;
+      });
+    }
+    const lightDomShimModule = await EcopagesJsxRadiantSsrPolicy.runtimeModulesPromise;
+    lightDomShimModule.installLightDomShim();
+  }
+}
+export {
+  EcopagesJsxRadiantSsrPolicy
+};

package/src/ecopages-jsx-render-session.d.ts

@@ -0,0 +1,39 @@
+import type { ProcessedAsset } from '@ecopages/core/services/asset-processing-service';
+export declare const ECOPAGES_JSX_SSR_RENDER_STATE_KEY: unique symbol;
+/**
+ * Tracks JSX SSR asset-collection state for one active render flow.
+ *
+ * @remarks
+ * The renderer still mirrors this state into `@ecopages/jsx/server` so nested
+ * JSX renders and existing SSR-scope probes can observe it, but it also keeps
+ * an internal async-local copy. That fallback avoids losing renderer state when
+ * host runtimes such as Vite end up loading separate module identities for the
+ * JSX server helpers.
+ */
+export declare class EcopagesJsxRenderSession {
+    private readonly dedupeProcessedAssets;
+    constructor(dedupeProcessedAssets: (assets: ProcessedAsset[]) => ProcessedAsset[]);
+    /**
+     * Runs one render inside the active session scope.
+     *
+     * @remarks
+     * When a render is already active, the current session state is reused and
+     * mirrored back into the JSX SSR scope so nested `renderToString()` calls see
+     * the same asset frame stack. When no session exists yet, a new state is
+     * created and published through both the internal async-local store and the
+     * JSX SSR scope bridge.
+     */
+    withActiveScope<T>(render: () => T): T;
+    beginCollectedAssetFrame(): ProcessedAsset[];
+    endCollectedAssetFrame(frame: ProcessedAsset[]): ProcessedAsset[];
+    recordCollectedAssets(collectedAssets: ProcessedAsset[]): ProcessedAsset[];
+    /**
+     * Resolves the current render-session state from the local async scope first.
+     *
+     * @remarks
+     * The fallback read from `@ecopages/jsx/server` keeps compatibility with code
+     * that still inspects the public SSR scope directly, while the async-local
+     * store remains the authoritative source for renderer-owned bookkeeping.
+     */
+    private getState;
+}

package/src/ecopages-jsx-render-session.js

@@ -0,0 +1,78 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { getActiveSsrScopeValue, withActiveSsrScopeValue } from "@ecopages/jsx/server";
+const ECOPAGES_JSX_SSR_RENDER_STATE_KEY = /* @__PURE__ */ Symbol.for("@ecopages/ecopages-jsx.ssr-render-state");
+const renderStateStorage = new AsyncLocalStorage();
+class EcopagesJsxRenderSession {
+  dedupeProcessedAssets;
+  constructor(dedupeProcessedAssets) {
+    this.dedupeProcessedAssets = dedupeProcessedAssets;
+  }
+  /**
+   * Runs one render inside the active session scope.
+   *
+   * @remarks
+   * When a render is already active, the current session state is reused and
+   * mirrored back into the JSX SSR scope so nested `renderToString()` calls see
+   * the same asset frame stack. When no session exists yet, a new state is
+   * created and published through both the internal async-local store and the
+   * JSX SSR scope bridge.
+   */
+  withActiveScope(render) {
+    const activeState = renderStateStorage.getStore();
+    if (activeState) {
+      return withActiveSsrScopeValue(ECOPAGES_JSX_SSR_RENDER_STATE_KEY, activeState, render);
+    }
+    const jsxScopeState = getActiveSsrScopeValue(ECOPAGES_JSX_SSR_RENDER_STATE_KEY);
+    if (jsxScopeState) {
+      return renderStateStorage.run(jsxScopeState, () => render());
+    }
+    const state = {
+      collectedAssetFrames: []
+    };
+    return renderStateStorage.run(
+      state,
+      () => withActiveSsrScopeValue(ECOPAGES_JSX_SSR_RENDER_STATE_KEY, state, render)
+    );
+  }
+  beginCollectedAssetFrame() {
+    const state = this.getState();
+    const frame = [];
+    state.collectedAssetFrames.push(frame);
+    return frame;
+  }
+  endCollectedAssetFrame(frame) {
+    const activeFrame = this.getState().collectedAssetFrames.pop();
+    if (!activeFrame || activeFrame !== frame) {
+      return this.dedupeProcessedAssets(frame);
+    }
+    return this.dedupeProcessedAssets(activeFrame);
+  }
+  recordCollectedAssets(collectedAssets) {
+    const dedupedAssets = this.dedupeProcessedAssets(collectedAssets);
+    const state = this.getState();
+    const activeFrame = state.collectedAssetFrames[state.collectedAssetFrames.length - 1];
+    if (activeFrame) {
+      activeFrame.push(...dedupedAssets);
+    }
+    return dedupedAssets;
+  }
+  /**
+   * Resolves the current render-session state from the local async scope first.
+   *
+   * @remarks
+   * The fallback read from `@ecopages/jsx/server` keeps compatibility with code
+   * that still inspects the public SSR scope directly, while the async-local
+   * store remains the authoritative source for renderer-owned bookkeeping.
+   */
+  getState() {
+    const state = renderStateStorage.getStore() ?? getActiveSsrScopeValue(ECOPAGES_JSX_SSR_RENDER_STATE_KEY);
+    if (!state) {
+      throw new Error("Ecopages JSX SSR render state is unavailable outside the active render scope.");
+    }
+    return state;
+  }
+}
+export {
+  ECOPAGES_JSX_SSR_RENDER_STATE_KEY,
+  EcopagesJsxRenderSession
+};

package/src/ecopages-jsx-renderer.d.ts

@@ -1,13 +1,9 @@
-import type { ComponentRenderInput, ComponentRenderResult, EcoComponent, EcoComponentConfig, EcoPageFile, GetMetadata, IntegrationRendererRenderOptions, RouteRendererBody } from '@ecopages/core';
+import type { ComponentRenderInput, ComponentRenderResult, EcoComponent, IntegrationRendererRenderOptions, RouteRendererBody } from '@ecopages/core';
 import { IntegrationRenderer, type RenderToResponseContext, type RouteModuleLoadOptions } from '@ecopages/core/route-renderer/integration-renderer';
 import { type JsxRenderable } from '@ecopages/jsx';
+import { type EcopagesJsxMdxPageModule } from './ecopages-jsx-mdx.js';
 import type { EcopagesJsxRendererOptions } from './ecopages-jsx.types.js';
 export type { EcopagesJsxRendererConfig, EcopagesJsxRendererOptions } from './ecopages-jsx.types.js';
-type MdxPageModule = EcoPageFile<{
-    config?: EcoComponentConfig;
-    layout?: EcoComponent;
-    getMetadata?: GetMetadata;
-}>;
 /**
  * Local Ecopages renderer for JSX templates in the docs app.
  *
@@ -16,68 +12,29 @@ type MdxPageModule = EcoPageFile<{
  */
 export declare class EcopagesJsxRenderer extends IntegrationRenderer<JsxRenderable> {
     name: string;
-    private static radiantServerRuntimeInstallPromise;
-    private static readonly SCRIPT_IMPORT_RE;
-    private readonly intrinsicCustomElementAssets;
-    private readonly intrinsicCustomElementScriptFiles;
-    private collectedAssetFrames;
-    private importedIntrinsicScriptFrames;
     private readonly mdxExtensions;
-    private readonly radiantSsrEnabled;
+    private readonly renderSession;
+    private readonly radiantSsrPolicy;
     /**
      * Re-renders queued JSX children inside the owning renderer so nested custom
-     * elements and queued foreign boundaries contribute assets to the same frame.
+     * elements and queued foreign subtrees contribute assets to the same frame.
      */
-    private renderQueuedBoundaryChildren;
+    private renderQueuedForeignSubtreeChildren;
     /**
-     * Resolves queued foreign boundaries after JSX has been stringified.
+     * Resolves queued foreign subtrees after JSX has been stringified.
      *
-     * JSX content needs one extra render pass because child boundaries may emit
+     * JSX content needs one extra render pass because child foreign subtrees may emit
      * additional browser assets while also replacing placeholder tokens.
      */
-    private resolveOwnedBoundaryHtml;
+    private resolveOwnedForeignSubtreeHtml;
     constructor({ appConfig, assetProcessingService, resolvedIntegrationDependencies, jsxConfig, runtimeOrigin, }: EcopagesJsxRendererOptions);
     /** Returns whether the requested page file should be treated as MDX. */
     isMdxFile(filePath: string): boolean;
-    protected importPageFile(file: string, options?: RouteModuleLoadOptions): Promise<MdxPageModule>;
+    protected importPageFile(file: string, options?: RouteModuleLoadOptions): Promise<EcopagesJsxMdxPageModule>;
     render(options: IntegrationRendererRenderOptions<JsxRenderable>): Promise<RouteRendererBody>;
     renderComponent(input: ComponentRenderInput): Promise<ComponentRenderResult>;
-    protected createComponentBoundaryRuntime(options: {
-        boundaryInput: ComponentRenderInput;
-        rendererCache: Map<string, IntegrationRenderer<any>>;
-    }): import("@ecopages/core").ComponentBoundaryRuntime;
     renderToResponse<P = any>(view: EcoComponent<P>, props: P, ctx: RenderToResponseContext): Promise<Response>;
-    /**
-     * Normalizes MDX modules into the same page contract as JSX route modules.
-     *
-     * MDX files export page metadata alongside generated component code, so the
-     * renderer folds those exports back into the Ecopages component shape before
-     * any layout or document-shell logic runs.
-     */
-    private normalizeMdxPageModule;
-    private beginCollectedAssetFrame;
-    private endCollectedAssetFrame;
     private renderJsx;
-    private renderEcoComponent;
-    private recordCollectedAssets;
-    private beginImportedIntrinsicScriptFrame;
-    private endImportedIntrinsicScriptFrame;
-    private getActiveImportedIntrinsicScriptFiles;
-    /**
-     * Collects intrinsic custom-element script files already owned by the current
-     * component tree through direct source imports or dependency declarations.
-     */
-    private collectImportedIntrinsicScriptFiles;
-    private extractImportedIntrinsicScriptFiles;
-    private extractConfiguredDependencyScriptFiles;
-    private resolveImportedIntrinsicScriptFile;
-    private ensureRadiantServerRuntimeIfEnabled;
-    private ensureRadiantServerRuntimeInstalled;
-    private isFunctionComponent;
-    private createComponentProps;
-    private collectComponentAssets;
-    private invokeComponent;
-    private createEcoMeta;
-    private wrapMdxPage;
+    private withCustomElementRenderHook;
     private createIntrinsicCustomElementRenderHook;
 }