@ecopages/core 0.2.0-alpha.7 → 0.2.0-alpha.8

package/src/services/assets/asset-processing-service/index.js

@@ -0,0 +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/assets/asset-processing-service/processor.interface.d.ts

@@ -0,0 +1,22 @@
+import type { IHmrManager } from '../../../internal-types';
+import type { AssetDefinition, ProcessedAsset } from './assets.types';
+/**
+ * Base interface for asset processors.
+ * Processors transform asset definitions into processed assets.
+ */
+export interface AssetProcessor<T extends AssetDefinition = AssetDefinition> {
+    process(asset: T): Promise<ProcessedAsset>;
+}
+/**
+ * Interface for processors that support HMR (Hot Module Replacement).
+ * These processors can receive an HMR manager to enable hot reloading capabilities.
+ */
+export interface HmrAwareProcessor extends AssetProcessor {
+    setHmrManager(hmrManager: IHmrManager): void;
+}
+/**
+ * Type guard to check if a processor supports HMR.
+ * @param processor - The processor to check
+ * @returns True if the processor implements HmrAwareProcessor
+ */
+export declare function isHmrAware(processor: AssetProcessor): processor is HmrAwareProcessor;

package/src/services/assets/asset-processing-service/processor.interface.js

@@ -0,0 +1,6 @@
+function isHmrAware(processor) {
+  return "setHmrManager" in processor && typeof processor.setHmrManager === "function";
+}
+export {
+  isHmrAware
+};

package/src/services/assets/asset-processing-service/processor.registry.d.ts

@@ -0,0 +1,8 @@
+import type { AssetKind, AssetSource } from './assets.types';
+import type { BaseProcessor } from './processors/base/base-processor';
+export declare class ProcessorRegistry {
+    private processors;
+    register(kind: AssetKind, variant: AssetSource, processor: BaseProcessor<any>): void;
+    getProcessor(kind: AssetKind, variant: AssetSource): BaseProcessor<any> | undefined;
+    getAllProcessors(): Map<`${AssetKind}-${AssetSource}`, BaseProcessor<any>>;
+}

package/src/services/assets/asset-processing-service/processor.registry.js

@@ -0,0 +1,15 @@
+class ProcessorRegistry {
+  processors = /* @__PURE__ */ new Map();
+  register(kind, variant, processor) {
+    this.processors.set(`${kind}-${variant}`, processor);
+  }
+  getProcessor(kind, variant) {
+    return this.processors.get(`${kind}-${variant}`);
+  }
+  getAllProcessors() {
+    return this.processors;
+  }
+}
+export {
+  ProcessorRegistry
+};

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

@@ -0,0 +1,24 @@
+import type { EcoPagesAppConfig } from '../../../../../internal-types.js';
+import type { BaseAsset, ProcessedAsset } from '../../assets.types.js';
+export declare abstract class BaseProcessor<T extends BaseAsset> {
+    protected appConfig: EcoPagesAppConfig;
+    /**
+     * Cache for processed assets to avoid reprocessing the same asset multiple times.
+     * The cache key is a combination of the asset name and its hash.
+     * The cache value is the processed asset.
+     */
+    protected cache: Map<string, ProcessedAsset>;
+    constructor({ appConfig }: {
+        appConfig: EcoPagesAppConfig;
+    });
+    get isDevelopment(): boolean;
+    get isProduction(): boolean;
+    abstract process(dep: T): Promise<ProcessedAsset>;
+    protected getAssetsDir(): string;
+    protected writeCacheFile(key: string, path: ProcessedAsset): void;
+    protected getCacheFile(key: string): ProcessedAsset | undefined;
+    protected hasCacheFile(key: string): boolean;
+    protected generateHash(content: string): string;
+    protected buildCacheKey(identifier: string, contentHash: string, dep: T): string;
+    protected getOrProcess(cacheKey: string, processFn: () => ProcessedAsset | Promise<ProcessedAsset>): Promise<ProcessedAsset>;
+}

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

