@ecopages/core 0.2.0-alpha.8 → 0.2.1-beta.0

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

@@ -1,17 +1,22 @@
 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 { fileSystem } from "@ecopages/file-system";
-import { isHmrAware } from "./processor.interface";
-import { ProcessorRegistry } from "./processor.registry";
+import { deduplicateAssetDependencies, getAssetDependencyKey } from "./asset-dependency-keys.js";
+import {
+  partitionGroupedContentScriptDependencies,
+  processGroupedDependencyBundles
+} from "./grouped-content-bundles.js";
+import { isHmrAware } from "./processor.interface.js";
+import { ProcessorRegistry } from "./processor.registry.js";
+import { processUngroupedDependency } from "./ungrouped-dependency-processing.js";
 import {
   ContentScriptProcessor,
   ContentStylesheetProcessor,
   FileScriptProcessor,
   FileStylesheetProcessor,
   NodeModuleScriptProcessor
-} from "./processors";
+} from "./processors/index.js";
 class AssetProcessingService {
   static RESOLVED_ASSETS_DIR = RESOLVED_ASSETS_DIR;
   registry = new ProcessorRegistry();
@@ -62,71 +67,11 @@ class AssetProcessingService {
   async processDependencies(deps, key) {
     const depsDir = path.join(this.config.absolutePaths.distDir, RESOLVED_ASSETS_DIR);
     fileSystem.ensureDir(depsDir);
-    const dedupedDeps = this.deduplicateDependencies(deps);
+    const dedupedDeps = deduplicateAssetDependencies(deps);
     const results = await this.processDependenciesParallel(dedupedDeps, key);
     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) {
-      const key = this.getDependencyKey(dep);
-      if (!seen.has(key)) {
-        seen.set(key, dep);
-      }
-    }
-    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;
-    }
-    const pluginNames = dep.bundleOptions?.plugins?.map((plugin) => plugin.name) ?? [];
-    const signature = {
-      bundle: dep.bundle,
-      inline: dep.inline,
-      excludeFromHtml: dep.excludeFromHtml,
-      naming: dep.bundleOptions?.naming,
-      external: dep.bundleOptions?.external,
-      minify: dep.bundleOptions?.minify,
-      plugins: pluginNames
-    };
-    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) {
-      parts.push(dep.filepath);
-    } else if ("content" in dep) {
-      parts.push(`content:${this.generateHash(dep.content)}`);
-    } else if ("importPath" in dep) {
-      parts.push(dep.importPath);
-    }
-    if ("position" in dep && dep.position) {
-      parts.push(dep.position);
-    }
-    const scriptBuildSignature = this.getScriptDependencyBuildSignature(dep);
-    if (scriptBuildSignature) {
-      parts.push(`build:${scriptBuildSignature}`);
-    }
-    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.
    *
