@ecopages/core 0.2.0-beta.9 → 0.2.0-rc.1

package/src/services/assets/asset-processing-service/processors/script/file-script.processor.js

@@ -1,97 +1,98 @@
-import path from "node:path";
-import { RESOLVED_ASSETS_DIR } from "../../../../../config/constants.js";
-import { fileSystem } from "@ecopages/file-system";
-import { BaseScriptProcessor } from "../base/base-script-processor.js";
-class FileScriptProcessor extends BaseScriptProcessor {
-  hmrManager;
-  resolveHmrOutputFilepath(entrypointPath) {
-    if (!this.hmrManager || !("getDistDir" in this.hmrManager)) {
-      return void 0;
+import path from 'node:path';
+import { RESOLVED_ASSETS_DIR } from '../../../../../config/constants.js';
+import { fileSystem } from '@ecopages/file-system';
+import { BaseScriptProcessor } from '../base/base-script-processor.js';
+export class FileScriptProcessor extends BaseScriptProcessor {
+    hmrManager;
+    setHmrManager(hmrManager) {
+        this.hmrManager = hmrManager;
     }
-    const getDistDir = this.hmrManager.getDistDir;
-    if (typeof getDistDir !== "function") {
-      return void 0;
-    }
-    const relativePathJs = path.relative(this.appConfig.absolutePaths.srcDir, entrypointPath).replace(/\.(tsx?|jsx?|mdx?)$/, ".js").replace(/\[([^\]]+)\]/g, "_$1_");
-    return path.join(getDistDir.call(this.hmrManager), relativePathJs);
-  }
-  setHmrManager(hmrManager) {
-    this.hmrManager = hmrManager;
-  }
-  async process(dep) {
-    if (this.hmrManager?.isEnabled() && !dep.inline) {
-      const outputUrl = await this.hmrManager.registerScriptEntrypoint(dep.filepath);
-      const outputFilepath = this.resolveHmrOutputFilepath(dep.filepath);
-      return {
-        filepath: outputFilepath ?? dep.filepath,
-        sourceFilepath: dep.filepath,
-        srcUrl: outputUrl,
-        kind: "script",
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: false,
-        excludeFromHtml: dep.excludeFromHtml,
-        packageRole: dep.packageRole,
-        bundledSourceFilepaths: dep.bundledSourceFilepaths
-      };
-    }
-    const content = fileSystem.readFileSync(dep.filepath);
-    const shouldBundle = this.shouldBundle(dep);
-    const configHash = this.generateHash(
-      JSON.stringify({
-        bundle: shouldBundle,
-        minify: shouldBundle && this.isProduction,
-        opts: dep.bundleOptions
-      })
-    );
-    const cachekey = `${this.buildCacheKey(dep.filepath, this.generateHash(content), dep)}:${configHash}`;
-    return this.getOrProcess(cachekey, async () => {
-      if (!shouldBundle) {
-        const outFilepath = path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath);
-        let filepath;
-        if (!dep.inline) {
-          filepath = path.join(this.getAssetsDir(), outFilepath);
-          fileSystem.copyFile(dep.filepath, filepath);
+    async process(dep) {
+        /**
+         * If HMR Manager is active, delegate build/watch to it.
+         */
+        if (this.hmrManager?.isEnabled() && !dep.inline) {
+            const resolvedOutput = this.hmrManager.getResolvedScriptOutput?.(dep.filepath);
+            if (resolvedOutput) {
+                return {
+                    filepath: resolvedOutput.outputPath,
+                    sourceFilepath: dep.filepath,
+                    srcUrl: resolvedOutput.outputUrl,
+                    kind: 'script',
+                    position: dep.position,
+                    attributes: dep.attributes,
+                    inline: false,
+                    excludeFromHtml: dep.excludeFromHtml,
+                    packageRole: dep.packageRole,
+                    bundledSourceFilepaths: dep.bundledSourceFilepaths,
+                };
+            }
+            const registered = await this.hmrManager.registerScriptEntrypoint(dep.filepath);
+            return {
+                filepath: registered.outputPath,
+                sourceFilepath: dep.filepath,
+                srcUrl: registered.outputUrl,
+                kind: 'script',
+                position: dep.position,
+                attributes: dep.attributes,
+                inline: false,
+                excludeFromHtml: dep.excludeFromHtml,
+                packageRole: dep.packageRole,
+                bundledSourceFilepaths: dep.bundledSourceFilepaths,
+            };
         }
-        return {
-          filepath,
-          sourceFilepath: dep.filepath,
-          content,
-          kind: "script",
-          position: dep.position,
-          attributes: dep.attributes,
-          inline: dep.inline,
-          excludeFromHtml: dep.excludeFromHtml,
-          packageRole: dep.packageRole,
-          bundledSourceFilepaths: dep.bundledSourceFilepaths
-        };
-      }
-      const relativeFilepath = path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath);
-      const outdirPath = path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR, relativeFilepath);
-      const outdirDirname = path.dirname(outdirPath);
-      const bundlerOptions = this.getBundlerOptions(dep);
-      const bundledFilePath = await this.bundleScript({
-        entrypoint: dep.filepath,
-        outdir: outdirDirname,
-        minify: this.isProduction,
-        ...bundlerOptions,
-        plugins: bundlerOptions.plugins
-      });
-      return {
-        filepath: bundledFilePath,
-        sourceFilepath: dep.filepath,
-        content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : void 0,
-        kind: "script",
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: dep.inline,
-        excludeFromHtml: dep.excludeFromHtml,
-        packageRole: dep.packageRole,
-        bundledSourceFilepaths: dep.bundledSourceFilepaths
-      };
-    });
-  }
+        const content = fileSystem.readFileSync(dep.filepath);
+        const shouldBundle = this.shouldBundle(dep);
+        const configHash = this.generateHash(JSON.stringify({
+            bundle: shouldBundle,
+            minify: shouldBundle && this.isProduction,
+            opts: dep.bundleOptions,
+        }));
+        const cachekey = `${this.buildCacheKey(dep.filepath, this.generateHash(content), dep)}:${configHash}`;
+        return this.getOrProcess(cachekey, async () => {
+            if (!shouldBundle) {
+                const outFilepath = path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath);
+                let filepath;
+                if (!dep.inline) {
+                    filepath = path.join(this.getAssetsDir(), outFilepath);
+                    fileSystem.copyFile(dep.filepath, filepath);
+                }
+                return {
+                    filepath,
+                    sourceFilepath: dep.filepath,
+                    content,
+                    kind: 'script',
+                    position: dep.position,
+                    attributes: dep.attributes,
+                    inline: dep.inline,
+                    excludeFromHtml: dep.excludeFromHtml,
+                    packageRole: dep.packageRole,
+                    bundledSourceFilepaths: dep.bundledSourceFilepaths,
+                };
+            }
+            const relativeFilepath = path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath);
+            const outdirPath = path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR, relativeFilepath);
+            const outdirDirname = path.dirname(outdirPath);
+            const bundlerOptions = this.getBundlerOptions(dep);
+            const bundledFilePath = await this.bundleScript({
+                entrypoint: dep.filepath,
+                outdir: outdirDirname,
+                minify: this.isProduction,
+                ...bundlerOptions,
+                plugins: bundlerOptions.plugins,
+            });
+            return {
+                filepath: bundledFilePath,
+                sourceFilepath: dep.filepath,
+                content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : undefined,
+                kind: 'script',
+                position: dep.position,
+                attributes: dep.attributes,
+                inline: dep.inline,
+                excludeFromHtml: dep.excludeFromHtml,
+                packageRole: dep.packageRole,
+                bundledSourceFilepaths: dep.bundledSourceFilepaths,
+            };
+        });
+    }
 }