@@ -0,0 +1,64 @@
+import path from "node:path";
+import { RESOLVED_ASSETS_DIR } from "../../../../../constants.js";
+import { rapidhash } from "../../../../../utils/hash.js";
+import { isDevelopmentRuntime, isProductionRuntime } from "../../../../../utils/runtime.js";
+import { fileSystem } from "@ecopages/file-system";
+class BaseProcessor {
+  appConfig;
+  /**
+   * Cache for processed assets to avoid reprocessing the same asset multiple times.
+   * The cache key is a combination of the asset name and its hash.
+   * The cache value is the processed asset.
+   */
+  cache = /* @__PURE__ */ new Map();
+  constructor({ appConfig }) {
+    this.appConfig = appConfig;
+  }
+  get isDevelopment() {
+    return isDevelopmentRuntime();
+  }
+  get isProduction() {
+    return isProductionRuntime();
+  }
+  getAssetsDir() {
+    return path.join(this.appConfig.absolutePaths.distDir, RESOLVED_ASSETS_DIR);
+  }
+  writeCacheFile(key, path2) {
+    this.cache.set(key, path2);
+  }
+  getCacheFile(key) {
+    return this.cache.get(key);
+  }
+  hasCacheFile(key) {
+    return this.cache.has(key);
+  }
+  generateHash(content) {
+    return rapidhash(content).toString();
+  }
+  buildCacheKey(identifier, contentHash, dep) {
+    const attrsHash = dep.attributes ? this.generateHash(JSON.stringify(dep.attributes)) : "";
+    const position = dep.position ?? "";
+    return `${identifier}:${contentHash}:${position}:${attrsHash}`;
+  }
+  getOrProcess(cacheKey, processFn) {
+    if (this.hasCacheFile(cacheKey)) {
+      const cached = this.getCacheFile(cacheKey);
+      if (!cached.filepath || fileSystem.exists(cached.filepath)) {
+        return Promise.resolve(cached);
+      }
+      this.cache.delete(cacheKey);
+    }
+    const result = processFn();
+    if (result instanceof Promise) {
+      return result.then((asset) => {
+        this.writeCacheFile(cacheKey, asset);
+        return asset;
+      });
+    }
+    this.writeCacheFile(cacheKey, result);
+    return Promise.resolve(result);
+  }
+}
+export {
+  BaseProcessor
+};

package/src/services/assets/asset-processing-service/processors/base/base-script-processor.d.ts

@@ -0,0 +1,17 @@
+import type { EcoPagesAppConfig } from '../../../../../internal-types';
+import type { EcoBuildPlugin } from '../../../../../build/build-types.js';
+import type { ScriptAsset } from '../../assets.types';
+import { BaseProcessor } from './base-processor';
+export declare abstract class BaseScriptProcessor<T extends ScriptAsset> extends BaseProcessor<T> {
+    private readonly browserBundleService;
+    constructor({ appConfig }: {
+        appConfig: EcoPagesAppConfig;
+    });
+    protected shouldBundle(dep: T): boolean;
+    protected getBundlerOptions(dep: T): Record<string, any>;
+    protected collectBuildPlugins(): EcoBuildPlugin[];
+    protected bundleScript({ entrypoint, outdir, plugins: additionalPlugins, ...rest }: {
+        entrypoint: string;
+        outdir: string;
+    } & ScriptAsset['bundleOptions']): Promise<string>;
+}

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

