@ecopages/core 0.2.0-beta.26 → 0.2.0-beta.28

package/src/route-renderer/orchestration/page-browser-graph/page-browser-graph-session.js

@@ -0,0 +1,436 @@
+import path from "node:path";
+import { createHash } from "node:crypto";
+import { appLogger } from "../../../global/app-logger.js";
+function isSkipCacheGroupedOutcome(outcome) {
+  return "skipCache" in outcome;
+}
+function serializeGraphKey(key) {
+  return `${key.policy}::${key.integrationName}::${key.routeFile}::${key.entryFingerprint}`;
+}
+function normalizeDependencyPath(filePath) {
+  return path.resolve(filePath);
+}
+function parseSerializedGraphKey(serializedKey) {
+  if (serializedKey.startsWith("grouped::")) {
+    return void 0;
+  }
+  const [policy, integrationName, routeFile, entryFingerprint] = serializedKey.split("::");
+  if (!policy || !integrationName || !routeFile || entryFingerprint === void 0) {
+    return void 0;
+  }
+  if (policy !== "development" && policy !== "production") {
+    return void 0;
+  }
+  return {
+    policy,
+    integrationName,
+    routeFile,
+    entryFingerprint
+  };
+}
+class GraphDependencyIndex {
+  dependencyToGraphKeys = /* @__PURE__ */ new Map();
+  bindRecord(record) {
+    const serializedKey = serializeGraphKey(record.key);
+    for (const dependencyPath of record.dependencyPaths) {
+      this.addDependencyBinding(normalizeDependencyPath(dependencyPath), serializedKey);
+    }
+  }
+  unbindRecord(record) {
+    const serializedKey = serializeGraphKey(record.key);
+    for (const dependencyPath of record.dependencyPaths) {
+      this.removeDependencyBinding(normalizeDependencyPath(dependencyPath), serializedKey);
+    }
+  }
+  bindGroupedRecord(integrationName, record) {
+    const serializedKey = `grouped::${integrationName}`;
+    for (const dependencyPath of record.dependencyPaths) {
+      this.addDependencyBinding(normalizeDependencyPath(dependencyPath), serializedKey);
+    }
+  }
+  unbindGroupedRecord(integrationName, record) {
+    const serializedKey = `grouped::${integrationName}`;
+    for (const dependencyPath of record.dependencyPaths) {
+      this.removeDependencyBinding(normalizeDependencyPath(dependencyPath), serializedKey);
+    }
+  }
+  getAffectedKeys(filePath) {
+    return new Set(this.dependencyToGraphKeys.get(normalizeDependencyPath(filePath)) ?? []);
+  }
+  resetForTests() {
+    this.dependencyToGraphKeys.clear();
+  }
+  addDependencyBinding(dependencyPath, serializedKey) {
+    const graphKeys = this.dependencyToGraphKeys.get(dependencyPath) ?? /* @__PURE__ */ new Set();
+    graphKeys.add(serializedKey);
+    this.dependencyToGraphKeys.set(dependencyPath, graphKeys);
+  }
+  removeDependencyBinding(dependencyPath, serializedKey) {
+    const graphKeys = this.dependencyToGraphKeys.get(dependencyPath);
+    if (!graphKeys) {
+      return;
+    }
+    graphKeys.delete(serializedKey);
+    if (graphKeys.size === 0) {
+      this.dependencyToGraphKeys.delete(dependencyPath);
+    }
+  }
+}
+class SessionPageBrowserGraphCache {
+  records = /* @__PURE__ */ new Map();
+  inFlight = /* @__PURE__ */ new Map();
+  groupedRecords = /* @__PURE__ */ new Map();
+  groupedInFlight = /* @__PURE__ */ new Map();
+  dependencyIndex = new GraphDependencyIndex();
+  graphGenerations = /* @__PURE__ */ new Map();
+  groupedGenerations = /* @__PURE__ */ new Map();
+  buildCount = 0;
+  getGraphByRoute(integrationName, routeFile, policy) {
+    const normalizedRoute = normalizeDependencyPath(routeFile);
+    for (const record of this.records.values()) {
+      if (record.key.integrationName !== integrationName) {
+        continue;
+      }
+      if (record.key.policy !== policy) {
+        continue;
+      }
+      if (normalizeDependencyPath(record.key.routeFile) !== normalizedRoute) {
+        continue;
+      }
+      return record.result;
+    }
+    return void 0;
+  }
+  getBuildCount() {
+    return this.buildCount;
+  }
+  getAffectedGraphIdentities(filePath) {
+    const identities = [];
+    for (const serializedKey of this.dependencyIndex.getAffectedKeys(filePath)) {
+      const identity = parseSerializedGraphKey(serializedKey);
+      if (identity) {
+        identities.push(identity);
+      }
+    }
+    return identities;
+  }
+  resolveGraph(key, build) {
+    const serializedKey = serializeGraphKey(key);
+    const cached = this.records.get(serializedKey);
+    if (cached) {
+      return Promise.resolve(cached.result);
+    }
+    const pending = this.inFlight.get(serializedKey);
+    if (pending) {
+      return pending;
+    }
+    const buildGeneration = this.bumpGraphGeneration(serializedKey);
+    const buildPromise = this.runGraphBuild(serializedKey, key, buildGeneration, build);
+    this.inFlight.set(serializedKey, buildPromise);
+    return buildPromise;
+  }
+  resolveGroupedGraph(integrationName, build) {
+    const cached = this.groupedRecords.get(integrationName);
+    if (cached) {
+      return Promise.resolve(cached.assetsByRoute);
+    }
+    const pending = this.groupedInFlight.get(integrationName);
+    if (pending) {
+      return pending;
+    }
+    const buildGeneration = this.bumpGroupedGeneration(integrationName);
+    const buildPromise = this.runGroupedBuild(integrationName, buildGeneration, build);
+    this.groupedInFlight.set(integrationName, buildPromise);
+    return buildPromise;
+  }
+  peekGroupedGraph(integrationName) {
+    return this.groupedRecords.get(integrationName)?.assetsByRoute;
+  }
+  invalidateByFilePath(filePath) {
+    const normalizedFilePath = normalizeDependencyPath(filePath);
+    const affectedKeys = this.dependencyIndex.getAffectedKeys(normalizedFilePath);
+    let invalidated = 0;
+    for (const serializedKey of affectedKeys) {
+      if (serializedKey.startsWith("grouped::")) {
+        const integrationName = serializedKey.slice("grouped::".length);
+        invalidated += this.invalidateGroupedRecord(integrationName);
+        continue;
+      }
+      invalidated += this.invalidateSerializedGraphKey(serializedKey);
+    }
+    for (const serializedKey of this.inFlight.keys()) {
+      const identity = parseSerializedGraphKey(serializedKey);
+      if (!identity) {
+        continue;
+      }
+      if (normalizeDependencyPath(identity.routeFile) !== normalizedFilePath) {
+        continue;
+      }
+      if (affectedKeys.has(serializedKey)) {
+        continue;
+      }
+      this.bumpGraphGeneration(serializedKey);
+      this.inFlight.delete(serializedKey);
+      invalidated += 1;
+    }
+    if (invalidated > 0) {
+      appLogger.debug(
+        `[PageBrowserGraphSession] invalidated ${invalidated} graph record(s) for ${normalizedFilePath}`
+      );
+    }
+    return invalidated;
+  }
+  invalidateRoute(integrationName, routeFile) {
+    const normalizedRoute = normalizeDependencyPath(routeFile);
+    for (const [serializedKey, record] of this.records) {
+      if (record.key.integrationName !== integrationName) {
+        continue;
+      }
+      if (normalizeDependencyPath(record.key.routeFile) !== normalizedRoute) {
+        continue;
+      }
+      this.invalidateSerializedGraphKey(serializedKey);
+    }
+  }
+  invalidateByRouteFile(routeFile) {
+    const normalizedRoute = normalizeDependencyPath(routeFile);
+    for (const [serializedKey, record] of this.records) {
+      if (normalizeDependencyPath(record.key.routeFile) !== normalizedRoute) {
+        continue;
+      }
+      this.invalidateSerializedGraphKey(serializedKey);
+    }
+  }
+  resetForTests() {
+    this.records.clear();
+    this.inFlight.clear();
+    this.groupedRecords.clear();
+    this.groupedInFlight.clear();
+    this.graphGenerations.clear();
+    this.groupedGenerations.clear();
+    this.dependencyIndex.resetForTests();
+    this.buildCount = 0;
+  }
+  exportRecords(policy) {
+    return [...this.records.values()].filter((record) => record.key.policy === policy);
+  }
+  clearPolicyRecords(policy) {
+    for (const [serializedKey, record] of this.records) {
+      if (record.key.policy !== policy) {
+        continue;
+      }
+      this.dependencyIndex.unbindRecord(record);
+      this.records.delete(serializedKey);
+      this.inFlight.delete(serializedKey);
+      this.graphGenerations.delete(serializedKey);
+    }
+    if (policy === "production") {
+      for (const integrationName of [...this.groupedRecords.keys()]) {
+        const groupedRecord = this.groupedRecords.get(integrationName);
+        if (groupedRecord) {
+          this.dependencyIndex.unbindGroupedRecord(integrationName, groupedRecord);
+        }
+        this.groupedRecords.delete(integrationName);
+        this.groupedInFlight.delete(integrationName);
+        this.groupedGenerations.delete(integrationName);
+      }
+    }
+  }
+  pruneStaleRouteRecords(key) {
+    const normalizedRoute = normalizeDependencyPath(key.routeFile);
+    for (const [serializedKey, record] of this.records) {
+      if (record.key.integrationName !== key.integrationName) {
+        continue;
+      }
+      if (normalizeDependencyPath(record.key.routeFile) !== normalizedRoute) {
+        continue;
+      }
+      if (record.key.entryFingerprint === key.entryFingerprint && record.key.policy === key.policy) {
+        continue;
+      }
+      this.invalidateSerializedGraphKey(serializedKey);
+    }
+  }
+  bumpGraphGeneration(serializedKey) {
+    const next = (this.graphGenerations.get(serializedKey) ?? 0) + 1;
+    this.graphGenerations.set(serializedKey, next);
+    return next;
+  }
+  bumpGroupedGeneration(integrationName) {
+    const next = (this.groupedGenerations.get(integrationName) ?? 0) + 1;
+    this.groupedGenerations.set(integrationName, next);
+    return next;
+  }
+  invalidateSerializedGraphKey(serializedKey) {
+    const record = this.records.get(serializedKey);
+    if (record) {
+      this.dependencyIndex.unbindRecord(record);
+      this.records.delete(serializedKey);
+    }
+    this.bumpGraphGeneration(serializedKey);
+    this.inFlight.delete(serializedKey);
+    return record ? 1 : 0;
+  }
+  invalidateGroupedRecord(integrationName) {
+    const groupedRecord = this.groupedRecords.get(integrationName);
+    if (groupedRecord) {
+      this.dependencyIndex.unbindGroupedRecord(integrationName, groupedRecord);
+      this.groupedRecords.delete(integrationName);
+    }
+    this.bumpGroupedGeneration(integrationName);
+    this.groupedInFlight.delete(integrationName);
+    return groupedRecord ? 1 : 0;
+  }
+  async runGraphBuild(serializedKey, key, buildGeneration, build) {
+    try {
+      this.buildCount += 1;
+      const buildResult = await build();
+      if (!buildResult) {
+        return void 0;
+      }
+      if (!this.canCommitGraphBuild(serializedKey, buildGeneration)) {
+        const existing = this.records.get(serializedKey);
+        return existing?.result;
+      }
+      this.pruneStaleRouteRecords(key);
+      const previous = this.records.get(serializedKey);
+      if (previous) {
+        this.dependencyIndex.unbindRecord(previous);
+      }
+      const record = {
+        key,
+        result: buildResult.result,
+        dependencyPaths: buildResult.dependencyPaths,
+        committedAt: Date.now(),
+        generation: buildGeneration
+      };
+      this.records.set(serializedKey, record);
+      this.dependencyIndex.bindRecord(record);
+      return record.result;
+    } catch (error) {
+      return Promise.reject(error);
+    } finally {
+      this.inFlight.delete(serializedKey);
+    }
+  }
+  async runGroupedBuild(integrationName, buildGeneration, build) {
+    try {
+      this.buildCount += 1;
+      const buildResult = await build();
+      if (!buildResult) {
+        return /* @__PURE__ */ new Map();
+      }
+      if (isSkipCacheGroupedOutcome(buildResult)) {
+        return buildResult.assetsByRoute;
+      }
+      if (!this.canCommitGroupedBuild(integrationName, buildGeneration)) {
+        const existing = this.groupedRecords.get(integrationName);
+        return existing?.assetsByRoute ?? /* @__PURE__ */ new Map();
+      }
+      const previous = this.groupedRecords.get(integrationName);
+      if (previous) {
+        this.dependencyIndex.unbindGroupedRecord(integrationName, previous);
+      }
+      const record = {
+        assetsByRoute: buildResult.assetsByRoute,
+        dependencyPaths: buildResult.dependencyPaths,
+        generation: buildGeneration
+      };
+      this.groupedRecords.set(integrationName, record);
+      this.dependencyIndex.bindGroupedRecord(integrationName, record);
+      return record.assetsByRoute;
+    } catch (error) {
+      return Promise.reject(error);
+    } finally {
+      this.groupedInFlight.delete(integrationName);
+    }
+  }
+  canCommitGraphBuild(serializedKey, buildGeneration) {
+    return this.graphGenerations.get(serializedKey) === buildGeneration;
+  }
+  canCommitGroupedBuild(integrationName, buildGeneration) {
+    return this.groupedGenerations.get(integrationName) === buildGeneration;
+  }
+}
+const sessionByAppConfig = /* @__PURE__ */ new WeakMap();
+function getAppPageBrowserGraphSession(appConfig) {
+  const existing = appConfig.runtime?.pageBrowserGraphSession;
+  if (existing) {
+    return existing;
+  }
+  const cached = sessionByAppConfig.get(appConfig);
+  if (cached) {
+    return cached;
+  }
+  const session = new SessionPageBrowserGraphCache();
+  sessionByAppConfig.set(appConfig, session);
+  appConfig.runtime = {
+    ...appConfig.runtime ?? {},
+    pageBrowserGraphSession: session
+  };
+  return session;
+}
+function invalidatePageBrowserGraphSession(appConfig, filePath) {
+  return getAppPageBrowserGraphSession(appConfig).invalidateByFilePath(filePath);
+}
+function getAffectedPageBrowserGraphIdentities(appConfig, filePath) {
+  return getAppPageBrowserGraphSession(appConfig).getAffectedGraphIdentities(filePath);
+}
+function createPageBrowserGraphEntryFingerprint(contribution) {
+  const descriptors = [
+    ...(contribution.dependencies ?? []).map((dependency) => describeAssetDependency(dependency)),
+    ...(contribution.assets ?? []).map((asset) => describeProcessedAsset(asset))
+  ].sort((left, right) => left.localeCompare(right));
+  return descriptors.join("|") || "empty";
+}
+function collectPageBrowserGraphDependencyPaths(routeFile, contribution, processedAssets) {
+  const dependencyPaths = /* @__PURE__ */ new Set([normalizeDependencyPath(routeFile)]);
+  for (const dependency of contribution.dependencies ?? []) {
+    if (dependency.source === "file") {
+      dependencyPaths.add(normalizeDependencyPath(dependency.filepath));
+    }
+  }
+  for (const asset of processedAssets) {
+    if (asset.sourceFilepath) {
+      dependencyPaths.add(normalizeDependencyPath(asset.sourceFilepath));
+    }
+    for (const bundledSourceFilepath of asset.bundledSourceFilepaths ?? []) {
+      dependencyPaths.add(normalizeDependencyPath(bundledSourceFilepath));
+    }
+  }
+  return dependencyPaths;
+}
+function describeProcessedAsset(asset) {
+  const filepath = asset.filepath ?? "";
+  const sourceFilepath = asset.sourceFilepath ?? "";
+  const content = typeof asset.content === "string" ? asset.content : "";
+  const contentDigest = content ? createHash("sha1").update(content).digest("hex").slice(0, 12) : "";
+  return `asset:${asset.kind}:${filepath}:${sourceFilepath}:${contentDigest}`;
+}
+function describeAssetDependency(dependency) {
+  switch (dependency.source) {
+    case "file":
+      return `file:${dependency.filepath}`;
+    case "node-module":
+      return `module:${dependency.importPath}`;
+    case "content": {
+      const content = typeof dependency.content === "string" ? dependency.content : "";
+      const contentDigest = createHash("sha1").update(content).digest("hex").slice(0, 12);
+      const name = "name" in dependency && typeof dependency.name === "string" ? dependency.name : "";
+      return `content:${dependency.kind}:${name}:${contentDigest}`;
+    }
+    default: {
+      const exhaustive = dependency;
+      return String(exhaustive);
+    }
+  }
+}
+export {
+  GraphDependencyIndex,
+  SessionPageBrowserGraphCache,
+  collectPageBrowserGraphDependencyPaths,
+  createPageBrowserGraphEntryFingerprint,
+  getAffectedPageBrowserGraphIdentities,
+  getAppPageBrowserGraphSession,
+  invalidatePageBrowserGraphSession
+};

