@ecopages/core 0.2.0-alpha.2 → 0.2.0-alpha.21

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

@@ -1,4 +1,4 @@
-import type { EcoBuildPlugin } from '../../build/build-types.js';
+import type { EcoBuildPlugin } from '../../../build/build-types.js';
 export type AssetSource = 'content' | 'file' | 'node-module';
 export type AssetKind = 'script' | 'stylesheet';
 export type AssetPosition = 'head' | 'body';
@@ -13,6 +13,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.d.ts

@@ -0,0 +1,55 @@
+import type { EcoBuildPlugin } from '../../../build/build-types.js';
+import type { AssetDefinition } from './assets.types.js';
+import { type BrowserRuntimeEntryModuleConfig } from './browser-runtime-entry.factory.js';
+export declare const BROWSER_RUNTIME_SCRIPT_ATTRIBUTES: {
+    readonly type: "module";
+    readonly defer: "";
+};
+/**
+ * Builds the public vendor URL used for generated browser runtime assets.
+ */
+export declare function buildBrowserRuntimeAssetUrl(fileName: string): string;
+/**
+ * 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 declare 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;
+/**
+ * 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 declare 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;

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

@@ -0,0 +1,48 @@
+import { AssetFactory } from "./asset.factory.js";
+import {
+  createBrowserRuntimeEntryModule
+} from "./browser-runtime-entry.factory.js";
+const BROWSER_RUNTIME_SCRIPT_ATTRIBUTES = {
+  type: "module",
+  defer: ""
+};
+function buildBrowserRuntimeAssetUrl(fileName) {
+  return `/${AssetFactory.RESOLVED_ASSETS_VENDORS_DIR}/${fileName}`;
+}
+function createBrowserRuntimeScriptAsset(options) {
+  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 ?? {}
+    }
+  });
+}
+function createBrowserRuntimeModuleAsset(options) {
+  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
+  });
+}
+export {
+  BROWSER_RUNTIME_SCRIPT_ATTRIBUTES,
+  buildBrowserRuntimeAssetUrl,
+  createBrowserRuntimeModuleAsset,
+  createBrowserRuntimeScriptAsset
+};

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

@@ -0,0 +1,20 @@
+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 declare function createBrowserRuntimeEntryModule(options: {
+    modules: BrowserRuntimeEntryModuleConfig[];
+    fileName: string;
+    rootDir?: string;
+    cacheDirName?: string;
+}): string;

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

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from "node:module";
+function createBrowserRuntimeEntryModule(options) {
+  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 = /* @__PURE__ */ new Set();
+  const statements = [];
+  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;
+}
+function getModuleExportNames(specifier, requireFromRoot) {
+  const moduleExports = requireFromRoot(specifier);
+  return Object.keys(moduleExports).filter((name) => name !== "__esModule" && name !== "default").filter((name) => /^[$A-Z_a-z][$\w]*$/.test(name)).sort();
+}
+export {
+  createBrowserRuntimeEntryModule
+};

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

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

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

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

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

