@ecopages/ecopages-jsx 0.2.1 → 0.3.1

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

@@ -1,108 +1,36 @@
-import type { CompileOptions } from '@mdx-js/mdx';
-import type { EcoBuildPlugin } from '@ecopages/core/build/build-types';
-import { IntegrationPlugin, type IntegrationPluginConfig } from '@ecopages/core/plugins/integration-plugin';
+import { IntegrationPlugin, type IntegrationRendererBase, type IntegrationRuntimeContext, type EcoBuildPlugin } from '@ecopages/core/integration';
+import { type AssetDefinition } from '@ecopages/core/integration';
 import type { JsxRenderable } from '@ecopages/jsx';
 import { EcopagesJsxRenderer } from './ecopages-jsx-renderer.js';
-type MdxPluginList = NonNullable<CompileOptions['remarkPlugins']>;
-type MdxCompileOptions = Omit<CompileOptions, 'jsxImportSource' | 'jsxRuntime' | 'remarkPlugins' | 'rehypePlugins' | 'recmaPlugins'> & {
-    remarkPlugins?: MdxPluginList;
-    rehypePlugins?: MdxPluginList;
-    recmaPlugins?: MdxPluginList;
-};
-/**
- * Stable integration name shared by the JSX plugin and renderer.
- *
- * Ecopages uses this identifier to match route files, renderer instances, and
- * cross-integration component boundaries.
- */
-export declare const ECOPAGES_JSX_PLUGIN_NAME = "ecopages-jsx";
-/**
- * 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?: MdxCompileOptions;
-    /** 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[];
-};
-/** Options for the JSX integration plugin. */
-export type EcopagesJsxPluginOptions = Omit<IntegrationPluginConfig, 'name' | 'extensions'> & {
-    /** Optional JSX route extensions. Defaults to `.tsx`. */
-    extensions?: string[];
-    /**
-     * Whether to include the `@ecopages/radiant` and `@ecopages/signals` vendor
-     * bundles and bare-specifier mappings.
-     *
-     * Set to `false` when pages do not use Radiant web components.
-     * @default true
-     */
-    radiant?: boolean;
-    /** Optional MDX integration configuration. */
-    mdx?: EcopagesJsxMdxOptions;
-};
+import type { EcopagesJsxPluginOptions } from './ecopages-jsx.types.js';
+export type { EcopagesJsxMdxOptions, EcopagesJsxPluginOptions, EcopagesJsxRendererConfig, } from './ecopages-jsx.types.js';
 /** JSX integration plugin for Ecopages, supporting `.tsx` templates and optional Radiant web components. */
 export declare class EcopagesJsxPlugin extends IntegrationPlugin<JsxRenderable> {
-    /** Renderer implementation used for JSX and MDX routes. */
-    renderer: IntegrationPlugin<JsxRenderable>["renderer"];
-    private intrinsicCustomElementAssets;
+    renderer: new (options: import("@ecopages/core/integration").IntegrationRendererOptions) => import("@ecopages/core/integration").IntegrationRenderer<JsxRenderable> & {
+        name: string;
+    };
+    readonly bundlesPageDependencies = true;
     private includeRadiant;
-    private mdxEnabled;
     private mdxCompilerOptions?;
     private mdxExtensions;
-    private mdxLoaderPlugin?;
-    private runtimeBundleService;
-    private runtimeSpecifierMap;
-    private runtimeDepsInitialized;
-    /** Returns the build plugins required by the JSX integration. */
-    get plugins(): EcoBuildPlugin[];
-    /** Returns the browser-only build plugins required by the JSX integration. */
-    get browserBuildPlugins(): EcoBuildPlugin[];
     /**
-     * Exposes the bare-module specifier map used by the import map.
+     * Returns the build plugins required by the JSX integration.
      *
-     * Client bundles keep these imports external so the browser can load the
-     * shared runtime packages from the generated vendor assets.
-     */
-    getRuntimeSpecifierMap(): Record<string, string>;
-    /**
-     * Creates the renderer instance and attaches the discovered intrinsic custom
-     * element assets before the renderer handles any requests.
-     */
-    initializeRenderer(): EcopagesJsxRenderer;
-    /**
-     * Creates a JSX integration plugin.
-     *
-     * When MDX is enabled, the plugin also claims the configured MDX extensions
-     * and prepares compiler options around the shared `@ecopages/jsx` runtime.
+     * @remarks
+     * Returns a new loader declaration without registering or initializing it. The build manifest owns the
+     * resulting instance for the app runtime.
      */
+    plugins(app: IntegrationRuntimeContext['appConfig']): EcoBuildPlugin[];
+    /** Creates the renderer instance with the resolved JSX integration runtime options. */
+    createRenderer(base: IntegrationRendererBase): EcopagesJsxRenderer;
     constructor(options?: EcopagesJsxPluginOptions);
-    /** Ensures MDX build hooks are ready before Ecopages collects contributions. */
-    prepareBuildContributions(): Promise<void>;
-    /**
-     * Registers MDX tooling, discovers intrinsic custom-element assets, and then
-     * completes the base integration setup.
-     */
-    setup(): Promise<void>;
-    private ensureMdxLoaderPlugin;
-    private setupMdxBunPlugin;
-    private buildIntrinsicCustomElementAssetRegistry;
-    private collectScriptEntryFiles;
-    private resolveIntrinsicCustomElementAsset;
-    private extractIntrinsicCustomElementTagNames;
+    private getDependencies;
+    /** Assigns grouped-build metadata for page-owned JSX content scripts. */
+    prepareAssetDependencies(dependencies: AssetDefinition[]): AssetDefinition[];
+    /** Registers JSX HMR strategy, dev-transform plugins, and Radiant SSR invalidation hooks. */
+    hmr(context: IntegrationRuntimeContext): void;
 }
 /**
- * Creates the JSX integration plugin.
+ * Creates the JSX integration plugin with resolved defaults.
  */
 export declare const ecopagesJsxPlugin: (options?: EcopagesJsxPluginOptions) => EcopagesJsxPlugin;
