@ecopages/ecopages-jsx 0.2.1 → 0.3.0

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

@@ -0,0 +1,122 @@
+import { createMarkupNodeLike } from '@ecopages/jsx';
+import { createServerHydrationBindingState, withServerHydrationBindingState } from '@ecopages/jsx/server';
+/**
+ * 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. Resolved runtime modules are cached on the policy
+ * instance so repeated renders on the same renderer reuse one load without
+ * process-wide mutable class state. Light-DOM constructor installation remains
+ * process-global and idempotent via {@link ensureRadiantLightDomGlobals}; the
+ * Radiant installer also repairs incomplete DOM globals left by another runtime.
+ */
+export class EcopagesJsxRadiantSsrPolicy {
+    runtimeModules;
+    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 this.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.
+     *
+     * The render hook owns the host's JSX children, so `applyChildren` runs inside the host's context providers.
+     * A consumer passed as a child of a provider host then resolves that provider in the server HTML instead of
+     * rendering its fallback state.
+     */
+    renderIntrinsicElementMarkup(instance, applyChildren) {
+        const runtime = this.runtimeModules;
+        if (!runtime?.resolveRadiantElementRenderBridge(instance)) {
+            return undefined;
+        }
+        return createMarkupNodeLike(withServerHydrationBindingState(createServerHydrationBindingState(), () => {
+            const service = runtime.createRadiantElementSsrService(instance);
+            service.applyLightDom(() => applyChildren?.());
+            return service.renderHostToString({ mode: 'hydrate' }, service.getHostAttributes());
+        }));
+    }
+    async ensureRuntimeInstalled() {
+        if (!this.runtimeModulesPromise) {
+            const radiantLightDomShimEntry = import.meta.resolve('@ecopages/radiant/server/light-dom-shim');
+            const radiantElementSsrRuntimeModuleUrl = import.meta
+                .resolve('@ecopages/radiant/server/radiant-element-ssr');
+            this.runtimeModulesPromise = (async () => {
+                const lightDomShimModule = await import(/* @vite-ignore */ radiantLightDomShimEntry);
+                ensureRadiantLightDomGlobals(lightDomShimModule.ensureLightDomShim);
+                const radiantElementSsrRuntimeModule = (await import(
+                /* @vite-ignore */ radiantElementSsrRuntimeModuleUrl));
+                const modules = {
+                    createRadiantElementSsrService: radiantElementSsrRuntimeModule.createRadiantElementSsrService,
+                    ensureLightDomShim: lightDomShimModule.ensureLightDomShim,
+                    resolveRadiantElementRenderBridge: radiantElementSsrRuntimeModule.resolveRadiantElementRenderBridge,
+                    withServerRadiantElementSsrRuntime: radiantElementSsrRuntimeModule.withServerRadiantElementSsrRuntime,
+                };
+                this.runtimeModules = modules;
+                return modules;
+            })();
+        }
+        await this.runtimeModulesPromise;
+        const lightDomShimModule = this.runtimeModules;
+        if (lightDomShimModule) {
+            ensureRadiantLightDomGlobals(lightDomShimModule.ensureLightDomShim);
+        }
+    }
+}
+/**
+ * Installs Radiant light-DOM constructors on `globalThis` once.
+ *
+ * @remarks
+ * Custom-element constructors must be process-global; undoing them between tests
+ * is unsafe. Callers that clear globals for isolation must rely on a fresh policy
+ * instance so {@link EcopagesJsxRadiantSsrPolicy.prepareRuntime} re-runs the
+ * completeness check.
+ */
+function ensureRadiantLightDomGlobals(ensureLightDomShim) {
+    const window = ensureLightDomShim();
+    if (!window) {
+        return;
+    }
+    Object.assign(globalThis, {
+        CSS: window.CSS,
+        CustomEvent: window.CustomEvent,
+        Document: window.Document,
+        Element: window.Element,
+        Event: window.Event,
+        EventTarget: window.EventTarget,
+        HTMLScriptElement: window.HTMLScriptElement,
+        HTMLElement: window.HTMLElement,
+        Node: window.Node,
+        document: window.document,
+        customElements: window.customElements,
+        requestAnimationFrame: window.requestAnimationFrame,
+        cancelAnimationFrame: window.cancelAnimationFrame,
+        window,
+    });
+}

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

