@ecopages/core 0.2.0-alpha.22 → 0.2.0-alpha.24

package/src/plugins/eco-component-meta-plugin.js

@@ -1,163 +0,0 @@
-import path from "node:path";
-import { parseSync } from "oxc-parser";
-import { rapidhash } from "../utils/hash.js";
-import {
-  createEcoBuildPluginFromSourceTransform,
-  createVitePluginFromSourceTransform
-} from "./source-transform.js";
-const REGEX_SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
-const VALID_LOADER_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"]);
-function hasValidLoaderExtension(ext) {
-  for (const validExt of VALID_LOADER_EXTENSIONS) {
-    if (ext.endsWith(validExt)) {
-      return true;
-    }
-  }
-  return false;
-}
-function buildExtensionToIntegrationMap(integrations) {
-  const mapping = [];
-  for (const integration of integrations) {
-    for (const ext of integration.extensions) {
-      mapping.push([ext, integration.name]);
-    }
-  }
-  mapping.sort((a, b) => b[0].length - a[0].length);
-  return mapping;
-}
-function detectIntegration(filePath, extensionToIntegration) {
-  for (const [ext, integration] of extensionToIntegration) {
-    if (filePath.endsWith(ext)) {
-      return integration;
-    }
-  }
-  return "ghtml";
-}
-function createExtensionPattern(extensions) {
-  if (extensions.length === 0) {
-    throw new Error("[eco-component-meta-plugin] No extensions configured. At least one integration is required.");
-  }
-  const uniqueExtensions = [...new Set(extensions)];
-  const escaped = uniqueExtensions.map((ext) => ext.replace(REGEX_SPECIAL_CHARS, "\\$&"));
-  return new RegExp(`(${escaped.join("|")})(\\?.*)?$`);
-}
-function createEcoComponentMetaTransform(options) {
-  const allExtensions = options.config.integrations.flatMap((integration) => integration.extensions).filter(hasValidLoaderExtension);
-  if (allExtensions.length === 0) {
-    throw new Error("[eco-component-meta-plugin] No extensions configured. At least one integration is required.");
-  }
-  const extensionPattern = createExtensionPattern(allExtensions);
-  const extensionToIntegration = buildExtensionToIntegrationMap(options.config.integrations);
-  return {
-    name: "eco-component-meta-plugin",
-    enforce: "pre",
-    filter: extensionPattern,
-    transform(code, id) {
-      const integration = detectIntegration(id, extensionToIntegration);
-      return {
-        code: injectEcoMeta(code, id, integration)
-      };
-    }
-  };
-}
-function createEcoComponentMetaPlugin(options) {
-  return createEcoBuildPluginFromSourceTransform(createEcoComponentMetaTransform(options));
-}
-function createEcoComponentMetaVitePlugin(options) {
-  return createVitePluginFromSourceTransform(createEcoComponentMetaTransform(options));
-}
-function findInjectionPoints(node, insertions, injection, isInsideEcoComponent = false) {
-  if (!node || typeof node !== "object") return;
-  const n = node;
-  if (n.type === "CallExpression") {
-    const callee = n.callee;
-    if (callee?.type === "MemberExpression" || callee?.type === "StaticMemberExpression") {
-      const obj = callee.object;
-      const prop = callee.property;
-      if (obj?.type === "Identifier" && obj?.name === "eco" && (prop?.name === "page" || prop?.name === "component" || prop?.name === "html" || prop?.name === "layout")) {
-        const args = n.arguments;
-        const firstArg = args?.[0];
-        if (firstArg?.type === "ObjectExpression") {
-          const start = firstArg.start;
-          if (typeof start === "number") {
-            insertions.push({ position: start + 1, text: injection });
-          }
-        }
-      }
-    }
-  }
-  if (n.type === "AssignmentExpression") {
-    const left = n.left;
-    const right = n.right;
-    if (left?.type === "MemberExpression" || left?.type === "StaticMemberExpression") {
-      const prop = left.property;
-      if (prop?.name === "config" && right?.type === "ObjectExpression") {
-        const start = right.start;
-        if (typeof start === "number") {
-          insertions.push({ position: start + 1, text: injection });
-        }
-      }
-    }
-  }
-  if (n.type === "ObjectProperty" || n.type === "Property") {
-    const key = n.key;
-    const value = n.value;
-    if ((key?.type === "Identifier" || key?.type === "IdentifierName") && key?.name === "config" && value?.type === "ObjectExpression" && isInsideEcoComponent) {
-      const start = value.start;
-      if (typeof start === "number") {
-        insertions.push({ position: start + 1, text: injection });
-      }
-    }
-  }
-  let childIsInsideEcoComponent = isInsideEcoComponent;
-  if (n.type === "VariableDeclarator") {
-    const id = n.id;
-    const typeAnnotation = id?.typeAnnotation;
-    if (typeAnnotation) {
-      const typeStr = JSON.stringify(typeAnnotation);
-      if (typeStr.includes("EcoComponent")) {
-        childIsInsideEcoComponent = true;
-      }
-    }
-  }
-  for (const key in n) {
-    if (key === "start" || key === "end" || key === "type") continue;
-    const value = n[key];
-    if (Array.isArray(value)) {
-      for (const child of value) {
-        findInjectionPoints(child, insertions, injection, childIsInsideEcoComponent);
-      }
-    } else if (typeof value === "object" && value !== null) {
-      findInjectionPoints(value, insertions, injection, childIsInsideEcoComponent);
-    }
-  }
-}
-function injectEcoMeta(contents, filePath, integration) {
-  const result = parseSync(filePath, contents);
-  if (result.errors.length > 0) {
-    console.warn(`[eco-component-meta-plugin] Parse errors in ${filePath}:`, result.errors);
-    return contents;
-  }
-  const ast = result.program;
-  const id = rapidhash(filePath).toString(36);
-  const injection = ` __eco: { id: "${id}", file: "${filePath}", integration: "${integration}" },`;
-  const insertions = [];
-  findInjectionPoints(ast, insertions, injection);
-  if (insertions.length === 0) {
-    return contents;
-  }
-  insertions.sort((a, b) => b.position - a.position);
-  let transformed = contents;
-  for (const { position, text } of insertions) {
-    transformed = transformed.slice(0, position) + text + transformed.slice(position);
-  }
-  return transformed;
-}
-var eco_component_meta_plugin_default = createEcoComponentMetaPlugin;
-export {
-  createEcoComponentMetaPlugin,
-  createEcoComponentMetaTransform,
-  createEcoComponentMetaVitePlugin,
-  eco_component_meta_plugin_default as default,
-  injectEcoMeta
-};