@@ -0,0 +1,72 @@
+import { appLogger } from "../../../../../global/app-logger";
+import { getAppBrowserBuildPlugins } from "../../../../../build/build-adapter.js";
+import { fileSystem } from "@ecopages/file-system";
+import path from "node:path";
+import { BaseProcessor } from "./base-processor";
+import { BrowserBundleService } from "../../../browser-bundle.service.js";
+class BaseScriptProcessor extends BaseProcessor {
+  browserBundleService;
+  constructor({ appConfig }) {
+    super({ appConfig });
+    this.browserBundleService = new BrowserBundleService(appConfig);
+  }
+  shouldBundle(dep) {
+    return dep.bundle !== false;
+  }
+  getBundlerOptions(dep) {
+    return dep.bundleOptions || {};
+  }
+  collectBuildPlugins() {
+    return getAppBrowserBuildPlugins(this.appConfig);
+  }
+  async bundleScript({
+    entrypoint,
+    outdir,
+    plugins: additionalPlugins,
+    ...rest
+  }) {
+    const buildPlugins = this.collectBuildPlugins();
+    const allPlugins = additionalPlugins ? [...additionalPlugins, ...buildPlugins] : buildPlugins;
+    const buildResult = await this.browserBundleService.bundle({
+      profile: "browser-script",
+      entrypoints: [entrypoint],
+      outdir,
+      root: this.appConfig.rootDir,
+      splitting: true,
+      naming: "[name]-[hash].[ext]",
+      plugins: allPlugins,
+      ...rest
+    });
+    if (!buildResult.success) {
+      for (const log of buildResult.logs) {
+        appLogger.debug(log.message, log);
+      }
+    }
+    const entryBaseName = path.parse(entrypoint).name;
+    const entryOutput = buildResult.outputs.map((output) => output.path).find((outputPath) => path.basename(outputPath) === `${entryBaseName}.js`);
+    if (entryOutput) {
+      return entryOutput;
+    }
+    const nonVendorOutput = buildResult.outputs.map((output) => output.path).find((outputPath) => !path.basename(outputPath).startsWith("vendors"));
+    if (nonVendorOutput) {
+      return nonVendorOutput;
+    }
+    const primaryOutput = buildResult.outputs[0]?.path;
+    if (primaryOutput) {
+      return primaryOutput;
+    }
+    const namedFallbackOutput = path.join(outdir, `${entryBaseName}.js`);
+    if (fileSystem.exists(namedFallbackOutput)) {
+      return namedFallbackOutput;
+    }
+    const fallbackOutput = path.join(outdir, "entry_0.js");
+    if (fileSystem.exists(fallbackOutput)) {
+      return fallbackOutput;
+    }
+    const logMessage = buildResult.logs.map((log) => log.message).join(" | ");
+    throw new Error(`No build output generated for ${entrypoint}${logMessage ? `: ${logMessage}` : ""}`);
+  }
+}
+export {
+  BaseScriptProcessor
+};

package/src/services/assets/asset-processing-service/processors/index.d.ts

@@ -0,0 +1,5 @@
+export * from './script/content-script.processor';
+export * from './script/file-script.processor';
+export * from './script/node-module-script.processor';
+export * from './stylesheet/content-stylesheet.processor';
+export * from './stylesheet/file-stylesheet.processor';

package/src/services/assets/asset-processing-service/processors/index.js

@@ -0,0 +1,5 @@
+export * from "./script/content-script.processor";
+export * from "./script/file-script.processor";
+export * from "./script/node-module-script.processor";
+export * from "./stylesheet/content-stylesheet.processor";
+export * from "./stylesheet/file-stylesheet.processor";

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

@@ -0,0 +1,5 @@
+import type { ContentScriptAsset, ProcessedAsset } from '../../assets.types';
+import { BaseScriptProcessor } from '../base/base-script-processor';
+export declare class ContentScriptProcessor extends BaseScriptProcessor<ContentScriptAsset> {
+    process(dep: ContentScriptAsset): Promise<ProcessedAsset>;
+}

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

@@ -0,0 +1,57 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { BaseScriptProcessor } from "../base/base-script-processor";
+class ContentScriptProcessor extends BaseScriptProcessor {
+  async process(dep) {
+    const hash = this.generateHash(dep.content);
+    const filename = dep.name ? `${dep.name}.js` : `script-${hash}.js`;
+    const shouldBundle = this.shouldBundle(dep);
+    const filepath = path.join(this.getAssetsDir(), "scripts", filename);
+    if (!shouldBundle) {
+      if (!dep.inline) fileSystem.write(filepath, dep.content);
+      const unbundledProcessedAsset = {
+        filepath,
+        content: dep.inline ? dep.content : void 0,
+        kind: "script",
+        position: dep.position,
+        attributes: dep.attributes,
+        inline: dep.inline,
+        excludeFromHtml: dep.excludeFromHtml
+      };
+      this.writeCacheFile(filename, unbundledProcessedAsset);
+      return unbundledProcessedAsset;
+    }
+    if (dep.content) {
+      const tempDir = this.appConfig.absolutePaths.distDir;
+      fileSystem.ensureDir(tempDir);
+      const tempFileName = path.join(
+        tempDir,
+        `${path.parse(filename).name}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp.js`
+      );
+      fileSystem.write(tempFileName, dep.content);
+      const bundledFilePath = await this.bundleScript({
+        entrypoint: tempFileName,
+        outdir: this.getAssetsDir(),
+        minify: this.isProduction,
+        naming: `${path.parse(filename).name}-[hash].[ext]`,
+        ...this.getBundlerOptions(dep)
+      });
+      const processedAsset = {
+        filepath: bundledFilePath,
+        content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : void 0,
+        kind: "script",
+        position: dep.position,
+        attributes: dep.attributes,
+        inline: dep.inline,
+        excludeFromHtml: dep.excludeFromHtml
+      };
+      fileSystem.remove(tempFileName);
+      this.writeCacheFile(filename, processedAsset);
+      return processedAsset;
+    }
+    throw new Error("No content found for script asset");
+  }
+}
+export {
+  ContentScriptProcessor
+};

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

