@ecopages/core 0.2.0-alpha.4 → 0.2.0-alpha.6

package/src/services/{asset-processing-service → assets/asset-processing-service}/asset-processing.service.ts

@@ -1,8 +1,8 @@
 import path from 'node:path';
-import { RESOLVED_ASSETS_DIR } from '../../constants';
-import { appLogger } from '../../global/app-logger';
-import type { EcoPagesAppConfig, IHmrManager } from '../../internal-types';
-import { rapidhash } from '../../utils/hash';
+import { RESOLVED_ASSETS_DIR } from '../../../constants';
+import { appLogger } from '../../../global/app-logger';
+import type { EcoPagesAppConfig, IHmrManager } from '../../../internal-types';
+import { rapidhash } from '../../../utils/hash';
 import { fileSystem } from '@ecopages/file-system';
 import type { AssetDefinition, AssetKind, AssetSource, ProcessedAsset } from './assets.types';
 import { isHmrAware } from './processor.interface';
@@ -15,13 +15,28 @@ import {
 	NodeModuleScriptProcessor,
 } from './processors';
 
+/**
+ * Processes declared component and page asset dependencies for one app instance.
+ *
+ * @remarks
+ * This service is the shared bridge between dependency declarations and emitted
+ * runtime-ready assets. It owns deduplication, processor dispatch, cache reuse,
+ * output URL normalization, and production gzip preparation so route rendering
+ * and HMR flows do not need to understand processor-specific behavior.
+ */
 export class AssetProcessingService {
 	static readonly RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
 	private registry = new ProcessorRegistry();
 	private hmrManager?: IHmrManager;
 	private cache = new Map<string, { asset: ProcessedAsset }>();
+	private readonly config: EcoPagesAppConfig;
 
-	constructor(private readonly config: EcoPagesAppConfig) {}
+	/**
+	 * Creates the asset-processing service bound to one finalized app config.
+	 */
+	constructor(config: EcoPagesAppConfig) {
+		this.config = config;
+	}
 
 	/**
 	 * Set the HMR manager for the asset processing service.
@@ -54,6 +69,14 @@ export class AssetProcessingService {
 		this.registry.register(kind, variant, processor);
 	}
 
+	/**
+	 * Processes one dependency list into normalized emitted assets.
+	 *
+	 * @remarks
+	 * Dependencies are deduplicated before processor execution so repeated
+	 * declarations across the render tree reuse the same emitted outputs and cache
+	 * entries.
+	 */
 	async processDependencies(deps: AssetDefinition[], key: string): Promise<ProcessedAsset[]> {
 		const depsDir = path.join(this.config.absolutePaths.distDir, RESOLVED_ASSETS_DIR);
 		fileSystem.ensureDir(depsDir);
@@ -65,6 +88,9 @@ export class AssetProcessingService {
 		return results;
 	}
 
+	/**
+	 * Removes duplicate dependency declarations while preserving first-seen order.
+	 */
 	private deduplicateDependencies(deps: AssetDefinition[]): AssetDefinition[] {
 		const seen = new Map<string, AssetDefinition>();
 
@@ -78,6 +104,10 @@ export class AssetProcessingService {
 		return Array.from(seen.values());
 	}
 
+	/**
+	 * Builds the cache signature fragment for script dependencies that can vary by
+	 * bundling policy.
+	 */
 	private getScriptDependencyBuildSignature(dep: AssetDefinition): string | undefined {
 		if (dep.kind !== 'script') {
 			return undefined;
@@ -97,6 +127,9 @@ export class AssetProcessingService {
 		return this.generateHash(JSON.stringify(signature));
 	}
 
+	/**
+	 * Derives the stable cache key for one dependency declaration.
+	 */
 	private getDependencyKey(dep: AssetDefinition): string {
 		const parts: string[] = [dep.kind, dep.source];
 
@@ -120,10 +153,21 @@ export class AssetProcessingService {
 		return parts.join(':');
 	}
 
+	/**
+	 * Hashes content used in dependency cache and signature keys.
+	 */
 	private generateHash(content: string): string {
 		return rapidhash(content).toString();
 	}
 
+	/**
+	 * Processes deduplicated dependencies grouped by processor type.
+	 *
+	 * @remarks
+	 * Grouping keeps cache and processor behavior isolated by asset kind/source
+	 * pair, while still allowing the overall dependency set to resolve in
+	 * parallel.
+	 */
 	private async processDependenciesParallel(deps: AssetDefinition[], key: string): Promise<ProcessedAsset[]> {
 		const grouped = this.groupDependenciesByType(deps);
 
@@ -182,6 +226,9 @@ export class AssetProcessingService {
 		return allTypeResults.flat();
 	}
 
+	/**
+	 * Groups dependencies by processor bucket.
+	 */
 	private groupDependenciesByType(deps: AssetDefinition[]): Record<string, AssetDefinition[]> {
 		return deps.reduce(
 			(acc, dep) => {
@@ -194,6 +241,9 @@ export class AssetProcessingService {
 		);
 	}
 
+	/**
+	 * Converts a dist-local file path into its public URL.
+	 */
 	private getSrcUrl(filepath: string): string | undefined {
 		const distDir = this.config.absolutePaths.distDir;
 		if (!filepath.startsWith(distDir)) return undefined;
@@ -203,6 +253,9 @@ export class AssetProcessingService {
 		return urlPath.replace(/\\/g, '/');
 	}
 
+	/**
+	 * Normalizes the public source URL for one processed asset.
+	 */
 	private resolveProcessedAssetSrcUrl(processed: ProcessedAsset): string | undefined {
 		if (processed.srcUrl) {
 			if (this.isFilesystemPath(processed.srcUrl)) {
@@ -220,6 +273,10 @@ export class AssetProcessingService {
 		return undefined;
 	}
 
+	/**
+	 * Returns whether a value should be interpreted as a filesystem path instead
+	 * of an already-public URL.
+	 */
 	private isFilesystemPath(value: string): boolean {
 		if (value.startsWith('http://') || value.startsWith('https://') || value.startsWith('//')) {
 			return false;
@@ -237,6 +294,13 @@ export class AssetProcessingService {
 		return /^[A-Za-z]:\\/.test(value);
 	}
 
+	/**
+	 * Applies post-processing for emitted production assets.
+	 *
+	 * @remarks
+	 * Current optimization is intentionally conservative: only generated CSS and
+	 * JavaScript files inside the app dist directory are gzipped.
+	 */
 	private async optimizeDependencies(processedAssets: ProcessedAsset[]): Promise<void> {
 		if (process.env.NODE_ENV !== 'production') {
 			return;
@@ -266,19 +330,44 @@ export class AssetProcessingService {
 		}
 	}
 
+	/**
+	 * Returns the cached processed asset for a dependency key when available.
+	 */
 	private getCachedAsset(dep: AssetDefinition, depKey: string): ProcessedAsset | null {
+		if (process.env.NODE_ENV !== 'production' && dep.source === 'file' && dep.kind === 'stylesheet') {
+			return null;
+		}
+
 		const cached = this.cache.get(depKey);
-		return cached?.asset ?? null;
+		if (!cached) {
+			return null;
+		}
+
+		if (cached.asset.filepath && !fileSystem.exists(cached.asset.filepath)) {
+			this.cache.delete(depKey);
+			return null;
+		}
+
+		return cached.asset;
 	}
 
+	/**
+	 * Stores one processed asset in the dependency cache.
+	 */
 	private setCachedAsset(dep: AssetDefinition, depKey: string, asset: ProcessedAsset): void {
 		this.cache.set(depKey, { asset });
 	}
 
+	/**
+	 * Clears all cached processed assets.
+	 */
 	clearCache(): void {
 		this.cache.clear();
 	}
 
+	/**
+	 * Removes cached assets that were produced from the given file path.
+	 */
 	invalidateCacheForFile(filepath: string): void {
 		for (const [key, value] of this.cache.entries()) {
 			if (value.asset.filepath === filepath) {
@@ -287,6 +376,9 @@ export class AssetProcessingService {
 		}
 	}
 
+	/**
+	 * Creates a service prewired with the default core processors.
+	 */
 	static createWithDefaultProcessors(appConfig: EcoPagesAppConfig): AssetProcessingService {
 		const service = new AssetProcessingService(appConfig);
 
@@ -300,6 +392,9 @@ export class AssetProcessingService {
 		return service;
 	}
 
+	/**
+	 * Returns the processor registry owned by this service.
+	 */
 	getRegistry(): ProcessorRegistry {
 		return this.registry;
 	}

package/src/services/assets/asset-processing-service/asset.factory.test.ts

@@ -0,0 +1,63 @@
+import { expect, test } from 'vitest';
+import { AssetFactory } from './asset.factory';
+
+test('AssetFactory - createInlineScriptAsset', () => {
+	const asset = AssetFactory.createInlineContentScript({
+		content: 'console.log("test")',
+	});
+	expect(asset.kind).toBe('script');
+	expect(asset.source).toBe('content');
+	expect(asset.inline).toBe(true);
+	expect(asset.position).toBe('body');
+});
+
+test('AssetFactory - createSrcScriptAsset', () => {
+	const asset = AssetFactory.createFileScript({
+		filepath: 'https://test.com/script.js',
+	});
+	expect(asset.kind).toBe('script');
+	expect(asset.source).toBe('file');
+});
+
+test('AssetFactory - createJsonAssetScript', () => {
+	const asset = AssetFactory.createJsonScript({
+		content: '{"test": true}',
+	});
+	expect(asset.kind).toBe('script');
+	expect(asset.source).toBe('content');
+	expect(asset.attributes?.type).toBe('application/json');
+});
+
+test('AssetFactory - createInlineStylesheetAsset', () => {
+	const asset = AssetFactory.createInlineContentStylesheet({
+		content: 'body { color: red; }',
+	});
+	expect(asset.kind).toBe('stylesheet');
+	expect(asset.source).toBe('content');
+	expect(asset.position).toBe('head');
+});
+
+test('AssetFactory - createContentScript', () => {
+	const asset = AssetFactory.createContentScript({
+		content: 'console.log("test")',
+	});
+	expect(asset.kind).toBe('script');
+	expect(asset.source).toBe('content');
+	expect(asset.position).toBe('body');
+});
+
+test('AssetFactory - createInlineContentScript', () => {
+	const asset = AssetFactory.createInlineContentScript({
+		content: 'console.log("test")',
+	});
+	expect(asset.inline).toBe(true);
+	expect(asset.source).toBe('content');
+});
+
+test('AssetFactory - createFileScript', () => {
+	const asset = AssetFactory.createFileScript({
+		filepath: '/path/to/script.js',
+	});
+	expect(asset.kind).toBe('script');
+	expect(asset.source).toBe('file');
+});

package/src/services/{asset-processing-service → assets/asset-processing-service}/asset.factory.ts

@@ -1,5 +1,5 @@
-import { RESOLVED_ASSETS_DIR, RESOLVED_ASSETS_VENDORS_DIR } from '../../constants';
-import { deepMerge } from '../../utils/deep-merge';
+import { RESOLVED_ASSETS_DIR, RESOLVED_ASSETS_VENDORS_DIR } from '../../../constants';
+import { deepMerge } from '../../../utils/deep-merge';
 import type {
 	ContentScriptAsset,
 	ContentStylesheetAsset,

package/src/services/{asset-processing-service → assets/asset-processing-service}/assets.types.ts

@@ -1,4 +1,4 @@
-import type { EcoBuildPlugin } from '../../build/build-types.ts';
+import type { EcoBuildPlugin } from '../../../build/build-types.ts';
 
 export type AssetSource = 'content' | 'file' | 'node-module';
 export type AssetKind = 'script' | 'stylesheet';
@@ -16,6 +16,7 @@ export interface ScriptAsset extends BaseAsset {
 	inline?: boolean;
 	bundle?: boolean;
 	bundleOptions?: {
+		define?: Record<string, string>;
 		minify?: boolean;
 		external?: string[];
 		naming?: string;

package/src/services/assets/asset-processing-service/browser-runtime-asset.factory.test.ts

@@ -0,0 +1,72 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { test } from 'vitest';
+import {
+	BROWSER_RUNTIME_SCRIPT_ATTRIBUTES,
+	buildBrowserRuntimeAssetUrl,
+	createBrowserRuntimeModuleAsset,
+	createBrowserRuntimeScriptAsset,
+} from './browser-runtime-asset.factory.ts';
+
+test('buildBrowserRuntimeAssetUrl uses the vendors asset directory', () => {
+	assert.equal(buildBrowserRuntimeAssetUrl('react.js'), '/assets/vendors/react.js');
+});
+
+test('createBrowserRuntimeScriptAsset creates a hidden head runtime bundle asset', () => {
+	const plugin = { name: 'runtime-plugin', setup() {} };
+	const asset = createBrowserRuntimeScriptAsset({
+		importPath: '/tmp/react-entry.mjs',
+		name: 'react',
+		fileName: 'react.js',
+		bundleOptions: {
+			plugins: [plugin],
+		},
+	});
+
+	assert.deepEqual(asset, {
+		kind: 'script',
+		source: 'node-module',
+		position: 'head',
+		importPath: '/tmp/react-entry.mjs',
+		name: 'react',
+		excludeFromHtml: true,
+		bundleOptions: {
+			naming: 'react.js',
+			plugins: [plugin],
+		},
+		attributes: BROWSER_RUNTIME_SCRIPT_ATTRIBUTES,
+	});
+});
+
+test('createBrowserRuntimeModuleAsset creates an entry module and hidden runtime asset together', () => {
+	const rootDir = fs.mkdtempSync(path.join(os.tmpdir(), 'eco-browser-runtime-asset-'));
+	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
+	fs.mkdirSync(path.join(rootDir, 'node_modules', 'runtime-a'), { recursive: true });
+	fs.writeFileSync(
+		path.join(rootDir, 'node_modules', 'runtime-a', 'index.js'),
+		"module.exports = { default: 'runtime-a', alpha: 'a' };",
+		'utf8',
+	);
+
+	try {
+		const asset = createBrowserRuntimeModuleAsset({
+			rootDir,
+			cacheDirName: 'ecopages-browser-runtime-test',
+			modules: [{ specifier: 'runtime-a', defaultExport: true }],
+			name: 'runtime-a',
+			fileName: 'runtime-a.js',
+		});
+
+		assert.equal(asset.source, 'node-module');
+		assert.equal(
+			asset.importPath.endsWith(path.join('ecopages-browser-runtime-test', 'runtime-a-entry.mjs')),
+			true,
+		);
+		assert.equal(asset.bundleOptions?.naming, 'runtime-a.js');
+		assert.equal(asset.excludeFromHtml, true);
+	} finally {
+		fs.rmSync(rootDir, { recursive: true, force: true });
+	}
+});

package/src/services/assets/asset-processing-service/browser-runtime-asset.factory.ts

@@ -0,0 +1,95 @@
+import type { EcoBuildPlugin } from '../../../build/build-types.ts';
+import { AssetFactory } from './asset.factory.ts';
+import type { AssetDefinition } from './assets.types.ts';
+import {
+	createBrowserRuntimeEntryModule,
+	type BrowserRuntimeEntryModuleConfig,
+} from './browser-runtime-entry.factory.ts';
+
+export const BROWSER_RUNTIME_SCRIPT_ATTRIBUTES = {
+	type: 'module',
+	defer: '',
+} as const;
+
+/**
+ * Builds the public vendor URL used for generated browser runtime assets.
+ */
+export function buildBrowserRuntimeAssetUrl(fileName: string): string {
+	return `/${AssetFactory.RESOLVED_ASSETS_VENDORS_DIR}/${fileName}`;
+}
+
+/**
+ * Declares a browser runtime script asset backed by one importable module.
+ *
+ * @remarks
+ * Runtime assets are emitted as excluded head scripts because integrations often
+ * need the bundler output and specifier registration without injecting the raw
+ * asset directly into HTML during dependency resolution.
+ */
+export function createBrowserRuntimeScriptAsset(options: {
+	importPath: string;
+	name: string;
+	fileName: string;
+	bundleOptions?: {
+		define?: Record<string, string>;
+		minify?: boolean;
+		external?: string[];
+		naming?: string;
+		plugins?: EcoBuildPlugin[];
+	};
+	attributes?: Record<string, string>;
+}): AssetDefinition {
+	return AssetFactory.createNodeModuleScript({
+		position: 'head',
+		importPath: options.importPath,
+		name: options.name,
+		excludeFromHtml: true,
+		bundleOptions: {
+			naming: options.fileName,
+			...options.bundleOptions,
+		},
+		attributes: {
+			...BROWSER_RUNTIME_SCRIPT_ATTRIBUTES,
+			...(options.attributes ?? {}),
+		},
+	});
+}
+
+/**
+ * Creates a browser runtime asset from a generated re-export entry module.
+ *
+ * @remarks
+ * This is the shared "module list -> generated entry file -> runtime asset"
+ * path used by integrations that need browser-side runtime bundles without
+ * owning bespoke entry-file generation logic.
+ */
+export function createBrowserRuntimeModuleAsset(options: {
+	modules: BrowserRuntimeEntryModuleConfig[];
+	name: string;
+	fileName: string;
+	cacheDirName?: string;
+	rootDir?: string;
+	bundleOptions?: {
+		define?: Record<string, string>;
+		minify?: boolean;
+		external?: string[];
+		naming?: string;
+		plugins?: EcoBuildPlugin[];
+	};
+	attributes?: Record<string, string>;
+}): AssetDefinition {
+	const importPath = createBrowserRuntimeEntryModule({
+		modules: options.modules,
+		fileName: `${options.name}-entry.mjs`,
+		rootDir: options.rootDir,
+		cacheDirName: options.cacheDirName,
+	});
+
+	return createBrowserRuntimeScriptAsset({
+		importPath,
+		name: options.name,
+		fileName: options.fileName,
+		bundleOptions: options.bundleOptions,
+		attributes: options.attributes,
+	});
+}

package/src/services/assets/asset-processing-service/browser-runtime-entry.factory.test.ts

@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+import { test } from 'vitest';
+import { createBrowserRuntimeEntryModule } from './browser-runtime-entry.factory.ts';
+
+test('createBrowserRuntimeEntryModule writes a shared runtime entry file', () => {
+	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-browser-runtime-entry-'));
+	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
+
+	try {
+		const filePath = createBrowserRuntimeEntryModule({
+			rootDir,
+			cacheDirName: 'ecopages-react-runtime-test',
+			fileName: 'runtime-entry.mjs',
+			modules: [{ specifier: 'node:path' }, { specifier: 'node:fs' }],
+		});
+
+		assert.equal(path.basename(filePath), 'runtime-entry.mjs');
+		assert.equal(
+			filePath,
+			path.join(rootDir, 'node_modules', '.cache', 'ecopages-react-runtime-test', 'runtime-entry.mjs'),
+		);
+
+		const contents = fs.readFileSync(filePath, 'utf8');
+		assert.match(contents, /export \{ .*basename.* \} from 'node:path';/);
+		assert.match(contents, /export \{ .*readFileSync.* \} from 'node:fs';/);
+	} finally {
+		fs.rmSync(rootDir, { recursive: true, force: true });
+	}
+});
+
+test('createBrowserRuntimeEntryModule preserves a default export and deduplicates named exports', () => {
+	const rootDir = fs.mkdtempSync(path.join(tmpdir(), 'eco-browser-runtime-entry-'));
+	fs.writeFileSync(path.join(rootDir, 'package.json'), '{}', 'utf8');
+	fs.mkdirSync(path.join(rootDir, 'node_modules', 'runtime-a'), { recursive: true });
+	fs.mkdirSync(path.join(rootDir, 'node_modules', 'runtime-b'), { recursive: true });
+	fs.writeFileSync(
+		path.join(rootDir, 'node_modules', 'runtime-a', 'index.js'),
+		"module.exports = { default: 'runtime-a', alpha: 'a', shared: 'shared-a' };",
+		'utf8',
+	);
+	fs.writeFileSync(
+		path.join(rootDir, 'node_modules', 'runtime-b', 'index.js'),
+		"module.exports = { beta: 'b', shared: 'shared-b' };",
+		'utf8',
+	);
+
+	try {
+		const filePath = createBrowserRuntimeEntryModule({
+			rootDir,
+			cacheDirName: 'ecopages-react-runtime-test',
+			fileName: 'runtime-entry.mjs',
+			modules: [{ specifier: 'runtime-a', defaultExport: true }, { specifier: 'runtime-b' }],
+		});
+
+		const contents = fs.readFileSync(filePath, 'utf8');
+		assert.match(contents, /import __ecopages_default_export__ from 'runtime-a';/);
+		assert.match(contents, /export default __ecopages_default_export__;/);
+		assert.match(contents, /export \{ alpha, shared \} from 'runtime-a';/);
+		assert.match(contents, /export \{ beta \} from 'runtime-b';/);
+		assert.doesNotMatch(contents, /export \{ .*shared.* \} from 'runtime-b';/);
+	} finally {
+		fs.rmSync(rootDir, { recursive: true, force: true });
+	}
+});

package/src/services/assets/asset-processing-service/browser-runtime-entry.factory.ts

@@ -0,0 +1,78 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { createRequire } from 'node:module';
+
+export type BrowserRuntimeEntryModuleConfig = {
+	specifier: string;
+	defaultExport?: boolean;
+};
+
+/**
+ * Creates a generated ESM entry module that re-exports runtime modules through
+ * one stable file.
+ *
+ * @remarks
+ * Integrations use this helper when they need a browser runtime asset composed
+ * from multiple bare specifiers but do not want to own temporary file assembly
+ * logic themselves. The generated file lives under a cache directory inside the
+ * consuming app root so repeated runs can reuse the same location.
+ */
+export function createBrowserRuntimeEntryModule(options: {
+	modules: BrowserRuntimeEntryModuleConfig[];
+	fileName: string;
+	rootDir?: string;
+	cacheDirName?: string;
+}): string {
+	const rootDir = options.rootDir ?? process.cwd();
+	const artifactsDir = path.join(
+		rootDir,
+		'node_modules',
+		'.cache',
+		options.cacheDirName ?? 'ecopages-browser-runtime',
+	);
+	fs.mkdirSync(artifactsDir, { recursive: true });
+
+	const requireFromRoot = createRequire(path.join(rootDir, 'package.json'));
+	const seenExports = new Set<string>();
+	const statements: string[] = [];
+
+	for (const module of options.modules) {
+		if (module.defaultExport) {
+			statements.push(`import __ecopages_default_export__ from '${module.specifier}';`);
+			statements.push('export default __ecopages_default_export__;');
+		}
+
+		const exportNames = getModuleExportNames(module.specifier, requireFromRoot).filter(
+			(name) => !seenExports.has(name),
+		);
+
+		if (exportNames.length > 0) {
+			statements.push(`export { ${exportNames.join(', ')} } from '${module.specifier}';`);
+			for (const exportName of exportNames) {
+				seenExports.add(exportName);
+			}
+		}
+	}
+
+	const filePath = path.join(artifactsDir, options.fileName);
+	fs.writeFileSync(filePath, statements.join('\n'), 'utf-8');
+	return filePath;
+}
+
+/**
+ * Reads the named runtime exports that should be re-exported from a generated
+ * runtime entry module.
+ *
+ * @remarks
+ * Default exports are handled separately because generated runtime entry files
+ * need to emit a synthetic default binding only when the caller explicitly asks
+ * for it.
+ */
+function getModuleExportNames(specifier: string, requireFromRoot: ReturnType<typeof createRequire>): string[] {
+	const moduleExports = requireFromRoot(specifier);
+
+	return Object.keys(moduleExports)
+		.filter((name) => name !== '__esModule' && name !== 'default')
+		.filter((name) => /^[$A-Z_a-z][$\w]*$/.test(name))
+		.sort();
+}

package/src/services/{asset-processing-service → assets/asset-processing-service}/index.ts

@@ -1,3 +1,5 @@
 export * from './asset.factory';
 export * from './asset-processing.service';
 export * from './assets.types';
+export * from './browser-runtime-asset.factory';
+export * from './browser-runtime-entry.factory';

package/src/services/{asset-processing-service → assets/asset-processing-service}/processor.interface.ts

@@ -1,4 +1,4 @@
-import type { IHmrManager } from '../../internal-types';
+import type { IHmrManager } from '../../../internal-types';
 import type { AssetDefinition, ProcessedAsset } from './assets.types';
 
 /**