package/src/plugins/foreign-jsx-override-plugin.d.ts

@@ -1,31 +0,0 @@
-import type { EcoBuildPlugin } from '../build/build-types.js';
-/**
- * Options for the shared foreign-JSX override build plugin.
- */
-export interface ForeignJsxOverrideOptions {
-    /** JSX runtime that should own the transformed foreign files. */
-    hostJsxImportSource: string;
-    /** Extensions claimed by other JSX integrations that may appear in the host graph. */
-    foreignExtensions: string[];
-    /** Optional plugin name override for debug output. */
-    name?: string;
-}
-/**
- * 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 esbuild 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 declare function createForeignJsxOverridePlugin(options: ForeignJsxOverrideOptions): EcoBuildPlugin;

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

@@ -1,35 +0,0 @@
-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"));
-  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) => {
-        const source = readFileSync(args.path, "utf-8");
-        const loader = args.path.endsWith(".jsx") ? "jsx" : "tsx";
-        if (source.includes("@jsxImportSource")) {
-          return void 0;
-        }
-        return {
-          contents: pragma + source,
-          loader,
-          resolveDir: path.dirname(args.path)
-        };
-      });
-    }
-  };
-}
-export {
-  createForeignJsxOverridePlugin
-};

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

@@ -1,219 +0,0 @@
-import type { EcoBuildPlugin } from '../build/build-types.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 { RuntimeCapabilityDeclaration } from './runtime-capability.js';
-export type { RuntimeCapabilityDeclaration, RuntimeCapabilityTag } from './runtime-capability.js';
-export declare const INTEGRATION_PLUGIN_ERRORS: {
-    readonly NOT_INITIALIZED_WITH_APP_CONFIG: "Plugin not initialized with app config";
-    readonly NOT_INITIALIZED_WITH_ASSET_SERVICE: "Plugin not initialized with asset dependency service";
-};
-/**
- * Base configuration shared by all integration plugins.
- *
- * @remarks
- * Integrations declare their file ownership, optional runtime requirements, and
- * any global assets or build-time contributions here. Runtime-only side effects
- * belong in `setup()` rather than the constructor.
- */
-export interface IntegrationPluginConfig {
-    /**
-     * The name of the integration plugin.
-     */
-    name: string;
-    /**
-     * The extensions that this plugin supports (e.g., ['.kita.js', '.kita.tsx']).
-     */
-    extensions: string[];
-    /**
-     * The dependencies that this plugin requires on a global level.
-     * These dependencies will be resolved during the setup process and injected into the global scope of the application.
-     * 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.
-     */
-    runtimeCapability?: RuntimeCapabilityDeclaration;
-    /**
-     * JSX import source owned by this integration.
-     *
-     * @remarks
-     * This is primarily used by mixed-JSX flows where host-owned browser bundles
-     * need to preserve the correct JSX runtime for files claimed by the
-     * integration.
-     */
-    jsxImportSource?: string;
-}
-type RendererClass<C> = new (options: {
-    appConfig: EcoPagesAppConfig;
-    assetProcessingService: AssetProcessingService;
-    resolvedIntegrationDependencies: ProcessedAsset[];
-    rendererModules?: unknown;
-    runtimeOrigin: string;
-}) => IntegrationRenderer<C>;
-/**
- * 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.
- */
-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[];
-    protected resolvedIntegrationDependencies: ProcessedAsset[];
-    protected options?: Record<string, unknown>;
-    protected appConfig?: EcoPagesAppConfig;
-    protected assetProcessingService?: AssetProcessingService;
-    protected hmrManager?: IHmrManager;
-    runtimeOrigin: string;
-    get plugins(): EcoBuildPlugin[];
-    /**
-     * 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(): EcoBuildPlugin[];
-    /**
-     * 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: IntegrationPluginConfig);
-    /**
-     * 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: EcoPagesAppConfig): void;
-    /**
-     * Records the runtime origin used for page-module loading and renderer setup.
-     */
-    setRuntimeOrigin(runtimeOrigin: string): void;
-    /**
-     * Returns an HMR strategy for this integration, if applicable.
-     * The strategy will be registered with the HmrManager during initialization.
-     *
-     * @returns HmrStrategy instance or undefined if no custom HMR handling needed
-     *
-     * @example
-     * ```typescript
-     * getHmrStrategy(): HmrStrategy {
-     *   const context = this.hmrManager!.getDefaultContext();
-     *   return new ReactHmrStrategy(context);
-     * }
-     * ```
-     */
-    getHmrStrategy?(): HmrStrategy | undefined;
-    /**
-     * Returns bare-specifier mappings that should be registered in the active
-     * runtime specifier registry.
-     *
-     * @remarks
-     * Integrations that own browser runtime bundles can override this to expose
-     * stable bare specifiers for client-side imports.
-     *
-     * Today these mappings are consumed by the development runtime and browser
-     * bundle aliasing path. They are intentionally generic enough to grow into a
-     * broader import-map-style facility later without moving framework-specific
-     * map contents into core.
-     */
-    getRuntimeSpecifierMap(): Record<string, string>;
-    /**
-     * Attaches the shared HMR manager and registers integration-owned development hooks.
-     *
-     * @remarks
-     * The default implementation registers both runtime bare-specifier mappings and
-     * the optional integration HMR strategy. Integrations should override this only
-     * when they need to extend that shared behavior rather than replace it.
-     */
-    setHmrManager(hmrManager: IHmrManager): void;
-    /**
-     * Creates the asset-processing service used for global integration dependencies.
-     */
-    initializeAssetDefinitionService(): void;
-    /**
-     * Returns processed global assets resolved during `setup()`.
-     */
-    getResolvedIntegrationDependencies(): ProcessedAsset[];
-    /**
-     * Creates the shared renderer options owned by core lifecycle setup.
-     */
-    protected createRendererOptions(options?: {
-        rendererModules?: unknown;
-    }): {
-        appConfig: EcoPagesAppConfig;
-        assetProcessingService: AssetProcessingService;
-        resolvedIntegrationDependencies: ProcessedAsset[];
-        rendererModules: unknown;
-        runtimeOrigin: string;
-    };
-    /**
-     * Attaches runtime-only services after a renderer instance has been created.
-     */
-    protected attachRendererRuntimeServices<T extends IntegrationRenderer<C>>(renderer: T): T;
-    /**
-     * 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?: {
-        rendererModules?: unknown;
-    }): IntegrationRenderer<C>;
-    /**
-     * 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()`.
-     */
-    prepareBuildContributions(): Promise<void>;
-    /**
-     * Performs runtime-only integration setup after config build has already
-     * sealed manifest contributions.
-     */
-    setup(): Promise<void>;
-    /**
-     * 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.
-     */
-    teardown(): Promise<void>;
-}

