@ecopages/core 0.2.0-beta.4 → 0.2.0-beta.41

package/src/plugins/foreign-jsx-override-plugin.js

@@ -1,41 +1,53 @@
-import { readFileSync } from "node:fs";
-import path from "node:path";
-function createForeignJsxOverridePlugin(options) {
-  const extensions = options.foreignExtensions.filter((ext) => ext.endsWith(".tsx") || ext.endsWith(".jsx"));
-  const excludedExtensions = (options.excludeExtensions ?? []).filter(
-    (ext) => ext.endsWith(".tsx") || ext.endsWith(".jsx")
-  );
-  if (extensions.length === 0) {
-    return {
-      name: options.name ?? "foreign-jsx-override",
-      setup() {
-      }
-    };
-  }
-  const pragma = `/** @jsxImportSource ${options.hostJsxImportSource} */
-`;
-  const filter = new RegExp(`(${extensions.map((e) => e.replace(".", "\\.")).join("|")})$`);
-  return {
-    name: options.name ?? "foreign-jsx-override",
-    setup(build) {
-      build.onLoad({ filter }, (args) => {
-        if (excludedExtensions.some((extension) => args.path.endsWith(extension))) {
-          return void 0;
-        }
-        const source = readFileSync(args.path, "utf-8");
-        const loader = args.path.endsWith(".jsx") ? "jsx" : "tsx";
-        if (source.includes("@jsxImportSource")) {
-          return void 0;
-        }
+import { readFileSync } from 'node:fs';
+import path from 'node:path';
+import { createJsxImportSourcePragma, filterJsxSourceExtensions } from './jsx-import-source.utils.js';
+/**
+ * Build plugin that prepends a `@jsxImportSource` pragma to foreign integration
+ * files bundled into a host integration's client graph.
+ *
+ * When a host integration (e.g. React) bundles a component file that belongs to
+ * another JSX integration (e.g. `.kita.tsx`), that file inherits the project
+ * `tsconfig` JSX runtime which produces the wrong output (HTML strings instead
+ * of framework elements). This plugin rewrites the source to explicitly target
+ * the host's JSX factory so the bundler compiles every JSX expression into the
+ * correct element creation calls.
+ *
+ * The plugin is intentionally framework-agnostic: any integration that does
+ * client-side bundling can use it by passing its own `jsxImportSource` and the
+ * set of foreign extensions collected from the app config.
+ *
+ * When no JSX-bearing foreign extensions are present, the returned plugin is a
+ * no-op so integrations can register it unconditionally.
+ */
+export function createForeignJsxOverridePlugin(options) {
+    const extensions = filterJsxSourceExtensions(options.foreignExtensions);
+    const excludedExtensions = filterJsxSourceExtensions(options.excludeExtensions ?? []);
+    if (extensions.length === 0) {
         return {
-          contents: pragma + source,
-          loader,
-          resolveDir: path.dirname(args.path)
+            name: options.name ?? 'foreign-jsx-override',
+            setup() { },
         };
-      });
     }
-  };
+    const pragma = createJsxImportSourcePragma(options.hostJsxImportSource);
+    const filter = new RegExp(`(${extensions.map((e) => e.replace('.', '\\.')).join('|')})$`);
+    return {
+        name: options.name ?? 'foreign-jsx-override',
+        setup(build) {
+            build.onLoad({ filter }, (args) => {
+                if (excludedExtensions.some((extension) => args.path.endsWith(extension))) {
+                    return undefined;
+                }
+                const source = readFileSync(args.path, 'utf-8');
+                const loader = args.path.endsWith('.jsx') ? 'jsx' : 'tsx';
+                if (source.includes('@jsxImportSource')) {
+                    return undefined;
+                }
+                return {
+                    contents: pragma + source,
+                    loader,
+                    resolveDir: path.dirname(args.path),
+                };
+            });
+        },
+    };
 }
-export {
-  createForeignJsxOverridePlugin
-};

package/src/plugins/integration-plugin.d.ts

@@ -1,15 +1,17 @@
-import type { EcoBuildPlugin } from '../build/build-types.js';
-import { type BrowserRuntimeManifest } from '../build/browser-runtime-manifest.js';
+import type { EcoBuildPlugin } from '../build/contracts/build-types.js';
+import { type BrowserRuntimeManifest } from '../build/browser/browser-runtime-manifest.js';
 import type { EcoPagesAppConfig, IHmrManager } from '../types/internal-types.js';
 import type { HmrStrategy } from '../hmr/hmr-strategy.js';
 import type { EcoPagesElement } from '../types/public-types.js';
 import type { IntegrationRenderer } from '../route-renderer/orchestration/integration-renderer.js';
 import { AssetProcessingService } from '../services/assets/asset-processing-service/asset-processing.service.js';
 import type { AssetDefinition, ProcessedAsset } from '../services/assets/asset-processing-service/assets.types.js';
+import type { StaticExportContext } from '../static-site-generator/static-export-context.js';
 import type { RuntimeCapabilityDeclaration } from './runtime-capability.js';
 export type { RuntimeCapabilityDeclaration, RuntimeCapabilityTag } from './runtime-capability.js';
-export type { EcoBuildLoader, EcoBuildOnLoadArgs, EcoBuildOnLoadResult, EcoBuildOnResolveArgs, EcoBuildOnResolveResult, EcoBuildPlugin, EcoBuildPluginBuilder, } from '../build/build-types.js';
+export type { EcoBuildLoader, EcoBuildOnLoadArgs, EcoBuildOnLoadResult, EcoBuildOnResolveArgs, EcoBuildOnResolveResult, EcoBuildPlugin, EcoBuildPluginBuilder, } from '../build/contracts/build-types.js';
 export type { PageBrowserGraphContribution, PageBrowserGraphContributionContext } from '../types/public-types.js';
+export type { StaticExportContext } from '../static-site-generator/static-export-context.js';
 export type { HtmlDocumentContribution, HtmlDocumentContributionContext, } from '../route-renderer/orchestration/integration-renderer.js';
 /**
  * Type-erased integration plugin stored in app-level registries.
@@ -47,13 +49,6 @@ export interface IntegrationPluginConfig {
      * They are not specific to any particular page or component.
      */
     integrationDependencies?: AssetDefinition[];
-    /**
-     * The strategy to use for static building.
-     * - 'render': Execute component function directly (faster, efficient).
-     * - 'fetch': Start server and fetch URL (slower, needed for some SSR like Lit).
-     * @default 'render'
-     */
-    staticBuildStep?: 'render' | 'fetch';
     /**
      * Declares runtime-specific requirements that must be satisfied before the
      * app can start with this integration enabled.
@@ -87,8 +82,11 @@ type RendererClass<C> = new (options: {
  *
  * Core owns lifecycle ordering. Integrations declare contributions through the
  * hooks on this class, while `ConfigBuilder.build()` and app startup decide when
- * those hooks run. For page-browser and document shaping, integrations should
- * prefer the contribution contracts re-exported from this module:
+ * those hooks run. Build plugins map to {@link AppBuildManifest} buckets:
+ * `plugins` → `runtimePlugins`, `browserBuildPlugins` → `browserBundlePlugins`,
+ * `browserRuntimeManifest` → client import rewrite map. For page-browser and
+ * document shaping, integrations should prefer the contribution contracts
+ * re-exported from this module:
  * `PageBrowserGraphContribution` / `PageBrowserGraphContributionContext` and
  * `HtmlDocumentContribution` / `HtmlDocumentContributionContext`.
  */
@@ -96,7 +94,6 @@ export declare abstract class IntegrationPlugin<C = EcoPagesElement> {
     readonly name: string;
     readonly extensions: string[];
     abstract renderer: RendererClass<C>;
-    readonly staticBuildStep: 'render' | 'fetch';
     readonly runtimeCapability?: RuntimeCapabilityDeclaration;
     readonly jsxImportSource?: string;
     protected integrationDependencies: AssetDefinition[];
@@ -106,6 +103,14 @@ export declare abstract class IntegrationPlugin<C = EcoPagesElement> {
     protected assetProcessingService?: AssetProcessingService;
     protected hmrManager?: IHmrManager;
     runtimeOrigin: string;
+    /**
+     * Returns build plugins shared by server-oriented and browser-oriented builds.
+     *
+     * @remarks
+     * Collected into {@link AppBuildManifest.runtimePlugins} during config finalization.
+     * MDX loaders, virtual-module resolvers, and other transforms that must run during
+     * route-module transpile belong here—not in {@link browserBuildPlugins}.
+     */
     get plugins(): EcoBuildPlugin[];
     /**
      * Returns build plugins that should only apply to browser-oriented bundles.
@@ -199,11 +204,18 @@ export declare abstract class IntegrationPlugin<C = EcoPagesElement> {
      * Renderers are cheap runtime objects. They receive the finalized app config,
      * a fresh asset-processing service, integration-global processed assets, and
      * any renderer module context supplied by the active runtime.
-            renderer.name ||= this.name;
      */
     initializeRenderer(options?: {
         rendererModules?: unknown;
     }): IntegrationRenderer<C>;
+    /**
+     * Shapes one dependency batch before core asset processing runs.
+     *
+     * @remarks
+     * Integrations use this to assign grouped-build metadata or other batch-level
+     * policy without teaching core about integration-specific asset graphs.
+     */
+    prepareAssetDependencies?(dependencies: AssetDefinition[]): AssetDefinition[];
     /**
      * Prepares build-facing contributions before the app build manifest is sealed.
      *
@@ -213,6 +225,23 @@ export declare abstract class IntegrationPlugin<C = EcoPagesElement> {
      * `setup()`.
      */
     prepareBuildContributions(): Promise<void>;
+    /**
+     * Reports whether this integration's build inputs changed since the last
+     * incremental static build.
+     */
+    didChange(): boolean;
+    /**
+     * Runs integration-specific setup before static page generation begins.
+     *
+     * @remarks
+     * Integrations that need build-scoped SSR preload or worker sessions should
+     * start them here rather than per-page inside the renderer.
+     */
+    beforeStaticExport?(_context: StaticExportContext): Promise<void>;
+    /**
+     * Releases resources started in {@link beforeStaticExport}.
+     */
+    afterStaticExport?(_context: StaticExportContext): Promise<void>;
     /**
      * Performs runtime-only integration setup after config build has already
      * sealed manifest contributions.

package/src/plugins/integration-plugin.js

@@ -1,201 +1,223 @@
-import { createBrowserRuntimeManifest } from "../build/browser-runtime-manifest.js";
-import { AssetProcessingService } from "../services/assets/asset-processing-service/asset-processing.service.js";
-import { deepMerge } from "../utils/deep-merge.js";
-import { invariant } from "../utils/invariant.js";
-const INTEGRATION_PLUGIN_ERRORS = {
-  NOT_INITIALIZED_WITH_APP_CONFIG: "Plugin not initialized with app config",
-  NOT_INITIALIZED_WITH_ASSET_SERVICE: "Plugin not initialized with asset dependency service"
+import { createBrowserRuntimeManifest, } from '../build/browser/browser-runtime-manifest.js';
+import { AssetProcessingService } from '../services/assets/asset-processing-service/asset-processing.service.js';
+import { deepMerge } from '../utils/deep-merge.js';
+import { invariant } from '../utils/invariant.js';
+export const INTEGRATION_PLUGIN_ERRORS = {
+    NOT_INITIALIZED_WITH_APP_CONFIG: 'Plugin not initialized with app config',
+    NOT_INITIALIZED_WITH_ASSET_SERVICE: 'Plugin not initialized with asset dependency service',
 };
-function mergeIntegrationOptions(defaults, overrides) {
-  return deepMerge(defaults, overrides);
+export function mergeIntegrationOptions(defaults, overrides) {
+    return deepMerge(defaults, overrides);
 }
-function assertIntegrationInvariant(condition, message) {
-  invariant(condition, message);
+export function assertIntegrationInvariant(condition, message) {
+    invariant(condition, message);
 }
-class IntegrationPlugin {
-  name;
-  extensions;
-  staticBuildStep;
-  runtimeCapability;
-  jsxImportSource;
-  integrationDependencies;
-  resolvedIntegrationDependencies = [];
-  options;
-  appConfig;
-  assetProcessingService;
-  hmrManager;
-  get plugins() {
-    return [];
-  }
-  /**
-   * Returns build plugins that should only apply to browser-oriented bundles.
-   *
-   * @remarks
-   * Browser-only transforms such as runtime import aliasing belong here so they
-   * do not affect server bundles or static-page module generation.
-   */
-  get browserBuildPlugins() {
-    return [];
-  }
-  /**
-   * Returns shared browser runtime asset declarations owned by this integration.
-   *
-   * @remarks
-   * Core seals these declarations into the app build manifest so app-owned browser
-   * bundle paths can rewrite manifest-owned imports even when a specific build
-   * request does not install an integration-local runtime rewrite plugin.
-   */
-  get browserRuntimeManifest() {
-    return createBrowserRuntimeManifest();
-  }
-  /**
-   * Creates the integration with static declaration-only configuration.
-   *
-   * @remarks
-   * Constructors are expected to stay side-effect free. Build-manifest
-   * contributions belong in `prepareBuildContributions()` and runtime-only setup
-   * belongs in `setup()`.
-   */
-  constructor(config) {
-    this.name = config.name;
-    this.extensions = config.extensions;
-    this.integrationDependencies = config.integrationDependencies || [];
-    this.staticBuildStep = config.staticBuildStep || "render";
-    this.runtimeCapability = config.runtimeCapability;
-    this.jsxImportSource = config.jsxImportSource;
-  }
-  /**
-   * Attaches the finalized app config to the integration.
-   *
-   * Core calls this during config finalization before runtime setup so the
-   * integration can resolve asset paths and other app-owned services later.
-   */
-  setConfig(appConfig) {
-    this.appConfig = appConfig;
-    this.initializeAssetDefinitionService();
-  }
-  /**
-   * Records the runtime origin used for page-module loading and renderer setup.
-   */
-  setRuntimeOrigin(runtimeOrigin) {
-    this.runtimeOrigin = runtimeOrigin;
-  }
-  /**
-   * Attaches the shared HMR manager and registers integration-owned development hooks.
-   *
-   * @remarks
-   * The default implementation registers the optional integration HMR strategy.
-   * Integrations should override this only when they need to extend that shared
-   * behavior rather than replace it.
-   */
-  setHmrManager(hmrManager) {
-    this.hmrManager = hmrManager;
-    const strategy = this.getHmrStrategy?.();
-    if (strategy) {
-      hmrManager.registerStrategy(strategy);
+/**
+ * Base class for framework integrations.
+ *
+ * @remarks
+ * An integration owns three main concerns:
+ * - which file extensions it claims
+ * - which renderer class turns those files into HTML
+ * - which build-time or runtime contributions must be registered for that framework
+ *
+ * Core owns lifecycle ordering. Integrations declare contributions through the
+ * hooks on this class, while `ConfigBuilder.build()` and app startup decide when
+ * those hooks run. Build plugins map to {@link AppBuildManifest} buckets:
+ * `plugins` → `runtimePlugins`, `browserBuildPlugins` → `browserBundlePlugins`,
+ * `browserRuntimeManifest` → client import rewrite map. For page-browser and
+ * document shaping, integrations should prefer the contribution contracts
+ * re-exported from this module:
+ * `PageBrowserGraphContribution` / `PageBrowserGraphContributionContext` and
+ * `HtmlDocumentContribution` / `HtmlDocumentContributionContext`.
+ */
+export class IntegrationPlugin {
+    name;
+    extensions;
+    runtimeCapability;
+    jsxImportSource;
+    integrationDependencies;
+    resolvedIntegrationDependencies = [];
+    options;
+    appConfig;
+    assetProcessingService;
+    hmrManager;
+    /**
+     * Returns build plugins shared by server-oriented and browser-oriented builds.
+     *
+     * @remarks
+     * Collected into {@link AppBuildManifest.runtimePlugins} during config finalization.
+     * MDX loaders, virtual-module resolvers, and other transforms that must run during
+     * route-module transpile belong here—not in {@link browserBuildPlugins}.
+     */
+    get plugins() {
+        return [];
     }
-    if (this.assetProcessingService) {
-      this.assetProcessingService.setHmrManager(hmrManager);
+    /**
+     * Returns build plugins that should only apply to browser-oriented bundles.
+     *
+     * @remarks
+     * Browser-only transforms such as runtime import aliasing belong here so they
+     * do not affect server bundles or static-page module generation.
+     */
+    get browserBuildPlugins() {
+        return [];
     }
-  }
-  /**
-   * Creates the asset-processing service used for global integration dependencies.
-   */
-  initializeAssetDefinitionService() {
-    if (!this.appConfig) throw new Error(INTEGRATION_PLUGIN_ERRORS.NOT_INITIALIZED_WITH_APP_CONFIG);
-    this.assetProcessingService = AssetProcessingService.createWithDefaultProcessors(this.appConfig);
-    if (this.hmrManager) {
-      this.assetProcessingService.setHmrManager(this.hmrManager);
+    /**
+     * Returns shared browser runtime asset declarations owned by this integration.
+     *
+     * @remarks
+     * Core seals these declarations into the app build manifest so app-owned browser
+     * bundle paths can rewrite manifest-owned imports even when a specific build
+     * request does not install an integration-local runtime rewrite plugin.
+     */
+    get browserRuntimeManifest() {
+        return createBrowserRuntimeManifest();
     }
-  }
-  /**
-   * Returns processed global assets resolved during `setup()`.
-   */
-  getResolvedIntegrationDependencies() {
-    return this.resolvedIntegrationDependencies;
-  }
-  /**
-   * Creates the shared renderer options owned by core lifecycle setup.
-   */
-  createRendererOptions(options) {
-    if (!this.appConfig) {
-      throw new Error(INTEGRATION_PLUGIN_ERRORS.NOT_INITIALIZED_WITH_APP_CONFIG);
+    /**
+     * Creates the integration with static declaration-only configuration.
+     *
+     * @remarks
+     * Constructors are expected to stay side-effect free. Build-manifest
+     * contributions belong in `prepareBuildContributions()` and runtime-only setup
+     * belongs in `setup()`.
+     */
+    constructor(config) {
+        this.name = config.name;
+        this.extensions = config.extensions;
+        this.integrationDependencies = config.integrationDependencies || [];
+        this.runtimeCapability = config.runtimeCapability;
+        this.jsxImportSource = config.jsxImportSource;
     }
-    const assetProcessingService = AssetProcessingService.createWithDefaultProcessors(this.appConfig);
-    if (this.hmrManager) {
-      assetProcessingService.setHmrManager(this.hmrManager);
+    /**
+     * Attaches the finalized app config to the integration.
+     *
+     * Core calls this during config finalization before runtime setup so the
+     * integration can resolve asset paths and other app-owned services later.
+     */
+    setConfig(appConfig) {
+        this.appConfig = appConfig;
+        this.initializeAssetDefinitionService();
     }
-    return {
-      appConfig: this.appConfig,
-      assetProcessingService,
-      resolvedIntegrationDependencies: this.resolvedIntegrationDependencies,
-      rendererModules: options?.rendererModules,
-      runtimeOrigin: this.runtimeOrigin
-    };
-  }
-  /**
-   * Attaches runtime-only services after a renderer instance has been created.
-   */
-  attachRendererRuntimeServices(renderer) {
-    if (typeof renderer.name !== "string" || renderer.name.length === 0) {
-      renderer.name = this.name;
+    /**
+     * Records the runtime origin used for page-module loading and renderer setup.
+     */
+    setRuntimeOrigin(runtimeOrigin) {
+        this.runtimeOrigin = runtimeOrigin;
     }
-    if (this.hmrManager) {
-      renderer.setHmrManager(this.hmrManager);
+    /**
+     * Attaches the shared HMR manager and registers integration-owned development hooks.
+     *
+     * @remarks
+     * The default implementation registers the optional integration HMR strategy.
+     * Integrations should override this only when they need to extend that shared
+     * behavior rather than replace it.
+     */
+    setHmrManager(hmrManager) {
+        this.hmrManager = hmrManager;
+        const strategy = this.getHmrStrategy?.();
+        if (strategy) {
+            hmrManager.registerStrategy(strategy);
+        }
+        if (this.assetProcessingService) {
+            this.assetProcessingService.setHmrManager(hmrManager);
+        }
     }
-    return renderer;
-  }
-  /**
-   * Instantiates the integration renderer with app-owned services.
-   *
-   * @remarks
-   * Renderers are cheap runtime objects. They receive the finalized app config,
-   * a fresh asset-processing service, integration-global processed assets, and
-   * any renderer module context supplied by the active runtime.
-  		renderer.name ||= this.name;
-   */
-  initializeRenderer(options) {
-    const renderer = new this.renderer(this.createRendererOptions(options));
-    renderer.name ||= this.name;
-    return this.attachRendererRuntimeServices(renderer);
-  }
-  /**
-   * Prepares build-facing contributions before the app build manifest is sealed.
-   *
-   * @remarks
-   * Integrations can override this when runtime or build plugin declarations must
-   * be materialized ahead of runtime startup. Runtime-only side effects stay in
-   * `setup()`.
-   */
-  async prepareBuildContributions() {
-  }
-  /**
-   * Performs runtime-only integration setup after config build has already
-   * sealed manifest contributions.
-   */
-  async setup() {
-    if (this.integrationDependencies.length === 0) return;
-    if (!this.assetProcessingService) throw new Error(INTEGRATION_PLUGIN_ERRORS.NOT_INITIALIZED_WITH_ASSET_SERVICE);
-    this.resolvedIntegrationDependencies = await this.assetProcessingService.processDependencies(
-      this.integrationDependencies,
-      this.name
-    );
-    this.initializeRenderer();
-  }
-  /**
-   * Releases runtime resources owned by the integration.
-   *
-   * @remarks
-   * Most integrations do not need custom teardown. Override this only for
-   * explicit cleanup such as watchers, compiler handles, or runtime registries
-   * that outlive individual requests.
-   */
-  async teardown() {
-  }
+    /**
+     * Creates the asset-processing service used for global integration dependencies.
+     */
+    initializeAssetDefinitionService() {
+        if (!this.appConfig)
+            throw new Error(INTEGRATION_PLUGIN_ERRORS.NOT_INITIALIZED_WITH_APP_CONFIG);
+        this.assetProcessingService = AssetProcessingService.createWithDefaultProcessors(this.appConfig);
+        if (this.hmrManager) {
+            this.assetProcessingService.setHmrManager(this.hmrManager);
+        }
+    }
+    /**
+     * Returns processed global assets resolved during `setup()`.
+     */
+    getResolvedIntegrationDependencies() {
+        return this.resolvedIntegrationDependencies;
+    }
+    /**
+     * Creates the shared renderer options owned by core lifecycle setup.
+     */
+    createRendererOptions(options) {
+        if (!this.appConfig) {
+            throw new Error(INTEGRATION_PLUGIN_ERRORS.NOT_INITIALIZED_WITH_APP_CONFIG);
+        }
+        const assetProcessingService = AssetProcessingService.createWithDefaultProcessors(this.appConfig);
+        if (this.hmrManager) {
+            assetProcessingService.setHmrManager(this.hmrManager);
+        }
+        return {
+            appConfig: this.appConfig,
+            assetProcessingService,
+            resolvedIntegrationDependencies: this.resolvedIntegrationDependencies,
+            rendererModules: options?.rendererModules,
+            runtimeOrigin: this.runtimeOrigin,
+        };
+    }
+    /**
+     * Attaches runtime-only services after a renderer instance has been created.
+     */
+    attachRendererRuntimeServices(renderer) {
+        if (typeof renderer.name !== 'string' || renderer.name.length === 0) {
+            renderer.name = this.name;
+        }
+        if (this.hmrManager) {
+            renderer.setHmrManager(this.hmrManager);
+        }
+        return renderer;
+    }
+    /**
+     * Instantiates the integration renderer with app-owned services.
+     *
+     * @remarks
+     * Renderers are cheap runtime objects. They receive the finalized app config,
+     * a fresh asset-processing service, integration-global processed assets, and
+     * any renderer module context supplied by the active runtime.
+     */
+    initializeRenderer(options) {
+        const renderer = new this.renderer(this.createRendererOptions(options));
+        renderer.name ||= this.name;
+        return this.attachRendererRuntimeServices(renderer);
+    }
+    /**
+     * Prepares build-facing contributions before the app build manifest is sealed.
+     *
+     * @remarks
+     * Integrations can override this when runtime or build plugin declarations must
+     * be materialized ahead of runtime startup. Runtime-only side effects stay in
+     * `setup()`.
+     */
+    async prepareBuildContributions() { }
+    /**
+     * Reports whether this integration's build inputs changed since the last
+     * incremental static build.
+     */
+    didChange() {
+        return false;
+    }
+    /**
+     * Performs runtime-only integration setup after config build has already
+     * sealed manifest contributions.
+     */
+    async setup() {
+        if (this.integrationDependencies.length === 0)
+            return;
+        if (!this.assetProcessingService)
+            throw new Error(INTEGRATION_PLUGIN_ERRORS.NOT_INITIALIZED_WITH_ASSET_SERVICE);
+        this.resolvedIntegrationDependencies = await this.assetProcessingService.processDependencies(this.integrationDependencies, this.name);
+    }
+    /**
+     * Releases runtime resources owned by the integration.
+     *
+     * @remarks
+     * Most integrations do not need custom teardown. Override this only for
+     * explicit cleanup such as watchers, compiler handles, or runtime registries
+     * that outlive individual requests.
+     */
+    async teardown() { }
 }
-export {
-  INTEGRATION_PLUGIN_ERRORS,
-  IntegrationPlugin,
-  assertIntegrationInvariant,
-  mergeIntegrationOptions
-};

package/src/plugins/jsx-import-source.utils.d.ts

@@ -0,0 +1,8 @@
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
+export declare function createJsxImportSourcePragma(jsxImportSource: string): string;
+export declare function prependJsxImportSourceIfMissing(code: string, jsxImportSource: string | undefined): string;
+export declare function isJsxSourceExtension(extension: string): boolean;
+export declare function filterJsxSourceExtensions(extensions: string[]): string[];
+export declare function collectJsxExtensions(integrations: NonNullable<EcoPagesAppConfig['integrations']>, options?: {
+    excludeIntegrationName?: string;
+}): string[];

package/src/plugins/jsx-import-source.utils.js

@@ -0,0 +1,21 @@
+export function createJsxImportSourcePragma(jsxImportSource) {
+    return `/** @jsxImportSource ${jsxImportSource} */\n`;
+}
+export function prependJsxImportSourceIfMissing(code, jsxImportSource) {
+    if (!jsxImportSource || code.includes('@jsxImportSource')) {
+        return code;
+    }
+    return createJsxImportSourcePragma(jsxImportSource) + code;
+}
+export function isJsxSourceExtension(extension) {
+    return extension.endsWith('.tsx') || extension.endsWith('.jsx');
+}
+export function filterJsxSourceExtensions(extensions) {
+    return extensions.filter(isJsxSourceExtension);
+}
+export function collectJsxExtensions(integrations, options) {
+    return integrations
+        .filter((integration) => integration.jsxImportSource)
+        .filter((integration) => integration.name !== options?.excludeIntegrationName)
+        .flatMap((integration) => filterJsxSourceExtensions(integration.extensions));
+}