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

package/src/router/client/navigation-coordinator.js

@@ -0,0 +1,215 @@
+const ECO_DOCUMENT_OWNER_ATTRIBUTE = "data-eco-document-owner";
+function getEcoDocumentOwner(doc) {
+  const owner = doc.documentElement.getAttribute(ECO_DOCUMENT_OWNER_ATTRIBUTE);
+  return owner && owner.length > 0 ? owner : null;
+}
+function getCandidateOwners(currentOwner, registrations, excludedOwner) {
+  const owners = [];
+  if (currentOwner !== "none" && currentOwner !== excludedOwner) {
+    owners.push(currentOwner);
+  }
+  for (const owner of registrations.keys()) {
+    if (owner === currentOwner || owner === excludedOwner) {
+      continue;
+    }
+    owners.push(owner);
+  }
+  return owners;
+}
+function createEcoNavigationRuntime() {
+  const registrations = /* @__PURE__ */ new Map();
+  const listeners = /* @__PURE__ */ new Set();
+  let owner = "none";
+  let navigationSequence = 0;
+  let navigationAbortController = null;
+  const emit = (event) => {
+    for (const listener of listeners) {
+      listener(event);
+    }
+  };
+  const updateOwner = (nextOwner, reason) => {
+    if (owner === nextOwner) {
+      return;
+    }
+    const previousOwner = owner;
+    owner = nextOwner;
+    emit({
+      type: "owner-change",
+      owner: nextOwner,
+      previousOwner,
+      reason
+    });
+  };
+  const cancelNavigationTransaction = (navigationId, abortController) => {
+    if (navigationSequence !== navigationId || navigationAbortController !== abortController) {
+      return;
+    }
+    navigationSequence += 1;
+    navigationAbortController = null;
+    abortController.abort();
+  };
+  const completeNavigationTransaction = (navigationId, abortController) => {
+    if (navigationSequence !== navigationId || navigationAbortController !== abortController) {
+      return;
+    }
+    navigationAbortController = null;
+  };
+  const runtime = {
+    getOwnerState() {
+      const activeRuntime = registrations.get(owner);
+      return {
+        owner,
+        canHandleSpaNavigation: typeof activeRuntime?.navigate === "function"
+      };
+    },
+    hasPendingNavigationTransaction() {
+      return navigationAbortController !== null;
+    },
+    beginNavigationTransaction() {
+      navigationAbortController?.abort();
+      const abortController = new AbortController();
+      const navigationId = ++navigationSequence;
+      navigationAbortController = abortController;
+      return {
+        id: navigationId,
+        signal: abortController.signal,
+        isCurrent: () => navigationSequence === navigationId && navigationAbortController === abortController,
+        cancel: () => {
+          cancelNavigationTransaction(navigationId, abortController);
+        },
+        complete: () => {
+          completeNavigationTransaction(navigationId, abortController);
+        }
+      };
+    },
+    cancelCurrentNavigationTransaction() {
+      if (!navigationAbortController) {
+        return;
+      }
+      cancelNavigationTransaction(navigationSequence, navigationAbortController);
+    },
+    setOwner(nextOwner) {
+      updateOwner(nextOwner, "set");
+    },
+    claimOwnership(nextOwner) {
+      updateOwner(nextOwner, "claim");
+    },
+    releaseOwnership(currentOwner) {
+      if (owner !== currentOwner) {
+        return;
+      }
+      updateOwner("none", "release");
+    },
+    resolveDocumentOwner(doc, fallbackOwner = "none") {
+      return getEcoDocumentOwner(doc) ?? fallbackOwner;
+    },
+    adoptDocumentOwner(doc, fallbackOwner = "none") {
+      const nextOwner = runtime.resolveDocumentOwner(doc, fallbackOwner);
+      updateOwner(nextOwner, "document");
+      return nextOwner;
+    },
+    isOwnedByAnotherRuntime(candidateOwner) {
+      return owner !== "none" && owner !== candidateOwner;
+    },
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    register(registration) {
+      registrations.set(registration.owner, registration);
+      emit({
+        type: "registration-change",
+        owner: registration.owner,
+        status: "registered"
+      });
+      return () => {
+        const currentRegistration = registrations.get(registration.owner);
+        if (currentRegistration !== registration) {
+          return;
+        }
+        registrations.delete(registration.owner);
+        emit({
+          type: "registration-change",
+          owner: registration.owner,
+          status: "unregistered"
+        });
+        if (owner === registration.owner) {
+          updateOwner("none", "unregister");
+        }
+      };
+    },
+    async requestNavigation(request) {
+      for (const candidateOwner of getCandidateOwners(owner, registrations, request.source)) {
+        const registration = registrations.get(candidateOwner);
+        if (!registration?.navigate) {
+          continue;
+        }
+        const handled = await registration.navigate(request);
+        if (handled !== false) {
+          return true;
+        }
+      }
+      return false;
+    },
+    async requestHandoff(request) {
+      if (request.targetOwner === "none") {
+        return false;
+      }
+      if (request.isStaleSourceNavigation?.()) {
+        return true;
+      }
+      const registration = registrations.get(request.targetOwner);
+      if (!registration?.handoffNavigation) {
+        return false;
+      }
+      if (request.isStaleSourceNavigation?.()) {
+        return true;
+      }
+      const handled = await registration.handoffNavigation(request);
+      return handled !== false;
+    },
+    async reloadCurrentPage(request) {
+      for (const candidateOwner of getCandidateOwners(owner, registrations)) {
+        const registration = registrations.get(candidateOwner);
+        if (!registration?.reloadCurrentPage) {
+          continue;
+        }
+        await registration.reloadCurrentPage(request);
+        return true;
+      }
+      return false;
+    },
+    async cleanupOwner(targetOwner) {
+      if (targetOwner === "none") {
+        return;
+      }
+      const registration = registrations.get(targetOwner);
+      if (!registration?.cleanupBeforeHandoff) {
+        return;
+      }
+      await registration.cleanupBeforeHandoff();
+      if (owner === targetOwner) {
+        updateOwner("none", "release");
+      }
+    },
+    async cleanupCurrentOwner() {
+      await runtime.cleanupOwner(owner);
+    }
+  };
+  return runtime;
+}
+function getEcoNavigationRuntime(windowObject = window) {
+  const runtimeWindow = windowObject;
+  runtimeWindow.__ECO_PAGES__ = runtimeWindow.__ECO_PAGES__ || {};
+  if (!runtimeWindow.__ECO_PAGES__.navigation) {
+    runtimeWindow.__ECO_PAGES__.navigation = createEcoNavigationRuntime();
+  }
+  return runtimeWindow.__ECO_PAGES__.navigation;
+}
+export {
+  ECO_DOCUMENT_OWNER_ATTRIBUTE,
+  getEcoDocumentOwner,
+  getEcoNavigationRuntime
+};