package/src/route-renderer/orchestration/{page-browser-graph.service.d.ts → page-browser-graph/page-browser-graph.service.d.ts}

@@ -1,10 +1,12 @@
-import type { EcoPagesAppConfig } from '../../types/internal-types.js';
-import type { PageBrowserGraphContribution, PageBrowserGraphResult } from '../../types/public-types.js';
-import { type AssetProcessingService } from '../../services/assets/asset-processing-service/index.js';
+import type { EcoPagesAppConfig } from '../../../types/internal-types.js';
+import type { PageBrowserGraphContribution, PageBrowserGraphResult } from '../../../types/public-types.js';
+import { type AssetProcessingService } from '../../../services/assets/asset-processing-service/index.js';
+import { type GraphPolicy } from './page-browser-graph-session.js';
 export type PageBrowserGraphResolveInput = {
     routeFile: string;
     integrationName: string;
     collectContribution: (routeFile: string) => Promise<PageBrowserGraphContribution | undefined>;
+    policy?: GraphPolicy;
 };
 /**
  * Resolves declarative page browser graph assets for one route and integration.
@@ -12,12 +14,16 @@ export type PageBrowserGraphResolveInput = {
 export declare class PageBrowserGraphService {
     private readonly appConfig;
     private readonly assetProcessingService;
-    private readonly pageBrowserGraphCache;
-    private readonly groupedPageBrowserGraphCache;
     constructor(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService);
     resolvePageBrowserGraph(input: PageBrowserGraphResolveInput): Promise<PageBrowserGraphResult | undefined>;
+    /**
+     * Resolves or builds one Page Browser Graph under the given policy.
+     */
+    getOrBuild(input: PageBrowserGraphResolveInput): Promise<PageBrowserGraphResult | undefined>;
+    private resolveGraphPolicy;
     private isHmrEnabled;