-export {};

package/src/ecopages-jsx.plugin.js

@@ -1,248 +1,146 @@
-import { readFile, readdir } from "node:fs/promises";
-import path from "node:path";
-import { IntegrationPlugin } from "@ecopages/core/plugins/integration-plugin";
-import { AssetFactory } from "@ecopages/core/services/asset-processing-service";
-import { VFile } from "vfile";
-import { EcopagesJsxRenderer } from "./ecopages-jsx-renderer.js";
-import { JsxRuntimeBundleService } from "./services/jsx-runtime-bundle.service.js";
-const mergePluginLists = (...lists) => {
-  const merged = lists.flatMap((list) => list ? [...list] : []);
-  return merged.length > 0 ? merged : void 0;
-};
-const escapeRegex = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-const createMdxLoaderPlugin = (compilerOptions, extensions) => {
-  const escapedExts = extensions.map(escapeRegex);
-  const filter = new RegExp(`(${escapedExts.join("|")})(\\?.*)?$`);
-  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)
-        };
-      });
+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 !== undefined;
+    if (mdxEnabled) {
+        appendMdxExtensions(extensions, mdxExtensions);
     }
-  };
+    return {
+        ...baseConfig,
+        extensions,
+        includeRadiant: radiant ?? true,
+        mdxExtensions,
+        mdxCompilerOptions: mdxEnabled && mdx ? resolveMdxCompilerOptions(mdx) : undefined,
+    };
 };