@@ -1,5 +1,5 @@
-import type { IHmrManager } from '../../internal-types';
-import type { AssetDefinition, ProcessedAsset } from './assets.types';
+import type { IHmrManager } from '../../../types/internal-types.js';
+import type { AssetDefinition, ProcessedAsset } from './assets.types.js';
 /**
  * Base interface for asset processors.
  * Processors transform asset definitions into processed assets.

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

@@ -1,5 +1,5 @@
-import type { AssetKind, AssetSource } from './assets.types';
-import type { BaseProcessor } from './processors/base/base-processor';
+import type { AssetKind, AssetSource } from './assets.types.js';
+import type { BaseProcessor } from './processors/base/base-processor.js';
 export declare class ProcessorRegistry {
     private processors;
     register(kind: AssetKind, variant: AssetSource, processor: BaseProcessor<any>): void;

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

@@ -1,4 +1,4 @@
-import type { EcoPagesAppConfig } from '../../../../internal-types.js';
+import type { EcoPagesAppConfig } from '../../../../../types/internal-types.js';
 import type { BaseAsset, ProcessedAsset } from '../../assets.types.js';
 export declare abstract class BaseProcessor<T extends BaseAsset> {
     protected appConfig: EcoPagesAppConfig;

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

@@ -1,7 +1,8 @@
 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 { RESOLVED_ASSETS_DIR } from "../../../../../config/constants.js";
+import { rapidhash } from "../../../../../utils/hash.js";
+import { isDevelopmentRuntime, isProductionRuntime } from "../../../../../utils/runtime.js";
+import { fileSystem } from "@ecopages/file-system";
 class BaseProcessor {
   appConfig;
   /**
@@ -41,7 +42,11 @@ class BaseProcessor {
   }
   getOrProcess(cacheKey, processFn) {
     if (this.hasCacheFile(cacheKey)) {
-      return Promise.resolve(this.getCacheFile(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) {

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

@@ -1,8 +1,9 @@
-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';
+import type { EcoPagesAppConfig } from '../../../../../types/internal-types.js';
+import type { EcoBuildPlugin } from '../../../../../build/build-types.js';
+import type { ScriptAsset } from '../../assets.types.js';
+import { BaseProcessor } from './base-processor.js';
 export declare abstract class BaseScriptProcessor<T extends ScriptAsset> extends BaseProcessor<T> {
+    private readonly browserBundleService;
     constructor({ appConfig }: {
         appConfig: EcoPagesAppConfig;
     });

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

@@ -1,11 +1,14 @@
-import { appLogger } from "../../../../global/app-logger";
-import { defaultBuildAdapter } from "../../../../build/build-adapter.js";
+import { appLogger } from "../../../../../global/app-logger.js";
+import { getAppBrowserBuildPlugins } from "../../../../../build/build-adapter.js";
 import { fileSystem } from "@ecopages/file-system";
 import path from "node:path";
-import { BaseProcessor } from "./base-processor";
+import { BaseProcessor } from "./base-processor.js";
+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;
@@ -14,18 +17,7 @@ class BaseScriptProcessor extends BaseProcessor {
     return dep.bundleOptions || {};
   }
   collectBuildPlugins() {
-    const plugins = [];
-    if (this.appConfig.processors?.size) {
-      for (const processor of this.appConfig.processors.values()) {
-        if (processor.buildPlugins) {
-          plugins.push(...processor.buildPlugins);
-        }
-      }
-    }
-    if (this.appConfig.loaders?.size) {
-      plugins.push(...this.appConfig.loaders.values());
-    }
-    return plugins;
+    return getAppBrowserBuildPlugins(this.appConfig);
   }
   async bundleScript({
     entrypoint,
@@ -35,31 +27,31 @@ class BaseScriptProcessor extends BaseProcessor {
   }) {
     const buildPlugins = this.collectBuildPlugins();
     const allPlugins = additionalPlugins ? [...additionalPlugins, ...buildPlugins] : buildPlugins;
-    const build = await defaultBuildAdapter.build({
+    const buildResult = await this.browserBundleService.bundle({
+      profile: "browser-script",
       entrypoints: [entrypoint],
       outdir,
       root: this.appConfig.rootDir,
-      ...defaultBuildAdapter.getTranspileOptions("browser-script"),
       splitting: true,
       naming: "[name]-[hash].[ext]",
       plugins: allPlugins,
       ...rest
     });
-    if (!build.success) {
-      for (const log of build.logs) {
+    if (!buildResult.success) {
+      for (const log of buildResult.logs) {
         appLogger.debug(log.message, log);
       }
     }
     const entryBaseName = path.parse(entrypoint).name;
-    const entryOutput = build.outputs.map((output) => output.path).find((outputPath) => path.basename(outputPath) === `${entryBaseName}.js`);
+    const entryOutput = buildResult.outputs.map((output) => output.path).find((outputPath) => path.basename(outputPath) === `${entryBaseName}.js`);
     if (entryOutput) {
       return entryOutput;
     }
-    const nonVendorOutput = build.outputs.map((output) => output.path).find((outputPath) => !path.basename(outputPath).startsWith("vendors"));
+    const nonVendorOutput = buildResult.outputs.map((output) => output.path).find((outputPath) => !path.basename(outputPath).startsWith("vendors"));
     if (nonVendorOutput) {
       return nonVendorOutput;
     }
-    const primaryOutput = build.outputs[0]?.path;
+    const primaryOutput = buildResult.outputs[0]?.path;
     if (primaryOutput) {
       return primaryOutput;
     }
@@ -71,7 +63,7 @@ class BaseScriptProcessor extends BaseProcessor {
     if (fileSystem.exists(fallbackOutput)) {
       return fallbackOutput;
     }
-    const logMessage = build.logs.map((log) => log.message).join(" | ");
+    const logMessage = buildResult.logs.map((log) => log.message).join(" | ");
     throw new Error(`No build output generated for ${entrypoint}${logMessage ? `: ${logMessage}` : ""}`);
   }
 }

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
-import { BaseScriptProcessor } from "../base/base-script-processor";
+import { BaseScriptProcessor } from "../base/base-script-processor.js";
 class ContentScriptProcessor extends BaseScriptProcessor {
   async process(dep) {
     const hash = this.generateHash(dep.content);

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

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

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

@@ -1,17 +1,29 @@
 import path from "node:path";
-import { RESOLVED_ASSETS_DIR } from "../../../../constants";
+import { RESOLVED_ASSETS_DIR } from "../../../../../config/constants.js";
 import { fileSystem } from "@ecopages/file-system";
-import { BaseScriptProcessor } from "../base/base-script-processor";
+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;
+    }
+    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.registerEntrypoint(dep.filepath);
+      const outputUrl = await this.hmrManager.registerScriptEntrypoint(dep.filepath);
+      const outputFilepath = this.resolveHmrOutputFilepath(dep.filepath);
       return {
-        filepath: dep.filepath,
+        filepath: outputFilepath ?? dep.filepath,
         srcUrl: outputUrl,
         kind: "script",
         position: dep.position,

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

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

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

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
-import { defaultBuildAdapter } from "../../../../build/build-adapter.js";
-import { BaseScriptProcessor } from "../base/base-script-processor";
+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);
@@ -24,12 +24,13 @@ class NodeModuleScriptProcessor extends BaseScriptProcessor {
         };
       }
       const outdir = path.join(this.getAssetsDir(), "vendors");
+      const bundlerOptions = this.getBundlerOptions(dep);
       const filePath = await this.bundleScript({
         entrypoint: modulePath,
         outdir,
         minify: this.isProduction,
-        naming: dep.name ? `${dep.name}-[hash].[ext]` : "[name]-[hash].[ext]",
-        ...this.getBundlerOptions(dep)
+        naming: bundlerOptions.naming ?? (dep.name ? `${dep.name}-[hash].[ext]` : "[name]-[hash].[ext]"),
+        ...bundlerOptions
       });
       return {
         filepath: filePath,
@@ -46,7 +47,7 @@ class NodeModuleScriptProcessor extends BaseScriptProcessor {
       return importPath;
     }
     try {
-      return defaultBuildAdapter.resolve(importPath, rootDir);
+      return getAppBuildAdapter(this.appConfig).resolve(importPath, rootDir);
     } catch {
       return this.resolveModulePathFallback(importPath, rootDir);
     }

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

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

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
-import { BaseProcessor } from "../base/base-processor";
+import { BaseProcessor } from "../base/base-processor.js";
 class ContentStylesheetProcessor extends BaseProcessor {
   async process(dep) {
     const hash = this.generateHash(dep.content);

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

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

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
-import { BaseProcessor } from "../base/base-processor";
+import { BaseProcessor } from "../base/base-processor.js";
 class FileStylesheetProcessor extends BaseProcessor {
   static PROCESSABLE_STYLESHEET_EXTENSIONS = /* @__PURE__ */ new Set([".css", ".scss", ".sass", ".less"]);
   getStyleContent = (srcUrl) => {
@@ -41,7 +41,10 @@ class FileStylesheetProcessor extends BaseProcessor {
     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.srcDir, dep.filepath));
