@ecopages/ecopages-jsx 0.2.0-rc.8 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecopages/ecopages-jsx",
-  "version": "0.2.0-rc.8",
+  "version": "0.2.0",
   "description": "JSX integration plugin for Ecopages",
   "keywords": [
     "ecopages",
@@ -34,12 +34,12 @@
     "directory": "packages/integrations/ecopages-jsx"
   },
   "dependencies": {
-    "@ecopages/mdx": "0.2.0-rc.8",
+    "@ecopages/mdx": "0.2.0",
     "@mdx-js/mdx": "^3.1.1",
     "vfile": "^6.0.3"
   },
   "peerDependencies": {
-    "@ecopages/core": "0.2.0-rc.8",
+    "@ecopages/core": "0.2.0",
     "@ecopages/jsx": "^0.3.0-rc.9",
     "@ecopages/radiant": "^0.3.0-rc.9"
   }

package/src/ecopages-jsx-hmr-ownership.d.ts

@@ -1,16 +1,20 @@
 /**
- * Tracks the source files that participate in the active SSR render tree.
+ * Tracks the source files that produced the most recent JSX render.
  *
  * @remarks
- * The JSX integration renderer calls {@link updateEjsxHmrOwnership} after each
- * page, component, or view render so the HMR strategy can answer
- * "does this changed file affect SSR HTML?" without re-walking the tree on
- * every watcher event.
+ * The JSX renderer runs each page, component, or view render inside
+ * {@link withEjsxHmrOwnershipScope} and records its components with
+ * {@link recordEjsxHmrOwnership}. `EcopagesJsxHmrStrategy` reads the result to
+ * decide whether a changed file affects SSR HTML without walking the component
+ * tree on every watcher event.
  *
- * The state is module-scoped because the HMR strategy and renderer live in
- * different call sites (server strategy vs SSR renderer) and share no other
- * lifecycle anchor. A fresh state is installed only when the source-file set
- * changes, so the renderer's per-render hook stays O(1) in the steady state.
+ * The state is module-scoped because the renderer and the HMR strategy share no
+ * other lifecycle anchor. Publishing replaces it only when the file set changes,
+ * so repeated renders of the same page keep the existing state.
+ *
+ * Only the latest top-level render is kept. With several pages open, a file
+ * used only by a page that rendered earlier is not matched until that page
+ * renders again.
  */
 import type { EcoComponent } from '@ecopages/core';
 export type EjsxHmrOwnershipState = {
@@ -32,13 +36,21 @@ export declare function getEjsxHmrOwnership(): EjsxHmrOwnershipState;
  */
 export declare function updateEjsxHmrOwnership(components: ReadonlyArray<EcoComponent | Partial<EcoComponent> | undefined>): void;
 /**
- * Merges one render tree into a pending ownership set during an active render.
+ * Runs one render and publishes the files it recorded once the outermost scope ends.
+ *
+ * @remarks
+ * Nested renders, such as components and foreign subtrees resolved inside a
+ * page, join the outer scope, so the published set covers the whole render tree
+ * instead of the last nested render.
  */
-export declare function mergeEjsxHmrOwnership(target: Set<string>, components: ReadonlyArray<EcoComponent | undefined>): void;
+export declare function withEjsxHmrOwnershipScope<T>(render: () => T | Promise<T>): Promise<T>;
 /**
- * Publishes the merged ownership set for the completed render.
+ * Adds the source files of `components`, their declared dependencies and their
+ * layouts to the active render scope.
+ *
+ * @throws Error when called outside {@link withEjsxHmrOwnershipScope}.
  */
-export declare function publishEjsxHmrOwnership(files: ReadonlySet<string>): void;
+export declare function recordEjsxHmrOwnership(components: ReadonlyArray<EcoComponent | undefined>): void;
 /**
  * Resets the state to empty. Used by tests and by HMR manager teardown.
  */

package/src/ecopages-jsx-hmr-ownership.js

@@ -1,17 +1,22 @@
 /**
- * Tracks the source files that participate in the active SSR render tree.
+ * Tracks the source files that produced the most recent JSX render.
  *
  * @remarks
- * The JSX integration renderer calls {@link updateEjsxHmrOwnership} after each
- * page, component, or view render so the HMR strategy can answer
- * "does this changed file affect SSR HTML?" without re-walking the tree on
- * every watcher event.
+ * The JSX renderer runs each page, component, or view render inside
+ * {@link withEjsxHmrOwnershipScope} and records its components with
+ * {@link recordEjsxHmrOwnership}. `EcopagesJsxHmrStrategy` reads the result to
+ * decide whether a changed file affects SSR HTML without walking the component
+ * tree on every watcher event.
  *
- * The state is module-scoped because the HMR strategy and renderer live in
- * different call sites (server strategy vs SSR renderer) and share no other
- * lifecycle anchor. A fresh state is installed only when the source-file set
- * changes, so the renderer's per-render hook stays O(1) in the steady state.
+ * The state is module-scoped because the renderer and the HMR strategy share no
+ * other lifecycle anchor. Publishing replaces it only when the file set changes,
+ * so repeated renders of the same page keep the existing state.
+ *
+ * Only the latest top-level render is kept. With several pages open, a file
+ * used only by a page that rendered earlier is not matched until that page
+ * renders again.
  */
+import { AsyncLocalStorage } from 'node:async_hooks';
 import { rapidhash } from '@ecopages/core/hash';
 import { collectComponentConfigFilePaths } from '@ecopages/core/route-renderer/page-loading/file-scoped-dependency-components';
 const EMPTY_STATE = {
@@ -19,6 +24,7 @@ const EMPTY_STATE = {
     hash: '',
 };
 let currentState = EMPTY_STATE;
+const pendingFileOwners = new AsyncLocalStorage();
 /**
  * Returns the most recently recorded active render tree.
  */
@@ -38,17 +44,49 @@ export function updateEjsxHmrOwnership(components) {
     publishEjsxHmrOwnership(collectFileOwners(components));
 }
 /**
- * Merges one render tree into a pending ownership set during an active render.
+ * Runs one render and publishes the files it recorded once the outermost scope ends.
+ *
+ * @remarks
+ * Nested renders, such as components and foreign subtrees resolved inside a
+ * page, join the outer scope, so the published set covers the whole render tree
+ * instead of the last nested render.
  */
-export function mergeEjsxHmrOwnership(target, components) {
+export async function withEjsxHmrOwnershipScope(render) {
+    if (pendingFileOwners.getStore()) {
+        return await render();
+    }
+    const fileOwners = new Set();
+    try {
+        return await pendingFileOwners.run(fileOwners, render);
+    }
+    finally {
+        if (fileOwners.size > 0) {
+            publishEjsxHmrOwnership(fileOwners);
+        }
+    }
+}
+/**
+ * Adds the source files of `components`, their declared dependencies and their
+ * layouts to the active render scope.
+ *
+ * @throws Error when called outside {@link withEjsxHmrOwnershipScope}.
+ */
+export function recordEjsxHmrOwnership(components) {
+    const fileOwners = pendingFileOwners.getStore();
+    if (!fileOwners) {
+        throw new Error('Ecopages JSX HMR ownership can only be recorded inside an active render scope.');
+    }
     for (const file of collectFileOwners(components)) {
-        target.add(file);
+        fileOwners.add(file);
     }
 }
 /**
- * Publishes the merged ownership set for the completed render.
+ * Resets the state to empty. Used by tests and by HMR manager teardown.
  */
-export function publishEjsxHmrOwnership(files) {
+export function resetEjsxHmrOwnership() {
+    currentState = EMPTY_STATE;
+}
+function publishEjsxHmrOwnership(files) {
     const hash = hashFileSet(files);
     if (hash === currentState.hash) {
         return;
@@ -58,12 +96,6 @@ export function publishEjsxHmrOwnership(files) {
         hash,
     };
 }
-/**
- * Resets the state to empty. Used by tests and by HMR manager teardown.
- */
-export function resetEjsxHmrOwnership() {
-    currentState = EMPTY_STATE;
-}
 function collectFileOwners(components) {
     return collectComponentConfigFilePaths(components, { includeLayouts: true });
 }

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

@@ -19,6 +19,5 @@ export interface CreateEcopagesJsxMdxLoaderPluginOptions {
     projectRoot: string;
 }
 export declare const createMdxLoaderPlugin: (options: CreateEcopagesJsxMdxLoaderPluginOptions) => EcoBuildPlugin;
-export declare const registerBunMdxPlugin: (options: CreateEcopagesJsxMdxLoaderPluginOptions) => 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

@@ -18,18 +18,6 @@ export const createMdxLoaderPlugin = (options) => createMdxLoaderPluginCore({
     loader: 'js',
     projectRoot: options.projectRoot,
 });
-export const registerBunMdxPlugin = async (options) => {
-    if (typeof Bun === 'undefined') {
-        return;
-    }
-    const plugin = createMdxLoaderPlugin(options);
-    Bun.plugin({
-        name: plugin.name,
-        setup(build) {
-            return plugin.setup(build);
-        },
-    });
-};
 export const isMdxFile = (filePath, extensions) => {
     return extensions.some((ext) => filePath.endsWith(ext));
 };

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

@@ -14,7 +14,6 @@ export type { EcopagesJsxRendererConfig, EcopagesJsxRendererOptions } from './ec
 export declare class EcopagesJsxRenderer extends IntegrationRenderer<JsxRenderable> {
     name: string;
     private readonly mdxExtensions;
-    private readonly renderSession;
     private readonly radiantSsrPolicy;
     private readonly ssrScriptPreloader;
     /**
@@ -34,7 +33,7 @@ export declare class EcopagesJsxRenderer extends IntegrationRenderer<JsxRenderab
     private isJsxSerializableForeignChild;
     /**
      * Re-renders queued JSX children inside the owning renderer so nested custom
-     * elements and queued foreign subtrees contribute assets to the same frame.
+     * elements and queued foreign subtrees resolve here rather than as opaque markup.
      */
     private renderQueuedForeignSubtreeChildren;
     protected createForeignChildRuntime(options: {
@@ -52,10 +51,4 @@ export declare class EcopagesJsxRenderer extends IntegrationRenderer<JsxRenderab
     private withCustomElementRenderHook;
     private withPreparedRadiantRuntime;
     private createIntrinsicCustomElementRenderHook;
-    /**
-     * Records the source files that produced the current render so
-     * {@link EcopagesJsxHmrStrategy} can match later watcher events without
-     * re-walking the component tree.
-     */
-    private recordHmrOwnership;
 }

package/src/ecopages-jsx-renderer.js

@@ -1,14 +1,13 @@
 import { IntegrationRenderer, } from '@ecopages/core/route-renderer/orchestration/integration-renderer';
 import { resolveDocumentShellLayouts } from '@ecopages/core/route-renderer/orchestration/document-shell/layout-shell-props.service';
-import { getForeignSubtreeResolutionContextKey, resolveOwningIntegrationRenderer, } from '@ecopages/core/route-renderer/orchestration/foreign-child/owning-renderer-resolution';
 import { createMarkupNodeLike } from '@ecopages/jsx';
 import { renderToString, withServerCustomElementRenderHook } from '@ecopages/jsx/server';
 import { ECOPAGES_JSX_PLUGIN_NAME } from './ecopages-jsx.constants.js';
 import { isMdxFile, normalizeMdxPageModule, } from './ecopages-jsx-mdx.js';
-import { EcopagesJsxRenderSession } from './ecopages-jsx-render-session.js';
+import { recordEjsxHmrOwnership, withEjsxHmrOwnershipScope } from './ecopages-jsx-hmr-ownership.js';
 import { EcopagesJsxRadiantSsrPolicy } from './ecopages-jsx-radiant-ssr-policy.js';
 import { CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES, CustomElementScriptPreloader, } from '@ecopages/core/route-renderer/orchestration/custom-element-scripts/custom-element-script-preloader';
-import { createCustomElementSsrPreloadEntrypointResolver } from '@ecopages/core/route-renderer/orchestration/custom-element-scripts/custom-element-ssr-preload-entrypoint';
+import { createSharedServerModuleImporter } from '@ecopages/core/route-renderer/orchestration/custom-element-scripts/custom-element-server-module-importer';
 /**
  * Local Ecopages renderer for JSX templates in the docs app.
  *
@@ -18,7 +17,6 @@ import { createCustomElementSsrPreloadEntrypointResolver } from '@ecopages/core/
 export class EcopagesJsxRenderer extends IntegrationRenderer {
     name = ECOPAGES_JSX_PLUGIN_NAME;
     mdxExtensions;
-    renderSession;
     radiantSsrPolicy;
     ssrScriptPreloader;
     /**
@@ -75,26 +73,15 @@ export class EcopagesJsxRenderer extends IntegrationRenderer {
     }
     /**
      * Re-renders queued JSX children inside the owning renderer so nested custom
-     * elements and queued foreign subtrees contribute assets to the same frame.
+     * elements and queued foreign subtrees resolve here rather than as opaque markup.
      */
     async renderQueuedForeignSubtreeChildren(children, queuedResolutionsByToken, resolveToken) {
         if (children === undefined) {
-            return { assets: [] };
+            return {};
         }
-        let assets = [];
-        let html;
-        if (typeof children === 'string') {
-            html = children;
-        }
-        else {
-            const renderedChildren = await this.renderJsx(children);
-            html = renderedChildren.html;
-            assets = renderedChildren.assets;
-        }
-        html = await this.foreignSubtreeExecutionService.resolveQueuedTokens(html, queuedResolutionsByToken, resolveToken);
+        const html = typeof children === 'string' ? children : await this.renderJsx(children);
         return {
-            assets,
-            html,
+            html: await this.foreignSubtreeExecutionService.resolveQueuedTokens(html, queuedResolutionsByToken, resolveToken),
         };
     }
     createForeignChildRuntime(options) {
@@ -124,26 +111,25 @@ export class EcopagesJsxRenderer extends IntegrationRenderer {
             runtimeOrigin,
         });
         this.mdxExtensions = jsxConfig?.mdxExtensions ?? ['.mdx'];
-        this.renderSession = new EcopagesJsxRenderSession((assets) => this.htmlTransformer.dedupeProcessedAssets(assets));
         const radiantSsrEnabled = jsxConfig?.radiantSsrEnabled ?? false;
         this.radiantSsrPolicy = jsxConfig?.radiantSsrPolicy ?? new EcopagesJsxRadiantSsrPolicy(radiantSsrEnabled);
         const preferSourceImports = typeof Bun !== 'undefined';
         this.ssrScriptPreloader = new CustomElementScriptPreloader({
             cacheScope: CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES.ecopagesJsx,
-            /**
-             * @remarks
-             * Node production builds evaluate registration scripts through the
-             * asset pipeline during render. Preloading through the app module loader
-             * registers Radiant hosts in an isolated graph and breaks SSR.
-             */
-            enabled: radiantSsrEnabled && preferSourceImports,
+            collectForIntegration: ECOPAGES_JSX_PLUGIN_NAME,
+            enabled: radiantSsrEnabled,
             logLabel: 'ecopages-jsx',
             preferSourceImports,
             resolveDependencyPath: (componentDir, sourcePath) => this.resolveDependencyPath(componentDir, sourcePath),
-            resolvePreloadEntrypoint: createCustomElementSsrPreloadEntrypointResolver({
-                preferSourceImports,
-                processDependencies: this.assetProcessingService?.processDependencies?.bind(this.assetProcessingService),
-            }),
+            /**
+             * @remarks
+             * Bun imports the source file through `preferSourceImports`. Node must
+             * not: dev asset output is still the `.tsx` source, and a browser bundle
+             * is a second Radiant graph. The page server-module loader transpiles
+             * the script and externalizes packages, so `customElements.define` hits
+             * the same module instances the page already loaded.
+             */
+            importServerModule: preferSourceImports ? undefined : createSharedServerModuleImporter(this.appConfig),
         });
     }
     /** Returns whether the requested page file should be treated as MDX. */
@@ -164,7 +150,7 @@ export class EcopagesJsxRenderer extends IntegrationRenderer {
                 options.HtmlTemplate,
                 ...(options.resolvedPageDependencyComponents ?? []),
             ]);
-            return await this.renderSession.withActiveScope(async () => {
+            return await withEjsxHmrOwnershipScope(async () => {
                 try {
                     const result = await this.renderPageWithDocumentShell({
                         page: {
@@ -191,7 +177,7 @@ export class EcopagesJsxRenderer extends IntegrationRenderer {
                         metadata: options.metadata,
                         pageProps: options.pageProps ?? {},
                     });
-                    this.recordHmrOwnership([
+                    recordEjsxHmrOwnership([
                         options.Page,
                         options.Layout,
                         options.HtmlTemplate,
@@ -208,8 +194,7 @@ export class EcopagesJsxRenderer extends IntegrationRenderer {
     async renderComponent(input) {
         return await this.withPreparedRadiantRuntime(async () => {
             await this.ssrScriptPreloader.preloadSsrScripts([input.component]);
-            return await this.renderSession.withActiveScope(async () => {
-                const assetFrame = this.renderSession.beginCollectedAssetFrame();
+            return await withEjsxHmrOwnershipScope(async () => {
                 try {
                     if (typeof input.component !== 'function') {
                         throw new TypeError('JSX renderer expected a callable component.');
@@ -224,34 +209,17 @@ export class EcopagesJsxRenderer extends IntegrationRenderer {
                                 : input.children,
                         };
                     const content = await this.withCustomElementRenderHook(() => component(componentProps));
-                    const rendered = await this.renderJsx(content);
-                    const queuedForeignSubtreeResolution = await this.foreignSubtreeExecutionService.resolveQueuedHtml({
-                        currentIntegrationName: this.name,
-                        html: rendered.html,
-                        runtimeContext: this.foreignSubtreeExecutionService.getQueuedRuntimeContext(input, getForeignSubtreeResolutionContextKey(this.name)),
-                        queueLabel: 'Ecopages JSX',
-                        getOwningRenderer: (integrationName, rendererCache) => resolveOwningIntegrationRenderer({
-                            appConfig: this.appConfig,
-                            runtimeOrigin: this.runtimeOrigin,
-                            currentIntegrationName: this.name,
-                            currentRenderer: this,
-                            integrationName,
-                            cache: rendererCache,
-                        }),
-                        applyAttributesToFirstElement: (resolvedHtml, attributes) => this.htmlTransformer.applyAttributesToFirstElement(resolvedHtml, attributes),
-                        dedupeProcessedAssets: (assets) => this.htmlTransformer.dedupeProcessedAssets(assets),
-                        renderQueuedChildren: (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => this.renderQueuedForeignSubtreeChildren(children, queuedResolutionsByToken, resolveToken),
-                    });
+                    const html = await this.renderJsx(content);
+                    const queuedForeignSubtreeResolution = await this.resolveQueuedForeignSubtrees(html, this.getQueuedForeignSubtreeContext(input), (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => this.renderQueuedForeignSubtreeChildren(children, queuedResolutionsByToken, resolveToken));
                     const componentAssets = input.component.config?.dependencies &&
                         typeof this.assetProcessingService?.processDependencies === 'function'
                         ? await this.processComponentDependencies([input.component])
                         : [];
                     const assets = this.htmlTransformer.dedupeProcessedAssets([
-                        ...this.renderSession.endCollectedAssetFrame(assetFrame),
                         ...queuedForeignSubtreeResolution.assets,
                         ...componentAssets,
                     ]);
-                    this.recordHmrOwnership([input.component]);
+                    recordEjsxHmrOwnership([input.component]);
                     return this.finalizeIslandComponentRender(input, {
                         html: queuedForeignSubtreeResolution.html,
                         canAttachAttributes: true,
@@ -261,7 +229,6 @@ export class EcopagesJsxRenderer extends IntegrationRenderer {
                     });
                 }
                 catch (error) {
-                    this.renderSession.endCollectedAssetFrame(assetFrame);
                     throw this.createRenderError('Error rendering component', error);
                 }
             });
@@ -272,7 +239,7 @@ export class EcopagesJsxRenderer extends IntegrationRenderer {
             const viewComponent = view;
             const layouts = viewComponent.config?.layouts;
             await this.ssrScriptPreloader.preloadSsrScripts([view, ...(layouts ?? [])]);
-            return await this.renderSession.withActiveScope(async () => {
+            return await withEjsxHmrOwnershipScope(async () => {
                 try {
                     if (typeof view !== 'function') {
                         throw new TypeError('JSX renderer expected a callable view component.');
@@ -283,7 +250,7 @@ export class EcopagesJsxRenderer extends IntegrationRenderer {
                         ctx,
                         layout: layouts?.[layouts.length - 1],
                     });
-                    this.recordHmrOwnership([view]);
+                    recordEjsxHmrOwnership([view]);
                     return response;
                 }
                 catch (error) {
@@ -293,13 +260,7 @@ export class EcopagesJsxRenderer extends IntegrationRenderer {
         });
     }
     async renderJsx(value) {
-        const collectedAssets = [];
-        const html = await this.withCustomElementRenderHook(() => renderToString(value));
-        const dedupedAssets = this.renderSession.recordCollectedAssets(collectedAssets);
-        return {
-            assets: dedupedAssets,
-            html,
-        };
+        return await this.withCustomElementRenderHook(() => renderToString(value));
     }
     async withCustomElementRenderHook(render) {
         return await this.radiantSsrPolicy.withRuntime(() => withServerCustomElementRenderHook(this.createIntrinsicCustomElementRenderHook(), render));
@@ -313,12 +274,4 @@ export class EcopagesJsxRenderer extends IntegrationRenderer {
             return instance ? this.radiantSsrPolicy.renderIntrinsicElementMarkup(instance) : undefined;
         };
     }
-    /**
-     * Records the source files that produced the current render so
-     * {@link EcopagesJsxHmrStrategy} can match later watcher events without
-     * re-walking the component tree.
-     */
-    recordHmrOwnership(components) {
-        this.renderSession.mergeHmrOwnership(components);
-    }
 }

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

@@ -10,7 +10,6 @@ export type { EcopagesJsxMdxOptions, EcopagesJsxPluginOptions, EcopagesJsxRender
 export declare class EcopagesJsxPlugin extends IntegrationPlugin<JsxRenderable> {
     renderer: typeof EcopagesJsxRenderer;
     private includeRadiant;
-    private mdxEnabled;
     private mdxCompilerOptions?;
     private mdxExtensions;
     private mdxLoaderPlugin?;
@@ -39,17 +38,14 @@ export declare class EcopagesJsxPlugin extends IntegrationPlugin<JsxRenderable>
      */
     getHmrStrategy(): HmrStrategy | undefined;
     /**
-     * Registers MDX tooling and completes the base integration setup.
+     * Ensures the MDX loader exists, then completes the base integration setup.
+     *
+     * @remarks
+     * Bun registers `integration.plugins` after `setup()` returns. Calling
+     * `Bun.plugin` here would install the same MDX loader twice.
      */
     setup(): Promise<void>;
     private ensureMdxLoaderPlugin;
-    /**
-     * Registers Bun's MDX loader at runtime setup time.
-     *
-     * Build-time contribution collection may run where Bun is absent, so
-     * this hook stays isolated from manifest preparation.
-     */
-    private registerMdxBunPlugin;
 }
 /**
  * Creates the JSX integration plugin with resolved defaults.

package/src/ecopages-jsx.plugin.js

@@ -2,7 +2,7 @@ import { IntegrationPlugin, } from '@ecopages/core/plugins/integration-plugin';
 import { AssetFactory } from '@ecopages/core/services/asset-processing-service';
 import { ECOPAGES_JSX_PLUGIN_NAME } from './ecopages-jsx.constants.js';
 import { RADIANT_INSTALL_HYDRATOR_FILEPATH } from './resolve-radiant-install-hydrator.js';
-import { appendMdxExtensions, createMdxLoaderPlugin, registerBunMdxPlugin, resolveMdxCompilerOptions, } from './ecopages-jsx-mdx.js';
+import { appendMdxExtensions, createMdxLoaderPlugin, resolveMdxCompilerOptions, } from './ecopages-jsx-mdx.js';
 import { EcopagesJsxRenderer } from './ecopages-jsx-renderer.js';
 import { EcopagesJsxHmrStrategy } from './ecopages-jsx-hmr-strategy.js';
 import { EcopagesJsxDevTransformContributor } from './dev-transform/ecopages-jsx-dev-transform-contributor.js';
@@ -30,7 +30,6 @@ const resolvePluginOptions = (options) => {
         ...baseConfig,
         extensions,
         includeRadiant: radiant ?? true,
-        mdxEnabled,
         mdxExtensions,
         mdxCompilerOptions: mdxEnabled && mdx ? resolveMdxCompilerOptions(mdx) : undefined,
     };
@@ -39,7 +38,6 @@ const resolvePluginOptions = (options) => {
 export class EcopagesJsxPlugin extends IntegrationPlugin {
     renderer = EcopagesJsxRenderer;
     includeRadiant;
-    mdxEnabled;
     mdxCompilerOptions;
     mdxExtensions;
     mdxLoaderPlugin;
@@ -59,7 +57,7 @@ export class EcopagesJsxPlugin extends IntegrationPlugin {
     }
     constructor(options) {
         const config = resolvePluginOptions(options);
-        const { extensions, includeRadiant, mdxEnabled, mdxExtensions, mdxCompilerOptions, ...baseConfig } = config;
+        const { extensions, includeRadiant, mdxExtensions, mdxCompilerOptions, ...baseConfig } = config;
         super({
             name: ECOPAGES_JSX_PLUGIN_NAME,
             extensions,
@@ -67,7 +65,6 @@ export class EcopagesJsxPlugin extends IntegrationPlugin {
             ...baseConfig,
         });
         this.includeRadiant = includeRadiant;
-        this.mdxEnabled = mdxEnabled;
         this.mdxExtensions = mdxExtensions;
         this.mdxCompilerOptions = mdxCompilerOptions;
         if (this.includeRadiant) {
@@ -137,17 +134,18 @@ export class EcopagesJsxPlugin extends IntegrationPlugin {
         });
     }
     /**
-     * Registers MDX tooling and completes the base integration setup.
+     * Ensures the MDX loader exists, then completes the base integration setup.
+     *
+     * @remarks
+     * Bun registers `integration.plugins` after `setup()` returns. Calling
+     * `Bun.plugin` here would install the same MDX loader twice.
      */
     async setup() {
         this.ensureMdxLoaderPlugin();
-        if (typeof Bun !== 'undefined' && this.mdxEnabled && this.mdxCompilerOptions) {
-            await this.registerMdxBunPlugin();
-        }
         await super.setup();
     }
     ensureMdxLoaderPlugin() {
-        if (!this.mdxEnabled || !this.mdxCompilerOptions || this.mdxLoaderPlugin) {
+        if (!this.mdxCompilerOptions || this.mdxLoaderPlugin) {
             return;
         }
         if (!this.appConfig?.rootDir) {
@@ -159,25 +157,6 @@ export class EcopagesJsxPlugin extends IntegrationPlugin {
             projectRoot: this.appConfig.rootDir,
         });
     }
-    /**
-     * Registers Bun's MDX loader at runtime setup time.
-     *
-     * Build-time contribution collection may run where Bun is absent, so
-     * this hook stays isolated from manifest preparation.
-     */
-    async registerMdxBunPlugin() {
-        if (typeof Bun === 'undefined' || !this.mdxCompilerOptions) {
-            return;
-        }
-        if (!this.appConfig) {
-            throw new Error('[EcopagesJsxPlugin] Cannot register Bun MDX plugin: appConfig is not set');
-        }
-        await registerBunMdxPlugin({
-            compilerOptions: this.mdxCompilerOptions,
-            extensions: this.mdxExtensions,
-            projectRoot: this.appConfig.rootDir,
-        });
-    }
 }
 /**
  * Creates the JSX integration plugin with resolved defaults.

package/src/page-owned-content-script-grouping.js

@@ -1,4 +1,4 @@
-import { rapidhash } from '@ecopages/core/utils/hash';
+import { rapidhash } from '@ecopages/core/hash';
 import { ECOPAGES_JSX_PLUGIN_NAME } from './ecopages-jsx.constants.js';
 /** Shared grouped-build id prefix for page-owned content scripts. */
 const PAGE_OWNED_CONTENT_SCRIPT_BUNDLE_PREFIX = 'ecopages';

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

@@ -1,42 +0,0 @@
-import type { EcoComponent } from '@ecopages/core';
-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. HMR ownership accumulated during the outer scope is
-     * published once when that scope completes.
-     */
-    withActiveScope<T>(render: () => T | Promise<T>): Promise<T>;
-    beginCollectedAssetFrame(): ProcessedAsset[];
-    endCollectedAssetFrame(frame: ProcessedAsset[]): ProcessedAsset[];
-    mergeHmrOwnership(components: ReadonlyArray<EcoComponent | undefined>): void;
-    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

@@ -1,111 +0,0 @@
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { getActiveSsrScopeValue, withActiveSsrScopeValue } from '@ecopages/jsx/server';
-import { mergeEjsxHmrOwnership, publishEjsxHmrOwnership } from './ecopages-jsx-hmr-ownership.js';
-export const ECOPAGES_JSX_SSR_RENDER_STATE_KEY = Symbol.for('@ecopages/ecopages-jsx.ssr-render-state');
-const renderStateStorage = new AsyncLocalStorage();
-function ensurePendingHmrFileOwners(state) {
-    if (!state.pendingHmrFileOwners) {
-        state.pendingHmrFileOwners = new Set();
-    }
-    return state.pendingHmrFileOwners;
-}
-function commitPendingHmrOwnership(state) {
-    const pending = state.pendingHmrFileOwners;
-    if (!pending || pending.size === 0) {
-        return;
-    }
-    publishEjsxHmrOwnership(pending);
-    pending.clear();
-}
-async function runWithCommittedHmrOwnership(state, render) {
-    try {
-        return await render();
-    }
-    finally {
-        commitPendingHmrOwnership(state);
-    }
-}
-/**
- * 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 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. HMR ownership accumulated during the outer scope is
-     * published once when that scope completes.
-     */
-    async withActiveScope(render) {
-        const activeState = renderStateStorage.getStore();
-        if (activeState) {
-            return await withActiveSsrScopeValue(ECOPAGES_JSX_SSR_RENDER_STATE_KEY, activeState, render);
-        }
-        const jsxScopeState = getActiveSsrScopeValue(ECOPAGES_JSX_SSR_RENDER_STATE_KEY);
-        if (jsxScopeState) {
-            ensurePendingHmrFileOwners(jsxScopeState);
-            return await runWithCommittedHmrOwnership(jsxScopeState, () => renderStateStorage.run(jsxScopeState, () => render()));
-        }
-        const state = {
-            collectedAssetFrames: [],
-            pendingHmrFileOwners: new Set(),
-        };
-        return await runWithCommittedHmrOwnership(state, () => 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);
-    }
-    mergeHmrOwnership(components) {
-        mergeEjsxHmrOwnership(ensurePendingHmrFileOwners(this.getState()), components);
-    }
-    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;
-    }
-}