-export {
-  FileScriptProcessor
-};

package/src/services/assets/asset-processing-service/processors/script/node-module-script.processor.js

@@ -1,140 +1,141 @@
-import path from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { fileSystem } from "@ecopages/file-system";
-import { getAppBuildAdapter } from "../../../../../build/build-adapter.js";
-import { BaseScriptProcessor } from "../base/base-script-processor.js";
-class NodeModuleScriptProcessor extends BaseScriptProcessor {
-  async process(dep) {
-    const modulePath = this.resolveModulePath(dep.importPath, this.appConfig.rootDir);
-    const moduleName = path.basename(modulePath);
-    const filename = dep.name ?? `nm-${moduleName}`;
-    const shouldBundle = this.shouldBundle(dep);
-    const configHash = this.generateHash(
-      JSON.stringify({
-        bundle: shouldBundle,
-        inline: dep.inline,
-        minify: shouldBundle && !dep.inline && this.isProduction,
-        opts: dep.bundleOptions
-      })
-    );
-    const cachekey = `${this.buildCacheKey(filename, this.generateHash(modulePath), dep)}:${configHash}`;
-    return this.getOrProcess(cachekey, async () => {
-      if (dep.inline || !shouldBundle) {
-        const content = fileSystem.readFileAsBuffer(modulePath).toString();
-        const filepath = dep.inline ? void 0 : path.join(this.getAssetsDir(), "vendors", filename);
-        if (filepath) {
-          fileSystem.ensureDir(path.dirname(filepath));
-          if (!fileSystem.exists(filepath) || fileSystem.readFileAsBuffer(filepath).toString() !== content) {
-            fileSystem.copyFile(modulePath, filepath);
-          }
-        }
-        return {
-          filepath,
-          content,
-          kind: dep.kind,
-          position: dep.position,
-          attributes: dep.attributes,
-          inline: dep.inline,
-          excludeFromHtml: dep.excludeFromHtml,
-          packageRole: dep.packageRole,
-          bundledSourceFilepaths: dep.bundledSourceFilepaths
-        };
-      }
-      const outdir = path.join(this.getAssetsDir(), "vendors");
-      const bundlerOptions = this.getBundlerOptions(dep);
-      const filePath = await this.bundleScript({
-        entrypoint: modulePath,
-        outdir,
-        minify: this.isProduction,
-        naming: bundlerOptions.naming ?? (dep.name ? `${dep.name}-[hash].[ext]` : "[name]-[hash].[ext]"),
-        ...bundlerOptions
-      });
-      return {
-        filepath: filePath,
-        kind: dep.kind,
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: dep.inline,
-        excludeFromHtml: dep.excludeFromHtml,
-        packageRole: dep.packageRole,
-        bundledSourceFilepaths: dep.bundledSourceFilepaths
-      };
-    });
-  }
-  /**
-   * Resolves a node-module script entry from the current app boundary.
-   *
-   * @remarks
-   * The build adapter remains the primary resolution surface because Bun/native
-   * host-owned builds may have a more accurate view of aliases and package
-   * ownership than core does. The local fallback only runs when that adapter
-   * resolution is unavailable.
-   */
-  resolveModulePath(importPath, rootDir) {
-    if (path.isAbsolute(importPath) && fileSystem.exists(importPath)) {
-      return importPath;
-    }
-    try {
-      return getAppBuildAdapter(this.appConfig).resolve(importPath, rootDir);
-    } catch {
-      return this.resolveModulePathFallback(importPath, rootDir);
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { fileSystem } from '@ecopages/file-system';
+import { getAppBuildAdapter } from '../../../../../build/build-adapter.js';
+import { BaseScriptProcessor } from '../base/base-script-processor.js';
+/**
+ * Processes browser script assets whose entrypoint is referenced by package specifier.
+ *
+ * @remarks
+ * Resolution stays app-boundary-first: prefer the active build adapter, then fall back
+ * to ESM export-map resolution, and only then probe a small set of literal file paths.
+ */
+export class NodeModuleScriptProcessor extends BaseScriptProcessor {
+    async process(dep) {
+        const modulePath = this.resolveModulePath(dep.importPath, this.appConfig.rootDir);
+        const moduleName = path.basename(modulePath);
+        const filename = dep.name ?? `nm-${moduleName}`;
+        const shouldBundle = this.shouldBundle(dep);
+        const configHash = this.generateHash(JSON.stringify({
+            bundle: shouldBundle,
+            inline: dep.inline,
+            minify: shouldBundle && !dep.inline && this.isProduction,
+            opts: dep.bundleOptions,
+        }));
+        const cachekey = `${this.buildCacheKey(filename, this.generateHash(modulePath), dep)}:${configHash}`;
+        return this.getOrProcess(cachekey, async () => {
+            if (dep.inline || !shouldBundle) {
+                const content = fileSystem.readFileAsBuffer(modulePath).toString();
+                const filepath = dep.inline ? undefined : path.join(this.getAssetsDir(), 'vendors', filename);
+                if (filepath) {
+                    fileSystem.ensureDir(path.dirname(filepath));
+                    if (!fileSystem.exists(filepath) || fileSystem.readFileAsBuffer(filepath).toString() !== content) {
+                        fileSystem.copyFile(modulePath, filepath);
+                    }
+                }
+                return {
+                    filepath,
+                    content,
+                    kind: dep.kind,
+                    position: dep.position,
+                    attributes: dep.attributes,
+                    inline: dep.inline,
+                    excludeFromHtml: dep.excludeFromHtml,
+                    packageRole: dep.packageRole,
+                    bundledSourceFilepaths: dep.bundledSourceFilepaths,
+                };
+            }
+            const outdir = path.join(this.getAssetsDir(), 'vendors');
+            const bundlerOptions = this.getBundlerOptions(dep);
+            const filePath = await this.bundleScript({
+                entrypoint: modulePath,
+                outdir: outdir,
+                minify: this.isProduction,
+                naming: bundlerOptions.naming ?? (dep.name ? `${dep.name}-[hash].[ext]` : '[name]-[hash].[ext]'),
+                ...bundlerOptions,
+            });
+            return {
+                filepath: filePath,
+                kind: dep.kind,
+                position: dep.position,
+                attributes: dep.attributes,
+                inline: dep.inline,
+                excludeFromHtml: dep.excludeFromHtml,
+                packageRole: dep.packageRole,
+                bundledSourceFilepaths: dep.bundledSourceFilepaths,
+            };
+        });
     }
-  }
-  /**
-   * Resolves browser-owned script specifiers without relying on CommonJS resolution.
-   *
-   * @remarks
-   * This path intentionally stays ESM-first because these assets are emitted as
-   * browser scripts. We first ask Node's ESM resolver to evaluate the package
-   * export map from the app boundary. If that still fails, we fall back to a
-   * bounded filesystem probe so direct file installs and package subpaths like
-   * `pkg/client/entry` still resolve when the export map does not cover them.
-   */
-  resolveModulePathFallback(importPath, rootDir, maxDepth = 5) {
-    try {
-      return fileURLToPath(
-        import.meta.resolve(importPath, pathToFileURL(path.join(rootDir, "package.json")).href)
-      );
-    } catch {
+    /**
+     * Resolves a node-module script entry from the current app boundary.
+     *
+     * @remarks
+     * The build adapter remains the primary resolution surface because Bun/native
+     * host-owned builds may have a more accurate view of aliases and package
+     * ownership than core does. The local fallback only runs when that adapter
+     * resolution is unavailable.
+     */
+    resolveModulePath(importPath, rootDir) {
+        if (path.isAbsolute(importPath) && fileSystem.exists(importPath)) {
+            return importPath;
+        }
+        try {
+            return getAppBuildAdapter(this.appConfig).resolve(importPath, rootDir);
+        }
+        catch {
+            return this.resolveModulePathFallback(importPath, rootDir);
+        }
     }
-    let currentDir = rootDir;
-    let remainingDepth = maxDepth;
-    while (remainingDepth >= 0) {
-      for (const candidatePath of this.getFallbackCandidatePaths(currentDir, importPath)) {
-        if (fileSystem.exists(candidatePath)) {
-          return candidatePath;
+    /**
+     * Resolves browser-owned script specifiers without relying on CommonJS resolution.
+     *
+     * @remarks
+     * This path intentionally stays ESM-first because these assets are emitted as
+     * browser scripts. We first ask Node's ESM resolver to evaluate the package
+     * export map from the app boundary. If that still fails, we fall back to a
+     * bounded filesystem probe so direct file installs and package subpaths like
+     * `pkg/client/entry` still resolve when the export map does not cover them.
+     */
+    resolveModulePathFallback(importPath, rootDir, maxDepth = 5) {
+        try {
+            return fileURLToPath(import.meta.resolve(importPath, pathToFileURL(path.join(rootDir, 'package.json')).href));
+        }
+        catch { }
+        let currentDir = rootDir;
+        let remainingDepth = maxDepth;
+        while (remainingDepth >= 0) {
+            for (const candidatePath of this.getFallbackCandidatePaths(currentDir, importPath)) {
+                if (fileSystem.exists(candidatePath)) {
+                    return candidatePath;
+                }
+            }
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                break;
+            }
+            currentDir = parentDir;
+            remainingDepth -= 1;
         }
-      }
-      const parentDir = path.dirname(currentDir);
-      if (parentDir === currentDir) {
-        break;
-      }
-      currentDir = parentDir;
-      remainingDepth -= 1;
+        throw new Error(`Could not resolve module '${importPath}' from '${rootDir}'`);
+    }
+    /**
+     * Returns the file candidates we accept during the final literal filesystem probe.
+     *
+     * @remarks
+     * This is intentionally small and browser-entry-oriented: direct files, common
+     * JS extensions, and `index.*` entrypoints. If a package needs anything more
+     * exotic, it should resolve through the adapter or ESM export-map path above.
+     */
+    getFallbackCandidatePaths(rootDir, importPath) {
+        const moduleBasePath = path.join(rootDir, 'node_modules', importPath);
+        return [
+            moduleBasePath,
+            `${moduleBasePath}.js`,
+            `${moduleBasePath}.mjs`,
+            `${moduleBasePath}.cjs`,
+            path.join(moduleBasePath, 'index.js'),
+            path.join(moduleBasePath, 'index.mjs'),
+            path.join(moduleBasePath, 'index.cjs'),
+        ];
     }
-    throw new Error(`Could not resolve module '${importPath}' from '${rootDir}'`);
-  }
-  /**
-   * Returns the file candidates we accept during the final literal filesystem probe.
-   *
-   * @remarks
-   * This is intentionally small and browser-entry-oriented: direct files, common
-   * JS extensions, and `index.*` entrypoints. If a package needs anything more
-   * exotic, it should resolve through the adapter or ESM export-map path above.
-   */
-  getFallbackCandidatePaths(rootDir, importPath) {
-    const moduleBasePath = path.join(rootDir, "node_modules", importPath);
-    return [
-      moduleBasePath,
-      `${moduleBasePath}.js`,
-      `${moduleBasePath}.mjs`,
-      `${moduleBasePath}.cjs`,
-      path.join(moduleBasePath, "index.js"),
-      path.join(moduleBasePath, "index.mjs"),
-      path.join(moduleBasePath, "index.cjs")
-    ];
-  }
 }
-export {
-  NodeModuleScriptProcessor
-};

package/src/services/assets/asset-processing-service/processors/stylesheet/content-stylesheet.processor.d.ts

@@ -1,8 +1,5 @@
 import type { ContentStylesheetAsset, ProcessedAsset } from '../../assets.types.js';
 import { BaseProcessor } from '../base/base-processor.js';
 export declare class ContentStylesheetProcessor extends BaseProcessor<ContentStylesheetAsset> {
-    private static readonly PROCESSABLE_STYLESHEET_EXTENSIONS;
-    private isProcessableStylesheet;
-    private applyStylesheetProcessors;
     process(dep: ContentStylesheetAsset): Promise<ProcessedAsset>;
 }

package/src/services/assets/asset-processing-service/processors/stylesheet/content-stylesheet.processor.js

@@ -1,59 +1,28 @@
-import path from "node:path";
-import { fileSystem } from "@ecopages/file-system";
-import { BaseProcessor } from "../base/base-processor.js";
-class ContentStylesheetProcessor extends BaseProcessor {
-  static PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
-  isProcessableStylesheet(filepath) {
-    return ContentStylesheetProcessor.PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
-  }
-  async applyStylesheetProcessors(content, filepath) {
-    if (!this.isProcessableStylesheet(filepath)) {
-      return content;
+import path from 'node:path';
+import { fileSystem } from '@ecopages/file-system';
+import { BaseProcessor } from '../base/base-processor.js';
+import { applyStylesheetProcessors } from './stylesheet-processor-pipeline.js';
+export class ContentStylesheetProcessor extends BaseProcessor {
+    async process(dep) {
+        const virtualFilepath = path.join(this.appConfig.absolutePaths.distDir, 'styles', 'page-bundle.css');
+        const processedContent = await applyStylesheetProcessors(this.appConfig, dep.content, virtualFilepath);
+        const hash = this.generateHash(processedContent);
+        const filename = `style-${hash}.css`;
+        const cachekey = this.buildCacheKey(filename, hash, dep);
+        return this.getOrProcess(cachekey, () => {
+            const filepath = path.join(this.getAssetsDir(), 'styles', filename);
+            if (!dep.inline)
+                fileSystem.write(filepath, processedContent);
+            return {
+                filepath: dep.inline ? undefined : filepath,
+                content: dep.inline ? processedContent : undefined,
+                kind: 'stylesheet',
+                position: dep.position,
+                attributes: dep.attributes,
+                inline: dep.inline,
+                packageRole: dep.packageRole,
+                bundledSourceFilepaths: dep.bundledSourceFilepaths,
+            };
+        });
     }
-    let transformedContent = content;
-    const processors = this.appConfig.processors ? Array.from(this.appConfig.processors.values()) : [];
-    for (const processor of processors) {
-      const hasCapabilities = processor.getAssetCapabilities().length > 0;
-      const canProcessStylesheet = processor.canProcessAsset("stylesheet", filepath);
-      if (!canProcessStylesheet && (hasCapabilities || !processor.getName().includes("postcss"))) {
-        continue;
-      }
-      if (!processor.matchesFileFilter(filepath)) {
-        continue;
-      }
-      const result = await processor.process(transformedContent, filepath);
-      if (typeof result === "string") {
-        transformedContent = result;
-        continue;
-      }
-      if (result instanceof Buffer) {
-        transformedContent = result.toString();
-      }
-    }
-    return transformedContent;
-  }
-  async process(dep) {
-    const virtualFilepath = path.join(this.appConfig.absolutePaths.distDir, "styles", "page-bundle.css");
-    const processedContent = await this.applyStylesheetProcessors(dep.content, virtualFilepath);
-    const hash = this.generateHash(processedContent);
-    const filename = `style-${hash}.css`;
-    const cachekey = this.buildCacheKey(filename, hash, dep);
-    return this.getOrProcess(cachekey, () => {
-      const filepath = path.join(this.getAssetsDir(), "styles", filename);
-      if (!dep.inline) fileSystem.write(filepath, processedContent);
-      return {
-        filepath: dep.inline ? void 0 : filepath,
-        content: dep.inline ? processedContent : void 0,
-        kind: "stylesheet",
-        position: dep.position,
-        attributes: dep.attributes,
-        inline: dep.inline,
-        packageRole: dep.packageRole,
-        bundledSourceFilepaths: dep.bundledSourceFilepaths
-      };
-    });
-  }
 }
-export {
-  ContentStylesheetProcessor
-};

package/src/services/assets/asset-processing-service/processors/stylesheet/file-stylesheet.processor.d.ts

@@ -1,9 +1,6 @@
 import type { FileStylesheetAsset, ProcessedAsset } from '../../assets.types.js';
 import { BaseProcessor } from '../base/base-processor.js';
 export declare class FileStylesheetProcessor extends BaseProcessor<FileStylesheetAsset> {
-    private static readonly PROCESSABLE_STYLESHEET_EXTENSIONS;
     getStyleContent: (srcUrl: string) => Buffer;
-    private isProcessableStylesheet;
-    private applyStylesheetProcessors;
     process(dep: FileStylesheetAsset): Promise<ProcessedAsset>;
 }