@@ -0,0 +1,8 @@
+import type { IHmrManager } from '../../../../../internal-types';
+import type { FileScriptAsset, ProcessedAsset } from '../../assets.types';
+import { BaseScriptProcessor } from '../base/base-script-processor';
+export declare class FileScriptProcessor extends BaseScriptProcessor<FileScriptAsset> {
+    private hmrManager?;
+    setHmrManager(hmrManager: IHmrManager): void;
+    process(dep: FileScriptAsset): Promise<ProcessedAsset>;
+}

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

@@ -0,0 +1,76 @@
+import path from "node:path";
+import { RESOLVED_ASSETS_DIR } from "../../../../../constants";
+import { fileSystem } from "@ecopages/file-system";
+import { BaseScriptProcessor } from "../base/base-script-processor";
+class FileScriptProcessor extends BaseScriptProcessor {
+  hmrManager;
+  setHmrManager(hmrManager) {
+    this.hmrManager = hmrManager;
+  }
+  async process(dep) {
+    if (this.hmrManager?.isEnabled() && !dep.inline) {
+      const outputUrl = await this.hmrManager.registerScriptEntrypoint(dep.filepath);
+      return {
+        filepath: dep.filepath,
+        srcUrl: outputUrl,
+        kind: "script",
+        position: dep.position,
+        attributes: dep.attributes,
+        inline: false,
+        excludeFromHtml: dep.excludeFromHtml
+      };
+    }
+    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,
+          content,
+          kind: "script",
+          position: dep.position,
+          attributes: dep.attributes,
+          inline: dep.inline,
+          excludeFromHtml: dep.excludeFromHtml
+        };
+      }
+      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,
+        content: dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : void 0,
+        kind: "script",
+        position: dep.position,
+        attributes: dep.attributes,
+        inline: dep.inline,
+        excludeFromHtml: dep.excludeFromHtml
+      };
+    });
+  }
+}
+export {
+  FileScriptProcessor
+};

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

@@ -0,0 +1,7 @@
+import type { NodeModuleScriptAsset } from '../../assets.types';
+import { BaseScriptProcessor } from '../base/base-script-processor';
+export declare class NodeModuleScriptProcessor extends BaseScriptProcessor<NodeModuleScriptAsset> {
+    process(dep: NodeModuleScriptAsset): Promise<import("../../assets.types").ProcessedAsset>;
+    private resolveModulePath;
+    private resolveModulePathFallback;
+}

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

@@ -0,0 +1,75 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { getAppBuildAdapter } from "../../../../../build/build-adapter.js";
+import { BaseScriptProcessor } from "../base/base-script-processor";
+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 configHash = this.generateHash(
+      JSON.stringify({ inline: dep.inline, minify: !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) {
+        const content = fileSystem.readFileAsBuffer(modulePath).toString();
+        return {
+          content,
+          kind: dep.kind,
+          position: dep.position,
+          attributes: dep.attributes,
+          inline: true,
+          excludeFromHtml: dep.excludeFromHtml
+        };
+      }
+      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
+      };
+    });
+  }
+  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);
+    }
+  }
+  resolveModulePathFallback(importPath, rootDir, maxDepth = 5) {
+    let currentDir = rootDir;
+    let remainingDepth = maxDepth;
+    while (remainingDepth >= 0) {
+      const modulePath = path.join(currentDir, "node_modules", importPath);
+      if (fileSystem.exists(modulePath)) {
+        return modulePath;
+      }
+      const parentDir = path.dirname(currentDir);
+      if (parentDir === currentDir) {
+        break;
+      }
+      currentDir = parentDir;
+      remainingDepth -= 1;
+    }
+    throw new Error(`Could not resolve module '${importPath}' from '${rootDir}'`);
+  }
+}
+export {
+  NodeModuleScriptProcessor
+};

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

