@ecopages/core 0.2.0-alpha.27 → 0.2.0-alpha.28

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

@@ -1,334 +0,0 @@
-import { describe, expect, it, beforeAll, afterAll } from 'vitest';
-import { JsHmrStrategy, type JsHmrContext } from './js-hmr-strategy';
-import { HmrStrategyType } from '../hmr-strategy';
-import { InMemoryDevGraphService, NoopDevGraphService } from '../../services/runtime-state/dev-graph.service.ts';
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-
-const TMP_DIR = path.join(os.tmpdir(), 'js-hmr-strategy-test');
-const SRC_DIR = path.join(TMP_DIR, 'src');
-
-function createMockContext(overrides: Partial<JsHmrContext> = {}): JsHmrContext {
-	return {
-		getWatchedFiles: () => new Map(),
-		getEntrypointDependencyGraph: () => new NoopDevGraphService(),
-		getDistDir: () => TMP_DIR,
-		getPlugins: () => [],
-		getSrcDir: () => SRC_DIR,
-		getPagesDir: () => path.join(SRC_DIR, 'pages'),
-		getLayoutsDir: () => path.join(SRC_DIR, 'layouts'),
-		getTemplateExtensions: () => ['.tsx'],
-		getBrowserBundleService: () => ({
-			bundle: async () => ({ success: true, logs: [], outputs: [] }),
-		}),
-		...overrides,
-	};
-}
-
-describe('JsHmrStrategy', () => {
-	beforeAll(() => {
-		fs.mkdirSync(SRC_DIR, { recursive: true });
-	});
-
-	afterAll(() => {
-		fs.rmSync(TMP_DIR, { recursive: true, force: true });
-	});
-
-	describe('type', () => {
-		it('has SCRIPT type', () => {
-			const context = createMockContext();
-			const strategy = new JsHmrStrategy(context);
-			expect(strategy.type).toBe(HmrStrategyType.SCRIPT);
-		});
-
-		it('has default priority of 25', () => {
-			const context = createMockContext();
-			const strategy = new JsHmrStrategy(context);
-			expect(strategy.priority).toBe(25);
-		});
-	});
-
-	describe('matches', () => {
-		it('returns false when no watched files are registered', () => {
-			const context = createMockContext({
-				getWatchedFiles: () => new Map(),
-			});
-			const strategy = new JsHmrStrategy(context);
-
-			expect(strategy.matches(path.join(SRC_DIR, 'app.ts'))).toBe(false);
-		});
-
-		it('returns false for unrelated .ts files when dependency graph support is available', () => {
-			const devGraphService = new InMemoryDevGraphService();
-			const context = createMockContext({
-				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
-				getEntrypointDependencyGraph: () => devGraphService,
-			});
-			const strategy = new JsHmrStrategy(context);
-
-			expect(strategy.matches(path.join(SRC_DIR, 'component.ts'))).toBe(false);
-		});
-
-		it('returns true for dependency-connected .tsx files in src directory', () => {
-			const changedFile = path.join(SRC_DIR, 'component.tsx');
-			const devGraphService = new InMemoryDevGraphService();
-			devGraphService.setEntrypointDependencies(path.join(SRC_DIR, 'entry.ts'), [changedFile]);
-			const context = createMockContext({
-				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
-				getEntrypointDependencyGraph: () => devGraphService,
-			});
-			const strategy = new JsHmrStrategy(context);
-
-			expect(strategy.matches(changedFile)).toBe(true);
-		});
-
-		it('returns true for registered entrypoints even without dependency graph hits', () => {
-			const entrypoint = path.join(SRC_DIR, 'entry.tsx');
-			const devGraphService = new InMemoryDevGraphService();
-			const context = createMockContext({
-				getWatchedFiles: () => new Map([[entrypoint, '/output.js']]),
-				getEntrypointDependencyGraph: () => devGraphService,
-			});
-			const strategy = new JsHmrStrategy(context);
-
-			expect(strategy.matches(entrypoint)).toBe(true);
-		});
-
-		it('returns true for .js files in src directory', () => {
-			const context = createMockContext({
-				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
-			});
-			const strategy = new JsHmrStrategy(context);
-
-			expect(strategy.matches(path.join(SRC_DIR, 'utils.js'))).toBe(true);
-		});
-
-		it('returns true for .jsx files in src directory', () => {
-			const context = createMockContext({
-				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
-			});
-			const strategy = new JsHmrStrategy(context);
-
-			expect(strategy.matches(path.join(SRC_DIR, 'component.jsx'))).toBe(true);
-		});
-
-		it('returns false for .css files', () => {
-			const context = createMockContext({
-				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
-			});
-			const strategy = new JsHmrStrategy(context);
-
-			expect(strategy.matches(path.join(SRC_DIR, 'styles.css'))).toBe(false);
-		});
-
-		it('returns false for files outside src directory', () => {
-			const context = createMockContext({
-				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
-			});
-			const strategy = new JsHmrStrategy(context);
-
-			expect(strategy.matches('/other/path/file.ts')).toBe(false);
-		});
-
-		it('returns false for integration-owned route template files', () => {
-			const pagesDir = path.join(SRC_DIR, 'pages');
-			const context = createMockContext({
-				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
-				getPagesDir: () => pagesDir,
-				getTemplateExtensions: () => ['.kita.tsx', '.react.tsx'],
-			});
-			const strategy = new JsHmrStrategy(context);
-
-			expect(strategy.matches(path.join(pagesDir, 'index.kita.tsx'))).toBe(false);
-			expect(strategy.matches(path.join(pagesDir, 'home.react.tsx'))).toBe(false);
-		});
-
-		it('returns false for non-extension matches', () => {
-			const context = createMockContext({
-				getWatchedFiles: () => new Map([[path.join(SRC_DIR, 'entry.ts'), '/output.js']]),
-			});
-			const strategy = new JsHmrStrategy(context);
-
-			expect(strategy.matches(path.join(SRC_DIR, 'data.json'))).toBe(false);
-			expect(strategy.matches(path.join(SRC_DIR, 'readme.md'))).toBe(false);
-		});
-	});
-
-	describe('process', () => {
-		it('returns none when no watched files are registered', async () => {
-			const context = createMockContext({
-				getWatchedFiles: () => new Map(),
-			});
-			const strategy = new JsHmrStrategy(context);
-
-			const action = await strategy.process(path.join(SRC_DIR, 'app.ts'));
-
-			expect(action.type).toBe('none');
-		});
-
-		it('rebuilds only dependency-connected entrypoints when graph hit exists', async () => {
-			const entryA = path.join(SRC_DIR, 'entry-a.ts');
-			const entryB = path.join(SRC_DIR, 'entry-b.ts');
-			const depA = path.join(SRC_DIR, 'shared-a.ts');
-			const setEntrypointDependenciesCalls: Array<{ entrypointPath: string; dependencies: string[] }> = [];
-			let batchedEntrypoints: string[] = [];
-			const devGraphService = new InMemoryDevGraphService();
-			devGraphService.setEntrypointDependencies(entryA, [depA]);
-			devGraphService.setEntrypointDependencies(entryB, [entryB]);
-
-			const context = createMockContext({
-				getWatchedFiles: () =>
-					new Map([
-						[entryA, '/_hmr/entry-a.js'],
-						[entryB, '/_hmr/entry-b.js'],
-					]),
-				getEntrypointDependencyGraph: () => ({
-					supportsSelectiveInvalidation: () => devGraphService.supportsSelectiveInvalidation(),
-					getDependencyEntrypoints: (filePath: string) => devGraphService.getDependencyEntrypoints(filePath),
-					setEntrypointDependencies: (entrypointPath: string, dependencies: string[]) => {
-						setEntrypointDependenciesCalls.push({ entrypointPath, dependencies });
-						devGraphService.setEntrypointDependencies(entrypointPath, dependencies);
-					},
-					clearEntrypointDependencies: (entrypointPath: string) =>
-						devGraphService.clearEntrypointDependencies(entrypointPath),
-					reset: () => devGraphService.reset(),
-				}),
-			});
-
-			const strategy = new JsHmrStrategy(context) as unknown as {
-				process: (filePath: string) => Promise<{ type: string; events?: unknown[] }>;
-				[key: string]: unknown;
-			};
-
-			strategy.bundleEntrypoints = async (entrypoints: string[]) => {
-				batchedEntrypoints = entrypoints;
-				const dependencies = new Map<string, string[]>();
-				for (const ep of entrypoints) {
-					dependencies.set(path.resolve(ep), [ep, depA]);
-				}
-				return { success: true, dependencies };
-			};
-
-			strategy.processOutput = async () => {
-				return { success: true, requiresReload: false };
-			};
-
-			const action = await strategy.process(depA);
-
-			expect(batchedEntrypoints).toEqual([entryA]);
-			expect(setEntrypointDependenciesCalls).toEqual([{ entrypointPath: entryA, dependencies: [entryA, depA] }]);
-			expect(action).toEqual({
-				type: 'broadcast',
-				events: [
-					{
-						type: 'update',
-						path: '/_hmr/entry-a.js',
-						timestamp: expect.any(Number),
-					},
-				],
-			});
-		});
-
-		it('falls back to rebuilding all watched entrypoints when graph has no hit', async () => {
-			const entryA = path.join(SRC_DIR, 'entry-a.ts');
-			const entryB = path.join(SRC_DIR, 'entry-b.ts');
-			const changedFile = path.join(SRC_DIR, 'new-shared.ts');
-			let batchedEntrypoints: string[] = [];
-
-			const context = createMockContext({
-				getWatchedFiles: () =>
-					new Map([
-						[entryA, '/_hmr/entry-a.js'],
-						[entryB, '/_hmr/entry-b.js'],
-					]),
-				getEntrypointDependencyGraph: () => new NoopDevGraphService(),
-			});
-
-			const strategy = new JsHmrStrategy(context) as unknown as {
-				process: (filePath: string) => Promise<{ type: string; events?: unknown[] }>;
-				[key: string]: unknown;
-			};
-
-			strategy.bundleEntrypoints = async (entrypoints: string[]) => {
-				batchedEntrypoints = entrypoints;
-				const dependencies = new Map<string, string[]>();
-				for (const ep of entrypoints) {
-					dependencies.set(path.resolve(ep), [ep]);
-				}
-				return { success: true, dependencies };
-			};
-
-			strategy.processOutput = async () => {
-				return { success: true, requiresReload: false };
-			};
-
-			const action = await strategy.process(changedFile);
-
-			expect(batchedEntrypoints).toEqual([entryA, entryB]);
-			expect(action).toEqual({
-				type: 'broadcast',
-				events: [
-					{
-						type: 'update',
-						path: '/_hmr/entry-a.js',
-						timestamp: expect.any(Number),
-					},
-					{
-						type: 'update',
-						path: '/_hmr/entry-b.js',
-						timestamp: expect.any(Number),
-					},
-				],
-			});
-		});
-
-		it('skips watched entrypoints owned by higher-priority integration strategies', async () => {
-			const reactEntrypoint = path.join(SRC_DIR, 'react-page.tsx');
-			const scriptEntrypoint = path.join(SRC_DIR, 'widget.script.ts');
-			const changedFile = path.join(SRC_DIR, 'shared.ts');
-			let batchedEntrypoints: string[] = [];
-			const devGraphService = new InMemoryDevGraphService();
-			devGraphService.setEntrypointDependencies(reactEntrypoint, [changedFile]);
-			devGraphService.setEntrypointDependencies(scriptEntrypoint, [changedFile]);
-
-			const context = createMockContext({
-				getWatchedFiles: () =>
-					new Map([
-						[reactEntrypoint, '/_hmr/react-page.js'],
-						[scriptEntrypoint, '/_hmr/widget.script.js'],
-					]),
-				getEntrypointDependencyGraph: () => devGraphService,
-				shouldProcessEntrypoint: (entrypointPath: string) => entrypointPath !== reactEntrypoint,
-			});
-
-			const strategy = new JsHmrStrategy(context) as unknown as {
-				process: (filePath: string) => Promise<{ type: string; events?: unknown[] }>;
-				[key: string]: unknown;
-			};
-
-			strategy.bundleEntrypoints = async (entrypoints: string[]) => {
-				batchedEntrypoints = entrypoints;
-				return { success: true, dependencies: new Map([[path.resolve(scriptEntrypoint), [scriptEntrypoint]]]) };
-			};
-
-			strategy.processOutput = async () => {
-				return { success: true, requiresReload: false };
-			};
-
-			const action = await strategy.process(changedFile);
-
-			expect(batchedEntrypoints).toEqual([scriptEntrypoint]);
-			expect(action).toEqual({
-				type: 'broadcast',
-				events: [
-					{
-						type: 'update',
-						path: '/_hmr/widget.script.js',
-						timestamp: expect.any(Number),
-					},
-				],
-			});
-		});
-	});
-});

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