package/src/plugins/integration-plugin.js

@@ -1,196 +0,0 @@
-import { AssetProcessingService } from "../services/assets/asset-processing-service/asset-processing.service.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"
-};
-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 [];
-  }
-  /**
-   * 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;
-  }
-  /**
-   * Returns bare-specifier mappings that should be registered in the active
-   * runtime specifier registry.
-   *
-   * @remarks
-   * Integrations that own browser runtime bundles can override this to expose
-   * stable bare specifiers for client-side imports.
-   *
-   * Today these mappings are consumed by the development runtime and browser
-   * bundle aliasing path. They are intentionally generic enough to grow into a
-   * broader import-map-style facility later without moving framework-specific
-   * map contents into core.
-   */
-  getRuntimeSpecifierMap() {
-    return {};
-  }
-  /**
-   * Attaches the shared HMR manager and registers integration-owned development hooks.
-   *
-   * @remarks
-   * The default implementation registers both runtime bare-specifier mappings and
-   * 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;
-    hmrManager.registerSpecifierMap(this.getRuntimeSpecifierMap());
-    const strategy = this.getHmrStrategy?.();
-    if (strategy) {
-      hmrManager.registerStrategy(strategy);
-    }
-    if (this.assetProcessingService) {
-      this.assetProcessingService.setHmrManager(hmrManager);
-    }
-  }
-  /**
-   * 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.
-  		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() {
-  }
-}
-export {
-  INTEGRATION_PLUGIN_ERRORS,
-  IntegrationPlugin
-};