@ecopages/ecopages-jsx 0.2.1-beta.0 → 0.3.0

package/src/ecopages-jsx.plugin.js

@@ -1,120 +1,146 @@
-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 {
-  appendMdxExtensions,
-  createMdxLoaderPlugin,
-  registerBunMdxPlugin,
-  resolveMdxCompilerOptions
-} from "./ecopages-jsx-mdx.js";
-import { EcopagesJsxRenderer } from "./ecopages-jsx-renderer.js";
-const RADIANT_HYDRATOR_SCRIPT_ID = "ecopages-jsx-radiant-hydrator";
+import { IntegrationPlugin, } from '@ecopages/core/integration';
+import { AssetFactory } from '@ecopages/core/integration';
+import { requireAppRuntime } from '@ecopages/core/integration';
+import { ECOPAGES_JSX_PLUGIN_NAME } from './ecopages-jsx.constants.js';
+import { RADIANT_INSTALL_HYDRATOR_FILEPATH } from './resolve-radiant-install-hydrator.js';
+import { appendMdxExtensions, createMdxLoaderPlugin, resolveMdxCompilerOptions, } from './ecopages-jsx-mdx.js';
+import { createEcopagesJsxRenderer, createEcopagesJsxRendererHookFactory, 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';
+import { assignPageOwnedContentScriptGroupedBundles } from './page-owned-content-script-grouping.js';
+import { invalidateRadiantRegisteredScriptSsrRegistration } from './radiant-registered-script-ssr-invalidation.js';
+const RADIANT_HYDRATOR_SCRIPT_ID = 'ecopages-jsx-radiant-hydrator';
+/**
+ * Resolves user-facing plugin options into a fully-defaulted internal config.
+ *
+ * Defaults:
+ * - `extensions`: `['.tsx']`
+ * - `radiant`: `true`
+ * - MDX is disabled when `mdx` is omitted
+ * - `mdx.extensions`: `['.mdx']`
+ */
 const resolvePluginOptions = (options) => {
-  const { extensions: userExtensions, radiant, mdx, ...baseConfig } = options ?? {};
-  const extensions = [...userExtensions ?? [".tsx"]];
-  const mdxExtensions = mdx?.extensions ?? [".mdx"];
-  const mdxEnabled = mdx?.enabled ?? false;
-  if (mdxEnabled) {
-    appendMdxExtensions(extensions, mdxExtensions);
-  }
-  return {
-    ...baseConfig,
-    extensions,
-    includeRadiant: radiant ?? true,
-    mdxEnabled,
-    mdxExtensions,
-    mdxCompilerOptions: mdxEnabled && mdx ? resolveMdxCompilerOptions(mdx) : void 0
-  };
+    const { extensions: userExtensions, radiant, mdx, ...baseConfig } = options ?? {};
+    const extensions = [...(userExtensions ?? ['.tsx'])];
+    const mdxExtensions = mdx?.extensions ?? ['.mdx'];
+    const mdxEnabled = mdx !== undefined;
+    if (mdxEnabled) {
+        appendMdxExtensions(extensions, mdxExtensions);
+    }
+    return {
+        ...baseConfig,
+        extensions,
+        includeRadiant: radiant ?? true,
+        mdxExtensions,
+        mdxCompilerOptions: mdxEnabled && mdx ? resolveMdxCompilerOptions(mdx) : undefined,
+    };
 };
-class EcopagesJsxPlugin extends IntegrationPlugin {
-  renderer = EcopagesJsxRenderer;
-  includeRadiant;
-  mdxEnabled;
-  mdxCompilerOptions;
-  mdxExtensions;
-  mdxLoaderPlugin;
-  /** Returns the build plugins required by the JSX integration. */
-  get plugins() {
-    return [this.mdxLoaderPlugin].filter((plugin) => plugin !== void 0);
-  }
-  /** Creates the renderer instance with the resolved JSX integration runtime options. */
-  initializeRenderer(options) {
-    return this.attachRendererRuntimeServices(
-      new this.renderer({
-        ...this.createRendererOptions(options),
-        jsxConfig: {
-          mdxExtensions: this.mdxExtensions,
-          radiantSsrEnabled: this.includeRadiant
+/** JSX integration plugin for Ecopages, supporting `.tsx` templates and optional Radiant web components. */
+export class EcopagesJsxPlugin extends IntegrationPlugin {
+    renderer = EcopagesJsxRenderer;
+    bundlesPageDependencies = true;
+    includeRadiant;
+    mdxCompilerOptions;
+    mdxExtensions;
+    /**
+     * Returns the build plugins required by the JSX integration.
+     *
+     * @remarks
+     * Returns a new loader declaration without registering or initializing it. The build manifest owns the
+     * resulting instance for the app runtime.
+     */
+    plugins(app) {
+        if (!this.mdxCompilerOptions) {
+            return [];
         }
-      })
-    );
-  }
-  constructor(options) {
-    const config = resolvePluginOptions(options);
-    const { extensions, includeRadiant, mdxEnabled, mdxExtensions, mdxCompilerOptions, ...baseConfig } = config;
-    super({
-      name: ECOPAGES_JSX_PLUGIN_NAME,
-      extensions,
-      jsxImportSource: "@ecopages/jsx",
-      ...baseConfig
-    });
-    this.includeRadiant = includeRadiant;
-    this.mdxEnabled = mdxEnabled;
-    this.mdxExtensions = mdxExtensions;
-    this.mdxCompilerOptions = mdxCompilerOptions;
-    if (this.includeRadiant) {
-      this.integrationDependencies.unshift(...this.getDependencies());
+        return [
+            createMdxLoaderPlugin({
+                compilerOptions: this.mdxCompilerOptions,
+                extensions: this.mdxExtensions,
+                projectRoot: app.rootDir,
+                requestPipelineMetrics: requireAppRuntime(app).requestPipelineMetrics,
+            }),
+        ];
+    }
+    /** Creates the renderer instance with the resolved JSX integration runtime options. */
+    createRenderer(base) {
+        const jsxConfig = {
+            mdxExtensions: this.mdxExtensions,
+            radiantSsrEnabled: this.includeRadiant,
+        };
+        const customRendererOptions = { ...base, jsxConfig };
+        const renderer = this.renderer === EcopagesJsxRenderer
+            ? new (createEcopagesJsxRenderer(jsxConfig))(base)
+            : new this.renderer({
+                ...customRendererOptions,
+                hooks: createEcopagesJsxRendererHookFactory(jsxConfig),
+            });
+        renderer.name ||= this.name;
+        return renderer;
     }
-  }
-  getDependencies() {
-    return [
-      AssetFactory.createNodeModuleScript({
-        position: "head",
-        importPath: "@ecopages/radiant/client/install-hydrator",
-        bundle: false,
-        attributes: {
-          "data-eco-script-id": RADIANT_HYDRATOR_SCRIPT_ID
+    constructor(options) {
+        const config = resolvePluginOptions(options);
+        const { extensions, includeRadiant, mdxExtensions, mdxCompilerOptions, ...baseConfig } = config;
+        super({
+            name: ECOPAGES_JSX_PLUGIN_NAME,
+            extensions,
+            jsxImportSource: '@ecopages/jsx',
+            ...baseConfig,
+        });
+        this.includeRadiant = includeRadiant;
+        this.mdxExtensions = mdxExtensions;
+        this.mdxCompilerOptions = mdxCompilerOptions;
+        if (this.includeRadiant) {
+            this.integrationDependencies.unshift(...this.getDependencies());
         }
-      })
-    ];
-  }
-  /** Ensures MDX build hooks are ready before Ecopages collects contributions. */
-  async prepareBuildContributions() {
-    this.ensureMdxLoaderPlugin();
-  }
-  /**
-   * Registers MDX tooling and completes the base integration setup.
-   */
-  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) {
-      return;
+    getDependencies() {
+        return [
+            AssetFactory.createNodeModuleScript({
+                position: 'head',
+                importPath: RADIANT_INSTALL_HYDRATOR_FILEPATH,
+                bundle: false,
+                attributes: {
+                    'data-eco-script-id': RADIANT_HYDRATOR_SCRIPT_ID,
+                },
+            }),
+        ];
+    }
+    /** Assigns grouped-build metadata for page-owned JSX content scripts. */
+    prepareAssetDependencies(dependencies) {
+        return assignPageOwnedContentScriptGroupedBundles(dependencies);
     }
-    this.mdxLoaderPlugin = createMdxLoaderPlugin(this.mdxCompilerOptions, this.mdxExtensions);
-  }
-  /**
-   * 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;
+    /** Registers JSX HMR strategy, dev-transform plugins, and Radiant SSR invalidation hooks. */
+    hmr(context) {
+        super.hmr(context);
+        const manager = context.runtime.hmr;
+        if (!manager)
+            return;
+        const preloadScopes = context.runtime.customElementSsrPreloadScopes;
+        const hmrContext = manager.getDefaultContext();
+        const absolutePaths = context.appConfig.absolutePaths;
+        const strategy = new EcopagesJsxHmrStrategy({
+            getRegisteredEntrypoints: hmrContext.getRegisteredEntrypoints,
+            getSrcDir: hmrContext.getSrcDir,
+            getPagesDir: hmrContext.getPagesDir,
+            getLayoutsDir: hmrContext.getLayoutsDir,
+            getIncludesDir: () => absolutePaths.includesDir,
+            getTemplateExtensions: () => this.extensions,
+        });
+        manager.registerStrategy(strategy);
+        manager.registerDevTransformContributor(new EcopagesJsxDevTransformContributor({
+            strategy,
+            getMdxLoaderPlugin: () => context.runtime.buildManifest.server.find((plugin) => plugin.name === 'ecopages-jsx-mdx-loader'),
+        }));
+        if (!this.includeRadiant) {
+            return;
+        }
+        if (preloadScopes) {
+            manager.onScriptEntrypointChanged?.((scriptPath) => invalidateRadiantRegisteredScriptSsrRegistration(preloadScopes, scriptPath));
+        }
     }
-    await registerBunMdxPlugin(this.mdxCompilerOptions, this.mdxExtensions);
-  }
 }
-const ecopagesJsxPlugin = (options) => new EcopagesJsxPlugin(options);
-export {
-  EcopagesJsxPlugin,
-  ecopagesJsxPlugin
-};
+/**
+ * Creates the JSX integration plugin with resolved defaults.
+ */
+export const ecopagesJsxPlugin = (options) => new EcopagesJsxPlugin(options);

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

@@ -1,34 +1,13 @@
-import type { CompileOptions } from '@mdx-js/mdx';
-import type { IntegrationPluginConfig } from '@ecopages/core/plugins/integration-plugin';
-import type { AssetDefinition, AssetProcessingService, ProcessedAsset } from '@ecopages/core/services/asset-processing-service';
-import type { EcoPagesAppConfig } from '@ecopages/core';
-import type { EcopagesJsxRadiantSsrPolicy } from './ecopages-jsx-radiant-ssr-policy.js';
-type MdxPluginList = NonNullable<CompileOptions['remarkPlugins']>;
-export type EcopagesJsxMdxCompileOptions = Omit<CompileOptions, 'jsxImportSource' | 'jsxRuntime' | 'remarkPlugins' | 'rehypePlugins' | 'recmaPlugins'> & {
-    remarkPlugins?: MdxPluginList;
-    rehypePlugins?: MdxPluginList;
-    recmaPlugins?: MdxPluginList;
-};
+import type { MdxCompilerOptionsInput } from '@ecopages/mdx/core';
+import type { IntegrationPluginConfig } from '@ecopages/core/integration';
+import type { AssetDefinition } from '@ecopages/core/integration';
 /**
  * MDX configuration for the JSX integration.
  *
  * Mirrors Ecopages' built-in combined integration pattern where a single
  * JSX-capable plugin can own both `.tsx` and `.mdx` route files.
  */
-export type EcopagesJsxMdxOptions = {
-    /** Enables MDX file handling inside the JSX integration. */
-    enabled: boolean;
-    /** Additional MDX compiler options. JSX runtime fields are managed by the integration. */
-    compilerOptions?: EcopagesJsxMdxCompileOptions;
-    /** Extra remark plugins appended to `compilerOptions.remarkPlugins`. */
-    remarkPlugins?: MdxPluginList;
-    /** Extra rehype plugins appended to `compilerOptions.rehypePlugins`. */
-    rehypePlugins?: MdxPluginList;
-    /** Extra recma plugins appended to `compilerOptions.recmaPlugins`. */
-    recmaPlugins?: MdxPluginList;
-    /** Custom file extensions to treat as MDX. */
-    extensions?: string[];
-};
+export type EcopagesJsxMdxOptions = MdxCompilerOptionsInput;
 /** Options for the JSX integration plugin. */
 export type EcopagesJsxPluginOptions = Omit<IntegrationPluginConfig, 'name' | 'extensions'> & {
     /** Optional JSX route extensions. Defaults to `.tsx`. */
@@ -48,15 +27,6 @@ export type EcopagesJsxPluginOptions = Omit<IntegrationPluginConfig, 'name' | 'e
 };
 export type EcopagesJsxRendererConfig = {
     mdxExtensions?: string[];
-    radiantSsrPolicy?: EcopagesJsxRadiantSsrPolicy;
     radiantSsrEnabled?: boolean;
 };
-export type EcopagesJsxRendererOptions = {
-    appConfig: EcoPagesAppConfig;
-    assetProcessingService: AssetProcessingService;
-    resolvedIntegrationDependencies: ProcessedAsset[];
-    rendererModules?: unknown;
-    runtimeOrigin: string;
-    jsxConfig?: EcopagesJsxRendererConfig;
-};
 export type { AssetDefinition };

package/src/ecopages-jsx.types.js

@@ -0,0 +1 @@
+export {};

package/src/page-owned-content-script-grouping.d.ts

@@ -0,0 +1,11 @@
+import { type AssetDefinition } from '@ecopages/core/integration';
+/** Returns the app-wide grouped-build id used for page-owned content scripts. */
+export declare function createPageOwnedContentScriptBundleId(_integrationName?: string): string;
+/**
+ * Tags page-owned content scripts in one dependency batch with the app-wide client bundle id.
+ *
+ * @remarks
+ * Component file scripts and integration runtime assets stay ungrouped. Entries that
+ * already assign a grouped id are left unchanged.
+ */
+export declare function assignPageOwnedContentScriptGroupedBundles(dependencies: AssetDefinition[]): AssetDefinition[];

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

@@ -0,0 +1,57 @@
+import { APP_BROWSER_CLIENT_BUNDLE_ID, } from '@ecopages/core/integration';
+import { contentHash } from '@ecopages/core/build';
+/** Returns the app-wide grouped-build id used for page-owned content scripts. */
+export function createPageOwnedContentScriptBundleId(_integrationName) {
+    return APP_BROWSER_CLIENT_BUNDLE_ID;
+}
+function isPageOwnedGroupableContentScript(dep) {
+    if (dep.kind !== 'script' || dep.source !== 'content' || dep.inline) {
+        return false;
+    }
+    if (dep.groupedBundle?.id) {
+        return false;
+    }
+    if (dep.packageRole === 'keep-separate' || dep.packageRole === 'runtime' || dep.packageRole === 'dynamic-chunk') {
+        return false;
+    }
+    return true;
+}
+function createPageOwnedGroupedEntryName(dep, usedEntryNames) {
+    const baseName = dep.name ?? `script-${contentHash(dep.content, 16)}`;
+    if (!usedEntryNames.has(baseName)) {
+        usedEntryNames.add(baseName);
+        return baseName;
+    }
+    let suffix = 2;
+    let candidate = `${baseName}-${suffix}`;
+    while (usedEntryNames.has(candidate)) {
+        suffix += 1;
+        candidate = `${baseName}-${suffix}`;
+    }
+    usedEntryNames.add(candidate);
+    return candidate;
+}
+/**
+ * Tags page-owned content scripts in one dependency batch with the app-wide client bundle id.
+ *
+ * @remarks
+ * Component file scripts and integration runtime assets stay ungrouped. Entries that
+ * already assign a grouped id are left unchanged.
+ */
+export function assignPageOwnedContentScriptGroupedBundles(dependencies) {
+    const bundleId = APP_BROWSER_CLIENT_BUNDLE_ID;
+    const usedEntryNames = new Set();
+    for (const dependency of dependencies) {
+        if (!isPageOwnedGroupableContentScript(dependency)) {
+            continue;
+        }
+        dependency.groupedBundle = {
+            id: bundleId,
+            entryName: createPageOwnedGroupedEntryName(dependency, usedEntryNames),
+        };
+        if (dependency.bundle === false) {
+            dependency.bundle = true;
+        }
+    }
+    return dependencies;
+}

package/src/radiant-registered-script-ssr-invalidation.d.ts

@@ -0,0 +1,19 @@
+import type { CustomElementScriptPreloadScopeState } from '@ecopages/core/integration';
+/**
+ * Reads the custom-element tag name from a registered script module source file.
+ */
+export declare function resolveRadiantCustomElementTag(scriptPath: string): string | undefined;
+/**
+ * Removes one custom-element definition from the active runtime registry.
+ *
+ * @remarks
+ * Radiant's `@customElement` decorator and the SSR light-DOM shim both skip
+ * re-registration when a tag is already defined. During dev, server requests
+ * reuse the same process-global registry, so script edits would otherwise keep
+ * serving stale SSR markup until a full dev-server restart.
+ */
+export declare function clearRadiantCustomElementDefinition(tagName: string): void;
+/**
+ * Clears the SSR custom-element registry entry for one registered Radiant script module.
+ */
+export declare function invalidateRadiantRegisteredScriptSsrRegistration(preloadScopes: Map<string, CustomElementScriptPreloadScopeState>, scriptPath: string): boolean;

package/src/radiant-registered-script-ssr-invalidation.js

@@ -0,0 +1,49 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES, invalidateCustomElementScriptPreload, } from '@ecopages/core/integration';
+const CUSTOM_ELEMENT_TAG_PATTERN = /@customElement\s*\(\s*['"`]([^'"`]+)['"`]/u;
+/**
+ * Reads the custom-element tag name from a registered script module source file.
+ */
+export function resolveRadiantCustomElementTag(scriptPath) {
+    if (!existsSync(scriptPath)) {
+        return undefined;
+    }
+    const content = readFileSync(scriptPath, 'utf8');
+    const match = content.match(CUSTOM_ELEMENT_TAG_PATTERN);
+    return match?.[1];
+}
+/**
+ * Removes one custom-element definition from the active runtime registry.
+ *
+ * @remarks
+ * Radiant's `@customElement` decorator and the SSR light-DOM shim both skip
+ * re-registration when a tag is already defined. During dev, server requests
+ * reuse the same process-global registry, so script edits would otherwise keep
+ * serving stale SSR markup until a full dev-server restart.
+ */
+export function clearRadiantCustomElementDefinition(tagName) {
+    const registry = globalThis.customElements;
+    if (!registry) {
+        return;
+    }
+    if (typeof registry.delete === 'function') {
+        registry.delete(tagName);
+        return;
+    }
+    const definitions = registry.definitions;
+    if (definitions instanceof Map && definitions.has(tagName)) {
+        definitions.delete(tagName);
+    }
+}
+/**
+ * Clears the SSR custom-element registry entry for one registered Radiant script module.
+ */
+export function invalidateRadiantRegisteredScriptSsrRegistration(preloadScopes, scriptPath) {
+    invalidateCustomElementScriptPreload(preloadScopes, scriptPath, CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES.ecopagesJsx);
+    const tagName = resolveRadiantCustomElementTag(scriptPath);
+    if (!tagName) {
+        return false;
+    }
+    clearRadiantCustomElementDefinition(tagName);
+    return true;
+}

package/src/resolve-radiant-install-hydrator.d.ts

@@ -0,0 +1,2 @@
+/** Absolute path to `@ecopages/radiant/client/install-hydrator` from this integration package. */
+export declare const RADIANT_INSTALL_HYDRATOR_FILEPATH: string;

package/src/resolve-radiant-install-hydrator.js

@@ -0,0 +1,3 @@
+import { fileURLToPath } from 'node:url';
+/** Absolute path to `@ecopages/radiant/client/install-hydrator` from this integration package. */
+export const RADIANT_INSTALL_HYDRATOR_FILEPATH = fileURLToPath(import.meta.resolve('@ecopages/radiant/client/install-hydrator'));

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

@@ -1,46 +0,0 @@
-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;
-    /**
-     * Runs work with the current page-level hydrate binding namespace attached to JSX SSR.
-     *
-     * This lets page, layout, and document renders participate in one client-owned
-     * hydration root even though Ecopages composes them through multiple sibling render calls.
-     */
-    withHydrationBindingScope<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

@@ -1,93 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import {
-  createServerHydrationBindingState,
-  getActiveSsrScopeValue,
-  withActiveSsrScopeValue,
-  withServerHydrationBindingState
-} 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: [],
-      hydrationBindingState: createServerHydrationBindingState()
-    };
-    return renderStateStorage.run(
-      state,
-      () => withActiveSsrScopeValue(ECOPAGES_JSX_SSR_RENDER_STATE_KEY, state, render)
-    );
-  }
-  /**
-   * Runs work with the current page-level hydrate binding namespace attached to JSX SSR.
-   *
-   * This lets page, layout, and document renders participate in one client-owned
-   * hydration root even though Ecopages composes them through multiple sibling render calls.
-   */
-  withHydrationBindingScope(render) {
-    return withServerHydrationBindingState(this.getState().hydrationBindingState, 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
-};