@@ -1,54 +1,12 @@
-import type { ComponentRenderInput, ComponentRenderResult, EcoComponent, EcoComponentConfig, EcoPageFile, GetMetadata, IntegrationRendererRenderOptions, RouteRendererBody } from '@ecopages/core';
-import type { EcoPagesAppConfig } from '@ecopages/core/internal-types';
-import { IntegrationRenderer, type RenderToResponseContext } from '@ecopages/core/route-renderer/integration-renderer';
-import type { AssetProcessingService, ProcessedAsset } from '@ecopages/core/services/asset-processing-service';
+import { createIntegrationRenderer, type IntegrationRendererHookFactory } from '@ecopages/core/integration';
 import { type JsxRenderable } from '@ecopages/jsx';
-type MdxPageModule = EcoPageFile<{
-    config?: EcoComponentConfig;
-    layout?: EcoComponent;
-    getMetadata?: GetMetadata;
-}>;
-/**
- * Local Ecopages renderer for JSX templates in the docs app.
- *
- * This keeps the integration scoped to the docs package while supporting
- * async page, layout, and html template components on the server.
- */
-export declare class EcopagesJsxRenderer extends IntegrationRenderer<JsxRenderable> {
+import type { EcopagesJsxRendererConfig } from './ecopages-jsx.types.js';
+export type { EcopagesJsxRendererConfig } from './ecopages-jsx.types.js';
+export type EcopagesJsxRenderer = InstanceType<ReturnType<typeof createEcopagesJsxRenderer>>;
+/** Creates the hook-based Ecopages JSX renderer for one plugin configuration. */
+export declare function createEcopagesJsxRenderer(jsxConfig?: EcopagesJsxRendererConfig): ReturnType<typeof createIntegrationRenderer<JsxRenderable>>;
+/** Creates JSX renderer hooks that can also configure a custom renderer subclass. */
+export declare function createEcopagesJsxRendererHookFactory(jsxConfig?: EcopagesJsxRendererConfig): IntegrationRendererHookFactory;
+export declare const EcopagesJsxRenderer: new (options: import("@ecopages/core/integration").IntegrationRendererOptions) => import("@ecopages/core/integration").IntegrationRenderer<JsxRenderable> & {
     name: string;
-    static mdxExtensions: string[];
-    private intrinsicCustomElementAssets;
-    private collectedAssetFrames;
-    private radiantSsrEnabled;
-    private resolveQueuedBoundaryChildren;
-    private resolveQueuedBoundaryHtml;
-    constructor({ appConfig, assetProcessingService, resolvedIntegrationDependencies, runtimeOrigin, }: {
-        appConfig: EcoPagesAppConfig;
-        assetProcessingService: AssetProcessingService;
-        resolvedIntegrationDependencies: ProcessedAsset[];
-        runtimeOrigin: string;
-    });
-    /** Returns whether the requested page file should be treated as MDX. */
-    isMdxFile(filePath: string): boolean;
-    /**
-     * Supplies the intrinsic custom-element assets discovered by the plugin so
-     * component renders can attach the correct client scripts.
-     */
-    setIntrinsicCustomElementAssets(assetsByTagName: Map<string, readonly ProcessedAsset[]>): void;
-    /** Enables the Radiant SSR light-DOM shim for this renderer instance. */
-    setRadiantSsrEnabled(enabled: boolean): void;
-    protected importPageFile(file: string): Promise<MdxPageModule>;
-    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>;
-    private beginCollectedAssetFrame;
-    private endCollectedAssetFrame;
-    private renderJsx;
-    private renderEcoComponent;
-    private createIntrinsicCustomElementRenderHook;
-}
-export {};
+};

package/src/ecopages-jsx-renderer.js

