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

package/src/plugins/alias-resolver-plugin.d.ts

@@ -1,6 +1,6 @@
-import type { EcoBuildPlugin } from '../build/build-types.js';
+import type { EcoBuildPlugin } from '../build/contracts/build-types.js';
 import { AliasResolverCache } from './alias-resolver-cache.js';
-export declare function resolveAppSourceAliasPath(srcDir: string, specifier: string): string | undefined;
-export declare function createAliasResolverPlugin(srcDir: string, options?: {
+export declare function createAliasResolverPlugin(projectRoot: string, options?: {
     cache?: AliasResolverCache;
 }): EcoBuildPlugin;
+export { isBarePackageImportSpecifier, matchesTsconfigPathPrefix, loadTsconfigPathPrefixes, resolveProjectImportPath, resolveProjectModulePath, } from './tsconfig-import-resolver.js';

package/src/plugins/alias-resolver-plugin.js

@@ -1,65 +1,38 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { AliasResolverCache } from "./alias-resolver-cache.js";
-const RESOLVABLE_EXTENSIONS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mdx", ".css", ".scss", ".sass", ".less"];
-function findResolvablePath(candidate) {
-  if (path.extname(candidate)) {
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  for (const extension of RESOLVABLE_EXTENSIONS) {
-    const fileCandidate = `${candidate}${extension}`;
-    if (existsSync(fileCandidate)) {
-      return fileCandidate;
-    }
-  }
-  for (const extension of RESOLVABLE_EXTENSIONS) {
-    const indexCandidate = path.join(candidate, `index${extension}`);
-    if (existsSync(indexCandidate)) {
-      return indexCandidate;
-    }
-  }
-  return void 0;
+import { AliasResolverCache } from './alias-resolver-cache.js';
+import { loadTsconfigPathPrefixes, resolveProjectImportPath } from './tsconfig-import-resolver.js';
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
-function resolveAliasedBarrelTarget(resolvedPath) {
-  if (!path.basename(resolvedPath).startsWith("index.")) {
-    return resolvedPath;
-  }
-  const source = readFileSync(resolvedPath, "utf8").trim();
-  const match = source.match(/^export\s+\*\s+from\s+['"]([^'"]+)['"]\s*;?$/);
-  if (!match?.[1]?.startsWith(".")) {
-    return resolvedPath;
-  }
-  const target = findResolvablePath(path.resolve(path.dirname(resolvedPath), match[1]));
-  return target ?? resolvedPath;
-}
-function resolveAppSourceAliasPath(srcDir, specifier) {
-  if (!specifier.startsWith("@/")) {
-    return void 0;
-  }
-  const candidate = path.join(srcDir, specifier.slice(2));
-  const resolved = findResolvablePath(candidate);
-  return resolved ? resolveAliasedBarrelTarget(resolved) : void 0;
-}
-function createAliasResolverPlugin(srcDir, options) {
-  const cache = options?.cache ?? new AliasResolverCache();
-  return {
-    name: "ecopages-alias-resolver",
-    setup(build) {
-      build.onResolve({ filter: /^@\// }, (args) => {
-        const cached = cache.get(srcDir, args.path);
-        if (cached.hit) {
-          return cached.resolved ? { path: cached.resolved } : {};
-        }
-        const resolved = resolveAppSourceAliasPath(srcDir, args.path);
-        cache.set(srcDir, args.path, resolved);
-        return resolved ? { path: resolved } : {};
-      });
+function buildPathPrefixFilter(prefix) {
+    if (prefix.endsWith('/')) {
+        return new RegExp(`^${escapeRegExp(prefix)}`);
     }
-  };
+    return new RegExp(`^${escapeRegExp(prefix)}(?:/|$)`);
+}
+export function createAliasResolverPlugin(projectRoot, options) {
+    const cache = options?.cache ?? new AliasResolverCache();
+    const pathPrefixes = loadTsconfigPathPrefixes(projectRoot);
+    return {
+        name: 'ecopages-alias-resolver',
+        setup(build) {
+            if (pathPrefixes.length === 0) {
+                return;
+            }
+            for (const prefix of pathPrefixes) {
+                build.onResolve({ filter: buildPathPrefixFilter(prefix) }, (args) => {
+                    if (!args.importer) {
+                        return undefined;
+                    }
+                    const cached = cache.get(projectRoot, args.path);
+                    if (cached.hit) {
+                        return cached.resolved ? { path: cached.resolved } : undefined;
+                    }
+                    const resolved = resolveProjectImportPath(projectRoot, args.importer, args.path);
+                    cache.set(projectRoot, args.path, resolved);
+                    return resolved ? { path: resolved } : undefined;
+                });
+            }
+        },
+    };
 }
-export {
-  createAliasResolverPlugin,
-  resolveAppSourceAliasPath
-};
+export { isBarePackageImportSpecifier, matchesTsconfigPathPrefix, loadTsconfigPathPrefixes, resolveProjectImportPath, resolveProjectModulePath, } from './tsconfig-import-resolver.js';

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

@@ -0,0 +1,26 @@
+import type { EcoPagesAppConfig } from '../types/internal-types.js';
+import type { AssetProcessingService } from '../services/assets/asset-processing-service/asset-processing.service.js';
+import type { ProcessedAsset } from '../services/assets/asset-processing-service/assets.types.js';
+import type { EcoPagesElement } from '../types/public-types.js';
+import type { IntegrationRenderer } from '../route-renderer/orchestration/integration-renderer.js';
+import { IntegrationPlugin, type IntegrationPluginConfig } from './integration-plugin.js';
+type RendererClass<C> = new (options: {
+    appConfig: EcoPagesAppConfig;
+    assetProcessingService: AssetProcessingService;
+    resolvedIntegrationDependencies: ProcessedAsset[];
+    rendererModules?: unknown;
+    runtimeOrigin: string;
+}) => IntegrationRenderer<C>;
+export interface DefineIntegrationDefinition<C = EcoPagesElement> extends IntegrationPluginConfig {
+    renderer: RendererClass<C>;
+}
+export interface DefinedIntegration<C = EcoPagesElement> {
+    (options?: Omit<IntegrationPluginConfig, 'name'>): IntegrationPlugin<C>;
+    Plugin: new (options?: Omit<IntegrationPluginConfig, 'name'>) => IntegrationPlugin<C>;
+}
+/**
+ * Creates a typed integration plugin factory for integrations that only need
+ * declarative config and a renderer class.
+ */
+export declare function defineIntegration<C = EcoPagesElement>(definition: DefineIntegrationDefinition<C>): DefinedIntegration<C>;
+export {};

package/src/plugins/define-integration.js

@@ -0,0 +1,20 @@
+import { IntegrationPlugin } from './integration-plugin.js';
+/**
+ * Creates a typed integration plugin factory for integrations that only need
+ * declarative config and a renderer class.
+ */
+export function defineIntegration(definition) {
+    const { renderer, ...defaultConfig } = definition;
+    class DefinedIntegrationPlugin extends IntegrationPlugin {
+        renderer = renderer;
+        constructor(options) {
+            super({
+                ...defaultConfig,
+                ...options,
+            });
+        }
+    }
+    const factory = ((options) => new DefinedIntegrationPlugin(options));
+    factory.Plugin = DefinedIntegrationPlugin;
+    return factory;
+}

package/src/plugins/eco-component-meta-plugin.d.ts

@@ -1,108 +1,12 @@
-/**
- * Bun plugin that auto-injects `__eco` metadata into EcoComponent config objects.
- *
- * This plugin uses AST parsing (via oxc-parser) to reliably inject the `__eco` property
- * into EcoComponent config objects at import time. The injected metadata contains:
- * - `dir`: The directory path of the component file (used for dependency resolution)
- * - `integration`: The integration type (e.g., 'react', 'kitajs', 'ghtml', 'lit')
- *
- * The plugin intercepts file loading for all configured integration extensions and
- * transforms component configs before they are executed.
- *
- * @example
- * ```typescript
- * // Before transformation:
- * export default eco.page({
- *   render: () => '<div>Hello</div>',
- * });
- *
- * // After transformation:
- * export default eco.page({
- *   __eco: { id: "<hash>", file: "/path/to/pages/index.tsx", integration: "react" },
- *   render: () => '<div>Hello</div>',
- * });
- * ```
- *
- * @module eco-component-meta-plugin
- */
-import type { EcoBuildPlugin } from '../build/build-types.js';
 import type { EcoPagesAppConfig } from '../types/internal-types.js';
-import { type EcoSourceTransform, type EcoViteCompatiblePlugin } from './source-transform.js';
-/**
- * Options for creating the eco-component-meta-plugin.
- */
+import type { EcoSourceTransform, EcoViteCompatiblePlugin } from './source-transform.js';
+import type { EcoBuildPlugin } from '../build/contracts/build-types.js';
 export interface EcoComponentDirPluginOptions {
-    /** The EcoPages application configuration containing integration settings */
     config: EcoPagesAppConfig;
 }
-/**
- * Creates the bundler-neutral metadata transform used by Ecopages loaders and
- * Vite-compatible adapters.
- */
+/** Attributes real `eco.*()` factory calls with canonical component identity. */
+export declare function attributeComponentIdentity(contents: string, filePath: string, integration: string): string;
 export declare function createEcoComponentMetaTransform(options: EcoComponentDirPluginOptions): EcoSourceTransform;
-/**
- * Creates a build plugin that auto-injects `__eco` metadata into EcoComponent config objects.
- *
- * This plugin intercepts file loading for all integration-compatible files and:
- * 1. Strips any query string from the file path (for dev mode cache-busting)
- * 2. Reads the file contents
- * 3. Parses the AST using oxc-parser to find injection points
- * 4. Injects `__eco: { id: "...", file: "...", integration: "..." }` into config objects
- * 5. Returns the transformed content with the appropriate loader
- *
- * Supported patterns:
- * - `eco.page({ ... })` - Page component declarations
- * - `eco.component({ ... })` - Reusable component declarations
- * - `eco.html({ ... })` - HTML shell declarations
- * - `eco.layout({ ... })` - Layout declarations
- * - `Component.config = { ... }` - Config assignment pattern
- * - `config: { ... }` - Config property in object literals
- * - `export const config = { ... }` - Exported config declarations
- *
- * @param options - Plugin options containing the EcoPages config
- * @returns A build plugin instance ready for registration
- *
- * @example
- * ```typescript
- * import { createEcoComponentMetaPlugin } from '@ecopages/core';
- *
- * const plugin = createEcoComponentMetaPlugin({ config: appConfig });
- * appConfig.loaders.set(plugin.name, plugin);
- * ```
- */
-export declare function createEcoComponentMetaPlugin(options: EcoComponentDirPluginOptions): EcoBuildPlugin;
-/**
- * Creates a Vite-compatible metadata injection plugin from the shared
- * Ecopages source-transform primitive.
- */
 export declare function createEcoComponentMetaVitePlugin(options: EcoComponentDirPluginOptions): EcoViteCompatiblePlugin;
-/**
- * Injects `__eco` metadata into EcoComponent config objects in file content.
- *
- * Uses oxc-parser for robust AST-based code analysis, which handles edge cases
- * that regex-based approaches would miss (e.g., complex generics, nested objects,
- * comments, string literals containing similar patterns).
- *
- * The injection is performed by:
- * 1. Parsing the source code into an AST
- * 2. Walking the AST to find all config object patterns
- * 3. Collecting insertion points (sorted in reverse order to preserve positions)
- * 4. Inserting the `__eco` property at each point
- *
- * @param contents - The source code content to transform
- * @param filePath - Absolute path to the file (used to derive the directory)
- * @param integration - The integration identifier for this file type
- * @returns Transformed source code with `__eco` injected, or original if no patterns found
- *
- * @example
- * ```typescript
- * const result = injectEcoMeta(
- *   'export default eco.page({ render: () => "<div>Hi</div>" });',
- *   '/app/src/pages/index.tsx',
- *   'react'
- * );
- * // Result: 'export default eco.page({ __eco: { id: "<hash>", file: "/app/src/pages/index.tsx", integration: "react" }, render: () => "<div>Hi</div>" });'
- * ```
- */
-export declare function injectEcoMeta(contents: string, filePath: string, integration: string): string;
-export default createEcoComponentMetaPlugin;
+export declare function createEcoComponentMetaPlugin(options: EcoComponentDirPluginOptions): EcoBuildPlugin;
+export default createEcoComponentMetaTransform;

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

@@ -1,175 +1,133 @@
-import { cachedParseSync } from "../cache/module-parse-cache.js";
-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,
-        {
-          name: integration.name,
-          jsxImportSource: integration.jsxImportSource
-        }
-      ]);
-    }
-  }
-  mapping.sort((a, b) => b[0].length - a[0].length);
-  return mapping;
+import { prependJsxImportSourceIfMissing } from './jsx-import-source.utils.js';
+import { createEcoBuildPluginFromSourceTransform, createVitePluginFromSourceTransform } from './source-transform.js';
+import { cachedParseSync } from '../cache/module-parse-cache.js';
+import { rapidhash } from '../utils/hash.js';
+function integrationForFile(filePath, config) {
+    const candidates = config.integrations
+        .flatMap((integration) => integration.extensions.map((extension) => [extension, integration]))
+        .sort(([left], [right]) => right.length - left.length);
+    const match = candidates.find(([extension]) => filePath.endsWith(extension));
+    return match ? { name: match[1].name, jsxImportSource: match[1].jsxImportSource } : { name: 'ghtml' };
 }
-function detectIntegration(filePath, extensionToIntegration) {
-  for (const [ext, integration] of extensionToIntegration) {
-    if (filePath.endsWith(ext)) {
-      return integration;
-    }
-  }
-  return { name: "ghtml" };
+function isAstNode(value) {
+    return typeof value === 'object' && value !== null;
 }
-function prependJsxImportSource(code, jsxImportSource) {
-  if (!jsxImportSource || code.includes("@jsxImportSource")) {
-    return code;
-  }
-  return `/** @jsxImportSource ${jsxImportSource} */
-${code}`;
+function isEcoFactoryCall(node) {
+    if (node.type !== 'CallExpression' || !isAstNode(node.callee))
+        return false;
+    const callee = node.callee;
+    if (callee.type !== 'MemberExpression' && callee.type !== 'StaticMemberExpression')
+        return false;
+    if (!isAstNode(callee.object) || callee.object.type !== 'Identifier' || callee.object.name !== 'eco')
+        return false;
+    if (!isAstNode(callee.property) || callee.property.type !== 'Identifier')
+        return false;
+    return ['page', 'component', 'layout', 'html'].includes(String(callee.property.name));
 }
-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 isIdentityBinding(node) {
+    if (!isAstNode(node) || node.type !== 'CallExpression' || !isAstNode(node.callee))
+        return false;
+    return node.callee.type === 'Identifier' && node.callee.name === 'bindComponentIdentity';
 }
-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: prependJsxImportSource(injectEcoMeta(code, id, integration.name), integration.jsxImportSource)
-      };
+function walkAst(node, visit) {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            walkAst(child, visit);
+        return;
     }
-  };
-}
-function createEcoComponentMetaPlugin(options) {
-  return createEcoBuildPluginFromSourceTransform(createEcoComponentMetaTransform(options));
-}
-function createEcoComponentMetaVitePlugin(options) {
-  return createVitePluginFromSourceTransform(createEcoComponentMetaTransform(options));
+    if (!isAstNode(node))
+        return;
+    visit(node);
+    for (const value of Object.values(node))
+        walkAst(value, visit);
 }
-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 });
-          }
-        }
-      }
+function addIdentityBindingImport(contents, program) {
+    const imports = program.body.filter((node) => isAstNode(node) &&
+        node.type === 'ImportDeclaration' &&
+        isAstNode(node.source) &&
+        node.source.value === '@ecopages/core');
+    const valueImport = imports.find((node) => node.importKind !== 'type');
+    if (!valueImport)
+        return `import { bindComponentIdentity } from '@ecopages/core';\n${contents}`;
+    const specifiers = Array.isArray(valueImport.specifiers) ? valueImport.specifiers.filter(isAstNode) : [];
+    if (specifiers.some((specifier) => specifier.type === 'ImportSpecifier' &&
+        isAstNode(specifier.imported) &&
+        specifier.imported.name === 'bindComponentIdentity')) {
+        return contents;
     }
-  }
-  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 });
-        }
-      }
+    const namedSpecifiers = specifiers.filter((specifier) => specifier.type === 'ImportSpecifier');
+    if (namedSpecifiers.length > 0) {
+        const lastSpecifier = namedSpecifiers[namedSpecifiers.length - 1];
+        return `${contents.slice(0, lastSpecifier.end)}, bindComponentIdentity${contents.slice(lastSpecifier.end)}`;
     }
