@ecopages/core 0.2.0-alpha.8 → 0.2.1

package/src/eco/eco.js

@@ -1,56 +1,27 @@
-import { createNodeId, createPropsRef, createSlotRef, getComponentRenderContext } from "./component-render-context.js";
-import { createComponentMarker, parseComponentMarkers } from "../route-renderer/component-graph/component-marker.js";
-import { getComponentReference } from "../route-renderer/component-graph/component-reference.js";
-import { addTriggerAttribute, isThenable, wrapWithScriptsInjector } from "./eco.utils.js";
+import {
+  finalizeComponentRender,
+  interceptComponentBoundary
+} from "../route-renderer/orchestration/component-render-context.js";
+import { isThenable } from "../route-renderer/orchestration/render-output.utils.js";
 function createComponentFactory(options) {
   const integrationName = options.integration ?? options.__eco?.integration;
   const comp = ((props) => {
-    const renderContext = getComponentRenderContext();
-    const shouldEmitMarker = renderContext !== void 0 && renderContext.boundaryContext.decideBoundaryRender({
-      currentIntegration: renderContext.currentIntegration,
-      targetIntegration: integrationName,
-      component: comp
-    }) === "defer";
-    if (shouldEmitMarker && renderContext) {
-      const nodeId = createNodeId(renderContext);
-      const propsRef = createPropsRef(renderContext);
-      const componentRef = getComponentReference(comp);
-      const componentProps = props ?? {};
-      renderContext.propsByRef[propsRef] = componentProps;
-      let slotRef;
-      const children = componentProps.children;
-      if (typeof children === "string" && children.includes("<eco-marker")) {
-        const childMarkers = parseComponentMarkers(children);
-        if (childMarkers.length > 0) {
-          slotRef = createSlotRef(renderContext);
-          renderContext.slotChildrenByRef[slotRef] = childMarkers.map((marker) => marker.nodeId);
-        }
-      }
-      return createComponentMarker({
-        nodeId,
-        integration: integrationName,
-        componentRef,
-        propsRef,
-        slotRef
-      });
+    const componentProps = props ?? {};
+    const renderInline = () => finalizeComponentRender(comp, options.render(props));
+    const boundaryRender = interceptComponentBoundary({
+      component: comp,
+      props: componentProps,
+      targetIntegration: integrationName
+    });
+    if (isThenable(boundaryRender)) {
+      return boundaryRender.then(
+        (resolvedBoundaryRender) => resolvedBoundaryRender !== void 0 ? resolvedBoundaryRender : renderInline()
+      );
     }
-    const content = options.render(props);
-    const lazyTriggers = comp.config?._resolvedLazyTriggers;
-    if (lazyTriggers && lazyTriggers.length > 0) {
-      const triggerId = lazyTriggers[0].triggerId;
-      if (isThenable(content)) {
-        return content.then((resolvedContent) => addTriggerAttribute(resolvedContent, triggerId));
-      }
-      return addTriggerAttribute(content, triggerId);
+    if (boundaryRender !== void 0) {
+      return boundaryRender;
     }
-    const lazyGroups = comp.config?._resolvedLazyScripts;
-    if (lazyGroups && lazyGroups.length > 0) {
-      if (isThenable(content)) {
-        return content.then((resolvedContent) => wrapWithScriptsInjector(resolvedContent, lazyGroups));
-      }
-      return wrapWithScriptsInjector(content, lazyGroups);
-    }
-    return content;
+    return renderInline();
   });
   comp.config = {
     __eco: options.__eco,

package/src/eco/eco.types.d.ts

@@ -2,7 +2,7 @@
  * Type definitions for the eco namespace API
  * @module
  */
-import type { DependencyLazyTrigger, EcoComponent, EcoComponentDependencies, EcoHtmlComponent, EcoInjectedMeta, EcoLayoutComponent, EcoPageLayoutComponent, EcoPagesElement, GetMetadata, GetStaticPaths, GetStaticProps, HtmlTemplateProps, LayoutProps, Middleware, RequestLocals, RequestPageContext } from '../public-types.js';
+import type { DependencyLazyTrigger, EcoComponent, EcoComponentDependencies, EcoHtmlComponent, EcoInjectedMeta, EcoLayoutComponent, EcoPageLayoutComponent, EcoPagesElement, GetMetadata, GetStaticPaths, GetStaticProps, HtmlTemplateProps, LayoutProps, Middleware, RequestLocals, RequestPageContext } from '../types/public-types.js';
 import type { CacheStrategy } from '../services/cache/cache.types.js';
 type WithRequiredLocals<K extends keyof RequestLocals> = Omit<RequestLocals, K> & {
     [P in K]-?: Exclude<RequestLocals[P], null | undefined>;

package/src/eco/eco.utils.d.ts

@@ -1,40 +1 @@
-import type { EcoComponent } from '../public-types.js';
-/**
- * Returns `true` when `value` is a thenable (Promise-like) object.
- *
- * Used to transparently handle both synchronous and asynchronous component
- * render results without requiring every caller to branch on `instanceof Promise`.
- *
- * @typeParam T Expected resolved type of the thenable.
- */
-export declare function isThenable<T>(value: unknown): value is PromiseLike<T>;
-/**
- * Injects `data-eco-trigger` into the first real HTML element opening tag of
- * a component's rendered output string.
- *
- * The scan skips over leading whitespace, HTML comments (`<!-- -->`), CDATA
- * sections, and doctype declarations so that the attribute is always placed on
- * the first actual element — not spurious markup that can precede it.
- *
- * The insertion point is the end of the element's tag name, before any existing
- * attributes or the closing `>`, which produces output like:
- *
- * ```html
- * <my-element data-eco-trigger="eco-trigger-abc123" class="foo">…</my-element>
- * ```
- *
- * When no eligible opening tag is found the original string is returned
- * unchanged so callers never receive a broken fragment.
- *
- * @param content Rendered HTML string (or any value coercible to string).
- * @param triggerId Stable trigger identifier produced by `buildResolvedLazyTriggers`.
- */
-export declare function addTriggerAttribute(content: unknown, triggerId: string): string;
-/**
- * Wraps rendered component output in a `<scripts-injector>` element that
- * carries an inline injector map for the legacy (non-global-injector) path.
- *
- * @param content Rendered component HTML.
- * @param lazyGroups Resolved lazy script groups attached to the component config.
- */
-export declare function wrapWithScriptsInjector(content: unknown, lazyGroups: NonNullable<EcoComponent['config']>['_resolvedLazyScripts']): string;
+export { addTriggerAttribute, isThenable, wrapWithScriptsInjector, } from '../route-renderer/orchestration/render-output.utils.js';

package/src/eco/eco.utils.js

@@ -1,38 +1,8 @@
-import { buildInjectorMapScript } from "./lazy-injector-map.js";
-function isThenable(value) {
-  return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
-}
-function addTriggerAttribute(content, triggerId) {
-  const str = String(content);
-  let i = 0;
-  while (i < str.length) {
-    if (str[i] !== "<") {
-      i++;
-      continue;
-    }
-    const next = str[i + 1];
-    if (next === "!" || next === "?") {
-      const end = str.indexOf(">", i);
-      if (end === -1) break;
-      i = end + 1;
-      continue;
-    }
-    if (next && /[a-zA-Z]/.test(next)) {
-      const tagSlice = str.slice(i + 1);
-      const nameEnd = tagSlice.search(/[\s/>]/);
-      if (nameEnd === -1) break;
-      const insertAt = i + 1 + nameEnd;
-      return `${str.slice(0, insertAt)} data-eco-trigger="${triggerId}"${str.slice(insertAt)}`;
-    }
-    break;
-  }
-  return str;
-}
-function wrapWithScriptsInjector(content, lazyGroups) {
-  const wrappedContent = String(content);
-  const injectorMapScript = buildInjectorMapScript(lazyGroups ?? []);
-  return `<scripts-injector><script type="ecopages/injector-map">${injectorMapScript}<\/script>${wrappedContent}<\/scripts-injector>`;
-}
+import {
+  addTriggerAttribute,
+  isThenable,
+  wrapWithScriptsInjector
+} from "../route-renderer/orchestration/render-output.utils.js";
 export {
   addTriggerAttribute,
   isThenable,

package/src/eco/global-injector-map.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedLazyTrigger } from '../public-types.js';
+import type { ResolvedLazyTrigger } from '../types/public-types.js';
 /**
  * Serializes resolved lazy triggers into a JSON string safe for embedding
  * inside an inline `<script type="ecopages/global-injector-map">` tag.

package/src/eco/lazy-injector-map.d.ts

@@ -1,4 +1,4 @@
-import type { ResolvedLazyScriptGroup } from '../public-types.js';
+import type { ResolvedLazyScriptGroup } from '../types/public-types.js';
 /**
  * Creates a safe JSON payload string for `<script type="ecopages/injector-map">`.
  *

package/src/hmr/hmr-strategy.d.ts

@@ -1,4 +1,4 @@
-import type { ClientBridgeEvent } from '../public-types';
+import type { ClientBridgeEvent } from '../types/public-types.js';
 /**
  * HMR Strategy Pattern
  *
@@ -18,11 +18,13 @@ import type { ClientBridgeEvent } from '../public-types';
  *   async process(filePath: string): Promise<HmrAction> {
  *     return {
  *       type: 'broadcast',
- *       events: [{ type: 'update', path: filePath, timestamp: Date.now() }]
+ *       events: [{ type: 'update', path: filePath, timestamp: Date.now() }],
  *     };
  *   }
  * }
-
+ * ```
+ */
+/**
  * Defines the category of an HMR strategy, which determines its execution priority.
  * Strategies are evaluated in descending order: INTEGRATION → ASSET → SCRIPT → FALLBACK.
  *
@@ -30,28 +32,29 @@ import type { ClientBridgeEvent } from '../public-types';
  * The numeric values represent base priorities. Strategies can fine-tune their priority
  * using the `priorityOffset` property.
  */
-export declare enum HmrStrategyType {
+export declare const HmrStrategyType: {
     /**
      * Integration-specific strategies (React, Lit, etc.)
      * Highest priority to allow framework-specific HMR handling.
      */
-    INTEGRATION = 100,
+    readonly INTEGRATION: 100;
     /**
      * Asset processing strategies (CSS, images, etc.)
      * High priority for specialized asset handling.
      */
-    ASSET = 50,
+    readonly ASSET: 50;
     /**
      * Generic script bundling strategies (JS/TS)
      * Medium priority for standard script processing.
      */
-    SCRIPT = 25,
+    readonly SCRIPT: 25;
     /**
      * Fallback strategy for unhandled file types.
      * Lowest priority, triggers full page reload.
      */
-    FALLBACK = 0
-}
+    readonly FALLBACK: 0;
+};
+export type HmrStrategyType = (typeof HmrStrategyType)[keyof typeof HmrStrategyType];
 /**
  * Represents an action to be taken after processing a file change.
  */
@@ -62,7 +65,7 @@ export interface HmrAction {
     type: 'broadcast' | 'none';
     /**
      * The HMR events to broadcast, if type is 'broadcast'.
-     * capable of broadcasting multiple events at once.
+     * Multiple events may be broadcast in one action.
      */
     events?: ClientBridgeEvent[];
 }
@@ -74,8 +77,8 @@ export interface HmrAction {
  * whether they match the changed file path.
  *
  * @remarks
- * Strategies should be stateless and idempotent. The same file change should always
- * produce the same result when processed by the same strategy.
+ * Strategies are expected to be stateless and idempotent. The same file change
+ * should produce the same result when processed by the same strategy.
  *
  * @example
  * ```typescript
@@ -120,7 +123,7 @@ export declare abstract class HmrStrategy {
      * Determines if this strategy can handle the given file path.
      *
      * @param filePath - Absolute path to the changed file
-     * @returns True if this strategy should process the file
+     * @returns `true` when this strategy should process the file
      *
      * @example
      * ```typescript

package/src/hmr/hmr-strategy.js

@@ -1,10 +1,25 @@
-var HmrStrategyType = /* @__PURE__ */ ((HmrStrategyType2) => {
-  HmrStrategyType2[HmrStrategyType2["INTEGRATION"] = 100] = "INTEGRATION";
-  HmrStrategyType2[HmrStrategyType2["ASSET"] = 50] = "ASSET";
-  HmrStrategyType2[HmrStrategyType2["SCRIPT"] = 25] = "SCRIPT";
-  HmrStrategyType2[HmrStrategyType2["FALLBACK"] = 0] = "FALLBACK";
-  return HmrStrategyType2;
-})(HmrStrategyType || {});
+const HmrStrategyType = {
+  /**
+   * Integration-specific strategies (React, Lit, etc.)
+   * Highest priority to allow framework-specific HMR handling.
+   */
+  INTEGRATION: 100,
+  /**
+   * Asset processing strategies (CSS, images, etc.)
+   * High priority for specialized asset handling.
+   */
+  ASSET: 50,
+  /**
+   * Generic script bundling strategies (JS/TS)
+   * Medium priority for standard script processing.
+   */
+  SCRIPT: 25,
+  /**
+   * Fallback strategy for unhandled file types.
+   * Lowest priority, triggers full page reload.
+   */
+  FALLBACK: 0
+};
 class HmrStrategy {
   /**
    * Optional offset to fine-tune priority within the same category.

package/src/hmr/strategies/default-hmr-strategy.d.ts

@@ -6,7 +6,7 @@
  *
  * @module
  */
-import { HmrStrategy, HmrStrategyType, type HmrAction } from '../hmr-strategy';
+import { HmrStrategy, type HmrAction } from '../hmr-strategy.js';
 /**
  * Default fallback strategy for unhandled file types.
  *
@@ -25,7 +25,7 @@ import { HmrStrategy, HmrStrategyType, type HmrAction } from '../hmr-strategy';
  * ```
  */
 export declare class DefaultHmrStrategy extends HmrStrategy {
-    readonly type = HmrStrategyType.FALLBACK;
+    readonly type: 0;
     /**
      * Matches all file paths.
      *

package/src/hmr/strategies/default-hmr-strategy.js

@@ -1,4 +1,4 @@
-import { HmrStrategy, HmrStrategyType } from "../hmr-strategy";
+import { HmrStrategy, HmrStrategyType } from "../hmr-strategy.js";
 class DefaultHmrStrategy extends HmrStrategy {
   type = HmrStrategyType.FALLBACK;
   /**

package/src/hmr/strategies/js-hmr-strategy.d.ts

@@ -7,7 +7,7 @@
  *
  * @module
  */
-import { HmrStrategy, HmrStrategyType, type HmrAction } from '../hmr-strategy';
+import { HmrStrategy, type HmrAction } from '../hmr-strategy.js';
 import type { EcoBuildPlugin } from '../../build/build-types.js';
 import type { BrowserBundleExecutor } from '../../services/assets/browser-bundle.service.js';
 import type { EntrypointDependencyGraph } from '../../services/runtime-state/entrypoint-dependency-graph.service.js';
@@ -94,7 +94,7 @@ export interface JsHmrContext {
  * ```
  */
 export declare class JsHmrStrategy extends HmrStrategy {
-    readonly type = HmrStrategyType.SCRIPT;
+    readonly type: 25;
     private context;
     constructor(context: JsHmrContext);
     /**

package/src/hmr/strategies/js-hmr-strategy.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
-import { HmrStrategy, HmrStrategyType } from "../hmr-strategy";
-import { appLogger } from "../../global/app-logger";
+import { HmrStrategy, HmrStrategyType } from "../hmr-strategy.js";
+import { appLogger } from "../../global/app-logger.js";
 class JsHmrStrategy extends HmrStrategy {
   type = HmrStrategyType.SCRIPT;
   context;

package/src/index.browser.d.ts

@@ -1,3 +1,3 @@
-export type * from './public-types.js';
+export type * from './types/public-types.js';
 export type * from './eco/eco.types.js';
-export { eco } from './eco/eco.js';
+export { eco } from './eco/eco.browser.js';

package/src/index.browser.js

@@ -1,4 +1,4 @@
-import { eco } from "./eco/eco.js";
+import { eco } from "./eco/eco.browser.js";
 export {
   eco
 };

package/src/index.d.ts

@@ -1,5 +1,6 @@
-export type * from './public-types.js';
+export type * from './types/public-types.js';
 export type * from './eco/eco.types.js';
 export { eco } from './eco/eco.js';
-export { EcopagesApp, createApp, type EcopagesAppOptions } from './create-app.js';
 export { defineApiHandler, defineGroupHandler, type GroupHandler } from './adapters/shared/define-api-handler.js';
+export { createEcoBuildPluginFromSourceTransform, createVitePluginsFromAppSourceTransforms, getAppSourceTransforms, createVitePluginFromSourceTransform, normalizeTransformId, type EcoSourceTransform, type EcoSourceTransformResult, type EcoViteCompatiblePlugin, } from './plugins/source-transform.js';
+export { createEcoComponentMetaTransform } from './plugins/eco-component-meta-plugin.js';

package/src/index.js

@@ -1,10 +1,21 @@
 import { eco } from "./eco/eco.js";
-import { EcopagesApp, createApp } from "./create-app.js";
 import { defineApiHandler, defineGroupHandler } from "./adapters/shared/define-api-handler.js";
+import {
+  createEcoBuildPluginFromSourceTransform,
+  createVitePluginsFromAppSourceTransforms,
+  getAppSourceTransforms,
+  createVitePluginFromSourceTransform,
+  normalizeTransformId
+} from "./plugins/source-transform.js";
+import { createEcoComponentMetaTransform } from "./plugins/eco-component-meta-plugin.js";
 export {
-  EcopagesApp,
-  createApp,
+  createEcoBuildPluginFromSourceTransform,
+  createEcoComponentMetaTransform,
+  createVitePluginFromSourceTransform,
+  createVitePluginsFromAppSourceTransforms,
   defineApiHandler,
   defineGroupHandler,
-  eco
+  eco,
+  getAppSourceTransforms,
+  normalizeTransformId
 };

package/src/integrations/ghtml/ghtml-renderer.d.ts

@@ -2,7 +2,7 @@
  * This module contains the ghtml renderer
  * @module
  */
-import type { EcoComponent, EcoPagesElement, IntegrationRendererRenderOptions, RouteRendererBody } from '../../public-types.js';
+import type { ComponentRenderInput, ComponentRenderResult, EcoComponent, EcoPagesElement, IntegrationRendererRenderOptions, RouteRendererBody } from '../../types/public-types.js';
 import { IntegrationRenderer, type RenderToResponseContext } from '../../route-renderer/orchestration/integration-renderer.js';
 /**
  * A renderer for the ghtml integration.
@@ -10,6 +10,11 @@ import { IntegrationRenderer, type RenderToResponseContext } from '../../route-r
  */
 export declare class GhtmlRenderer extends IntegrationRenderer<EcoPagesElement> {
     name: string;
+    renderComponent(input: ComponentRenderInput): Promise<ComponentRenderResult>;
+    protected createComponentBoundaryRuntime(options: {
+        boundaryInput: ComponentRenderInput;
+        rendererCache: Map<string, IntegrationRenderer<any>>;
+    }): import("../../index.browser.js").ComponentBoundaryRuntime;
     render({ params, query, props, locals, pageLocals, metadata, Page, Layout, HtmlTemplate, }: IntegrationRendererRenderOptions): Promise<RouteRendererBody>;
     renderToResponse<P = Record<string, unknown>>(view: EcoComponent<P>, props: P, ctx: RenderToResponseContext): Promise<Response>;
 }

package/src/integrations/ghtml/ghtml-renderer.js

@@ -4,6 +4,18 @@ import {
 import { GHTML_PLUGIN_NAME } from "./ghtml.plugin.js";
 class GhtmlRenderer extends IntegrationRenderer {
   name = GHTML_PLUGIN_NAME;
+  async renderComponent(input) {
+    return this.renderStringComponentBoundaryWithQueuedForeignBoundaries(
+      input,
+      input.component
+    );
+  }
+  createComponentBoundaryRuntime(options) {
+    return this.createQueuedBoundaryRuntime({
+      boundaryInput: options.boundaryInput,
+      rendererCache: options.rendererCache
+    });
+  }
   async render({
     params,
     query,
@@ -16,42 +28,31 @@ class GhtmlRenderer extends IntegrationRenderer {
     HtmlTemplate
   }) {
     try {
-      const pageContent = await Page({ params, query, ...props, locals: pageLocals });
-      const children = Layout && typeof Layout === "function" ? await Layout({ children: pageContent, locals }) : pageContent;
-      const body = await HtmlTemplate({
+      return await this.renderPageWithDocumentShell({
+        page: {
+          component: Page,
+          props: { params, query, ...props, locals: pageLocals }
+        },
+        layout: Layout ? {
+          component: Layout,
+          props: locals ? { locals } : {}
+        } : void 0,
+        htmlTemplate: HtmlTemplate,
         metadata,
-        children,
-        pageProps: props || {}
+        pageProps: props ?? {}
       });
-      return this.DOC_TYPE + body;
     } catch (error) {
       throw this.createRenderError("Error rendering page", error);
     }
   }
   async renderToResponse(view, props, ctx) {
     try {
-      const Layout = view.config?.layout;
-      const viewFn = view;
-      const pageContent = await viewFn(props);
-      let body;
-      if (ctx.partial) {
-        body = pageContent;
-      } else {
-        const children = Layout ? await Layout({ children: pageContent }) : pageContent;
-        const HtmlTemplate = await this.getHtmlTemplate();
-        const metadata = view.metadata ? await view.metadata({
-          params: {},
-          query: {},
-          props,
-          appConfig: this.appConfig
-        }) : this.appConfig.defaultMetadata;
-        body = this.DOC_TYPE + await HtmlTemplate({
-          metadata,
-          children,
-          pageProps: props
-        });
-      }
-      return this.createHtmlResponse(body, ctx);
+      return await this.renderViewWithDocumentShell({
+        view,
+        props,
+        ctx,
+        layout: view.config?.layout
+      });
     } catch (error) {
       throw this.createRenderError("Error rendering view", error);
     }

package/src/integrations/ghtml/ghtml.plugin.d.ts

@@ -1,5 +1,5 @@
-import { IntegrationPlugin, type IntegrationPluginConfig } from '../../plugins/integration-plugin';
-import { GhtmlRenderer } from './ghtml-renderer';
+import { IntegrationPlugin, type IntegrationPluginConfig } from '../../plugins/integration-plugin.js';
+import { GhtmlRenderer } from './ghtml-renderer.js';
 /**
  * The name of the ghtml plugin
  */

package/src/integrations/ghtml/ghtml.plugin.js

@@ -1,5 +1,5 @@
-import { IntegrationPlugin } from "../../plugins/integration-plugin";
-import { GhtmlRenderer } from "./ghtml-renderer";
+import { IntegrationPlugin } from "../../plugins/integration-plugin.js";
+import { GhtmlRenderer } from "./ghtml-renderer.js";
 const GHTML_PLUGIN_NAME = "ghtml";
 class GhtmlPlugin extends IntegrationPlugin {
   renderer = GhtmlRenderer;

package/src/plugins/README.md

@@ -18,6 +18,7 @@ These contracts are responsible for:
 - `integration-plugin.ts`: framework-semantics contract for render integrations
 - `processor.ts`: asset-transformation contract for processors
 - `runtime-capability.ts`: runtime compatibility declaration types
+- `source-transform.ts`: bundler-neutral source-transform primitive with Ecopages adapters plus app-level Vite plugin composition helpers
 - `eco-component-meta-plugin.ts`: shared metadata transform used by core loading/build paths
 
 ## Ownership Rules

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

@@ -26,7 +26,8 @@
  * @module eco-component-meta-plugin
  */
 import type { EcoBuildPlugin } from '../build/build-types.js';
-import type { EcoPagesAppConfig } from '../internal-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.
  */
@@ -34,6 +35,11 @@ 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.
+ */
+export declare function createEcoComponentMetaTransform(options: EcoComponentDirPluginOptions): EcoSourceTransform;
 /**
  * Creates a build plugin that auto-injects `__eco` metadata into EcoComponent config objects.
  *
@@ -65,6 +71,11 @@ export interface EcoComponentDirPluginOptions {
  * ```
  */
 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.
  *

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

@@ -1,7 +1,10 @@
 import path from "node:path";
 import { parseSync } from "oxc-parser";
-import { fileSystem } from "@ecopages/file-system";
 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) {
@@ -38,30 +41,31 @@ function createExtensionPattern(extensions) {
   const escaped = uniqueExtensions.map((ext) => ext.replace(REGEX_SPECIAL_CHARS, "\\$&"));
   return new RegExp(`(${escaped.join("|")})(\\?.*)?$`);
 }
-function createEcoComponentMetaPlugin(options) {
+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",
-    setup(build) {
-      const allExtensions = options.config.integrations.flatMap((integration) => integration.extensions).filter(hasValidLoaderExtension);
-      if (allExtensions.length === 0) {
-        return;
-      }
-      const extensionPattern = createExtensionPattern(allExtensions);
-      const extensionToIntegration = buildExtensionToIntegrationMap(options.config.integrations);
-      build.onLoad({ filter: extensionPattern }, (args) => {
-        const filePath = args.path.split("?")[0];
-        const contents = fileSystem.readFileSync(filePath);
-        const integration = detectIntegration(filePath, extensionToIntegration);
-        const transformedContents = injectEcoMeta(contents, filePath, integration);
-        const ext = path.extname(filePath).slice(1);
-        return {
-          contents: transformedContents,
-          loader: ext || "ts"
-        };
-      });
+    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;
@@ -152,6 +156,8 @@ function injectEcoMeta(contents, filePath, integration) {
 var eco_component_meta_plugin_default = createEcoComponentMetaPlugin;
 export {
   createEcoComponentMetaPlugin,
+  createEcoComponentMetaTransform,
+  createEcoComponentMetaVitePlugin,
   eco_component_meta_plugin_default as default,
   injectEcoMeta
 };