@@ -1,263 +1,155 @@
-import { rapidhash } from "@ecopages/core/hash";
-import { IntegrationRenderer } from "@ecopages/core/route-renderer/integration-renderer";
-import { createMarkupNodeLike } from "@ecopages/jsx";
-import { renderToString, withServerCustomElementRenderHook } from "@ecopages/jsx/server";
-import { ECOPAGES_JSX_PLUGIN_NAME } from "./ecopages-jsx.plugin.js";
-let radiantLightDomShimInstallPromise;
-async function ensureRadiantLightDomShimInstalled() {
-  if (!radiantLightDomShimInstallPromise) {
-    radiantLightDomShimInstallPromise = import("@ecopages/radiant/server/light-dom-shim").then((module) => {
-      module.installLightDomShim();
-    }).then(() => void 0);
-  }
-  await radiantLightDomShimInstallPromise;
+import { HttpError } from '@ecopages/core/errors';
+import { createIntegrationRenderer, } from '@ecopages/core/integration';
+import { resolveQueuedTokens } from '@ecopages/core/integration';
+import { createMarkupNodeLike } from '@ecopages/jsx';
+import { renderToString, withServerCustomElementRenderHook } from '@ecopages/jsx/server';
+import { isMdxFile, normalizeMdxPageModule, } from './ecopages-jsx-mdx.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/integration';
+import { requireAppRuntime } from '@ecopages/core/integration';
+import { createSharedServerModuleImporter } from '@ecopages/core/integration';
+import { ECOPAGES_JSX_PLUGIN_NAME } from './ecopages-jsx.constants.js';
+/** Creates the hook-based Ecopages JSX renderer for one plugin configuration. */
+export function createEcopagesJsxRenderer(jsxConfig = {}) {
+    return createIntegrationRenderer(ECOPAGES_JSX_PLUGIN_NAME, createEcopagesJsxRendererHookFactory(jsxConfig));
 }
-const isEcoFunctionComponent = (component) => {
-  return typeof component === "function";
-};
-const renderComponent = async (component, props) => {
-  return await component(props);
-};
-const createEcoMeta = (file) => ({
-  id: String(rapidhash(file)),
-  file,
-  integration: ECOPAGES_JSX_PLUGIN_NAME
-});
-const wrapMdxPage = (page, {
-  config,
-  metadata
-}) => {
-  const wrappedPage = (async (props) => renderComponent(page, props));
-  wrappedPage.config = config;
-  if (metadata) {
-    wrappedPage.metadata = metadata;
-  }
-  return wrappedPage;
-};
-class EcopagesJsxRenderer extends IntegrationRenderer {
-  name = ECOPAGES_JSX_PLUGIN_NAME;
-  static mdxExtensions = [".mdx"];
-  intrinsicCustomElementAssets = /* @__PURE__ */ new Map();
-  collectedAssetFrames = [];
-  radiantSsrEnabled = false;
-  async resolveQueuedBoundaryChildren(children, queuedResolutionsByToken, resolveToken) {
-    if (children === void 0) {
-      return { assets: [] };
-    }
-    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.resolveQueuedBoundaryTokens(html, queuedResolutionsByToken, resolveToken);
-    return {
-      assets,
-      html
+/** Creates JSX renderer hooks that can also configure a custom renderer subclass. */
+export function createEcopagesJsxRendererHookFactory(jsxConfig = {}) {
+    const mdxExtensions = jsxConfig.mdxExtensions ?? ['.mdx'];
+    return ({ appConfig, resolveComponentDependencies, resolveDependencyPath, }) => {
+        const radiantSsrPolicy = new EcopagesJsxRadiantSsrPolicy(jsxConfig.radiantSsrEnabled ?? false);
+        const ssrScriptPreloader = new CustomElementScriptPreloader({
+            cacheScope: CUSTOM_ELEMENT_SSR_PRELOAD_CACHE_SCOPES.ecopagesJsx,
+            preloadScopes: requireAppRuntime(appConfig).customElementSsrPreloadScopes,
+            collectForIntegration: ECOPAGES_JSX_PLUGIN_NAME,
+            enabled: jsxConfig.radiantSsrEnabled ?? false,
+            logLabel: 'ecopages-jsx',
+            resolveDependencyPath,
+            importServerModule: createSharedServerModuleImporter(appConfig),
+        });
+        const withCustomElementRenderHook = async (render) => await radiantSsrPolicy.withRuntime(() => withServerCustomElementRenderHook(({ instance, applyChildren, }) => instance ? radiantSsrPolicy.renderIntrinsicElementMarkup(instance, applyChildren) : undefined, render, { ownsChildren: true }));
+        const renderJsx = async (value) => await withCustomElementRenderHook(() => renderToString(value));
+        const normalizeForeignChildProps = (input) => {
+            if (!input.targetIntegration || input.targetIntegration === ECOPAGES_JSX_PLUGIN_NAME) {
+                return input.props;
+            }
+            return normalizeForeignChildren(input.props);
+        };
+        return {
+            beforeImportPageModule: async () => await radiantSsrPolicy.prepareRuntime(),
+            normalizePageModule: (file, module) => isMdxFile(file, mdxExtensions)
+                ? normalizeMdxPageModule(file, module)
+                : module,
+            beforeRender: async (options) => {
+                await radiantSsrPolicy.prepareRuntime();
+                await ssrScriptPreloader.preloadSsrScripts([
+                    options.Page,
+                    options.Layout,
+                    options.HtmlTemplate,
+                    ...(options.pageDependencyComponents ?? []),
+                ]);
+            },
+            renderComponent: async (input) => {
+                await radiantSsrPolicy.prepareRuntime();
+                await ssrScriptPreloader.preloadSsrScripts([input.component]);
+                return await withEjsxHmrOwnershipScope(async () => {
+                    try {
+                        if (typeof input.component !== 'function') {
+                            throw new TypeError('JSX renderer expected a callable component.');
+                        }
+                        const component = input.component;
+                        const componentProps = input.children === undefined
+                            ? input.props
+                            : {
+                                ...input.props,
+                                children: typeof input.children === 'string'
+                                    ? createMarkupNodeLike(input.children)
+                                    : input.children,
+                            };
+                        const content = await withCustomElementRenderHook(() => component(componentProps));
+                        const html = await renderJsx(content);
+                        const assets = input.component.config?.dependencies
+                            ? await resolveComponentDependencies([input.component])
+                            : undefined;
+                        recordEjsxHmrOwnership([input.component]);
+                        return {
+                            html,
+                            canAttachAttributes: true,
+                            integrationName: ECOPAGES_JSX_PLUGIN_NAME,
+                            assets,
+                        };
+                    }
+                    catch (error) {
+                        throw createRenderError('Error rendering component', error);
+                    }
+                });
+            },
+            renderQueuedChildren: async (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => {
+                if (children === undefined) {
+                    return {};
+                }
+                const html = typeof children === 'string' ? children : await renderJsx(children);
+                return { html: await resolveQueuedTokens(html, queuedResolutionsByToken, resolveToken) };
+            },
+            normalizeForeignChildProps: (input) => normalizeForeignChildProps(input),
+            renderRoute: async (options, render) => await withEjsxHmrOwnershipScope(async () => {
+                const body = await render();
+                recordEjsxHmrOwnership([
+                    options.Page,
+                    options.Layout,
+                    options.HtmlTemplate,
+                    ...(options.pageDependencyComponents ?? []),
+                ]);
+                return body;
+            }),
+        };
     };
-  }
-  async resolveQueuedBoundaryHtml(html, runtimeContext) {
-    return this.resolveRendererOwnedQueuedBoundaryHtml({
-      html,
-      runtimeContext,
-      queueLabel: "Ecopages JSX",
-      renderQueuedChildren: async (children, _runtimeContext, queuedResolutionsByToken, resolveToken) => this.resolveQueuedBoundaryChildren(children, queuedResolutionsByToken, resolveToken)
-    });
-  }
-  constructor({
-    appConfig,
-    assetProcessingService,
-    resolvedIntegrationDependencies,
-    runtimeOrigin
-  }) {
-    super({
-      appConfig,
-      assetProcessingService,
-      resolvedIntegrationDependencies,
-      runtimeOrigin
-    });
-  }
-  /** Returns whether the requested page file should be treated as MDX. */
-  isMdxFile(filePath) {
-    return EcopagesJsxRenderer.mdxExtensions.some((ext) => filePath.endsWith(ext));
-  }
-  /**
-   * Supplies the intrinsic custom-element assets discovered by the plugin so
-   * component renders can attach the correct client scripts.
-   */
-  setIntrinsicCustomElementAssets(assetsByTagName) {
-    this.intrinsicCustomElementAssets = assetsByTagName;
-  }
-  /** Enables the Radiant SSR light-DOM shim for this renderer instance. */
-  setRadiantSsrEnabled(enabled) {
-    this.radiantSsrEnabled = enabled;
-  }
-  async importPageFile(file) {
-    const module = await super.importPageFile(file);
-    if (!this.isMdxFile(file)) {
-      return module;
+}
+export const EcopagesJsxRenderer = createEcopagesJsxRenderer();
+function normalizeForeignChildren(props) {
+    if (!('children' in props)) {
+        return props;
     }
-    const Page = module.default;
-    const normalizedConfig = {
-      ...module.config ?? Page.config ?? {},
-      ...module.layout ? { layout: module.layout } : {},
-      __eco: module.config?.__eco ?? Page.config?.__eco ?? createEcoMeta(file)
-    };
-    const wrappedPage = wrapMdxPage(Page, {
-      config: normalizedConfig,
-      metadata: module.getMetadata ?? Page.metadata
-    });
-    return {
-      ...module,
-      default: wrappedPage,
-      config: normalizedConfig
-    };
-  }
-  async render(options) {
-    try {
-      return await this.renderPageWithDocumentShell({
-        page: {
-          component: options.Page,
-          props: {
-            ...options.pageProps,
-            locals: options.pageLocals
-          }
-        },
-        layout: options.Layout ? {
-          component: options.Layout,
-          props: {
-            ...options.pageProps,
-            locals: options.locals
-          }
-        } : void 0,
-        htmlTemplate: options.HtmlTemplate,
-        metadata: options.metadata,
-        pageProps: options.pageProps ?? {}
-      });
-    } catch (error) {
-      throw this.createRenderError("Error rendering page", error);
+    const children = props.children;
+    if (children === undefined || typeof children === 'string') {
+        return props;
     }
-  }
-  async renderComponent(input) {
-    const assetFrame = this.beginCollectedAssetFrame();
-    try {
-      if (!isEcoFunctionComponent(input.component)) {
-        throw new TypeError("JSX renderer expected a callable component.");
-      }
-      let props = input.props;
-      if (input.children !== void 0) {
-        props = {
-          ...input.props,
-          children: typeof input.children === "string" ? createMarkupNodeLike(input.children) : input.children
+    if (typeof children === 'object' &&
+        children !== null &&
+        'nodeType' in children &&
+        typeof children.nodeType === 'number' &&
+        'outerHTML' in children &&
+        typeof children.outerHTML === 'string') {
+        return {
+            ...props,
+            children: children.outerHTML,
         };
-      }
-      const content = await this.renderEcoComponent(
-        input.component,
-        props
-      );
-      const rendered = await this.renderJsx(content);
-      const queuedBoundaryResolution = await this.resolveQueuedBoundaryHtml(
-        rendered.html,
-        this.getQueuedBoundaryRuntime(input)
-      );
-      const componentAssets = input.component.config?.dependencies && typeof this.assetProcessingService?.processDependencies === "function" ? await this.processComponentDependencies([input.component]) : [];
-      const assets = this.htmlTransformer.dedupeProcessedAssets([
-        ...this.endCollectedAssetFrame(assetFrame),
-        ...queuedBoundaryResolution.assets,
-        ...componentAssets
-      ]);
-      return {
-        html: queuedBoundaryResolution.html,
-        canAttachAttributes: true,
-        rootTag: this.getRootTagName(queuedBoundaryResolution.html),
-        integrationName: this.name,
-        assets
-      };
-    } catch (error) {
-      this.endCollectedAssetFrame(assetFrame);
-      throw this.createRenderError("Error rendering component", error);
     }
-  }
-  createComponentBoundaryRuntime(options) {
-    return this.createQueuedBoundaryRuntime({
-      boundaryInput: options.boundaryInput,
-      rendererCache: options.rendererCache
-    });
-  }
-  async renderToResponse(view, props, ctx) {
-    try {
-      if (!isEcoFunctionComponent(view)) {
-        throw new TypeError("JSX renderer expected a callable view component.");
-      }
-      return await this.renderViewWithDocumentShell({
-        view,
-        props,
-        ctx,
-        layout: view.config?.layout
-      });
-    } catch (error) {
-      throw this.createRenderError("Error rendering view", error);
-    }
-  }
-  beginCollectedAssetFrame() {
-    const frame = [];
-    this.collectedAssetFrames.push(frame);
-    return frame;
-  }
-  endCollectedAssetFrame(frame) {
-    const activeFrame = this.collectedAssetFrames.pop();
-    if (!activeFrame || activeFrame !== frame) {
-      return this.htmlTransformer.dedupeProcessedAssets(frame);
+    if (isJsxSerializableForeignChild(children)) {
+        return {
+            ...props,
+            children: renderToString(children),
+        };
     }
-    return this.htmlTransformer.dedupeProcessedAssets(activeFrame);
-  }
-  async renderJsx(value) {
-    if (this.radiantSsrEnabled) {
-      await ensureRadiantLightDomShimInstalled();
+    return props;
+}
+function isJsxSerializableForeignChild(children) {
+    if (Array.isArray(children)) {
+        return true;
     }
-    const collectedAssets = [];
-    const html = withServerCustomElementRenderHook(
-      this.createIntrinsicCustomElementRenderHook(collectedAssets),
-      () => renderToString(value)
-    );
-    const dedupedAssets = this.htmlTransformer.dedupeProcessedAssets(collectedAssets);
-    const activeFrame = this.collectedAssetFrames[this.collectedAssetFrames.length - 1];
-    if (activeFrame) {
-      activeFrame.push(...dedupedAssets);
+    if (children === null || typeof children !== 'object') {
+        return false;
     }
-    return {
-      assets: dedupedAssets,
-      html
-    };
-  }
-  async renderEcoComponent(component, props) {
-    if (this.radiantSsrEnabled) {
-      await ensureRadiantLightDomShimInstalled();
+    if ('$$typeof' in children) {
+        return true;
     }
-    const collectedAssets = [];
-    const rendered = await withServerCustomElementRenderHook(
-      this.createIntrinsicCustomElementRenderHook(collectedAssets),
-      () => renderComponent(component, props)
-    );
-    const activeFrame = this.collectedAssetFrames[this.collectedAssetFrames.length - 1];
-    if (activeFrame) {
-      activeFrame.push(...this.htmlTransformer.dedupeProcessedAssets(collectedAssets));
+    return 'strings' in children && Array.isArray(children.strings);
+}
+function createRenderError(message, cause) {
+    if (HttpError.isHttpError(cause)) {
+        return cause;
     }
-    return rendered;
-  }
-  createIntrinsicCustomElementRenderHook(target) {
-    return ({ tagName }) => {
-      const assets = this.intrinsicCustomElementAssets.get(tagName);
-      if (assets) {
-        target.push(...assets);
-      }
-      return void 0;
-    };
-  }
+    const errorMessage = cause instanceof Error ? `${message}: ${cause.message}` : message;
+    return HttpError.InternalServerError(errorMessage);
 }
-export {
-  EcopagesJsxRenderer
-};

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

@@ -0,0 +1,7 @@
+/**
+ * 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";

package/src/ecopages-jsx.constants.js

@@ -0,0 +1,7 @@
+/**
+ * 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 const ECOPAGES_JSX_PLUGIN_NAME = 'ecopages-jsx';