@@ -1,314 +0,0 @@
-/**
- * JavaScript HMR Strategy
- *
- * Handles hot module replacement for JavaScript and TypeScript entrypoints.
- * Bundles files, inspects the emitted output, and decides whether the browser
- * can hot-accept the change or must reload.
- *
- * @module
- */
-
-import path from 'node:path';
-import { fileSystem } from '@ecopages/file-system';
-import { HmrStrategy, HmrStrategyType, type HmrAction } from '../hmr-strategy.ts';
-import { appLogger } from '../../global/app-logger.ts';
-import type { EcoBuildPlugin } from '../../build/build-types.ts';
-import type { BrowserBundleExecutor } from '../../services/assets/browser-bundle.service.ts';
-import type { EntrypointDependencyGraph } from '../../services/runtime-state/entrypoint-dependency-graph.service.ts';
-
-/**
- * Context interface providing access to HmrManager state.
- * Required for JsHmrStrategy to access registered entrypoints and configuration.
- */
-export interface JsHmrContext {
-	/**
-	 * Map of registered entrypoints to their output URLs.
-	 */
-	getWatchedFiles(): Map<string, string>;
-
-	getEntrypointDependencyGraph(): EntrypointDependencyGraph;
-
-	/**
-	 * Directory where HMR bundles are written.
-	 */
-	getDistDir(): string;
-
-	/**
-	 * Build plugins to use during bundling.
-	 */
-	getPlugins(): EcoBuildPlugin[];
-
-	/**
-	 * Absolute path to the source directory.
-	 */
-	getSrcDir(): string;
-
-	/**
-	 * Absolute path to the pages directory.
-	 */
-	getPagesDir(): string;
-
-	/**
-	 * Absolute path to the layouts directory.
-	 */
-	getLayoutsDir(): string;
-
-	/**
-	 * All configured route-template extensions across integrations.
-	 */
-	getTemplateExtensions(): string[];
-
-	/**
-	 * Browser bundler used to rebuild changed entrypoints.
-	 */
-	getBrowserBundleService(): BrowserBundleExecutor;
-
-	/**
-	 * Returns whether a watched entrypoint should be rebuilt by the generic JS strategy.
-	 *
-	 * @remarks
-	 * Integrations with higher-priority HMR strategies can use this to keep the
-	 * generic JS strategy from overwriting their emitted entrypoints when a shared
-	 * dependency changes.
-	 */
-	shouldProcessEntrypoint?(entrypointPath: string): boolean;
-}
-
-/**
- * Strategy for handling JavaScript/TypeScript file changes with hot reloading.
- *
- * The processing steps are:
- * 1. Check if any entrypoints are registered
- * 2. Rebuild impacted entrypoints, or all watched entrypoints when no runtime
- *    dependency graph is available
- * 3. Emit rebuilt entrypoint bundles for browser delivery
- * 4. Inject generic HMR boilerplate
- * 5. Broadcast update events for each rebuilt entrypoint
- *
- * @remarks
- * Node can provide dependency-graph metadata, so this strategy can rebuild only
- * the entrypoints impacted by a changed dependency. Runtimes that do not expose
- * that metadata intentionally keep the rebuild-all fallback.
- *
- * @see https://bun.sh/docs/runtime/transpiler
- *
- * @example
- * ```typescript
- * const context = {
- *   getWatchedFiles: () => watchedFilesMap,
- *   getDistDir: () => '/path/to/dist/_hmr',
- *   getPlugins: () => [],
- *   getSrcDir: () => '/path/to/src'
- * };
- * const strategy = new JsHmrStrategy(context);
- * ```
- */
-export class JsHmrStrategy extends HmrStrategy {
-	readonly type = HmrStrategyType.SCRIPT;
-	private context: JsHmrContext;
-
-	constructor(context: JsHmrContext) {
-		super();
-		this.context = context;
-	}
-
-	/**
-	 * Determines if the file is a JS/TS file that could affect registered entrypoints.
-	 *
-	 * Matches if:
-	 * 1. There are registered entrypoints to rebuild
-	 * 2. The changed file is a JS/TS file in the src directory
-	 *
-	 * @param filePath - Absolute path to the changed file
-	 * @returns True if this file should trigger entrypoint rebuilds
-	 */
-	matches(filePath: string): boolean {
-		const watchedFiles = this.context.getWatchedFiles();
-		const isJsTs = /\.(ts|tsx|js|jsx)$/.test(filePath);
-		const isInSrc = filePath.startsWith(this.context.getSrcDir());
-		const isRouteTemplate =
-			filePath.startsWith(this.context.getPagesDir()) || filePath.startsWith(this.context.getLayoutsDir());
-		const isIntegrationTemplate =
-			isRouteTemplate && this.context.getTemplateExtensions().some((extension) => filePath.endsWith(extension));
-
-		if (watchedFiles.size === 0) {
-			return false;
-		}
-
-		if (!isJsTs || !isInSrc) {
-			return false;
-		}
-
-		if (isIntegrationTemplate) {
-			return false;
-		}
-
-		if (watchedFiles.has(filePath)) {
-			return true;
-		}
-
-		const entrypointDependencyGraph = this.context.getEntrypointDependencyGraph();
-		if (entrypointDependencyGraph.supportsSelectiveInvalidation()) {
-			return entrypointDependencyGraph.getDependencyEntrypoints(filePath).size > 0;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Processes a file change by rebuilding affected entrypoints.
-	 *
-	 * @param filePath - Absolute path to the changed file
-	 *
-	 * @remarks
-	 * If runtime-specific dependency graph hooks are unavailable, this strategy
-	 * falls back to rebuilding all watched entrypoints.
-	 * When multiple entrypoints are impacted they are bundled in a single esbuild
-	 * invocation to share AST parsing and chunk deduplication.
-	 * @returns Action to broadcast update events
-	 */
-	async process(filePath: string): Promise<HmrAction> {
-		appLogger.debug(`[JsHmrStrategy] Processing ${filePath}`);
-		const watchedFiles = this.context.getWatchedFiles();
-
-		if (watchedFiles.size === 0) {
-			appLogger.debug(`[JsHmrStrategy] No watched files to rebuild`);
-			return { type: 'none' };
-		}
-
-		const dependencyHits = this.context.getEntrypointDependencyGraph().getDependencyEntrypoints(filePath);
-		const hasDependencyHit = dependencyHits.size > 0;
-		const impactedEntrypoints = hasDependencyHit
-			? Array.from(dependencyHits).filter((entrypoint) => watchedFiles.has(entrypoint))
-			: Array.from(watchedFiles.keys());
-		const buildableEntrypoints = impactedEntrypoints.filter(
-			(entrypoint) => this.context.shouldProcessEntrypoint?.(entrypoint) ?? true,
-		);
-
-		if (!hasDependencyHit) {
-			appLogger.debug('[JsHmrStrategy] Dependency graph miss, rebuilding all watched entrypoints');
-		}
-
-		if (buildableEntrypoints.length === 0) {
-			return { type: 'none' };
-		}
-
-		const buildResult = await this.bundleEntrypoints(buildableEntrypoints);
-
-		if (!buildResult.success) {
-			return { type: 'none' };
-		}
-
-		const updates: string[] = [];
-		let reloadRequired = false;
-
-		for (const entrypoint of buildableEntrypoints) {
-			const outputUrl = watchedFiles.get(entrypoint);
-			if (!outputUrl) continue;
-
-			if (buildResult.dependencies) {
-				const entrypointDeps = buildResult.dependencies.get(path.resolve(entrypoint)) ?? [];
-				this.context.getEntrypointDependencyGraph().setEntrypointDependencies(entrypoint, entrypointDeps);
-			}
-
-			const srcDir = this.context.getSrcDir();
-			const relativePath = path.relative(srcDir, entrypoint);
-			const relativePathJs = relativePath.replace(/\.(tsx?|jsx?|mdx?)$/, '.js');
-			const outputPath = path.join(this.context.getDistDir(), relativePathJs);
-
-			const result = await this.processOutput(outputPath, outputUrl);
-			if (result.success) {
-				updates.push(outputUrl);
-				if (result.requiresReload) {
-					reloadRequired = true;
-				}
-			}
-		}
-
-		if (updates.length > 0) {
-			if (reloadRequired) {
-				appLogger.debug(`[JsHmrStrategy] Full reload required (no HMR accept found)`);
-				return {
-					type: 'broadcast',
-					events: [{ type: 'reload' }],
-				};
-			}
-
-			return {
-				type: 'broadcast',
-				events: updates.map((p) => ({
-					type: 'update',
-					path: p,
-					timestamp: Date.now(),
-				})),
-			};
-		}
-
-		return { type: 'none' };
-	}
-
-	/**
-	 * Bundles one or more entrypoints in a single esbuild invocation.
-	 * Uses the source directory as the output base so that the directory structure
-	 * is preserved under the HMR dist folder.
-	 */
-	private async bundleEntrypoints(
-		entrypoints: string[],
-	): Promise<{ success: boolean; dependencies?: Map<string, string[]> }> {
-		try {
-			const result = await this.context.getBrowserBundleService().bundle({
-				profile: 'hmr-entrypoint',
-				entrypoints,
-				outdir: this.context.getDistDir(),
-				outbase: this.context.getSrcDir(),
-				naming: '[dir]/[name]',
-				plugins: this.context.getPlugins(),
-				minify: false,
-			});
-
-			if (!result.success) {
-				appLogger.error('[JsHmrStrategy] Batched build failed:', result.logs);
-				return { success: false };
-			}
-
-			const dependencies = new Map<string, string[]>();
-			if (result.dependencyGraph?.entrypoints) {
-				for (const [entrypoint, deps] of Object.entries(result.dependencyGraph.entrypoints)) {
-					dependencies.set(path.resolve(entrypoint), deps);
-				}
-			}
-
-			return { success: true, dependencies };
-		} catch (error) {
-			appLogger.error('[JsHmrStrategy] Error in batched build:', error as Error);
-			return { success: false };
-		}
-	}
-
-	/**
-	 * Processes bundled output and determines whether the browser can hot-accept
-	 * the update or must fall back to a full reload.
-	 *
-	 * @param filepath - Path to the bundled output file
-	 * @param url - URL path for the bundled file
-	 * @returns True if processing was successful and update should be broadcast
-	 */
-	private async processOutput(filepath: string, url: string): Promise<{ success: boolean; requiresReload: boolean }> {
-		try {
-			const code = await fileSystem.readFile(filepath);
-
-			if (code.includes('/* [ecopages] hmr */')) {
-				// Legacy safety: previously processed bundles already carry the marker.
-				return { success: true, requiresReload: !code.includes('import.meta.hot.accept') };
-			}
-
-			appLogger.debug(`[JsHmrStrategy] Processed ${url}`);
-
-			const hasHmrAccept = code.includes('import.meta.hot.accept');
-			return { success: true, requiresReload: !hasHmrAccept };
-		} catch (error) {
-			appLogger.error(`[JsHmrStrategy] Error processing output for ${url}:`, error as Error);
-			return { success: false, requiresReload: false };
-		}
-	}
-}

package/src/index.browser.ts

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

package/src/index.ts

@@ -1,15 +0,0 @@
-export type * from './types/public-types.ts';
-export type * from './eco/eco.types.ts';
-export { eco } from './eco/eco.ts';
-export { defineApiHandler, defineGroupHandler, type GroupHandler } from './adapters/shared/define-api-handler.ts';
-export {
-	createEcoBuildPluginFromSourceTransform,
-	createVitePluginsFromAppSourceTransforms,
-	getAppSourceTransforms,
-	createVitePluginFromSourceTransform,
-	normalizeTransformId,
-	type EcoSourceTransform,
-	type EcoSourceTransformResult,
-	type EcoViteCompatiblePlugin,
-} from './plugins/source-transform.ts';
-export { createEcoComponentMetaTransform } from './plugins/eco-component-meta-plugin.ts';