-  }
-  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 });
-      }
+    if (specifiers.some((specifier) => specifier.type === 'ImportNamespaceSpecifier')) {
+        return `import { bindComponentIdentity } from '@ecopages/core';\n${contents}`;
     }
-  }
-  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;
-      }
+    const defaultSpecifier = specifiers.find((specifier) => specifier.type === 'ImportDefaultSpecifier');
+    if (defaultSpecifier) {
+        return `${contents.slice(0, defaultSpecifier.end)}, { bindComponentIdentity }${contents.slice(defaultSpecifier.end)}`;
     }
-  }
-  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);
+    return `import { bindComponentIdentity } from '@ecopages/core';\n${contents}`;
+}
+/** Attributes real `eco.*()` factory calls with canonical component identity. */
+export function attributeComponentIdentity(contents, filePath, integration) {
+    if (!contents.includes('eco.'))
+        return contents;
+    let program;
+    try {
+        program = cachedParseSync(filePath, contents, { sourceType: 'module' }).program;
+    }
+    catch {
+        return contents;
+    }
+    const identityLiteral = `{ id: ${JSON.stringify(rapidhash(filePath).toString(36))}, file: ${JSON.stringify(filePath)}, integration: ${JSON.stringify(integration)} }`;
+    const edits = [];
+    walkAst(program, (node) => {
+        if (!isEcoFactoryCall(node) || !Array.isArray(node.arguments))
+            return;
+        const firstArgument = node.arguments[0];
+        if (!isAstNode(firstArgument) || isIdentityBinding(firstArgument))
+            return;
+        if (typeof firstArgument.start !== 'number' || typeof firstArgument.end !== 'number')
+            return;
+        edits.push({
+            start: firstArgument.start,
+            end: firstArgument.end,
+            replacement: `bindComponentIdentity(${identityLiteral}, ${contents.slice(firstArgument.start, firstArgument.end)})`,
+        });
+    });
+    if (edits.length === 0)
+        return contents;
+    let transformed = contents;
+    for (const edit of edits.sort((left, right) => right.start - left.start)) {
+        transformed = `${transformed.slice(0, edit.start)}${edit.replacement}${transformed.slice(edit.end)}`;
     }
-  }
+    return addIdentityBindingImport(transformed, program);
+}
+export function createEcoComponentMetaTransform(options) {
+    const extensions = options.config.integrations
+        .flatMap((integration) => integration.extensions)
+        .filter((extension) => ['.ts', '.tsx', '.js', '.jsx'].some((suffix) => extension.endsWith(suffix)))
+        .map((extension) => extension.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    const filter = new RegExp(`(${extensions.join('|')})(\\?.*)?$`);
+    return {
+        name: 'eco-component-identity-attribution',
+        enforce: 'pre',
+        filter,
+        transform(code, id) {
+            if (id.endsWith('.mdx'))
+                return { code };
+            const integration = integrationForFile(id, options.config);
+            return {
+                code: prependJsxImportSourceIfMissing(attributeComponentIdentity(code, id, integration.name), integration.jsxImportSource),
+            };
+        },
+    };
+}
+export function createEcoComponentMetaVitePlugin(options) {
+    return createVitePluginFromSourceTransform(createEcoComponentMetaTransform(options));
 }
-function injectEcoMeta(contents, filePath, integration) {
-  const result = cachedParseSync(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;
+export function createEcoComponentMetaPlugin(options) {
+    return createEcoBuildPluginFromSourceTransform(createEcoComponentMetaTransform(options));
 }
-var eco_component_meta_plugin_default = createEcoComponentMetaPlugin;
-export {
-  createEcoComponentMetaPlugin,
-  createEcoComponentMetaTransform,
-  createEcoComponentMetaVitePlugin,
-  eco_component_meta_plugin_default as default,
-  injectEcoMeta
-};
+export default createEcoComponentMetaTransform;

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

@@ -1,4 +1,4 @@
-import type { EcoBuildPlugin } from '../build/build-types.js';
+import type { EcoBuildPlugin } from '../build/contracts/build-types.js';
 /**
  * Options for the shared foreign-JSX override build plugin.
  */