@ecopages/core 0.2.0-alpha.48 → 0.2.0-alpha.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecopages/core",
-  "version": "0.2.0-alpha.48",
+  "version": "0.2.0-alpha.49",
   "description": "Core package for Ecopages",
   "keywords": [
     "ecopages",
@@ -17,7 +17,7 @@
     "directory": "packages/core"
   },
   "dependencies": {
-    "@ecopages/file-system": "0.2.0-alpha.48",
+    "@ecopages/file-system": "0.2.0-alpha.49",
     "@ecopages/logger": "^0.2.3",
     "@ecopages/scripts-injector": "^0.1.5",
     "@worker-tools/html-rewriter": "0.1.0-pre.19",

package/src/build/build-adapter.js

@@ -227,6 +227,12 @@ class BunBuildAdapter {
     if (fs.existsSync(outputPath)) {
       return outputPath;
     }
+    for (const extension of [".js", ".mjs", ".cjs"]) {
+      const outputPathWithExtension = `${outputPath}${extension}`;
+      if (fs.existsSync(outputPathWithExtension)) {
+        return outputPathWithExtension;
+      }
+    }
     if (!outputPath.includes("[hash]")) {
       return outputPath;
     }

package/src/build/runtime-specifier-aliases.js

@@ -1,5 +1,5 @@
 import { parseSync } from "oxc-parser";
-const RUNTIME_SPECIFIER_ALIAS_MAP = /* @__PURE__ */ Symbol("ecopages.runtimeSpecifierAliasMap");
+const RUNTIME_SPECIFIER_ALIAS_MAP = /* @__PURE__ */ Symbol.for("ecopages.runtimeSpecifierAliasMap");
 function attachRuntimeSpecifierAliasMap(plugin, specifierMap) {
   plugin[RUNTIME_SPECIFIER_ALIAS_MAP] = specifierMap;
   return plugin;

package/src/route-renderer/orchestration/integration-renderer.js

@@ -184,9 +184,9 @@ class IntegrationRenderer {
     return await this.routeRenderOrchestrator.resolveDeclaredPageBrowserGraph({
       routeFile: filePath,
       integrationName: this.name,
-      collectContribution: async () => {
-        const pageModule = await this.importPageFile(filePath);
-        return await this.collectPageBrowserGraphContribution({ file: filePath, pageModule });
+      collectContribution: async (routeFile) => {
+        const pageModule = await this.importPageFile(routeFile);
+        return await this.collectPageBrowserGraphContribution({ file: routeFile, pageModule });
       }
     });
   }
@@ -241,7 +241,12 @@ class IntegrationRenderer {
       ...this.htmlTransformer.getProcessedDependencies(),
       ...nextDependencies
     ]);
-    this.htmlTransformer.setPagePackage(createPagePackage(mergedDependencies));
+    const currentPageBrowserGraph = this.htmlTransformer.getPagePackage()?.pageBrowserGraph;
+    this.htmlTransformer.setPagePackage(
+      createPagePackage(mergedDependencies, {
+        pageBrowserGraph: currentPageBrowserGraph
+      })
+    );
     return nextDependencies;
   }
   /**

package/src/route-renderer/orchestration/route-render-orchestrator.d.ts

@@ -94,6 +94,7 @@ export declare class RouteRenderOrchestrator {
     private readonly ownershipPlanningService;
     private readonly ownershipValidationService;
     private readonly pageBrowserGraphCache;
+    private readonly groupedPageBrowserGraphCache;
     constructor(appConfig: EcoPagesAppConfig, assetProcessingService: AssetProcessingService, dependencies?: RouteRenderOrchestratorDependencies);
     /**
      * Builds normalized route render options before the integration render runs.
@@ -106,11 +107,32 @@ export declare class RouteRenderOrchestrator {
     resolveDeclaredPageBrowserGraph(input: {
         routeFile: string;
         integrationName: string;
-        collectContribution: () => Promise<PageBrowserGraphContribution | undefined>;
+        collectContribution: (routeFile: string) => Promise<PageBrowserGraphContribution | undefined>;
     }): Promise<PageBrowserGraphResult | undefined>;
     private resolvePageBrowserGraph;
     private isHmrEnabled;
     private buildPageBrowserGraph;
+    /**
+     * Resolves grouped page-browser assets for all routes owned by one integration.
+     *
+     * @remarks
+     * This keeps one shared browser-build result available across sibling routes so
+     * navigation can reuse the same emitted client graph instead of rebuilding one
+     * page entry at a time. HMR bypasses this cache because the grouped build must
+     * reflect the latest source on every request.
+     */
+    private resolveGroupedPageBrowserAssets;
+    /**
+     * Builds the shared grouped page-browser asset map for one integration.
+     *
+     * @remarks
+     * Each route can declare grouped content-script dependencies that should be
+     * emitted together. This method collects those declarations across the owning
+     * integration, runs the grouped processor once, and then maps the emitted
+     * assets back onto the routes that reference them.
+     */
+    private buildGroupedPageBrowserAssets;
+    private listIntegrationRouteFiles;
     private partitionPageBrowserGraphAssets;
     /**
      * Captures one route render body as HTML while preserving a replayable body value.

package/src/route-renderer/orchestration/route-render-orchestrator.js

@@ -1,11 +1,13 @@
 import { createRequire } from "node:module";
 import path from "node:path";
+import { fileSystem } from "@ecopages/file-system";
 import {
   AssetFactory,
   createPagePackage
 } from "../../services/assets/asset-processing-service/index.js";
 import { buildGlobalInjectorBootstrapContent, buildGlobalInjectorMapScript } from "../../eco/global-injector-map.js";
 import { LocalsAccessError } from "../../errors/locals-access-error.js";
+import { appLogger } from "../../global/app-logger.js";
 import { inspectUnresolvedMarkerArtifactHtml } from "./render-output.utils.js";
 import { OwnershipValidationService } from "./ownership-validation.service.js";
 import { OwnershipPlanningService } from "./ownership-planning.service.js";
@@ -39,12 +41,19 @@ function createPageLocalsProxy(filePath) {
     }
   );
 }
+function isGroupedContentScriptAsset(asset) {
+  return asset.kind === "script" && asset.source === "content" && Boolean(asset.groupedBundle?.id);
+}
+function getGroupedBundleAssetKey(groupedBundle) {
+  return `${groupedBundle.id}:${groupedBundle.entryName}`;
+}
 class RouteRenderOrchestrator {
   appConfig;
   assetProcessingService;
   ownershipPlanningService;
   ownershipValidationService;
   pageBrowserGraphCache = /* @__PURE__ */ new Map();
+  groupedPageBrowserGraphCache = /* @__PURE__ */ new Map();
   constructor(appConfig, assetProcessingService, dependencies = {}) {
     this.appConfig = appConfig;
     this.assetProcessingService = assetProcessingService;
@@ -84,7 +93,7 @@ class RouteRenderOrchestrator {
     const pageBrowserGraph = await this.resolvePageBrowserGraph({
       routeFile: routeOptions.file,
       integrationName: adapter.name,
-      collectContribution: async () => await adapter.collectPageBrowserGraphContribution(routeOptions.file)
+      collectContribution: async (routeFile) => await adapter.collectPageBrowserGraphContribution(routeFile)
     });
     const usedIntegrationDependencies = this.collectUsedIntegrationDependencies(componentsToResolve, adapter.name);
     const allDependencies = [...resolvedDependencies, ...usedIntegrationDependencies];
@@ -165,17 +174,143 @@ class RouteRenderOrchestrator {
     return typeof this.assetProcessingService.getHmrManager === "function" && this.assetProcessingService.getHmrManager()?.isEnabled() === true;
   }
   async buildPageBrowserGraph(input) {
-    const contribution = await input.collectContribution();
+    const contribution = await input.collectContribution(input.routeFile);
     if (!contribution) {
       return void 0;
     }
-    const processedDependencies = contribution.dependencies?.length ? await this.assetProcessingService.processDependencies(
-      contribution.dependencies,
+    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 processedDependencies = ungroupedDependencies.length ? await this.assetProcessingService.processDependencies(
+      ungroupedDependencies,
       `${input.integrationName}:${input.routeFile}`
     ) : [];
-    const resolvedAssets = [...processedDependencies, ...contribution.assets ?? []];
+    const resolvedAssets = [...processedDependencies, ...groupedAssets, ...contribution.assets ?? []];
     return this.partitionPageBrowserGraphAssets(resolvedAssets);
   }
+  /**
+   * Resolves grouped page-browser assets for all routes owned by one integration.
+   *
+   * @remarks
+   * This keeps one shared browser-build result available across sibling routes so
+   * navigation can reuse the same emitted client graph instead of rebuilding one
+   * page entry at a time. HMR bypasses this cache because the grouped build must
+   * reflect the latest source on every request.
+   */
+  async resolveGroupedPageBrowserAssets(input, currentContribution) {
+    if (this.isHmrEnabled()) {
+      const result = await this.buildGroupedPageBrowserAssets(input, currentContribution);
+      return result.assetsByRoute;
+    }
+    const cacheKey = input.integrationName;
+    const cached = this.groupedPageBrowserGraphCache.get(cacheKey);
+    if (cached) {
+      return await cached;
+    }
+    const pendingGroupedAssets = 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, pendingGroupedAssets);
+    return await pendingGroupedAssets;
+  }
+  /**
+   * Builds the shared grouped page-browser asset map for one integration.
+   *
+   * @remarks
+   * Each route can declare grouped content-script dependencies that should be
+   * emitted together. This method collects those declarations across the owning
+   * integration, runs the grouped processor once, and then maps the emitted
+   * assets back onto the routes that reference them.
+   */
+  async buildGroupedPageBrowserAssets(input, currentContribution) {
+    const routeFiles = await this.listIntegrationRouteFiles(input.integrationName);
+    const currentRouteGroupedDependencies = (currentContribution.dependencies ?? []).filter(
+      (dep) => isGroupedContentScriptAsset(dep)
+    );
+    const groupedDependencies = [...currentRouteGroupedDependencies];
+    const groupedAssetKeysByRoute = /* @__PURE__ */ new Map();
+    let hasCollectionFailures = false;
+    if (currentRouteGroupedDependencies.length > 0) {
+      groupedAssetKeysByRoute.set(
+        input.routeFile,
+        new Set(currentRouteGroupedDependencies.map((dep) => getGroupedBundleAssetKey(dep.groupedBundle)))
+      );
+    }
+    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)}`
+        );
+        continue;
+      }
+      if (!contribution?.dependencies?.length) {
+        continue;
+      }
+      const routeGroupedDependencies = contribution.dependencies.filter(
+        (dep) => isGroupedContentScriptAsset(dep)
+      );
+      if (routeGroupedDependencies.length === 0) {
+        continue;
+      }
+      groupedDependencies.push(...routeGroupedDependencies);
+      groupedAssetKeysByRoute.set(
+        routeFile,
+        new Set(routeGroupedDependencies.map((dep) => getGroupedBundleAssetKey(dep.groupedBundle)))
+      );
+    }
+    if (groupedDependencies.length === 0) {
+      return {
+        assetsByRoute: /* @__PURE__ */ new Map(),
+        hasCollectionFailures
+      };
+    }
+    const processedGroupedDependencies = await this.assetProcessingService.processDependencies(
+      groupedDependencies,
+      `${input.integrationName}:grouped-page-browser-graph`
+    );
+    const groupedAssetsByRoute = /* @__PURE__ */ new Map();
+    for (const [routeFile, groupedAssetKeys] of groupedAssetKeysByRoute) {
+      groupedAssetsByRoute.set(
+        routeFile,
+        processedGroupedDependencies.filter((asset) => {
+          if (!asset.groupedBundle) {
+            return false;
+          }
+          return groupedAssetKeys.has(getGroupedBundleAssetKey(asset.groupedBundle));
+        })
+      );
+    }
+    return {
+      assetsByRoute: groupedAssetsByRoute,
+      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/services/assets/asset-processing-service/processors/script/content-script.processor.js

@@ -75,6 +75,7 @@ class ContentScriptProcessor extends BaseScriptProcessor {
         inline: dep.inline,
         excludeFromHtml: dep.excludeFromHtml,
         packageRole: dep.packageRole,
+        groupedBundle: dep.groupedBundle,
         bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
       this.writeCacheFile(filename, unbundledProcessedAsset);

package/src/services/module-loading/node-bootstrap-plugin.js

@@ -71,6 +71,18 @@ function resolvePackageExportTarget(packageDir, target) {
   const record = target;
   return resolvePackageExportTarget(packageDir, record.import) ?? resolvePackageExportTarget(packageDir, record.default) ?? resolvePackageExportTarget(packageDir, record.require);
 }
+function shouldRewriteProjectImportMeta(filePath, projectDir) {
+  const normalizedFilePath = path.normalize(filePath);
+  const normalizedProjectDir = path.normalize(projectDir);
+  return (normalizedFilePath === normalizedProjectDir || normalizedFilePath.startsWith(`${normalizedProjectDir}${path.sep}`)) && !normalizedFilePath.includes(`${path.sep}node_modules${path.sep}`);
+}
+function getLoaderForPath(filePath) {
+  const extension = path.extname(filePath).toLowerCase();
+  if (extension === ".tsx") return "tsx";
+  if (extension === ".ts") return "ts";
+  if (extension === ".jsx") return "jsx";
+  return "js";
+}
 function resolveInstalledPackageTarget(specifier, parentPath) {
   const packageName = getPackageNameFromSpecifier(specifier);
   const packageDir = findInstalledPackageDir(packageName, parentPath);
@@ -168,6 +180,20 @@ function createNodeBootstrapPlugin(options) {
       build.onResolve({ filter: /^bun:/ }, (args) => {
         throw new Error(getNodeUnsupportedBuiltinError(args.path, args.importer));
       });
+      build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, (args) => {
+        if (!shouldRewriteProjectImportMeta(args.path, options.projectDir)) {
+          return void 0;
+        }
+        const originalContents = readFileSync(args.path, "utf8");
+        const contents = originalContents.replaceAll("import.meta.env", "process.env").replaceAll("import.meta.dirname", JSON.stringify(path.dirname(args.path))).replaceAll("import.meta.filename", JSON.stringify(args.path)).replaceAll("import.meta.dir", JSON.stringify(path.dirname(args.path))).replaceAll("import.meta.path", JSON.stringify(args.path));
+        if (contents === originalContents) {
+          return void 0;
+        }
+        return {
+          contents,
+          loader: getLoaderForPath(args.path)
+        };
+      });
       build.onResolve({ filter: /^[@A-Za-z0-9][^:]*$/ }, (args) => {
         return resolveNodeBootstrapDependency(args, options);
       });