-const ECOPAGES_JSX_PLUGIN_NAME = "ecopages-jsx";
-class EcopagesJsxPlugin extends IntegrationPlugin {
-  /** Renderer implementation used for JSX and MDX routes. */
-  renderer = EcopagesJsxRenderer;
-  intrinsicCustomElementAssets = /* @__PURE__ */ new Map();
-  includeRadiant;
-  mdxEnabled;
-  mdxCompilerOptions;
-  mdxExtensions;
-  mdxLoaderPlugin;
-  runtimeBundleService;
-  runtimeSpecifierMap = {};
-  runtimeDepsInitialized = false;
-  /** Returns the build plugins required by the JSX integration. */
-  get plugins() {
-    return [this.mdxLoaderPlugin].filter((plugin) => plugin !== void 0);
-  }
-  /** Returns the browser-only build plugins required by the JSX integration. */
-  get browserBuildPlugins() {
-    return [this.runtimeBundleService.getBuildPlugin()].filter(
-      (plugin) => plugin !== void 0
-    );
-  }
-  /**
-   * Exposes the bare-module specifier map used by the import map.
-   *
-   * Client bundles keep these imports external so the browser can load the
-   * shared runtime packages from the generated vendor assets.
-   */
-  getRuntimeSpecifierMap() {
-    return this.runtimeSpecifierMap;
-  }
-  /**
-   * Creates the renderer instance and attaches the discovered intrinsic custom
-   * element assets before the renderer handles any requests.
-   */
-  initializeRenderer() {
-    const renderer = super.initializeRenderer();
-    renderer.setIntrinsicCustomElementAssets(this.intrinsicCustomElementAssets);
-    renderer.setRadiantSsrEnabled(this.includeRadiant);
-    return renderer;
-  }
-  /**
-   * Creates a JSX integration plugin.
-   *
-   * When MDX is enabled, the plugin also claims the configured MDX extensions
-   * and prepares compiler options around the shared `@ecopages/jsx` runtime.
-   */
-  constructor(options) {
-    const { extensions: _ignoredExtensions, ...restOptions } = options ?? {};
-    const extensions = [...options?.extensions ?? [".tsx"]];
-    const mdxExtensions = options?.mdx?.extensions ?? [".mdx"];
-    const includeRadiant = options?.radiant ?? true;
-    if (options?.mdx?.enabled) {
-      for (const extension of mdxExtensions) {
-        if (!extensions.includes(extension)) {
-          extensions.push(extension);
+/** 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 [];
         }
-      }
-    }
-    super({
-      name: ECOPAGES_JSX_PLUGIN_NAME,
-      extensions,
-      jsxImportSource: "@ecopages/jsx",
-      ...restOptions
-    });
-    this.includeRadiant = includeRadiant;
-    this.runtimeBundleService = new JsxRuntimeBundleService({ radiant: includeRadiant });
-    this.mdxEnabled = options?.mdx?.enabled ?? false;
-    this.mdxExtensions = mdxExtensions;
-    EcopagesJsxRenderer.mdxExtensions = this.mdxExtensions;
-    if (this.mdxEnabled) {
-      const { compilerOptions, remarkPlugins, rehypePlugins, recmaPlugins } = options?.mdx ?? {};
-      const resolvedCompilerOptions = {
-        format: "detect",
-        outputFormat: "program",
-        ...compilerOptions,
-        jsxImportSource: "@ecopages/jsx",
-        jsxRuntime: "automatic",
-        development: process.env.NODE_ENV === "development"
-      };
-      const mergedRemarkPlugins = mergePluginLists(compilerOptions?.remarkPlugins, remarkPlugins);
-      const mergedRehypePlugins = mergePluginLists(compilerOptions?.rehypePlugins, rehypePlugins);
-      const mergedRecmaPlugins = mergePluginLists(compilerOptions?.recmaPlugins, recmaPlugins);
-      if (mergedRemarkPlugins) {
-        resolvedCompilerOptions.remarkPlugins = mergedRemarkPlugins;
-      }
-      if (mergedRehypePlugins) {
-        resolvedCompilerOptions.rehypePlugins = mergedRehypePlugins;
-      }
-      if (mergedRecmaPlugins) {
-        resolvedCompilerOptions.recmaPlugins = mergedRecmaPlugins;
-      }
-      this.mdxCompilerOptions = resolvedCompilerOptions;
-    }
-  }
-  /** Ensures MDX build hooks are ready before Ecopages collects contributions. */
-  async prepareBuildContributions() {
-    if (!this.runtimeDepsInitialized) {
-      this.runtimeDepsInitialized = true;
-      this.runtimeBundleService.setRootDir(this.appConfig?.rootDir);
-      this.runtimeSpecifierMap = await this.runtimeBundleService.getSpecifierMap();
-      const vendorDeps = await this.runtimeBundleService.getDependencies();
-      this.integrationDependencies.unshift(...vendorDeps);
+        return [
+            createMdxLoaderPlugin({
+                compilerOptions: this.mdxCompilerOptions,
+                extensions: this.mdxExtensions,
+                projectRoot: app.rootDir,
+                requestPipelineMetrics: requireAppRuntime(app).requestPipelineMetrics,
+            }),
+        ];
     }
-    this.ensureMdxLoaderPlugin();
-  }
-  /**
-   * Registers MDX tooling, discovers intrinsic custom-element assets, and then
-   * completes the base integration setup.
-   */
-  async setup() {
-    this.ensureMdxLoaderPlugin();
-    if (typeof Bun !== "undefined" && this.mdxEnabled && this.mdxCompilerOptions) {
-      await this.setupMdxBunPlugin();
-    }
-    await this.buildIntrinsicCustomElementAssetRegistry();
-    await super.setup();
-  }
-  ensureMdxLoaderPlugin() {
-    if (!this.mdxEnabled || !this.mdxCompilerOptions || this.mdxLoaderPlugin) {
-      return;
-    }
-    this.mdxLoaderPlugin = createMdxLoaderPlugin(this.mdxCompilerOptions, this.mdxExtensions);
-  }
-  async setupMdxBunPlugin() {
-    if (typeof Bun === "undefined" || !this.mdxEnabled || !this.mdxCompilerOptions) {
-      return;
+    /** 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;
     }
-    const compilerOptions = this.mdxCompilerOptions;
-    const escapedExts = this.mdxExtensions.map(escapeRegex);
-    const filter = new RegExp(`(${escapedExts.join("|")})$`);
-    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" };
+    constructor(options) {
+        const config = resolvePluginOptions(options);
+        const { extensions, includeRadiant, mdxExtensions, mdxCompilerOptions, ...baseConfig } = config;
+        super({
+            name: ECOPAGES_JSX_PLUGIN_NAME,
+            extensions,
+            jsxImportSource: '@ecopages/jsx',
+            ...baseConfig,
         });
-      }
-    });
-  }
-  async buildIntrinsicCustomElementAssetRegistry() {
-    if (!this.appConfig || !this.assetProcessingService) {
-      return;
-    }
-    this.intrinsicCustomElementAssets.clear();
-    const scriptFiles = await this.collectScriptEntryFiles(this.appConfig.absolutePaths.srcDir);
-    for (const scriptFile of scriptFiles) {
-      const tagNames = await this.extractIntrinsicCustomElementTagNames(scriptFile);
-      if (tagNames.length === 0) {
-        continue;
-      }
-      const processedAsset = await this.resolveIntrinsicCustomElementAsset(scriptFile);
-      if (!processedAsset) {
-        continue;
-      }
-      for (const tagName of tagNames) {
-        this.intrinsicCustomElementAssets.set(tagName, [processedAsset]);
-      }
+        this.includeRadiant = includeRadiant;
+        this.mdxExtensions = mdxExtensions;
+        this.mdxCompilerOptions = mdxCompilerOptions;
+        if (this.includeRadiant) {
+            this.integrationDependencies.unshift(...this.getDependencies());
+        }
     }
-  }
-  async collectScriptEntryFiles(directory) {
-    const directoryEntries = await readdir(directory, { withFileTypes: true });
-    const scriptFiles = [];
-    for (const directoryEntry of directoryEntries) {
-      const entryPath = path.join(directory, directoryEntry.name);
-      if (directoryEntry.isDirectory()) {
-        scriptFiles.push(...await this.collectScriptEntryFiles(entryPath));
-        continue;
-      }
-      if (/\.script\.(?:ts|tsx)$/.test(directoryEntry.name)) {
-        scriptFiles.push(entryPath);
-      }
+    getDependencies() {
+        return [
+            AssetFactory.createNodeModuleScript({
+                position: 'head',
+                importPath: RADIANT_INSTALL_HYDRATOR_FILEPATH,
+                bundle: false,
+                attributes: {
+                    'data-eco-script-id': RADIANT_HYDRATOR_SCRIPT_ID,
+                },
+            }),
+        ];
     }
-    return scriptFiles;
-  }
-  async resolveIntrinsicCustomElementAsset(scriptFile) {
-    if (!this.assetProcessingService) {
-      return void 0;
+    /** Assigns grouped-build metadata for page-owned JSX content scripts. */
+    prepareAssetDependencies(dependencies) {
+        return assignPageOwnedContentScriptGroupedBundles(dependencies);
     }
-    const [processedAsset] = await this.assetProcessingService.processDependencies(
-      [
-        AssetFactory.createFileScript({
-          filepath: scriptFile,
-          position: "head",
-          attributes: {
-            type: "module",
-            defer: ""
-          }
-        })
-      ],
-      `${this.name}:intrinsic-custom-elements:${scriptFile}`
-    );
-    return processedAsset;
-  }
-  async extractIntrinsicCustomElementTagNames(scriptFile) {
-    const source = await readFile(scriptFile, "utf8");
-    const tagNames = /* @__PURE__ */ new Set();
-    for (const match of source.matchAll(/@customElement\(\s*['"]([^'"]+)['"]/g)) {
-      const tagName = match[1];
-      if (tagName) {
-        tagNames.add(tagName);
-      }
+    /** 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));
+        }
     }
-    return [...tagNames];
-  }
 }
-const ecopagesJsxPlugin = (options) => new EcopagesJsxPlugin(options);
-export {
-  ECOPAGES_JSX_PLUGIN_NAME,
-  EcopagesJsxPlugin,
-  ecopagesJsxPlugin
-};
+/**
+ * Creates the JSX integration plugin with resolved defaults.
+ */
+export const ecopagesJsxPlugin = (options) => new EcopagesJsxPlugin(options);

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

@@ -0,0 +1,32 @@
+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 = MdxCompilerOptionsInput;
+/** Options for the JSX integration plugin. */
+export type EcopagesJsxPluginOptions = Omit<IntegrationPluginConfig, 'name' | 'extensions'> & {
+    /** Optional JSX route extensions. Defaults to `.tsx`. */
+    extensions?: string[];
+    /**
+     * Whether to enable the Radiant SSR contract for JSX apps.
+     *
+     * When enabled, Ecopages JSX installs the Radiant server SSR runtime so
+     * intrinsic custom elements can render specialized host markup during SSR.
+     *
+     * Set to `false` when pages do not use Radiant web components.
+     * @default true
+     */
+    radiant?: boolean;
+    /** Optional MDX integration configuration. */
+    mdx?: EcopagesJsxMdxOptions;
+};
+export type EcopagesJsxRendererConfig = {
+    mdxExtensions?: string[];
+    radiantSsrEnabled?: boolean;
+};
+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;