@@ -0,0 +1,5 @@
+import type { ContentStylesheetAsset, ProcessedAsset } from '../../assets.types';
+import { BaseProcessor } from '../base/base-processor';
+export declare class ContentStylesheetProcessor extends BaseProcessor<ContentStylesheetAsset> {
+    process(dep: ContentStylesheetAsset): Promise<ProcessedAsset>;
+}

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

@@ -0,0 +1,25 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { BaseProcessor } from "../base/base-processor";
+class ContentStylesheetProcessor extends BaseProcessor {
+  async process(dep) {
+    const hash = this.generateHash(dep.content);
+    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, dep.content);
+      return {
+        filepath: dep.inline ? void 0 : filepath,
+        content: dep.inline ? dep.content : void 0,
+        kind: "stylesheet",
+        position: dep.position,
+        attributes: dep.attributes,
+        inline: dep.inline
+      };
+    });
+  }
+}
+export {
+  ContentStylesheetProcessor
+};

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

@@ -0,0 +1,9 @@
+import type { FileStylesheetAsset, ProcessedAsset } from '../../assets.types';
+import { BaseProcessor } from '../base/base-processor';
+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>;
+}

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

@@ -0,0 +1,66 @@
+import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
+import { BaseProcessor } from "../base/base-processor";
+class FileStylesheetProcessor extends BaseProcessor {
+  static PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
+  getStyleContent = (srcUrl) => {
+    return fileSystem.readFileAsBuffer(srcUrl);
+  };
+  isProcessableStylesheet(filepath) {
+    return FileStylesheetProcessor.PROCESSABLE_STYLESHEET_EXTENSIONS.has(path.extname(filepath));
+  }
+  async applyStylesheetProcessors(content, filepath) {
+    if (!this.isProcessableStylesheet(filepath)) {
+      return content;
+    }
+    let transformedContent = content;
+    for (const processor of this.appConfig.processors.values()) {
+      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 buffer = this.getStyleContent(dep.filepath);
+    const rawContent = buffer.toString();
+    const processedContent = await this.applyStylesheetProcessors(rawContent, dep.filepath);
+    const hash = this.generateHash(processedContent);
+    const cachekey = this.buildCacheKey(dep.filepath, hash, dep);
+    return this.getOrProcess(cachekey, () => {
+      const filepath = path.join(
+        this.getAssetsDir(),
+        path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath)
+      );
+      const outputBuffer = Buffer.from(processedContent);
+      if (!dep.inline) {
+        fileSystem.ensureDir(path.dirname(filepath));
+        fileSystem.write(filepath, outputBuffer);
+      }
+      return {
+        filepath,
+        content: dep.inline ? processedContent : void 0,
+        kind: "stylesheet",
+        position: dep.position,
+        attributes: dep.attributes,
+        inline: dep.inline
+      };
+    });
+  }
+}
+export {
+  FileStylesheetProcessor
+};

package/src/services/assets/browser-bundle.service.d.ts

@@ -0,0 +1,32 @@
+import type { BuildOptions, BuildResult, BuildTranspileProfile } from '../../build/build-adapter.js';
+import type { EcoPagesAppConfig } from '../../internal-types.js';
+export type BrowserBundleOptions = Omit<BuildOptions, 'target' | 'format' | 'sourcemap'> & {
+    profile: BuildTranspileProfile;
+};
+export interface BrowserBundleExecutor {
+    bundle(options: BrowserBundleOptions): Promise<BuildResult>;
+}
+/**
+ * App-owned boundary for browser-oriented bundle work.
+ *
+ * @remarks
+ * This service owns the shared browser transpile defaults and ensures browser
+ * builds always run through the app-owned executor rather than direct backend
+ * calls scattered across HMR and asset processing paths.
+ */
+export declare class BrowserBundleService implements BrowserBundleExecutor {
+    private readonly appConfig;
+    /**
+     * Creates the browser bundle boundary for one finalized app instance.
+     */
+    constructor(appConfig: EcoPagesAppConfig);
+    /**
+     * Runs one browser-targeted build through the app-owned executor.
+     *
+     * @remarks
+     * Browser defaults and app-owned browser build plugins are applied here so HMR
+     * and runtime asset generation do not have to recreate that policy at each call
+     * site.
+     */
+    bundle(options: BrowserBundleOptions): Promise<BuildResult>;
+}