@ecopages/core 0.2.0-beta.23 → 0.2.0-beta.25

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

@@ -0,0 +1,78 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL, fileURLToPath } from "node:url";
+import { isBarePackageImportSpecifier } from "../../../plugins/tsconfig-import-resolver.js";
+function resolvePackageEsmEntryPath(specifier, rootDir) {
+  try {
+    return fileURLToPath(import.meta.resolve(specifier, pathToFileURL(path.join(rootDir, "package.json")).href));
+  } catch {
+    return void 0;
+  }
+}
+function toRelativeEntryImport(entryDir, resolvedPath) {
+  let relativePath = path.relative(entryDir, resolvedPath).replace(/\\/g, "/");
+  if (!relativePath.startsWith(".")) {
+    relativePath = `./${relativePath}`;
+  }
+  return relativePath;
+}
+function resolveBrowserRuntimeEntryImport(options) {
+  const { specifier, requireFromRoot, entryDir, rootDir } = options;
+  if (specifier.startsWith("node:") || specifier.startsWith("file:")) {
+    return specifier;
+  }
+  if (specifier.startsWith(".")) {
+    const resolvedPath2 = requireFromRoot.resolve(specifier);
+    return toRelativeEntryImport(entryDir, resolvedPath2);
+  }
+  if (isBarePackageImportSpecifier(specifier, rootDir)) {
+    const esmResolvedPath = resolvePackageEsmEntryPath(specifier, rootDir);
+    if (esmResolvedPath) {
+      return toRelativeEntryImport(entryDir, esmResolvedPath);
+    }
+  }
+  const resolvedPath = requireFromRoot.resolve(specifier);
+  const esmSibling = resolvedPath.endsWith(".cjs") ? `${resolvedPath.slice(0, -4)}.js` : resolvedPath.endsWith(".cts") ? `${resolvedPath.slice(0, -4)}.ts` : void 0;
+  if (esmSibling && fs.existsSync(esmSibling)) {
+    return toRelativeEntryImport(entryDir, esmSibling);
+  }
+  return toRelativeEntryImport(entryDir, resolvedPath);
+}
+function inferBrowserRuntimeDefaultExportPolicy(options) {
+  const { specifier, requireFromRoot, rootDir } = options;
+  const esmPath = resolvePackageEsmEntryPath(specifier, rootDir);
+  if (esmPath && fs.existsSync(esmPath)) {
+    const source = fs.readFileSync(esmPath, "utf8");
+    if (/\bexport\s+default\b/.test(source)) {
+      return "emit-default";
+    }
+    if (/\bexport\s+(?:[\w*{]|const|let|var|function|class)/.test(source)) {
+      return "skip-default";
+    }
+  }
+  try {
+    const moduleExports = requireFromRoot(specifier);
+    if (moduleExports.default !== void 0) {
+      return "emit-default";
+    }
+    return moduleExports.__esModule === true ? "skip-default" : "emit-default";
+  } catch {
+    return "skip-default";
+  }
+}
+function listBrowserRuntimeModuleExportNames(specifier, requireFromRoot) {
+  let moduleExports;
+  try {
+    moduleExports = requireFromRoot(specifier);
+  } catch {
+    return [];
+  }
+  return Object.keys(moduleExports).filter((name) => name !== "__esModule" && name !== "default").filter((name) => /^[$A-Z_a-z][$\w]*$/.test(name)).sort();
+}
+export {
+  inferBrowserRuntimeDefaultExportPolicy,
+  listBrowserRuntimeModuleExportNames,
+  resolveBrowserRuntimeEntryImport,
+  resolvePackageEsmEntryPath,
+  toRelativeEntryImport
+};

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

@@ -2,6 +2,11 @@ import fs from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
 import { DEFAULT_ECOPAGES_WORK_DIR } from "../../../config/constants.js";
+import {
+  inferBrowserRuntimeDefaultExportPolicy,
+  listBrowserRuntimeModuleExportNames,
+  resolveBrowserRuntimeEntryImport
+} from "./browser-runtime-entry-resolution.js";
 function createBrowserRuntimeEntryModule(options) {
   if (options.modules.some((module) => !module.specifier.startsWith("node:")) && !options.rootDir) {
     throw new Error("createBrowserRuntimeEntryModule requires rootDir to resolve package specifiers");
@@ -20,12 +25,17 @@ function createBrowserRuntimeEntryModule(options) {
   const filePath = path.join(artifactsDir, options.fileName);
   const entryDir = path.dirname(filePath);
   for (const module of options.modules) {
-    const importSpecifier = resolveEntryImportSpecifier(module.specifier, requireFromRoot, entryDir);
-    if (module.defaultExport) {
+    const importSpecifier = resolveBrowserRuntimeEntryImport({
+      specifier: module.specifier,
+      requireFromRoot,
+      entryDir,
+      rootDir
+    });
+    if (module.defaultExport && inferBrowserRuntimeDefaultExportPolicy({ specifier: module.specifier, requireFromRoot, rootDir }) === "emit-default") {
       statements.push(`import __ecopages_default_export__ from '${importSpecifier}';`);
       statements.push("export default __ecopages_default_export__;");
     }
-    const exportNames = getModuleExportNames(module.specifier, requireFromRoot).filter(
+    const exportNames = listBrowserRuntimeModuleExportNames(module.specifier, requireFromRoot).filter(
       (name) => !seenExports.has(name)
     );
     if (exportNames.length > 0) {
@@ -41,21 +51,6 @@ function createBrowserRuntimeEntryModule(options) {
   }
   return filePath;
 }
-function resolveEntryImportSpecifier(specifier, requireFromRoot, entryDir) {
-  if (specifier.startsWith("node:") || specifier.startsWith("file:")) {
-    return specifier;
-  }
-  const resolvedPath = requireFromRoot.resolve(specifier);
-  let relativePath = path.relative(entryDir, resolvedPath).replace(/\\/g, "/");
-  if (!relativePath.startsWith(".")) {
-    relativePath = `./${relativePath}`;
-  }
-  return relativePath;
-}
-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/finalize-processed-asset.d.ts

@@ -0,0 +1,3 @@
+import type { ProcessedAsset } from './assets.types.js';
+/** Applies the public source URL to one processed asset when available. */
+export declare function finalizeProcessedAsset(processed: ProcessedAsset, resolveProcessedAssetSrcUrl: (processed: ProcessedAsset) => string | undefined): ProcessedAsset;

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

@@ -0,0 +1,7 @@
+function finalizeProcessedAsset(processed, resolveProcessedAssetSrcUrl) {
+  const srcUrl = resolveProcessedAssetSrcUrl(processed);
+  return srcUrl ? { ...processed, srcUrl } : processed;
+}
+export {
+  finalizeProcessedAsset
+};

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

@@ -1,4 +1,6 @@
 import type { AssetDefinition, ProcessedAsset } from './assets.types.js';
+/** Forces grouped content scripts to run through the bundler in production builds. */
+export declare function ensureGroupedContentScriptsBundle(dependencies: AssetDefinition[]): void;
 /**
  * Splits grouped content-script dependencies from ordinary dependencies so callers can
  * route them through `processGrouped` without changing ordering for the remaining assets.
@@ -12,7 +14,6 @@ type GroupedBundleProcessor = {
 };
 type ProcessGroupedDependencyBundlesOptions = {
     bundles: AssetDefinition[][];
-    key: string;
     getCachedAsset: (dep: AssetDefinition, depKey: string) => ProcessedAsset | null;
     getDependencyKey: (dep: AssetDefinition) => string;
     getGroupedProcessor: () => GroupedBundleProcessor | undefined;

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

@@ -1,3 +1,18 @@
+import { isDevelopmentRuntime } from "../../../utils/runtime.js";
+import { finalizeProcessedAsset } from "./finalize-processed-asset.js";
+function ensureGroupedContentScriptsBundle(dependencies) {
+  if (isDevelopmentRuntime()) {
+    return;
+  }
+  for (const dependency of dependencies) {
+    if (dependency.kind !== "script" || dependency.source !== "content" || !dependency.groupedBundle?.id) {
+      continue;
+    }
+    if (dependency.bundle === false) {
+      dependency.bundle = true;
+    }
+  }
+}
 function partitionGroupedContentScriptDependencies(typeDeps) {
   const groupedBundleDeps = /* @__PURE__ */ new Map();
   const ungroupedDeps = [];
@@ -18,7 +33,6 @@ function partitionGroupedContentScriptDependencies(typeDeps) {
 async function processGroupedDependencyBundles(options) {
   const {
     bundles,
-    key,
     getCachedAsset,
     getDependencyKey,
     getGroupedProcessor,
@@ -29,7 +43,7 @@ async function processGroupedDependencyBundles(options) {
   const groupedPromises = bundles.map(async (bundleDeps) => {
     const cachedResults = bundleDeps.map((dep) => {
       const cached = getCachedAsset(dep, getDependencyKey(dep));
-      return cached ? { key, ...cached } : null;
+      return cached ? finalizeProcessedAsset(cached, resolveProcessedAssetSrcUrl) : null;
     });
     if (cachedResults.every((result) => result !== null)) {
       return cachedResults.filter((result) => result !== null);
@@ -43,14 +57,9 @@ async function processGroupedDependencyBundles(options) {
       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;
+        const finalized = finalizeProcessedAsset(processed, resolveProcessedAssetSrcUrl);
+        setCachedAsset(dep, depKey, finalized);
+        return finalized;
       });
     } catch (error) {
       logError(error);
@@ -60,6 +69,7 @@ async function processGroupedDependencyBundles(options) {
   return (await Promise.all(groupedPromises)).flat();
 }
 export {
+  ensureGroupedContentScriptsBundle,
   partitionGroupedContentScriptDependencies,
   processGroupedDependencyBundles
 };

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

@@ -1,6 +1,8 @@
 export * from './asset.factory.js';
+export * from './grouped-content-bundles.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';
+export * from './browser-runtime-entry-resolution.js';

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

@@ -1,6 +1,8 @@
 export * from "./asset.factory.js";
+export * from "./grouped-content-bundles.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";
+export * from "./browser-runtime-entry-resolution.js";

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

@@ -0,0 +1,11 @@
+import type { ContentScriptAsset, ProcessedAsset } from './assets.types.js';
+/**
+ * Builds a processed content-script asset from one dependency declaration and a
+ * previously emitted output file.
+ *
+ * @remarks
+ * Dev disk cache entries store only output paths. Callers must materialize the
+ * full processed asset from the originating dependency so HTML and page-browser
+ * graph assembly receive grouped-bundle metadata and script attributes.
+ */
+export declare function materializeContentScriptAsset(dep: ContentScriptAsset, filepath: string): ProcessedAsset;

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

@@ -0,0 +1,17 @@
+function materializeContentScriptAsset(dep, filepath) {
+  return {
+    filepath,
+    kind: "script",
+    inline: dep.inline ?? false,
+    content: dep.inline ? dep.content : void 0,
+    position: dep.position,
+    attributes: dep.attributes,
+    excludeFromHtml: dep.excludeFromHtml,
+    packageRole: dep.packageRole,
+    groupedBundle: dep.groupedBundle,
+    bundledSourceFilepaths: dep.bundledSourceFilepaths
+  };
+}
+export {
+  materializeContentScriptAsset
+};

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

@@ -1,6 +1,13 @@
 import type { ContentScriptAsset, ProcessedAsset } from '../../assets.types.js';
 import { BaseScriptProcessor } from '../base/base-script-processor.js';
 export declare class ContentScriptProcessor extends BaseScriptProcessor<ContentScriptAsset> {
+    private getContentScriptEntryDir;
+    private getContentScriptEntryPath;
+    private createBundleConfigHash;
+    private createContentScriptCacheKey;
+    private toProcessedAsset;
+    private removeContentScriptEntry;
     processGrouped(deps: ContentScriptAsset[]): Promise<ProcessedAsset[]>;
+    private getGroupedBundlerOptions;
     process(dep: ContentScriptAsset): Promise<ProcessedAsset>;
 }

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

@@ -1,7 +1,50 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
+import { shouldUseDevBrowserScriptCache } from "../../../../../build/dev-browser-script-cache.js";
 import { BaseScriptProcessor } from "../base/base-script-processor.js";
 class ContentScriptProcessor extends BaseScriptProcessor {
+  getContentScriptEntryDir() {
+    const dir = path.join(this.appConfig.absolutePaths.workDir, "content-script-entries");
+    fileSystem.ensureDir(dir);
+    return dir;
+  }
+  getContentScriptEntryPath(contentHash) {
+    return path.join(this.getContentScriptEntryDir(), `${contentHash}.js`);
+  }
+  createBundleConfigHash(dep, shouldBundle) {
+    return this.generateHash(
+      JSON.stringify({
+        bundle: shouldBundle,
+        minify: shouldBundle && this.isProduction,
+        opts: dep.bundleOptions
+      })
+    );
+  }
+  createContentScriptCacheKey(dep, shouldBundle) {
+    const contentHash = this.generateHash(dep.content);
+    const configHash = this.createBundleConfigHash(dep, shouldBundle);
+    return `${this.buildCacheKey(`content-script:${contentHash}`, contentHash, dep)}:${configHash}`;
+  }
+  toProcessedAsset(dep, filepath, inlineContent) {
+    return {
+      filepath,
+      content: dep.inline ? inlineContent : void 0,
+      kind: "script",
+      position: dep.position,
+      attributes: dep.attributes,
+      inline: dep.inline,
+      excludeFromHtml: dep.excludeFromHtml,
+      packageRole: dep.packageRole,
+      groupedBundle: dep.groupedBundle,
+      bundledSourceFilepaths: dep.bundledSourceFilepaths
+    };
+  }
+  removeContentScriptEntry(contentHash) {
+    if (shouldUseDevBrowserScriptCache()) {
+      return;
+    }
+    fileSystem.remove(this.getContentScriptEntryPath(contentHash));
+  }
   async processGrouped(deps) {
     if (deps.length === 0) {
       return [];
@@ -10,109 +53,92 @@ class ContentScriptProcessor extends BaseScriptProcessor {
     if (!shouldBundle || deps.some((dep) => dep.inline)) {
       return Promise.all(deps.map((dep) => this.process(dep)));
     }
-    const tempDir = path.join(
-      this.appConfig.absolutePaths.distDir,
-      `grouped-script-entries-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`
-    );
-    fileSystem.ensureDir(tempDir);
+    let tempEntries = [];
     try {
-      const tempEntries = deps.map((dep, index) => {
-        const entryName = dep.groupedBundle?.entryName ?? dep.name ?? `grouped-script-${index}`;
-        const tempFilepath = path.join(tempDir, `${entryName}.js`);
+      tempEntries = deps.map((dep) => {
+        const contentHash = this.generateHash(dep.content);
+        const tempFilepath = this.getContentScriptEntryPath(contentHash);
         fileSystem.write(tempFilepath, dep.content);
         return {
           dep,
-          entryName,
+          contentHash,
           tempFilepath
         };
       });
-      const primaryDep = deps[0];
       const outputPaths = await this.bundleScripts({
-        ...this.getBundlerOptions(primaryDep),
-        entries: tempEntries.map(({ entryName, tempFilepath }) => ({
-          entryName,
+        ...this.getGroupedBundlerOptions(deps),
+        entries: tempEntries.map(({ dep, contentHash, tempFilepath }) => ({
+          entryName: dep.groupedBundle?.entryName ?? dep.name ?? contentHash,
           entrypoint: tempFilepath
         })),
         outdir: this.getAssetsDir(),
         minify: this.isProduction,
         naming: "[name]-[hash].[ext]"
       });
-      return tempEntries.map(({ dep, entryName }) => {
+      return tempEntries.map(({ dep, contentHash }) => {
+        const entryName = dep.groupedBundle?.entryName ?? dep.name ?? contentHash;
         const bundledFilePath = outputPaths.get(entryName);
         if (!bundledFilePath) {
           throw new Error(`Missing grouped bundle output for ${entryName}`);
         }
-        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,
-          packageRole: dep.packageRole,
-          groupedBundle: dep.groupedBundle,
-          bundledSourceFilepaths: dep.bundledSourceFilepaths
-        };
+        return this.toProcessedAsset(
+          dep,
+          bundledFilePath,
+          dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : void 0
+        );
       });
     } finally {
-      fileSystem.remove(tempDir);
+      for (const { contentHash } of tempEntries) {
+        this.removeContentScriptEntry(contentHash);
+      }
     }
   }
-  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,
-        packageRole: dep.packageRole,
-        groupedBundle: dep.groupedBundle,
-        bundledSourceFilepaths: dep.bundledSourceFilepaths
-      };
-      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,
-        packageRole: dep.packageRole,
-        groupedBundle: dep.groupedBundle,
-        bundledSourceFilepaths: dep.bundledSourceFilepaths
+  getGroupedBundlerOptions(deps) {
+    const primaryDep = deps[0];
+    const options = this.getBundlerOptions(primaryDep);
+    if (deps.some((dep) => dep.bundleOptions?.splitting === false)) {
+      return {
+        ...options,
+        splitting: false
       };
-      fileSystem.remove(tempFileName);
-      this.writeCacheFile(filename, processedAsset);
-      return processedAsset;
     }
-    throw new Error("No content found for script asset");
+    return options;
+  }
+  async process(dep) {
+    const shouldBundle = this.shouldBundle(dep);
+    const cacheKey = this.createContentScriptCacheKey(dep, shouldBundle);
+    return this.getOrProcess(cacheKey, async () => {
+      const hash = this.generateHash(dep.content);
+      const filename = dep.name ? `${dep.name}.js` : `script-${hash}.js`;
+      const filepath = path.join(this.getAssetsDir(), "scripts", filename);
+      if (!shouldBundle) {
+        if (!dep.inline) {
+          fileSystem.write(filepath, dep.content);
+        }
+        return this.toProcessedAsset(dep, filepath, dep.inline ? dep.content : void 0);
+      }
+      if (!dep.content) {
+        throw new Error("No content found for script asset");
+      }
+      const entryPath = this.getContentScriptEntryPath(hash);
+      fileSystem.write(entryPath, dep.content);
+      try {
+        const bundledFilePath = await this.bundleScript({
+          entrypoint: entryPath,
+          outdir: this.getAssetsDir(),
+          minify: this.isProduction,
+          naming: `${path.parse(filename).name}-[hash].[ext]`,
+          ...this.getBundlerOptions(dep)
+        });
+        return this.toProcessedAsset(
+          dep,
+          bundledFilePath,
+          dep.inline ? fileSystem.readFileSync(bundledFilePath).toString() : void 0
+        );
+      } finally {
+        this.removeContentScriptEntry(hash);
+      }
+    });
   }
 }
 export {

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

@@ -0,0 +1,4 @@
+import type { AnyIntegrationPlugin } from '../../../plugins/integration-plugin.js';
+import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
+/** Resolves the integration plugin that owns one asset-processing batch key. */
+export declare function resolveIntegrationPluginForProcessingKey(appConfig: EcoPagesAppConfig, processingKey: string): AnyIntegrationPlugin | undefined;

package/src/services/assets/asset-processing-service/resolve-integration-plugin.js

@@ -0,0 +1,17 @@
+function resolveIntegrationPluginForProcessingKey(appConfig, processingKey) {
+  if (!appConfig.integrations?.length) {
+    return void 0;
+  }
+  const exactMatch = appConfig.integrations.find((integration) => integration.name === processingKey);
+  if (exactMatch) {
+    return exactMatch;
+  }
+  const baseName = processingKey.split(":")[0];
+  if (!baseName || baseName === processingKey) {
+    return void 0;
+  }
+  return appConfig.integrations.find((integration) => integration.name === baseName);
+}
+export {
+  resolveIntegrationPluginForProcessingKey
+};

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

@@ -2,7 +2,6 @@ import type { AssetProcessor } from './processor.interface.js';
 import type { AssetDefinition, ProcessedAsset } from './assets.types.js';
 type ProcessUngroupedDependencyOptions = {
     dep: AssetDefinition;
-    key: string;
     depKey: string;
     getCachedAsset: (dep: AssetDefinition, depKey: string) => ProcessedAsset | null;
     getProcessor: (dep: AssetDefinition) => AssetProcessor | undefined;

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

@@ -1,8 +1,8 @@
 import { fileSystem } from "@ecopages/file-system";
+import { finalizeProcessedAsset } from "./finalize-processed-asset.js";
 async function processUngroupedDependency(options) {
   const {
     dep,
-    key,
     depKey,
     getCachedAsset,
     getProcessor,
@@ -14,7 +14,7 @@ async function processUngroupedDependency(options) {
   } = options;
   const cached = getCachedAsset(dep, depKey);
   if (cached) {
-    return { key, ...cached };
+    return finalizeProcessedAsset(cached, resolveProcessedAssetSrcUrl);
   }
   const processor = getProcessor(dep);
   if (!processor) {
@@ -27,14 +27,9 @@ async function processUngroupedDependency(options) {
   }
   try {
     const processed = await processor.process(dep);
-    const srcUrl = resolveProcessedAssetSrcUrl(processed);
-    const processedWithKey = {
-      key,
-      ...processed,
-      srcUrl
-    };
-    setCachedAsset(dep, depKey, processedWithKey);
-    return processedWithKey;
+    const finalized = finalizeProcessedAsset(processed, resolveProcessedAssetSrcUrl);
+    setCachedAsset(dep, depKey, finalized);
+    return finalized;
   } catch (error) {
     logProcessingError(dep, error);
     return null;

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

@@ -2,6 +2,9 @@ import { getAppBrowserBuildPlugins, getAppTranspileOptions } from "../../build/b
 import { requireBuildRuntime } from "../../build/build-runtime.js";
 import { mergeEcoBuildPlugins } from "../../build/build-manifest.js";
 import { getAppSourceTransforms } from "../../plugins/source-transform.js";
+import { startupTrace } from "../../diagnostics/startup-trace.js";
+import { requestBuildDedupe } from "../../diagnostics/request-build-dedupe.js";
+import { createBuildOptionsDedupeKey } from "../../build/deduping-build-executor.js";
 function resolveBrowserBundleExecutor(appConfig, profile, executor) {
   const buildRuntime = requireBuildRuntime(appConfig);
   if (executor === "hmr" && (profile === "hmr-entrypoint" || profile === "hmr-runtime")) {
@@ -38,12 +41,17 @@ class BrowserBundleService {
       sourceTransforms: getAppSourceTransforms(this.appConfig)
     };
     const buildExecutor = resolveBrowserBundleExecutor(this.appConfig, profile, executor);
-    return await buildExecutor.build(request);
+    const dedupeKey = createBuildOptionsDedupeKey(request);
+    return requestBuildDedupe.dedupeBuild(dedupeKey, async () => {
+      const result = await buildExecutor.build(request);
+      startupTrace.recordBrowserBundle(result.outputs);
+      return result;
+    });
   }
   async bundleGroupedEntries(entries, options) {
     const request = {
       ...options,
-      entrypoints: entries.map((entry) => entry.entrypoint)
+      entrypoints: Object.fromEntries(entries.map((entry) => [entry.entryName, entry.entrypoint]))
     };
     return this.bundle(request);
   }