package/src/router/{fs-router-scanner.d.ts → server/fs-router-scanner.d.ts}

@@ -1,4 +1,4 @@
-import type { EcoPagesAppConfig, Routes } from '../internal-types.js';
+import type { EcoPagesAppConfig, Routes } from '../../types/internal-types.js';
 type FSRouterScannerOptions = {
     buildMode: boolean;
 };
@@ -18,9 +18,9 @@ export declare class FSRouterScanner {
     private origin;
     private templatesExt;
     private options;
-    private appConfig;
+    readonly appConfig: EcoPagesAppConfig;
     routes: Routes;
-    private pageModuleImportService;
+    private serverModuleTranspiler;
     constructor({ dir, origin, templatesExt, options, appConfig, }: {
         dir: string;
         origin: string;

package/src/router/{fs-router-scanner.js → server/fs-router-scanner.js}

@@ -1,9 +1,10 @@
 import path from "node:path";
-import { appLogger } from "../global/app-logger.js";
+import { appLogger } from "../../global/app-logger.js";
 import { fileSystem } from "@ecopages/file-system";
-import { invariant } from "../utils/invariant.js";
+import { invariant } from "../../utils/invariant.js";
 import { existsSync } from "node:fs";
-import { PageModuleImportService } from "../services/page-module-import.service.js";
+import { getAppServerModuleTranspiler } from "../../services/module-loading/app-server-module-transpiler.service.js";
+import { resolveInternalExecutionDir } from "../../utils/resolve-work-dir.js";
 class FSRouterScanner {
   dir;
   origin = "";
@@ -11,7 +12,7 @@ class FSRouterScanner {
   options;
   appConfig;
   routes = {};
-  pageModuleImportService = new PageModuleImportService();
+  serverModuleTranspiler;
   constructor({
     dir,
     origin,
@@ -24,6 +25,7 @@ class FSRouterScanner {
     this.templatesExt = templatesExt;
     this.options = options;
     this.appConfig = appConfig;
+    this.serverModuleTranspiler = getAppServerModuleTranspiler(appConfig);
   }
   getRoutePath(path2) {
     const cleanedRoute = this.templatesExt.reduce((route, ext) => route.replace(ext, ""), path2).replace(/\/?index$/, "");
@@ -90,10 +92,9 @@ class FSRouterScanner {
     return this.createRoute("dynamic", { filePath, route, routePath });
   }
   async importPageModule(filePath) {
-    return this.pageModuleImportService.importModule({
+    return this.serverModuleTranspiler.importModule({
       filePath,
-      rootDir: this.appConfig.rootDir,
-      outdir: path.join(this.appConfig.absolutePaths.distDir, ".server-route-modules"),
+      outdir: path.join(resolveInternalExecutionDir(this.appConfig), ".server-route-modules"),
       externalPackages: false,
       transpileErrorMessage: (details) => `Error transpiling route module: ${details}`,
       noOutputMessage: (targetFilePath) => `No transpiled output generated for route module: ${targetFilePath}`
@@ -112,7 +113,12 @@ class FSRouterScanner {
     const filePath = path.join(this.dir, file);
     const isCatchAll = filePath.includes("[...");
     const isDynamic = !isCatchAll && filePath.includes("[") && filePath.includes("]");
-    const kind = isCatchAll ? "catch-all" : isDynamic ? "dynamic" : "exact";
+    let kind = "exact";
+    if (isCatchAll) {
+      kind = "catch-all";
+    } else if (isDynamic) {
+      kind = "dynamic";
+    }
     return { route, routePath, filePath, kind };
   }
   async scan() {

package/src/router/{fs-router.d.ts → server/fs-router.d.ts}

@@ -1,4 +1,4 @@
-import type { MatchResult, Route, Routes } from '../internal-types.js';
+import type { MatchResult, Route, Routes } from '../../types/internal-types.js';
 import type { FSRouterScanner } from './fs-router-scanner.js';
 /**
  * A class that manages the routes of the file system.

package/src/router/{fs-router.js → server/fs-router.js}

@@ -1,4 +1,4 @@
-import { appLogger } from "../global/app-logger.js";
+import { appLogger } from "../../global/app-logger.js";
 class FSRouter {
   origin;
   assetPrefix;

package/src/services/README.md

@@ -0,0 +1,29 @@
+# Core Services
+
+This directory contains the app-owned service layer used by runtime startup, rendering, asset processing, browser bundling, and development invalidation.
+
+## Purpose
+
+Services in this directory exist to keep cross-cutting framework logic out of adapters, integrations, and processors.
+
+Typical responsibilities include:
+
+- server-module loading and transpilation
+- browser bundle coordination
+- asset processing and runtime asset declaration helpers
+- runtime specifier registry management
+- server invalidation state and entrypoint dependency graphs
+- HTML finalization and dependency injection
+
+## Main Areas
+
+- `module-loading/`: framework-owned config/app bootstrap loading and server-side source loading
+- `assets/`: shared browser build coordination and processed asset pipelines
+- `invalidation/`: file-change classification and invalidation policy
+- `runtime-state/`: app-owned invalidation state, dependency graphs, and runtime specifier registry
+- `runtime-manifest/`: node runtime manifest derivation and persistence
+- `html/`: final HTML dependency injection and rewriter selection
+
+## Design Rule
+
+If a concern affects more than one integration or more than one runtime adapter, it usually belongs here instead of in a package-specific implementation.

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

@@ -0,0 +1,120 @@
+import type { EcoPagesAppConfig, IHmrManager } from '../../../types/internal-types.js';
+import type { AssetDefinition, AssetKind, AssetSource, ProcessedAsset } from './assets.types.js';
+import { ProcessorRegistry } from './processor.registry.js';
+/**
+ * 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 declare class AssetProcessingService {
+    static readonly RESOLVED_ASSETS_DIR = "assets";
+    private registry;
+    private hmrManager?;
+    private cache;
+    private readonly config;
+    /**
+     * Creates the asset-processing service bound to one finalized app config.
+     */
+    constructor(config: EcoPagesAppConfig);
+    /**
+     * Set the HMR manager for the asset processing service.
+     * @param hmrManager The HMR manager to set.
+     */
+    setHmrManager(hmrManager: IHmrManager): void;
+    getHmrManager(): IHmrManager | undefined;
+    /**
+     * Register a processor for a specific asset kind and source.
+     * @param kind The asset kind.
+     * @param variant The asset source.
+     * @param processor The processor to register.
+     */
+    registerProcessor(kind: AssetKind, variant: AssetSource, processor: any): void;
+    /**
+     * 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.
+     */
+    processDependencies(deps: AssetDefinition[], key: string): Promise<ProcessedAsset[]>;
+    /**
+     * Removes duplicate dependency declarations while preserving first-seen order.
+     */
+    private deduplicateDependencies;
+    /**
+     * Builds the cache signature fragment for script dependencies that can vary by
+     * bundling policy.
+     */
+    private getScriptDependencyBuildSignature;
+    /**
+     * Derives the stable cache key for one dependency declaration.
+     */
+    private getDependencyKey;
+    /**
+     * Hashes content used in dependency cache and signature keys.
+     */
+    private generateHash;
+    /**
+     * 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 processDependenciesParallel;
+    /**
+     * Groups dependencies by processor bucket.
+     */
+    private groupDependenciesByType;
+    /**
+     * Converts a dist-local file path into its public URL.
+     */
+    private getSrcUrl;
+    /**
+     * Normalizes the public source URL for one processed asset.
+     */
+    private resolveProcessedAssetSrcUrl;
+    /**
+     * Returns whether a value should be interpreted as a filesystem path instead
+     * of an already-public URL.
+     */
+    private isFilesystemPath;
+    /**
+     * 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 optimizeDependencies;
+    /**
+     * Returns the cached processed asset for a dependency key when available.
+     */
+    private getCachedAsset;
+    /**
+     * Stores one processed asset in the dependency cache.
+     */
+    private setCachedAsset;
+    /**
+     * Clears all cached processed assets.
+     */
+    clearCache(): void;
+    /**
+     * Removes cached assets that were produced from the given file path.
+     */
+    invalidateCacheForFile(filepath: string): void;
+    /**
+     * Creates a service prewired with the default core processors.
+     */
+    static createWithDefaultProcessors(appConfig: EcoPagesAppConfig): AssetProcessingService;
+    /**
+     * Returns the processor registry owned by this service.
+     */
+    getRegistry(): ProcessorRegistry;
+}

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

@@ -1,25 +1,29 @@
 import path from "node:path";
-import { RESOLVED_ASSETS_DIR } from "../../constants";
-import { appLogger } from "../../global/app-logger";
-import { rapidhash } from "../../utils/hash";
+import { RESOLVED_ASSETS_DIR } from "../../../config/constants.js";
+import { appLogger } from "../../../global/app-logger.js";
+import { rapidhash } from "../../../utils/hash.js";
 import { fileSystem } from "@ecopages/file-system";
-import { isHmrAware } from "./processor.interface";
-import { ProcessorRegistry } from "./processor.registry";
+import { isHmrAware } from "./processor.interface.js";
+import { ProcessorRegistry } from "./processor.registry.js";
 import {
   ContentScriptProcessor,
   ContentStylesheetProcessor,
   FileScriptProcessor,
   FileStylesheetProcessor,
   NodeModuleScriptProcessor
-} from "./processors";
+} from "./processors/index.js";
 class AssetProcessingService {
-  constructor(config) {
-    this.config = config;
-  }
   static RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
   registry = new ProcessorRegistry();
   hmrManager;
   cache = /* @__PURE__ */ new Map();
+  config;
+  /**
+   * Creates the asset-processing service bound to one finalized app config.
+   */
+  constructor(config) {
+    this.config = config;
+  }
   /**
    * Set the HMR manager for the asset processing service.
    * @param hmrManager The HMR manager to set.
@@ -47,6 +51,14 @@ 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, key) {
     const depsDir = path.join(this.config.absolutePaths.distDir, RESOLVED_ASSETS_DIR);
     fileSystem.ensureDir(depsDir);
@@ -55,6 +67,9 @@ class AssetProcessingService {
     await this.optimizeDependencies(results);
     return results;
   }
+  /**
+   * Removes duplicate dependency declarations while preserving first-seen order.
+   */
   deduplicateDependencies(deps) {
     const seen = /* @__PURE__ */ new Map();
     for (const dep of deps) {
@@ -65,6 +80,10 @@ class AssetProcessingService {
     }
     return Array.from(seen.values());
   }
+  /**
+   * Builds the cache signature fragment for script dependencies that can vary by
+   * bundling policy.
+   */
   getScriptDependencyBuildSignature(dep) {
     if (dep.kind !== "script") {
       return void 0;
@@ -81,6 +100,9 @@ class AssetProcessingService {
     };
     return this.generateHash(JSON.stringify(signature));
   }
+  /**
+   * Derives the stable cache key for one dependency declaration.
+   */
   getDependencyKey(dep) {
     const parts = [dep.kind, dep.source];
     if ("filepath" in dep) {
@@ -99,9 +121,20 @@ class AssetProcessingService {
     }
     return parts.join(":");
   }
+  /**
+   * Hashes content used in dependency cache and signature keys.
+   */
   generateHash(content) {
     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.
+   */
   async processDependenciesParallel(deps, key) {
     const grouped = this.groupDependenciesByType(deps);
     const groupPromises = Object.entries(grouped).map(async ([, typeDeps]) => {
@@ -147,6 +180,9 @@ class AssetProcessingService {
     const allTypeResults = await Promise.all(groupPromises);
     return allTypeResults.flat();
   }
+  /**
+   * Groups dependencies by processor bucket.
+   */
   groupDependenciesByType(deps) {
     return deps.reduce(
       (acc, dep) => {
@@ -158,6 +194,9 @@ class AssetProcessingService {
       {}
     );
   }
+  /**
+   * Converts a dist-local file path into its public URL.
+   */
   getSrcUrl(filepath) {
     const distDir = this.config.absolutePaths.distDir;
     if (!filepath.startsWith(distDir)) return void 0;
@@ -165,6 +204,9 @@ class AssetProcessingService {
     const urlPath = relativePath.startsWith("/") ? relativePath : `/${relativePath}`;
     return urlPath.replace(/\\/g, "/");
   }
+  /**
+   * Normalizes the public source URL for one processed asset.
+   */
   resolveProcessedAssetSrcUrl(processed) {
     if (processed.srcUrl) {
       if (this.isFilesystemPath(processed.srcUrl)) {
@@ -179,6 +221,10 @@ class AssetProcessingService {
     }
     return void 0;
   }
+  /**
+   * Returns whether a value should be interpreted as a filesystem path instead
+   * of an already-public URL.
+   */
   isFilesystemPath(value) {
     if (value.startsWith("http://") || value.startsWith("https://") || value.startsWith("//")) {
       return false;
@@ -192,6 +238,13 @@ 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.
+   */
   async optimizeDependencies(processedAssets) {
     if (process.env.NODE_ENV !== "production") {
       return;
@@ -215,16 +268,38 @@ class AssetProcessingService {
       }
     }
   }
+  /**
+   * Returns the cached processed asset for a dependency key when available.
+   */
   getCachedAsset(dep, depKey) {
+    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.
+   */
   setCachedAsset(dep, depKey, asset) {
     this.cache.set(depKey, { asset });
   }
+  /**
+   * Clears all cached processed assets.
+   */
   clearCache() {
     this.cache.clear();
   }
+  /**
+   * Removes cached assets that were produced from the given file path.
+   */
   invalidateCacheForFile(filepath) {
     for (const [key, value] of this.cache.entries()) {
       if (value.asset.filepath === filepath) {
@@ -232,6 +307,9 @@ class AssetProcessingService {
       }
     }
   }
+  /**
+   * Creates a service prewired with the default core processors.
+   */
   static createWithDefaultProcessors(appConfig) {
     const service = new AssetProcessingService(appConfig);
     service.registerProcessor("script", "content", new ContentScriptProcessor({ appConfig }));
@@ -241,6 +319,9 @@ class AssetProcessingService {
     service.registerProcessor("stylesheet", "file", new FileStylesheetProcessor({ appConfig }));
     return service;
   }
+  /**
+   * Returns the processor registry owned by this service.
+   */
   getRegistry() {
     return this.registry;
   }

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

@@ -1,4 +1,4 @@
-import type { ContentScriptAsset, ContentStylesheetAsset, FileScriptAsset, FileStylesheetAsset, InlineContentScriptAsset, InlineContentStylesheetAsset, InlineFileScriptAsset, JsonScriptAsset, NodeModuleScriptAsset } from './assets.types';
+import type { ContentScriptAsset, ContentStylesheetAsset, FileScriptAsset, FileStylesheetAsset, InlineContentScriptAsset, InlineContentStylesheetAsset, InlineFileScriptAsset, JsonScriptAsset, NodeModuleScriptAsset } from './assets.types.js';
 type CreateAssetOptions<T> = Omit<T, 'kind' | 'source' | 'inline'>;
 export declare class AssetFactory {
     static readonly RESOLVED_ASSETS_DIR = "assets";

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

@@ -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 "../../../config/constants.js";
+import { deepMerge } from "../../../utils/deep-merge.js";
 class AssetFactory {
   static RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
   static RESOLVED_ASSETS_VENDORS_DIR = RESOLVED_ASSETS_VENDORS_DIR;