-    private buildPageBrowserGraph;
+    private buildPageBrowserGraphRecord;
+    private materializePageBrowserGraph;
     private resolveGroupedPageBrowserAssets;
     private buildGroupedPageBrowserAssets;
     private listIntegrationRouteFiles;

package/src/route-renderer/orchestration/{page-browser-graph.service.js → page-browser-graph/page-browser-graph.service.js}

@@ -1,8 +1,14 @@
 import path from "node:path";
 import { fileSystem } from "@ecopages/file-system";
 import {
-} from "../../services/assets/asset-processing-service/index.js";
-import { appLogger } from "../../global/app-logger.js";
+} from "../../../services/assets/asset-processing-service/index.js";
+import { appLogger } from "../../../global/app-logger.js";
+import { startupTrace } from "../../../diagnostics/startup-trace.js";
+import {
+  collectPageBrowserGraphDependencyPaths,
+  createPageBrowserGraphEntryFingerprint,
+  getAppPageBrowserGraphSession
+} from "./page-browser-graph-session.js";
 function isGroupedContentScriptAsset(asset) {
   return asset.kind === "script" && asset.source === "content" && Boolean(asset.groupedBundle?.id);
 }
@@ -12,76 +18,106 @@ function getGroupedBundleAssetKey(groupedBundle) {
 class PageBrowserGraphService {
   appConfig;
   assetProcessingService;
-  pageBrowserGraphCache = /* @__PURE__ */ new Map();
-  groupedPageBrowserGraphCache = /* @__PURE__ */ new Map();
   constructor(appConfig, assetProcessingService) {
     this.appConfig = appConfig;
     this.assetProcessingService = assetProcessingService;
   }
   async resolvePageBrowserGraph(input) {
-    if (this.isHmrEnabled()) {
-      return await this.buildPageBrowserGraph(input);
+    return await this.getOrBuild(input);
+  }
+  /**
+   * Resolves or builds one Page Browser Graph under the given policy.
+   */
+  async getOrBuild(input) {
+    const policy = input.policy ?? this.resolveGraphPolicy();
+    const session = getAppPageBrowserGraphSession(this.appConfig);
+    if (!this.isHmrEnabled()) {
+      const cachedByRoute = session.getGraphByRoute(input.integrationName, input.routeFile, policy);
+      if (cachedByRoute) {
+        return cachedByRoute;
+      }
     }
-    const cacheKey = `${input.integrationName}:${input.routeFile}`;
-    const cachedGraph = this.pageBrowserGraphCache.get(cacheKey);
-    if (cachedGraph) {
-      return await cachedGraph;
+    const contribution = await input.collectContribution(input.routeFile);
+    if (!contribution) {
+      return void 0;
     }
-    const pendingGraph = this.buildPageBrowserGraph(input).catch((error) => {
-      this.pageBrowserGraphCache.delete(cacheKey);
-      throw error;
-    });
-    this.pageBrowserGraphCache.set(cacheKey, pendingGraph);
-    return await pendingGraph;
+    const entryFingerprint = createPageBrowserGraphEntryFingerprint(contribution);
+    return await session.resolveGraph(
+      {
+        integrationName: input.integrationName,
+        routeFile: input.routeFile,
+        entryFingerprint,
+        policy
+      },
+      async () => this.buildPageBrowserGraphRecord(input, contribution)
+    );
+  }
+  resolveGraphPolicy() {
+    return this.isHmrEnabled() ? "development" : "production";
   }
   isHmrEnabled() {
     return typeof this.assetProcessingService.getHmrManager === "function" && this.assetProcessingService.getHmrManager()?.isEnabled() === true;
   }
-  async buildPageBrowserGraph(input) {
-    const contribution = await input.collectContribution(input.routeFile);
-    if (!contribution) {
+  async buildPageBrowserGraphRecord(input, contribution) {
+    const result = await this.materializePageBrowserGraph(input, contribution);
+    if (!result) {
       return void 0;
     }
+    startupTrace.markFirstPageBrowserGraphReady(getAppPageBrowserGraphSession(this.appConfig).getBuildCount());
+    return result;
+  }
+  async materializePageBrowserGraph(input, contribution) {
     const groupedDependencies = (contribution.dependencies ?? []).filter((dep) => isGroupedContentScriptAsset(dep));
     const ungroupedDependencies = (contribution.dependencies ?? []).filter(
       (dep) => !isGroupedContentScriptAsset(dep)
     );
-    const groupedAssets = groupedDependencies.length ? (await this.resolveGroupedPageBrowserAssets(input, contribution)).get(input.routeFile) ?? [] : [];
+    const groupedAssets = groupedDependencies.length ? (await this.resolveGroupedPageBrowserAssets(input, contribution)).assetsByRoute.get(input.routeFile) ?? [] : [];
     const processedDependencies = ungroupedDependencies.length ? await this.assetProcessingService.processDependencies(
       ungroupedDependencies,
       `${input.integrationName}:${input.routeFile}`
     ) : [];
     const resolvedAssets = [...processedDependencies, ...groupedAssets, ...contribution.assets ?? []];
-    return this.partitionPageBrowserGraphAssets(resolvedAssets);
+    const result = this.partitionPageBrowserGraphAssets(resolvedAssets);
+    const dependencyPaths = collectPageBrowserGraphDependencyPaths(input.routeFile, contribution, resolvedAssets);
+    return {
+      result,
+      dependencyPaths
+    };
   }
   async resolveGroupedPageBrowserAssets(input, currentContribution) {
     if (this.isHmrEnabled()) {
-      const result = await this.buildGroupedPageBrowserAssets(input, currentContribution);
-      return result.assetsByRoute;
+      return await this.buildGroupedPageBrowserAssets(input, currentContribution);
     }
-    const cacheKey = input.integrationName;
-    let pending = this.groupedPageBrowserGraphCache.get(cacheKey);
-    if (!pending) {
-      pending = this.buildGroupedPageBrowserAssets(input, currentContribution).then((result) => {
-        if (result.hasCollectionFailures) {
-          this.groupedPageBrowserGraphCache.delete(cacheKey);
-        }
-        return result.assetsByRoute;
-      }).catch((error) => {
-        this.groupedPageBrowserGraphCache.delete(cacheKey);
-        throw error;
-      });
-      this.groupedPageBrowserGraphCache.set(cacheKey, pending);
-    }
-    return await pending;
+    const session = getAppPageBrowserGraphSession(this.appConfig);
+    const assetsByRoute = await session.resolveGroupedGraph(input.integrationName, async () => {
+      const built = await this.buildGroupedPageBrowserAssets(input, currentContribution);
+      if (built.hasCollectionFailures) {
+        return {
+          skipCache: true,
+          assetsByRoute: built.assetsByRoute,
+          dependencyPaths: built.dependencyPaths
+        };
+      }
+      return {
+        assetsByRoute: built.assetsByRoute,
+        dependencyPaths: built.dependencyPaths,
+        generation: 0
+      };
+    });
+    return {
+      assetsByRoute,
+      dependencyPaths: /* @__PURE__ */ new Set(),
+      hasCollectionFailures: false
+    };
   }
   async buildGroupedPageBrowserAssets(input, currentContribution) {
-    const routeFiles = await this.listIntegrationRouteFiles(input.integrationName);
+    const routeFiles = this.isHmrEnabled() ? [input.routeFile] : await this.listIntegrationRouteFiles(input.integrationName);
     const currentRouteGroupedDependencies = (currentContribution.dependencies ?? []).filter(
       (dep) => isGroupedContentScriptAsset(dep)
     );
     const groupedDependencies = [...currentRouteGroupedDependencies];
     const groupedAssetKeysByRoute = /* @__PURE__ */ new Map();
+    const dependencyPaths = /* @__PURE__ */ new Set([path.resolve(input.routeFile)]);
     let hasCollectionFailures = false;
     if (currentRouteGroupedDependencies.length > 0) {
       groupedAssetKeysByRoute.set(
@@ -103,9 +139,6 @@ class PageBrowserGraphService {
         );
         continue;
       }
-      if (this.isHmrEnabled()) {
-        continue;
-      }
       if (!contribution?.dependencies?.length) {
         continue;
       }
@@ -120,13 +153,20 @@ class PageBrowserGraphService {
         routeFile,
         new Set(routeGroupedDependencies.map((dep) => getGroupedBundleAssetKey(dep.groupedBundle)))
       );
+      dependencyPaths.add(path.resolve(routeFile));
     }
     if (groupedDependencies.length === 0) {
       return {
         assetsByRoute: /* @__PURE__ */ new Map(),
+        dependencyPaths,
         hasCollectionFailures
       };
     }
+    for (const dependency of groupedDependencies) {
+      if (dependency.source === "file") {
+        dependencyPaths.add(path.resolve(dependency.filepath));
+      }
+    }
     const processedGroupedDependencies = await this.assetProcessingService.processDependencies(
       groupedDependencies,
       `${input.integrationName}:grouped-page-browser-graph`
@@ -146,8 +186,17 @@ class PageBrowserGraphService {
       }
       groupedAssetsByRoute.set(routeFile, matchedAssets);
     }
+    for (const asset of processedGroupedDependencies) {
+      if (asset.sourceFilepath) {
+        dependencyPaths.add(path.resolve(asset.sourceFilepath));
+      }
+      for (const bundledSourceFilepath of asset.bundledSourceFilepaths ?? []) {
+        dependencyPaths.add(path.resolve(bundledSourceFilepath));
+      }
+    }
     return {
       assetsByRoute: groupedAssetsByRoute,
+      dependencyPaths,
       hasCollectionFailures
     };
   }

package/src/route-renderer/orchestration/{processed-asset-dedupe.d.ts → page-browser-graph/processed-asset-dedupe.d.ts}

@@ -1,3 +1,3 @@
-import type { ProcessedAsset } from '../../services/assets/asset-processing-service/index.js';
+import type { ProcessedAsset } from '../../../services/assets/asset-processing-service/index.js';
 export declare function buildProcessedAssetDedupeKey(asset: ProcessedAsset): string;
 export declare function dedupeProcessedAssets(assets: ProcessedAsset[]): ProcessedAsset[];