@@ -138,44 +83,53 @@ class AssetProcessingService {
   async processDependenciesParallel(deps, key) {
     const grouped = this.groupDependenciesByType(deps);
     const groupPromises = Object.entries(grouped).map(async ([, typeDeps]) => {
-      const typePromises = typeDeps.map(async (dep) => {
-        const depKey = this.getDependencyKey(dep);
-        const cached = this.getCachedAsset(dep, depKey);
-        if (cached) {
-          return { key, ...cached };
-        }
-        const processor = this.registry.getProcessor(dep.kind, dep.source);
-        if (!processor) {
-          appLogger.error(`No processor found for ${dep.kind}/${dep.source}`);
-          return null;
-        }
-        if (dep.source === "file" && "filepath" in dep) {
-          const fileExists = fileSystem.exists(dep.filepath);
-          if (!fileExists) {
-            appLogger.warn(`Skipping missing ${dep.kind} file: ${dep.filepath}`);
-            return null;
+      const { groupedBundleDeps, ungroupedDeps } = partitionGroupedContentScriptDependencies(typeDeps);
+      const typePromises = ungroupedDeps.map(
+        (dep) => processUngroupedDependency({
+          dep,
+          key,
+          depKey: getAssetDependencyKey(dep),
+          getCachedAsset: (assetDep, depKey) => this.getCachedAsset(assetDep, depKey),
+          getProcessor: (assetDep) => this.registry.getProcessor(assetDep.kind, assetDep.source),
+          resolveProcessedAssetSrcUrl: (processed) => this.resolveProcessedAssetSrcUrl(processed),
+          setCachedAsset: (assetDep, depKey, processed) => this.setCachedAsset(assetDep, depKey, processed),
+          logMissingProcessor: (assetDep) => {
+            appLogger.error(`No processor found for ${assetDep.kind}/${assetDep.source}`);
+          },
+          logMissingFile: (assetDep) => {
+            appLogger.warn(`Skipping missing ${assetDep.kind} file: ${assetDep.filepath}`);
+          },
+          logProcessingError: (assetDep, error) => {
+            appLogger.error(
+              `Failed to process dependency: ${error instanceof Error ? error.message : String(error)} for ${assetDep.kind}/${assetDep.source}`
+            );
+            appLogger.debug(error);
           }
-        }
-        try {
-          const processed = await processor.process(dep);
-          const srcUrl = this.resolveProcessedAssetSrcUrl(processed);
-          const processedWithKey = {
-            key,
-            ...processed,
-            srcUrl
-          };
-          this.setCachedAsset(dep, depKey, processedWithKey);
-          return processedWithKey;
-        } catch (error) {
+        })
+      );
+      const groupedResults = await processGroupedDependencyBundles({
+        bundles: Array.from(groupedBundleDeps.values()),
+        key,
+        getCachedAsset: (dep, depKey) => this.getCachedAsset(dep, depKey),
+        getDependencyKey: getAssetDependencyKey,
+        getGroupedProcessor: () => this.registry.getProcessor("script", "content"),
+        resolveProcessedAssetSrcUrl: (processed) => this.resolveProcessedAssetSrcUrl(processed),
+        setCachedAsset: (dep, depKey, processed) => this.setCachedAsset(dep, depKey, processed),
+        logError: (error) => {
           appLogger.error(
-            `Failed to process dependency: ${error instanceof Error ? error.message : String(error)} for ${dep.kind}/${dep.source}`
+            `Failed to process grouped dependency bundle: ${error instanceof Error ? error.message : String(error)}`
           );
           appLogger.debug(error);
-          return null;
         }
       });
       const typeResults = await Promise.all(typePromises);
-      return typeResults.filter((result) => result !== null);
+      const processedTypeResults = typeResults.flatMap((result) => {
+        if (!result) {
+          return [];
+        }
+        return Array.isArray(result) ? result : [result];
+      });
+      return [...processedTypeResults, ...groupedResults];
     });
     const allTypeResults = await Promise.all(groupPromises);
     return allTypeResults.flat();

package/src/services/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/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;

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

@@ -2,20 +2,30 @@ 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';
+export type AssetPackageRole = 'page-script' | 'page-style' | 'runtime' | 'keep-separate' | 'dynamic-chunk';
+export type GroupedScriptBundle = {
+    id: string;
+    entryName: string;
+};
 export interface BaseAsset {
     kind: AssetKind;
     source: AssetSource;
     attributes?: Record<string, string>;
     position?: AssetPosition;
+    packageRole?: AssetPackageRole;
+    bundledSourceFilepaths?: string[];
 }
 export interface ScriptAsset extends BaseAsset {
     kind: 'script';
     inline?: boolean;
     bundle?: boolean;
+    groupedBundle?: GroupedScriptBundle;
     bundleOptions?: {
         define?: Record<string, string>;
         minify?: boolean;
         external?: string[];
+        splitting?: boolean;
+        excludeAppBuildPlugins?: string[];
         naming?: string;
         plugins?: EcoBuildPlugin[];
     };
@@ -78,6 +88,7 @@ export interface JsonScriptAsset extends ScriptAsset {
 }
 export type ProcessedAsset = {
     filepath?: string;
+    sourceFilepath?: string;
     srcUrl?: string;
     content?: string;
     kind: AssetKind;
@@ -85,5 +96,8 @@ export type ProcessedAsset = {
     attributes?: Record<string, string>;
     inline?: boolean;
     excludeFromHtml?: boolean;
+    packageRole?: AssetPackageRole;
+    groupedBundle?: GroupedScriptBundle;
+    bundledSourceFilepaths?: string[];
 };
 export type AssetDefinition = ContentScriptAsset | FileScriptAsset | NodeModuleScriptAsset | JsonScriptAsset | ContentStylesheetAsset | FileStylesheetAsset;

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

@@ -25,6 +25,7 @@ export declare function createBrowserRuntimeScriptAsset(options: {
         define?: Record<string, string>;
         minify?: boolean;
         external?: string[];
+        excludeAppBuildPlugins?: string[];
         naming?: string;
         plugins?: EcoBuildPlugin[];
     };
@@ -48,6 +49,7 @@ export declare function createBrowserRuntimeModuleAsset(options: {
         define?: Record<string, string>;
         minify?: boolean;
         external?: string[];
+        excludeAppBuildPlugins?: string[];
         naming?: string;
         plugins?: EcoBuildPlugin[];
     };

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

@@ -14,6 +14,7 @@ function createBrowserRuntimeScriptAsset(options) {
     position: "head",
     importPath: options.importPath,
     name: options.name,
+    packageRole: "runtime",
     excludeFromHtml: true,
     bundleOptions: {
       naming: options.fileName,

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

@@ -0,0 +1,30 @@
+import type { AssetDefinition, ProcessedAsset } from './assets.types.js';
+/**
+ * Splits grouped content-script dependencies from ordinary dependencies so callers can
+ * route them through `processGrouped` without changing ordering for the remaining assets.
+ */
+export declare function partitionGroupedContentScriptDependencies(typeDeps: AssetDefinition[]): {
+    groupedBundleDeps: Map<string, AssetDefinition[]>;
+    ungroupedDeps: AssetDefinition[];
+};
+type GroupedBundleProcessor = {
+    processGrouped?: (deps: AssetDefinition[]) => Promise<ProcessedAsset[]>;
+};
+type ProcessGroupedDependencyBundlesOptions = {
+    bundles: AssetDefinition[][];
+    key: string;
+    getCachedAsset: (dep: AssetDefinition, depKey: string) => ProcessedAsset | null;
+    getDependencyKey: (dep: AssetDefinition) => string;
+    getGroupedProcessor: () => GroupedBundleProcessor | undefined;
+    resolveProcessedAssetSrcUrl: (processed: ProcessedAsset) => string | undefined;
+    setCachedAsset: (dep: AssetDefinition, depKey: string, processed: ProcessedAsset) => void;
+    logError: (error: unknown) => void;
+};
+/**
+ * Processes grouped content-script bundles while preserving per-entry cache keys.
+ *
+ * When every dependency in a bundle already has a cached processed asset, the cached
+ * entries are returned directly and the grouped processor is skipped.
+ */
+export declare function processGroupedDependencyBundles(options: ProcessGroupedDependencyBundlesOptions): Promise<ProcessedAsset[]>;
+export {};

package/src/services/assets/asset-processing-service/grouped-content-bundles.js

@@ -0,0 +1,65 @@
+function partitionGroupedContentScriptDependencies(typeDeps) {
+  const groupedBundleDeps = /* @__PURE__ */ new Map();
+  const ungroupedDeps = [];
+  for (const dep of typeDeps) {
+    if (dep.kind === "script" && dep.source === "content" && dep.groupedBundle?.id) {
+      const existing = groupedBundleDeps.get(dep.groupedBundle.id) ?? [];
+      existing.push(dep);
+      groupedBundleDeps.set(dep.groupedBundle.id, existing);
+      continue;
+    }
+    ungroupedDeps.push(dep);
+  }
+  return {
+    groupedBundleDeps,
+    ungroupedDeps
+  };
+}
+async function processGroupedDependencyBundles(options) {
+  const {
+    bundles,
+    key,
+    getCachedAsset,
+    getDependencyKey,
+    getGroupedProcessor,
+    resolveProcessedAssetSrcUrl,
+    setCachedAsset,
+    logError
+  } = options;
+  const groupedPromises = bundles.map(async (bundleDeps) => {
+    const cachedResults = bundleDeps.map((dep) => {
+      const cached = getCachedAsset(dep, getDependencyKey(dep));
+      return cached ? { key, ...cached } : null;
+    });
+    if (cachedResults.every((result) => result !== null)) {
+      return cachedResults.filter((result) => result !== null);
+    }
+    const processor = getGroupedProcessor();
+    if (!processor?.processGrouped) {
+      return [];
+    }
+    try {
+      const processedResults = await processor.processGrouped(bundleDeps);
+      return processedResults.map((processed, index) => {
+        const dep = bundleDeps[index];
+        const depKey = getDependencyKey(dep);
+        const srcUrl = resolveProcessedAssetSrcUrl(processed);
+        const processedWithKey = {
+          key,
+          ...processed,
+          srcUrl
+        };
+        setCachedAsset(dep, depKey, processedWithKey);
+        return processedWithKey;
+      });
+    } catch (error) {
+      logError(error);
+      return [];
+    }
+  });
+  return (await Promise.all(groupedPromises)).flat();
+}
+export {
+  partitionGroupedContentScriptDependencies,
+  processGroupedDependencyBundles
+};

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

@@ -1,5 +1,6 @@
-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';
+export * from './asset.factory.js';
+export * from './page-package.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

@@ -1,5 +1,6 @@
-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";
+export * from "./asset.factory.js";
+export * from "./page-package.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/page-package.d.ts

@@ -0,0 +1,6 @@
+import type { PagePackageResult } from '../../../types/public-types.js';
+import type { ProcessedAsset } from './assets.types.js';
+import type { PageBrowserGraphResult } from '../../../types/public-types.js';
+export declare function createPagePackage(assets: ProcessedAsset[], options?: {
+    pageBrowserGraph?: PageBrowserGraphResult;
+}): PagePackageResult;

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

@@ -0,0 +1,80 @@
+function getSuppressedSourceFilepaths(assets) {
+  const suppressed = /* @__PURE__ */ new Set();
+  for (const asset of assets) {
+    if ((asset.packageRole === "page-style" || asset.packageRole === "page-script") && Array.isArray(asset.bundledSourceFilepaths)) {
+      for (const filepath of asset.bundledSourceFilepaths) {
+        suppressed.add(filepath);
+      }
+    }
+  }
+  return suppressed;
+}
+function createPagePackage(assets, options = {}) {
+  const allAssets = [
+    ...assets,
+    ...options.pageBrowserGraph?.entryAssets ?? [],
+    ...options.pageBrowserGraph?.chunkAssets ?? []
+  ];
+  const inlineAssets = [];
+  const separateAssets = [];
+  const dynamicChunks = [];
+  let pageScript;
+  let pageStylesheet;
+  const suppressedSourceFilepaths = getSuppressedSourceFilepaths(allAssets);
+  for (const asset of allAssets) {
+    if (asset.inline) {
+      inlineAssets.push(asset);
+      continue;
+    }
+    if (asset.packageRole === "dynamic-chunk") {
+      dynamicChunks.push(asset);
+      continue;
+    }
+    if (!pageScript && asset.packageRole === "page-script") {
+      pageScript = asset;
+      continue;
+    }
+    if (!pageStylesheet && asset.packageRole === "page-style") {
+      pageStylesheet = asset;
+      continue;
+    }
+    if (asset.packageRole === "keep-separate" || asset.packageRole === "runtime") {
+      separateAssets.push(asset);
+      continue;
+    }
+    if (!pageScript && asset.kind === "script" && !asset.excludeFromHtml) {
+      pageScript = asset;
+      continue;
+    }
+    if (!pageStylesheet && asset.kind === "stylesheet") {
+      pageStylesheet = asset;
+      continue;
+    }
+    separateAssets.push(asset);
+  }
+  return {
+    assets: allAssets,
+    pageBrowserGraph: options.pageBrowserGraph,
+    htmlAssets: allAssets.filter((asset) => shouldIncludeInHtml(asset, suppressedSourceFilepaths)),
+    pageScript,
+    pageStylesheet,
+    inlineAssets,
+    separateAssets,
+    dynamicChunks
+  };
+}
+function shouldIncludeInHtml(asset, suppressedSourceFilepaths) {
+  if (asset.excludeFromHtml) {
+    return false;
+  }
+  if (asset.packageRole === "runtime") {
+    return false;
+  }
+  if (asset.sourceFilepath && suppressedSourceFilepaths.has(asset.sourceFilepath)) {
+    return false;
+  }
+  return true;
+}
+export {
+  createPagePackage
+};

package/src/services/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/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/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/assets/asset-processing-service/processors/base/base-processor.js

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { RESOLVED_ASSETS_DIR } from "../../../../../constants.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";
@@ -38,7 +38,8 @@ class BaseProcessor {
   buildCacheKey(identifier, contentHash, dep) {
     const attrsHash = dep.attributes ? this.generateHash(JSON.stringify(dep.attributes)) : "";
     const position = dep.position ?? "";
-    return `${identifier}:${contentHash}:${position}:${attrsHash}`;
+    const packageRole = dep.packageRole ?? "";
+    return `${identifier}:${contentHash}:${position}:${attrsHash}:${packageRole}`;
   }
   getOrProcess(cacheKey, processFn) {
     if (this.hasCacheFile(cacheKey)) {

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

@@ -1,7 +1,8 @@
-import type { EcoPagesAppConfig } from '../../../../../internal-types';
+import type { EcoPagesAppConfig } from '../../../../../types/internal-types.js';
 import type { EcoBuildPlugin } from '../../../../../build/build-types.js';
-import type { ScriptAsset } from '../../assets.types';
-import { BaseProcessor } from './base-processor';
+import type { ScriptAsset } from '../../assets.types.js';
+import { BaseProcessor } from './base-processor.js';
+import { type BrowserBundleGroupedEntry } from '../../../browser-bundle.service.js';
 export declare abstract class BaseScriptProcessor<T extends ScriptAsset> extends BaseProcessor<T> {
     private readonly browserBundleService;
     constructor({ appConfig }: {
@@ -9,9 +10,13 @@ export declare abstract class BaseScriptProcessor<T extends ScriptAsset> extends
     });
     protected shouldBundle(dep: T): boolean;
     protected getBundlerOptions(dep: T): Record<string, any>;
-    protected collectBuildPlugins(): EcoBuildPlugin[];
-    protected bundleScript({ entrypoint, outdir, plugins: additionalPlugins, ...rest }: {
+    protected collectBuildPlugins(excludePluginNames?: string[]): EcoBuildPlugin[];
+    protected bundleScript({ entrypoint, outdir, excludeAppBuildPlugins, plugins: additionalPlugins, ...rest }: {
         entrypoint: string;
         outdir: string;
     } & ScriptAsset['bundleOptions']): Promise<string>;
+    protected bundleScripts({ entries, outdir, excludeAppBuildPlugins, plugins: additionalPlugins, ...rest }: {
+        entries: BrowserBundleGroupedEntry[];
+        outdir: string;
+    } & ScriptAsset['bundleOptions']): Promise<Map<string, string>>;
 }