+      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));

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 '../../types/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>;
+}

package/src/services/assets/browser-bundle.service.js

@@ -0,0 +1,33 @@
+import { getAppBrowserBuildPlugins, getAppBuildExecutor, getAppTranspileOptions } from "../../build/build-adapter.js";
+import { mergeEcoBuildPlugins } from "../../build/build-manifest.js";
+class BrowserBundleService {
+  appConfig;
+  /**
+   * Creates the browser bundle boundary for one finalized app instance.
+   */
+  constructor(appConfig) {
+    this.appConfig = appConfig;
+  }
+  /**
+   * 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.
+   */
+  async bundle(options) {
+    const { profile, ...rawBuildOptions } = options;
+    const buildOptions = rawBuildOptions;
+    const plugins = buildOptions.plugins;
+    const request = {
+      ...buildOptions,
+      ...getAppTranspileOptions(this.appConfig, profile),
+      plugins: mergeEcoBuildPlugins(plugins, getAppBrowserBuildPlugins(this.appConfig))
+    };
+    return await getAppBuildExecutor(this.appConfig).build(request);
+  }
+}
+export {
+  BrowserBundleService
+};

package/src/services/{page-request-cache-coordinator.service.d.ts → cache/page-request-cache-coordinator.service.d.ts}

@@ -1,5 +1,5 @@
-import { type PageCacheService } from './cache/page-cache-service.js';
-import type { CacheStrategy, RenderResult } from './cache/cache.types.js';
+import { type PageCacheService } from './page-cache-service.js';
+import type { CacheStrategy, RenderResult } from './cache.types.js';
 /**
  * Coordinates request-time page caching concerns around one render invocation.
  *

package/src/services/{page-request-cache-coordinator.service.js → cache/page-request-cache-coordinator.service.js}

@@ -1,5 +1,7 @@
-import { getCacheControlHeader } from "./cache/page-cache-service.js";
+import { getCacheControlHeader } from "./page-cache-service.js";
 class PageRequestCacheCoordinator {
+  cacheService;
+  defaultCacheStrategy;
   constructor(cacheService, defaultCacheStrategy) {
     this.cacheService = cacheService;
     this.defaultCacheStrategy = defaultCacheStrategy;