@ecopages/core 0.2.0-beta.37 → 0.2.0-beta.38

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

@@ -1,23 +1,42 @@
 import path from 'node:path';
+import { serializeGroupedGraphCacheKey } from './route-instance-key.js';
 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}`;
+    return JSON.stringify([
+        'graph',
+        key.policy,
+        key.integrationName,
+        key.routeFile,
+        key.dependencyInstanceKey,
+        key.entryFingerprint,
+    ]);
 }
 function normalizeDependencyPath(filePath) {
     return path.resolve(filePath);
 }
 function parseSerializedGraphKey(serializedKey) {
-    if (serializedKey.startsWith('grouped::')) {
+    let parsed;
+    try {
+        parsed = JSON.parse(serializedKey);
+    }
+    catch {
         return undefined;
     }
-    const [policy, integrationName, routeFile, entryFingerprint] = serializedKey.split('::');
-    if (!policy || !integrationName || !routeFile || entryFingerprint === undefined) {
+    if (!Array.isArray(parsed) ||
+        parsed.length !== 6 ||
+        parsed[0] !== 'graph' ||
+        typeof parsed[1] !== 'string' ||
+        typeof parsed[2] !== 'string' ||
+        typeof parsed[3] !== 'string' ||
+        typeof parsed[4] !== 'string' ||
+        typeof parsed[5] !== 'string') {
         return undefined;
     }
+    const [, policy, integrationName, routeFile, dependencyInstanceKey, entryFingerprint] = parsed;
     if (policy !== 'development' && policy !== 'production') {
         return undefined;
     }
@@ -25,6 +44,7 @@ function parseSerializedGraphKey(serializedKey) {
         policy,
         integrationName,
         routeFile,
+        dependencyInstanceKey,
         entryFingerprint,
     };
 }
@@ -45,15 +65,23 @@ export class GraphDependencyIndex {
             this.removeDependencyBinding(normalizeDependencyPath(dependencyPath), serializedKey);
         }
     }
-    bindGroupedRecord(integrationName, record) {
-        const serializedKey = `grouped::${integrationName}`;
+    bindGroupedRecord(cacheKey, record) {
         for (const dependencyPath of record.dependencyPaths) {
-            this.addDependencyBinding(normalizeDependencyPath(dependencyPath), serializedKey);
+            this.addDependencyBinding(normalizeDependencyPath(dependencyPath), cacheKey);
         }
     }
-    unbindGroupedRecord(integrationName, record) {
-        const serializedKey = `grouped::${integrationName}`;
+    unbindGroupedRecord(cacheKey, record) {
         for (const dependencyPath of record.dependencyPaths) {
+            this.removeDependencyBinding(normalizeDependencyPath(dependencyPath), cacheKey);
+        }
+    }
+    bindPaths(serializedKey, dependencyPaths) {
+        for (const dependencyPath of dependencyPaths) {
+            this.addDependencyBinding(normalizeDependencyPath(dependencyPath), serializedKey);
+        }
+    }
+    unbindPaths(serializedKey, dependencyPaths) {
+        for (const dependencyPath of dependencyPaths) {
             this.removeDependencyBinding(normalizeDependencyPath(dependencyPath), serializedKey);
         }
     }
@@ -85,34 +113,32 @@ export class GraphDependencyIndex {
 export class SessionPageBrowserGraphCache {
     records = new Map();
     inFlight = new Map();
+    inFlightDependencyPaths = new Map();
+    inFlightGenerations = new Map();
     groupedRecords = new Map();
     groupedInFlight = new Map();
     dependencyIndex = new GraphDependencyIndex();
     graphGenerations = new Map();
     groupedGenerations = 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 undefined;
-    }
     /**
      * Page Browser Graph compilations in this dev-server session.
      */
     getBuildCount() {
         return this.buildCount;
     }
+    getGraphByRoute(integrationName, routeFile, policy, dependencyInstanceKey = '') {
+        const normalizedRoute = normalizeDependencyPath(routeFile);
+        for (const record of this.records.values()) {
+            if (record.key.integrationName === integrationName &&
+                record.key.policy === policy &&
+                normalizeDependencyPath(record.key.routeFile) === normalizedRoute &&
+                record.key.dependencyInstanceKey === dependencyInstanceKey) {
+                return record.result;
+            }
+        }
+        return undefined;
+    }
     getAffectedGraphIdentities(filePath) {
         const identities = [];
         for (const serializedKey of this.dependencyIndex.getAffectedKeys(filePath)) {
@@ -123,7 +149,7 @@ export class SessionPageBrowserGraphCache {
         }
         return identities;
     }
-    resolveGraph(key, build) {
+    resolveGraph(key, provisionalDependencyPaths, build) {
         const serializedKey = serializeGraphKey(key);
         const cached = this.records.get(serializedKey);
         if (cached) {
@@ -134,35 +160,38 @@ export class SessionPageBrowserGraphCache {
             return pending;
         }
         const buildGeneration = this.bumpGraphGeneration(serializedKey);
+        this.inFlightDependencyPaths.set(serializedKey, provisionalDependencyPaths);
+        this.inFlightGenerations.set(serializedKey, buildGeneration);
+        this.bindDependencyPaths(serializedKey, provisionalDependencyPaths);
         const buildPromise = this.runGraphBuild(serializedKey, key, buildGeneration, build);
         this.inFlight.set(serializedKey, buildPromise);
         return buildPromise;
     }
-    resolveGroupedGraph(integrationName, build) {
-        const cached = this.groupedRecords.get(integrationName);
+    resolveGroupedGraph(scope, build) {
+        const cacheKey = serializeGroupedGraphCacheKey(scope);
+        const cached = this.groupedRecords.get(cacheKey);
         if (cached) {
             return Promise.resolve(cached.assetsByRoute);
         }
-        const pending = this.groupedInFlight.get(integrationName);
+        const pending = this.groupedInFlight.get(cacheKey);
         if (pending) {
             return pending;
         }
-        const buildGeneration = this.bumpGroupedGeneration(integrationName);
-        const buildPromise = this.runGroupedBuild(integrationName, buildGeneration, build);
-        this.groupedInFlight.set(integrationName, buildPromise);
+        const buildGeneration = this.bumpGroupedGeneration(cacheKey);
+        const buildPromise = this.runGroupedBuild(cacheKey, buildGeneration, build);
+        this.groupedInFlight.set(cacheKey, buildPromise);
         return buildPromise;
     }
-    peekGroupedGraph(integrationName) {
-        return this.groupedRecords.get(integrationName)?.assetsByRoute;
+    peekGroupedGraph(scope) {
+        return this.groupedRecords.get(serializeGroupedGraphCacheKey(scope))?.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);
+            if (this.groupedRecords.has(serializedKey) || this.groupedInFlight.has(serializedKey)) {
+                invalidated += this.invalidateGroupedRecord(serializedKey);
                 continue;
             }
             invalidated += this.invalidateSerializedGraphKey(serializedKey);
@@ -178,9 +207,7 @@ export class SessionPageBrowserGraphCache {
             if (affectedKeys.has(serializedKey)) {
                 continue;
             }
-            this.bumpGraphGeneration(serializedKey);
-            this.inFlight.delete(serializedKey);
-            invalidated += 1;
+            invalidated += this.invalidateSerializedGraphKey(serializedKey);
         }
         if (invalidated > 0) {
             appLogger.debug(`[PageBrowserGraphSession] invalidated ${invalidated} graph record(s) for ${normalizedFilePath}`);
@@ -211,6 +238,8 @@ export class SessionPageBrowserGraphCache {
     resetForTests() {
         this.records.clear();
         this.inFlight.clear();
+        this.inFlightDependencyPaths.clear();
+        this.inFlightGenerations.clear();
         this.groupedRecords.clear();
         this.groupedInFlight.clear();
         this.graphGenerations.clear();
@@ -229,17 +258,23 @@ export class SessionPageBrowserGraphCache {
             this.dependencyIndex.unbindRecord(record);
             this.records.delete(serializedKey);
             this.inFlight.delete(serializedKey);
+            const inFlightDependencyPaths = this.inFlightDependencyPaths.get(serializedKey);
+            if (inFlightDependencyPaths) {
+                this.unbindDependencyPaths(serializedKey, inFlightDependencyPaths);
+                this.inFlightDependencyPaths.delete(serializedKey);
+            }
+            this.inFlightGenerations.delete(serializedKey);
             this.graphGenerations.delete(serializedKey);
         }
         if (policy === 'production') {
-            for (const integrationName of [...this.groupedRecords.keys()]) {
-                const groupedRecord = this.groupedRecords.get(integrationName);
+            for (const cacheKey of [...this.groupedRecords.keys()]) {
+                const groupedRecord = this.groupedRecords.get(cacheKey);
                 if (groupedRecord) {
-                    this.dependencyIndex.unbindGroupedRecord(integrationName, groupedRecord);
+                    this.dependencyIndex.unbindGroupedRecord(cacheKey, groupedRecord);
                 }
-                this.groupedRecords.delete(integrationName);
-                this.groupedInFlight.delete(integrationName);
-                this.groupedGenerations.delete(integrationName);
+                this.groupedRecords.delete(cacheKey);
+                this.groupedInFlight.delete(cacheKey);
+                this.groupedGenerations.delete(cacheKey);
             }
         }
     }
@@ -252,6 +287,9 @@ export class SessionPageBrowserGraphCache {
             if (normalizeDependencyPath(record.key.routeFile) !== normalizedRoute) {
                 continue;
             }
+            if (record.key.dependencyInstanceKey !== key.dependencyInstanceKey) {
+                continue;
+            }
             if (record.key.entryFingerprint === key.entryFingerprint && record.key.policy === key.policy) {
                 continue;
             }
@@ -263,9 +301,9 @@ export class SessionPageBrowserGraphCache {
         this.graphGenerations.set(serializedKey, next);
         return next;
     }
-    bumpGroupedGeneration(integrationName) {
-        const next = (this.groupedGenerations.get(integrationName) ?? 0) + 1;
-        this.groupedGenerations.set(integrationName, next);
+    bumpGroupedGeneration(cacheKey) {
+        const next = (this.groupedGenerations.get(cacheKey) ?? 0) + 1;
+        this.groupedGenerations.set(cacheKey, next);
         return next;
     }
     invalidateSerializedGraphKey(serializedKey) {
@@ -274,18 +312,24 @@ export class SessionPageBrowserGraphCache {
             this.dependencyIndex.unbindRecord(record);
             this.records.delete(serializedKey);
         }
+        const inFlightDependencyPaths = this.inFlightDependencyPaths.get(serializedKey);
+        if (inFlightDependencyPaths) {
+            this.unbindDependencyPaths(serializedKey, inFlightDependencyPaths);
+            this.inFlightDependencyPaths.delete(serializedKey);
+        }
+        const hadInFlightBuild = this.inFlight.delete(serializedKey);
+        this.inFlightGenerations.delete(serializedKey);
         this.bumpGraphGeneration(serializedKey);
-        this.inFlight.delete(serializedKey);
-        return record ? 1 : 0;
+        return record || hadInFlightBuild ? 1 : 0;
     }
-    invalidateGroupedRecord(integrationName) {
-        const groupedRecord = this.groupedRecords.get(integrationName);
+    invalidateGroupedRecord(cacheKey) {
+        const groupedRecord = this.groupedRecords.get(cacheKey);
         if (groupedRecord) {
-            this.dependencyIndex.unbindGroupedRecord(integrationName, groupedRecord);
-            this.groupedRecords.delete(integrationName);
+            this.dependencyIndex.unbindGroupedRecord(cacheKey, groupedRecord);
+            this.groupedRecords.delete(cacheKey);
         }
-        this.bumpGroupedGeneration(integrationName);
-        this.groupedInFlight.delete(integrationName);
+        this.bumpGroupedGeneration(cacheKey);
+        this.groupedInFlight.delete(cacheKey);
         return groupedRecord ? 1 : 0;
     }
     async runGraphBuild(serializedKey, key, buildGeneration, build) {
@@ -299,6 +343,11 @@ export class SessionPageBrowserGraphCache {
                 const existing = this.records.get(serializedKey);
                 return existing?.result;
             }
+            if (buildResult.cacheable === false) {
+                this.releaseInFlightDependencyPaths(serializedKey, buildGeneration);
+                return buildResult.result;
+            }
+            this.releaseInFlightDependencyPaths(serializedKey, buildGeneration);
             this.pruneStaleRouteRecords(key);
             const previous = this.records.get(serializedKey);
             if (previous) {
@@ -319,10 +368,10 @@ export class SessionPageBrowserGraphCache {
             return Promise.reject(error);
         }
         finally {
-            this.inFlight.delete(serializedKey);
+            this.clearInFlightBuild(serializedKey, buildGeneration);
         }
     }
-    async runGroupedBuild(integrationName, buildGeneration, build) {
+    async runGroupedBuild(cacheKey, buildGeneration, build) {
         try {
             this.buildCount += 1;
             const buildResult = await build();
@@ -332,35 +381,60 @@ export class SessionPageBrowserGraphCache {
             if (isSkipCacheGroupedOutcome(buildResult)) {
                 return buildResult.assetsByRoute;
             }
-            if (!this.canCommitGroupedBuild(integrationName, buildGeneration)) {
-                const existing = this.groupedRecords.get(integrationName);
+            if (!this.canCommitGroupedBuild(cacheKey, buildGeneration)) {
+                const existing = this.groupedRecords.get(cacheKey);
                 return existing?.assetsByRoute ?? new Map();
             }
-            const previous = this.groupedRecords.get(integrationName);
+            const previous = this.groupedRecords.get(cacheKey);
             if (previous) {
-                this.dependencyIndex.unbindGroupedRecord(integrationName, previous);
+                this.dependencyIndex.unbindGroupedRecord(cacheKey, previous);
             }
             const record = {
                 assetsByRoute: buildResult.assetsByRoute,
                 dependencyPaths: buildResult.dependencyPaths,
                 generation: buildGeneration,
             };
-            this.groupedRecords.set(integrationName, record);
-            this.dependencyIndex.bindGroupedRecord(integrationName, record);
+            this.groupedRecords.set(cacheKey, record);
+            this.dependencyIndex.bindGroupedRecord(cacheKey, record);
             return record.assetsByRoute;
         }
         catch (error) {
             return Promise.reject(error);
         }
         finally {
-            this.groupedInFlight.delete(integrationName);
+            this.groupedInFlight.delete(cacheKey);
         }
     }
     canCommitGraphBuild(serializedKey, buildGeneration) {
         return this.graphGenerations.get(serializedKey) === buildGeneration;
     }
-    canCommitGroupedBuild(integrationName, buildGeneration) {
-        return this.groupedGenerations.get(integrationName) === buildGeneration;
+    canCommitGroupedBuild(cacheKey, buildGeneration) {
+        return this.groupedGenerations.get(cacheKey) === buildGeneration;
+    }
+    bindDependencyPaths(serializedKey, dependencyPaths) {
+        this.dependencyIndex.bindPaths(serializedKey, dependencyPaths);
+    }
+    unbindDependencyPaths(serializedKey, dependencyPaths) {
+        this.dependencyIndex.unbindPaths(serializedKey, dependencyPaths);
+    }
+    clearInFlightBuild(serializedKey, buildGeneration) {
+        if (this.inFlightGenerations.get(serializedKey) !== buildGeneration) {
+            return;
+        }
+        this.releaseInFlightDependencyPaths(serializedKey, buildGeneration);
+        this.inFlight.delete(serializedKey);
+        this.inFlightGenerations.delete(serializedKey);
+    }
+    releaseInFlightDependencyPaths(serializedKey, buildGeneration) {
+        if (this.inFlightGenerations.get(serializedKey) !== buildGeneration) {
+            return;
+        }
+        const dependencyPaths = this.inFlightDependencyPaths.get(serializedKey);
+        if (!dependencyPaths) {
+            return;
+        }
+        this.unbindDependencyPaths(serializedKey, dependencyPaths);
+        this.inFlightDependencyPaths.delete(serializedKey);
     }
 }
 const sessionByAppConfig = new WeakMap();
@@ -424,6 +498,9 @@ export function collectPageBrowserGraphDependencyPaths(routeFile, contribution,
             dependencyPaths.add(normalizeDependencyPath(bundledSourceFilepath));
         }
     }
+    for (const watchPath of contribution.watchPaths ?? []) {
+        dependencyPaths.add(normalizeDependencyPath(watchPath));
+    }
     return dependencyPaths;
 }
 function describeProcessedAsset(asset) {

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

@@ -2,10 +2,18 @@ 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';
+import type { GroupedGraphBuildPlan } from './grouped-graph-build-plan.js';
+export type GroupedPageBrowserGraphContribution = {
+    routeFile: string;
+    dependencyInstanceKey: string;
+    contribution: PageBrowserGraphContribution | undefined;
+};
 export type PageBrowserGraphResolveInput = {
     routeFile: string;
+    dependencyInstanceKey?: string;
     integrationName: string;
-    collectContribution: (routeFile: string) => Promise<PageBrowserGraphContribution | undefined>;
+    collectContribution: () => Promise<PageBrowserGraphContribution | undefined>;
+    groupedBuildPlan?: GroupedGraphBuildPlan;
     policy?: GraphPolicy;
 };
 /**
@@ -26,6 +34,5 @@ export declare class PageBrowserGraphService {
     private materializePageBrowserGraph;
     private resolveGroupedPageBrowserAssets;
     private buildGroupedPageBrowserAssets;
-    private listIntegrationRouteFiles;
     private partitionPageBrowserGraphAssets;
 }

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

@@ -1,9 +1,9 @@
 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';
 import { startupTrace } from '../../../diagnostics/startup-trace.js';
 import { collectPageBrowserGraphDependencyPaths, createPageBrowserGraphEntryFingerprint, getAppPageBrowserGraphSession, } from './page-browser-graph-session.js';
+import { createRouteGraphLookupKey } from './route-instance-key.js';
 function isGroupedContentScriptAsset(asset) {
     return asset.kind === 'script' && asset.source === 'content' && Boolean(asset.groupedBundle?.id);
 }
@@ -29,13 +29,14 @@ export class PageBrowserGraphService {
     async getOrBuild(input) {
         const policy = input.policy ?? this.resolveGraphPolicy();
         const session = getAppPageBrowserGraphSession(this.appConfig);
+        const dependencyInstanceKey = input.dependencyInstanceKey ?? '';
         if (!this.isHmrEnabled()) {
-            const cachedByRoute = session.getGraphByRoute(input.integrationName, input.routeFile, policy);
+            const cachedByRoute = session.getGraphByRoute(input.integrationName, input.routeFile, policy, dependencyInstanceKey);
             if (cachedByRoute) {
                 return cachedByRoute;
             }
         }
-        const contribution = await input.collectContribution(input.routeFile);
+        const contribution = await input.collectContribution();
         if (!contribution) {
             return undefined;
         }
@@ -43,9 +44,10 @@ export class PageBrowserGraphService {
         return await session.resolveGraph({
             integrationName: input.integrationName,
             routeFile: input.routeFile,
+            dependencyInstanceKey,
             entryFingerprint,
             policy,
-        }, async () => this.buildPageBrowserGraphRecord(input, contribution));
+        }, collectPageBrowserGraphDependencyPaths(input.routeFile, contribution, contribution.assets ?? []), async () => this.buildPageBrowserGraphRecord(input, contribution));
     }
     resolveGraphPolicy() {
         return this.isHmrEnabled() ? 'development' : 'production';
@@ -65,10 +67,10 @@ export class PageBrowserGraphService {
     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)).assetsByRoute.get(input.routeFile) ??
-                [])
-            : [];
+        const groupedResolution = groupedDependencies.length
+            ? await this.resolveGroupedPageBrowserAssets(input, contribution)
+            : undefined;
+        const groupedAssets = groupedResolution?.assetsByRoute.get(createRouteGraphLookupKey(input.routeFile, input.dependencyInstanceKey ?? '')) ?? [];
         const processedDependencies = ungroupedDependencies.length
             ? await this.assetProcessingService.processDependencies(ungroupedDependencies, `${input.integrationName}:${input.routeFile}`)
             : [];
@@ -78,15 +80,29 @@ export class PageBrowserGraphService {
         return {
             result,
             dependencyPaths,
+            cacheable: groupedResolution?.cacheable ?? true,
         };
     }
     async resolveGroupedPageBrowserAssets(input, currentContribution) {
         if (this.isHmrEnabled()) {
             return await this.buildGroupedPageBrowserAssets(input, currentContribution);
         }
+        if (!input.groupedBuildPlan) {
+            const built = await this.buildGroupedPageBrowserAssets(input, currentContribution);
+            return {
+                ...built,
+                cacheable: false,
+            };
+        }
         const session = getAppPageBrowserGraphSession(this.appConfig);
-        const assetsByRoute = await session.resolveGroupedGraph(input.integrationName, async () => {
+        const groupedScope = {
+            integrationName: input.integrationName,
+            planKey: input.groupedBuildPlan.planKey,
+        };
+        let groupedCacheable = true;
+        const assetsByRoute = await session.resolveGroupedGraph(groupedScope, async () => {
             const built = await this.buildGroupedPageBrowserAssets(input, currentContribution);
+            groupedCacheable = !built.hasCollectionFailures;
             if (built.hasCollectionFailures) {
                 return {
                     skipCache: true,
@@ -103,34 +119,43 @@ export class PageBrowserGraphService {
         return {
             assetsByRoute,
             dependencyPaths: new Set(),
-            hasCollectionFailures: false,
+            hasCollectionFailures: !groupedCacheable,
+            cacheable: groupedCacheable,
         };
     }
     async buildGroupedPageBrowserAssets(input, currentContribution) {
-        const routeFiles = this.isHmrEnabled()
-            ? [input.routeFile]
-            : await this.listIntegrationRouteFiles(input.integrationName);
+        const dependencyInstanceKey = input.dependencyInstanceKey ?? '';
+        const currentRouteLookupKey = createRouteGraphLookupKey(input.routeFile, dependencyInstanceKey);
+        const groupedCollection = input.groupedBuildPlan
+            ? {
+                contributions: input.groupedBuildPlan.instances.map((instance) => ({
+                    routeFile: instance.routeFile,
+                    dependencyInstanceKey: instance.dependencyInstanceKey,
+                    contribution: instance.contribution,
+                })),
+                hasCollectionFailures: false,
+            }
+            : {
+                contributions: [],
+                hasCollectionFailures: false,
+            };
+        const groupedContributions = groupedCollection.contributions;
         const currentRouteGroupedDependencies = (currentContribution.dependencies ?? []).filter((dep) => isGroupedContentScriptAsset(dep));
         const groupedDependencies = [...currentRouteGroupedDependencies];
         const groupedAssetKeysByRoute = new Map();
+        const routeDisplayPaths = new Map();
         const dependencyPaths = new Set([path.resolve(input.routeFile)]);
-        let hasCollectionFailures = false;
+        let hasCollectionFailures = groupedCollection.hasCollectionFailures;
         if (currentRouteGroupedDependencies.length > 0) {
-            groupedAssetKeysByRoute.set(input.routeFile, new Set(currentRouteGroupedDependencies.map((dep) => getGroupedBundleAssetKey(dep.groupedBundle))));
+            groupedAssetKeysByRoute.set(currentRouteLookupKey, new Set(currentRouteGroupedDependencies.map((dep) => getGroupedBundleAssetKey(dep.groupedBundle))));
+            routeDisplayPaths.set(currentRouteLookupKey, input.routeFile);
         }
-        for (const routeFile of routeFiles) {
-            if (routeFile === input.routeFile) {
-                continue;
-            }
-            let contribution;
-            try {
-                contribution = await input.collectContribution(routeFile);
-            }
-            catch (error) {
-                hasCollectionFailures = true;
-                appLogger.warn(`Skipping grouped page-browser contribution for ${routeFile}: ${error instanceof Error ? error.message : String(error)}`);
+        for (const groupedContribution of groupedContributions) {
+            if (groupedContribution.routeFile === input.routeFile &&
+                groupedContribution.dependencyInstanceKey === dependencyInstanceKey) {
                 continue;
             }
+            const { contribution, routeFile } = groupedContribution;
             if (!contribution?.dependencies?.length) {
                 continue;
             }
@@ -139,7 +164,8 @@ export class PageBrowserGraphService {
                 continue;
             }
             groupedDependencies.push(...routeGroupedDependencies);
-            groupedAssetKeysByRoute.set(routeFile, new Set(routeGroupedDependencies.map((dep) => getGroupedBundleAssetKey(dep.groupedBundle))));
+            groupedAssetKeysByRoute.set(createRouteGraphLookupKey(routeFile, groupedContribution.dependencyInstanceKey), new Set(routeGroupedDependencies.map((dep) => getGroupedBundleAssetKey(dep.groupedBundle))));
+            routeDisplayPaths.set(createRouteGraphLookupKey(routeFile, groupedContribution.dependencyInstanceKey), routeFile);
             dependencyPaths.add(path.resolve(routeFile));
         }
         if (groupedDependencies.length === 0) {
@@ -147,6 +173,7 @@ export class PageBrowserGraphService {
                 assetsByRoute: new Map(),
                 dependencyPaths,
                 hasCollectionFailures,
+                cacheable: Boolean(input.groupedBuildPlan) && !hasCollectionFailures,
             };
         }
         for (const dependency of groupedDependencies) {
@@ -164,7 +191,7 @@ export class PageBrowserGraphService {
                 return groupedAssetKeys.has(getGroupedBundleAssetKey(asset.groupedBundle));
             });
             if (groupedAssetKeys.size > 0 && matchedAssets.length === 0) {
-                appLogger.warn(`Grouped page-browser assets for ${routeFile} are missing groupedBundle metadata after processing. Hydration scripts may be omitted from HTML.`);
+                appLogger.warn(`Grouped page-browser assets for ${routeDisplayPaths.get(routeFile) ?? routeFile} are missing groupedBundle metadata after processing. Hydration scripts may be omitted from HTML.`);
             }
             groupedAssetsByRoute.set(routeFile, matchedAssets);
         }
@@ -180,19 +207,9 @@ export class PageBrowserGraphService {
             assetsByRoute: groupedAssetsByRoute,
             dependencyPaths,
             hasCollectionFailures,
+            cacheable: Boolean(input.groupedBuildPlan) && !hasCollectionFailures,
         };
     }
-    async listIntegrationRouteFiles(integrationName) {
-        const integration = this.appConfig.integrations.find((plugin) => plugin.name === integrationName);
-        if (!integration) {
-            return [];
-        }
-        const scannedFiles = await fileSystem.glob(integration.extensions.map((extension) => `**/*${extension}`), { cwd: this.appConfig.absolutePaths.pagesDir });
-        return scannedFiles
-            .filter((file) => !file.includes('.ecopages-node.'))
-            .map((file) => path.join(this.appConfig.absolutePaths.pagesDir, file))
-            .sort((left, right) => left.localeCompare(right));
-    }
     partitionPageBrowserGraphAssets(assets) {
         const entryAssets = [];
         const chunkAssets = [];

package/src/route-renderer/orchestration/page-browser-graph/route-instance-key.d.ts

@@ -0,0 +1,29 @@
+import type { PageParams, PageQuery } from '../../../types/public-types.js';
+export type PageDependencyInstance = {
+    params?: PageParams;
+    query?: PageQuery;
+};
+export type GroupedGraphScope = {
+    integrationName: string;
+    planKey: string;
+};
+/**
+ * Builds a stable cache key for one concrete dependency resolver input.
+ *
+ * @remarks
+ * The representation deliberately retains scalar versus array values. Delimiter-based
+ * encodings would make otherwise distinct route inputs collide.
+ */
+export declare function createPageDependencyInstanceKey(input: PageDependencyInstance): string;
+/**
+ * Combines a route file with an optional dependency-instance key for grouped graph maps.
+ */
+export declare function createRouteGraphLookupKey(routeFile: string, dependencyInstanceKey?: string): string;
+/**
+ * Serializes the grouped graph cache scope for one integration and dependency instance.
+ */
+export declare function serializeGroupedGraphCacheKey(scope: GroupedGraphScope): string;
+/**
+ * Reconstructs dependency resolver inputs from a serialized dependency-instance key.
+ */
+export declare function parsePageDependencyInstanceKey(dependencyInstanceKey: string): PageDependencyInstance;