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

package/src/router/README.md

@@ -8,9 +8,9 @@ The router layer determines what route is being handled and how the client runti
 
 It is responsible for:
 
-- filesystem route scanning and classification (`exact`, `dynamic`, `catch-all`)
-- matching incoming request URLs to discovered routes
-- server-side static-path expansion for dynamic routes
+- filesystem route discovery and classification (`exact`, `dynamic`, `catch-all`)
+- matching incoming request URLs to canonical template routes
+- server-side static-path expansion for dynamic template routes
 - client-side navigation ownership and cross-runtime handoff
 - keeping route discovery separate from rendering execution
 
@@ -18,9 +18,8 @@ It is responsible for:
 
 ```
 router/
-├── server/                      # Server-side route scanning and matching
-│   ├── fs-router-scanner.ts     # Scans the filesystem and classifies routes
-│   └── fs-router.ts             # Matches request URLs to discovered routes
+├── server/                      # Server-side route discovery and matching
+│   └── route-registry.ts        # Owns template routes, request matching, static expansion, and reload
 └── client/                      # Browser-side navigation coordination
     ├── navigation-coordinator.ts # Singleton runtime coordinator
     └── link-intent.ts           # Shared anchor detection and intent recovery helpers
@@ -28,9 +27,9 @@ router/
 
 ## `server/`
 
-### `FSRouterScanner`
+### `RouteRegistry`
 
-Walks the pages directory and builds a `Routes` map keyed by route pathname.
+Owns the canonical set of filesystem-discovered template routes for one application.
 
 File patterns determine route kind:
 
@@ -40,13 +39,17 @@ File patterns determine route kind:
 | `[slug].tsx`    | `dynamic`   | `/blog/[slug]`    |
 | `[...slug].tsx` | `catch-all` | `/docs/[...slug]` |
 
-For `dynamic` routes, the scanner checks whether the page module exports `getStaticPaths`. If present, every returned path is expanded into a concrete `exact`-style route at scan time. In build mode, both `getStaticPaths` and `getStaticProps` are required or an invariant is thrown.
+The registry stores canonical template routes only. It compiles request-time matching metadata during `init()` and `reload()`, but it does not execute `staticPaths()` during discovery.
 
-Catch-all routes are registered but skipped during static generation with a warning.
+Build-time static expansion is a separate operation. The registry invokes `staticPaths()` lazily through an injected page-module adapter and returns concrete static path expansions for the static generator.
 
-### `FSRouter`
+The public interface is intentionally small:
 
-Holds the scanned `Routes` map and exposes a `match(requestUrl)` method used by adapters.
+- `templateRoutes` — ordered readonly template routes
+- `init()` / `reload()` — rebuild discovery state and match metadata
+- `matchRequest(requestUrl)` — request-time matching result with requested pathname, matched template route, params, and query
+- `listStaticPathExpansions()` — build-time expansion for dynamic routes
+- `listStaticGenerationRoutes()` — build-time route planning for static generation across exact and expanded routes
 
 Match priority:
 
@@ -54,12 +57,6 @@ Match priority:
 2. `dynamic` — the clean (bracket-stripped) prefix must appear in the pathname, and the segment counts must match.
 3. `catch-all` — the clean prefix must appear in the pathname.
 
-Additional helpers:
-
-- `getDynamicParams(route, pathname)` — extracts named and spread parameters from a matched dynamic or catch-all route.
-- `getSearchParams(url)` — converts `URLSearchParams` to a plain object.
-- `setOnReload(cb)` / `reload()` — re-scans routes and fires an optional callback, used during development HMR.
-
 ## `client/`
 
 ### Navigation Coordinator (`navigation-coordinator.ts`)
@@ -69,7 +66,7 @@ A singleton browser-side runtime stored on `window.__ECO_PAGES__.navigation`.
 Access it with:
 
 ```ts
-import { getEcoNavigationRuntime } from '@ecopages/core/router/client/navigation-coordinator';
+import { getEcoNavigationRuntime } from '@ecopages/core/router/navigation-coordinator';
 const runtime = getEcoNavigationRuntime();
 ```
 

package/src/router/server/route-registry.d.ts

@@ -0,0 +1,78 @@
+import type { EcoPagesAppConfig, RouteKind } from '../../types/internal-types.js';
+export type RouteParams = Record<string, string | string[]>;
+export type RouteQuery = Record<string, string>;
+export type TemplateRoute = {
+    readonly pathname: string;
+    readonly kind: RouteKind;
+    readonly filePath: string;
+    readonly paramNames: readonly string[];
+};
+export type RouteMatch = {
+    readonly requestedPathname: string;
+    readonly templateRoute: TemplateRoute;
+    readonly params: RouteParams;
+    readonly query: RouteQuery;
+};
+export type StaticPathExpansion = {
+    readonly pathname: string;
+    readonly templateRoute: TemplateRoute;
+    readonly params: RouteParams;
+};
+export type StaticGenerationRoute = {
+    readonly requestUrl: string;
+    readonly pathname: string;
+    readonly templateRoute: TemplateRoute;
+    readonly params: RouteParams;
+};
+export type StaticPathsContext = {
+    readonly appConfig: EcoPagesAppConfig;
+    readonly runtimeOrigin: string;
+};
+export type RouteRegistryPageModule = {
+    readonly staticPaths?: (context: StaticPathsContext) => Promise<{
+        paths: Array<{
+            params: RouteParams;
+        }>;
+    }>;
+    readonly staticProps?: unknown;
+};
+export interface RouteRegistryPageModuleAdapter {
+    loadPageModule(filePath: string): Promise<RouteRegistryPageModule>;
+}
+export type RouteRegistryOptions = {
+    pagesDir: string;
+    appConfig: EcoPagesAppConfig;
+    origin: string;
+    templatesExt: readonly string[];
+    buildMode: boolean;
+    pageModuleAdapter: RouteRegistryPageModuleAdapter;
+};
+export declare class RouteRegistry {
+    readonly origin: string;
+    readonly appConfig: EcoPagesAppConfig;
+    readonly pagesDir: string;
+    readonly templatesExt: readonly string[];
+    readonly buildMode: boolean;
+    private readonly pageModuleAdapter;
+    private templateRouteList;
+    private readonly reloadListeners;
+    constructor(options: RouteRegistryOptions);
+    get templateRoutes(): readonly TemplateRoute[];
+    init(): Promise<void>;
+    reload(): Promise<void>;
+    onReload(listener: () => void): () => void;
+    matchRequest(requestUrl: string): RouteMatch | null;
+    listStaticPathExpansions(input: {
+        runtimeOrigin: string;
+    }): Promise<readonly StaticPathExpansion[]>;
+    listStaticGenerationRoutes(input: {
+        runtimeOrigin: string;
+    }): Promise<readonly StaticGenerationRoute[]>;
+    private scanTemplateRoutes;
+    private getRoutePath;
+    private classifyRouteKind;
+    private getParamNames;
+    private tryExtractParams;
+    private getSearchParams;
+    private resolveTemplatePath;
+}

package/src/router/server/route-registry.js

@@ -0,0 +1,262 @@
+import path from "node:path";
+import { existsSync } from "node:fs";
+import { fileSystem } from "@ecopages/file-system";
+import { appLogger } from "../../global/app-logger.js";
+import { invariant } from "../../utils/invariant.js";
+const ROUTE_PRIORITY = {
+  exact: 0,
+  dynamic: 1,
+  "catch-all": 2
+};
+class RouteRegistry {
+  origin;
+  appConfig;
+  pagesDir;
+  templatesExt;
+  buildMode;
+  pageModuleAdapter;
+  templateRouteList = [];
+  reloadListeners = /* @__PURE__ */ new Set();
+  constructor(options) {
+    this.origin = options.origin;
+    this.appConfig = options.appConfig;
+    this.pagesDir = options.pagesDir;
+    this.templatesExt = options.templatesExt;
+    this.buildMode = options.buildMode;
+    this.pageModuleAdapter = options.pageModuleAdapter;
+  }
+  get templateRoutes() {
+    return this.templateRouteList;
+  }
+  async init() {
+    this.templateRouteList = await this.scanTemplateRoutes();
+    appLogger.debug("RouteRegistry initialized", this.templateRouteList);
+  }
+  async reload() {
+    await this.init();
+    for (const listener of this.reloadListeners) {
+      listener();
+    }
+  }
+  onReload(listener) {
+    this.reloadListeners.add(listener);
+    return () => {
+      this.reloadListeners.delete(listener);
+    };
+  }
+  matchRequest(requestUrl) {
+    const url = new URL(requestUrl);
+    const requestedPathname = normalizePathname(url.pathname);
+    const query = this.getSearchParams(url);
+    for (const route of this.templateRouteList) {
+      if (route.kind !== "exact") {
+        continue;
+      }
+      if (requestedPathname === route.pathname || requestedPathname === `${route.pathname}/`) {
+        return {
+          requestedPathname,
+          templateRoute: route,
+          params: {},
+          query
+        };
+      }
+    }
+    for (const route of this.templateRouteList) {
+      if (route.kind !== "dynamic") {
+        continue;
+      }
+      const params = this.tryExtractParams(route, requestedPathname);
+      if (!params) {
+        continue;
+      }
+      return {
+        requestedPathname,
+        templateRoute: route,
+        params,
+        query
+      };
+    }
+    for (const route of this.templateRouteList) {
+      if (route.kind !== "catch-all") {
+        continue;
+      }
+      const params = this.tryExtractParams(route, requestedPathname);
+      if (!params) {
+        continue;
+      }
+      return {
+        requestedPathname,
+        templateRoute: route,
+        params,
+        query
+      };
+    }
+    return null;
+  }
+  async listStaticPathExpansions(input) {
+    const expansions = [];
+    for (const route of this.templateRouteList) {
+      if (route.kind === "exact") {
+        continue;
+      }
+      const pageModule = await this.pageModuleAdapter.loadPageModule(route.filePath);
+      const staticPaths = pageModule.staticPaths;
+      if (this.buildMode) {
+        invariant(staticPaths !== void 0, `[ecopages] Missing getStaticPaths in ${route.filePath}`);
+        invariant(
+          pageModule.staticProps !== void 0,
+          `[ecopages] Missing getStaticProps in ${route.filePath}`
+        );
+      }
+      if (!staticPaths) {
+        continue;
+      }
+      const result = await staticPaths({
+        appConfig: this.appConfig,
+        runtimeOrigin: input.runtimeOrigin
+      });
+      for (const { params } of result.paths) {
+        expansions.push({
+          pathname: this.resolveTemplatePath(route.pathname, params),
+          templateRoute: route,
+          params
+        });
+      }
+    }
+    return expansions;
+  }
+  async listStaticGenerationRoutes(input) {
+    const staticPathExpansions = await this.listStaticPathExpansions(input);
+    return [
+      ...this.templateRouteList.filter((route) => route.kind === "exact").map((route) => ({
+        requestUrl: `${input.runtimeOrigin}${route.pathname}`,
+        pathname: route.pathname,
+        templateRoute: route,
+        params: {}
+      })),
+      ...staticPathExpansions.map((route) => ({
+        requestUrl: `${input.runtimeOrigin}${route.pathname}`,
+        pathname: route.pathname,
+        templateRoute: route.templateRoute,
+        params: route.params
+      }))
+    ];
+  }
+  async scanTemplateRoutes() {
+    if (!existsSync(this.pagesDir)) {
+      return [];
+    }
+    const scannedFiles = await fileSystem.glob(
+      this.templatesExt.map((ext) => `**/*${ext}`),
+      {
+        cwd: this.pagesDir
+      }
+    );
+    const templateRoutes = [];
+    for await (const file of scannedFiles) {
+      if (file.includes(".ecopages-node.")) {
+        continue;
+      }
+      const routePathname = this.getRoutePath(file);
+      const filePath = path.join(this.pagesDir, file);
+      const kind = this.classifyRouteKind(filePath);
+      templateRoutes.push({
+        pathname: routePathname,
+        kind,
+        filePath,
+        paramNames: this.getParamNames(routePathname)
+      });
+    }
+    return templateRoutes.sort((left, right) => {
+      const priorityDifference = ROUTE_PRIORITY[left.kind] - ROUTE_PRIORITY[right.kind];
+      if (priorityDifference !== 0) {
+        return priorityDifference;
+      }
+      if (left.pathname === "/") {
+        return -1;
+      }
+      if (right.pathname === "/") {
+        return 1;
+      }
+      return left.pathname.localeCompare(right.pathname);
+    });
+  }
+  getRoutePath(file) {
+    const cleanedRoute = this.templatesExt.reduce((route, ext) => route.replace(ext, ""), file).replace(/\/?index$/, "");
+    return normalizePathname(`/${cleanedRoute}`);
+  }
+  classifyRouteKind(filePath) {
+    if (filePath.includes("[...")) {
+      return "catch-all";
+    }
+    if (filePath.includes("[") && filePath.includes("]")) {
+      return "dynamic";
+    }
+    return "exact";
+  }
+  getParamNames(routePathname) {
+    const matches = routePathname.match(/\[(?:\.\.\.)?([^\]]+)\]/g);
+    return matches ? matches.map((match) => match.replace(/^\[(?:\.\.\.)?/, "").replace(/\]$/, "")) : [];
+  }
+  tryExtractParams(route, requestedPathname) {
+    const routeParts = route.pathname.split("/");
+    const pathnameParts = requestedPathname.split("/");
+    if (route.kind === "dynamic" && routeParts.length !== pathnameParts.length) {
+      return null;
+    }
+    const params = {};
+    for (let i = 0; i < routeParts.length; i++) {
+      const routePart = routeParts[i];
+      const pathnamePart = pathnameParts[i];
+      if (!routePart) {
+        continue;
+      }
+      if (routePart.startsWith("[...") && routePart.endsWith("]")) {
+        const paramName = routePart.slice(4, -1);
+        params[paramName] = pathnameParts.slice(i).filter(Boolean);
+        return params;
+      }
+      if (routePart.startsWith("[") && routePart.endsWith("]")) {
+        if (pathnamePart === void 0) {
+          return null;
+        }
+        params[routePart.slice(1, -1)] = pathnamePart;
+        continue;
+      }
+      if (routePart !== pathnamePart) {
+        return null;
+      }
+    }
+    if (route.kind === "catch-all") {
+      const cleanPathname = route.pathname.replace(/\[.*?\]/g, "");
+      return requestedPathname.includes(cleanPathname) ? params : null;
+    }
+    return params;
+  }
+  getSearchParams(url) {
+    const query = {};
+    for (const [key, value] of url.searchParams) {
+      query[key] = value;
+    }
+    return query;
+  }
+  resolveTemplatePath(pathname, params) {
+    let resolvedPath = pathname;
+    for (const [key, value] of Object.entries(params)) {
+      const serializedValue = Array.isArray(value) ? value.join("/") : value;
+      resolvedPath = resolvedPath.replace(`[...${key}]`, serializedValue);
+      resolvedPath = resolvedPath.replace(`[${key}]`, serializedValue);
+    }
+    return normalizePathname(resolvedPath);
+  }
+}
+function normalizePathname(pathname) {
+  if (!pathname || pathname === "/") {
+    return "/";
+  }
+  const normalized = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+export {
+  RouteRegistry
+};

package/src/services/README.md

@@ -11,7 +11,6 @@ Typical responsibilities include:
 - server-module loading and transpilation
 - browser bundle coordination
 - asset processing and runtime asset declaration helpers
-- runtime specifier registry management
 - server invalidation state and entrypoint dependency graphs
 - HTML finalization and dependency injection
 
@@ -20,7 +19,7 @@ Typical responsibilities include:
 - `module-loading/`: framework-owned config/app bootstrap loading and server-side source loading
 - `assets/`: shared browser build coordination and processed asset pipelines
 - `invalidation/`: file-change classification and invalidation policy
-- `runtime-state/`: app-owned invalidation state, dependency graphs, and runtime specifier registry
+- `runtime-state/`: app-owned invalidation state and dependency graphs
 - `runtime-manifest/`: node runtime manifest derivation and persistence
 - `html/`: final HTML dependency injection and rewriter selection
 

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

@@ -13,6 +13,7 @@ export interface BaseAsset {
     attributes?: Record<string, string>;
     position?: AssetPosition;
     packageRole?: AssetPackageRole;
+    bundledSourceFilepaths?: string[];
 }
 export interface ScriptAsset extends BaseAsset {
     kind: 'script';
@@ -87,6 +88,7 @@ export interface JsonScriptAsset extends ScriptAsset {
 }
 export type ProcessedAsset = {
     filepath?: string;
+    sourceFilepath?: string;
     srcUrl?: string;
     content?: string;
     kind: AssetKind;
@@ -96,5 +98,6 @@ export type ProcessedAsset = {
     excludeFromHtml?: boolean;
     packageRole?: AssetPackageRole;
     groupedBundle?: GroupedScriptBundle;
+    bundledSourceFilepaths?: string[];
 };
 export type AssetDefinition = ContentScriptAsset | FileScriptAsset | NodeModuleScriptAsset | JsonScriptAsset | ContentStylesheetAsset | FileStylesheetAsset;

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

@@ -1,4 +1,5 @@
 export * from './asset.factory.js';
+export * from './page-package.js';
 export * from './asset-processing.service.js';
 export * from './assets.types.js';
 export * from './browser-runtime-asset.factory.js';

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

@@ -1,4 +1,5 @@
 export * from "./asset.factory.js";
+export * from "./page-package.js";
 export * from "./asset-processing.service.js";
 export * from "./assets.types.js";
 export * from "./browser-runtime-asset.factory.js";

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

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

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

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

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

@@ -3,9 +3,7 @@ import { getAppBrowserBuildPlugins } from "../../../../../build/build-adapter.js
 import { fileSystem } from "@ecopages/file-system";
 import path from "node:path";
 import { BaseProcessor } from "./base-processor.js";
-import {
-  BrowserBundleService
-} from "../../../browser-bundle.service.js";
+import { BrowserBundleService } from "../../../browser-bundle.service.js";
 class BaseScriptProcessor extends BaseProcessor {
   browserBundleService;
   constructor({ appConfig }) {
@@ -113,7 +111,9 @@ class BaseScriptProcessor extends BaseProcessor {
         entryOutputs.set(entry.entryName, exactOutput);
         continue;
       }
-      const hashedOutput = outputs.find((outputPath) => path.basename(outputPath).startsWith(`${entry.entryName}-`));
+      const hashedOutput = outputs.find(
+        (outputPath) => path.basename(outputPath).startsWith(`${entry.entryName}-`)
+      );
       if (hashedOutput) {
         entryOutputs.set(entry.entryName, hashedOutput);
         continue;

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

@@ -51,7 +51,8 @@ class ContentScriptProcessor extends BaseScriptProcessor {
           inline: dep.inline,
           excludeFromHtml: dep.excludeFromHtml,
           packageRole: dep.packageRole,
-          groupedBundle: dep.groupedBundle
+          groupedBundle: dep.groupedBundle,
+          bundledSourceFilepaths: dep.bundledSourceFilepaths
         };
       });
     } finally {
@@ -73,7 +74,8 @@ class ContentScriptProcessor extends BaseScriptProcessor {
         attributes: dep.attributes,
         inline: dep.inline,
         excludeFromHtml: dep.excludeFromHtml,
-        packageRole: dep.packageRole
+        packageRole: dep.packageRole,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
       this.writeCacheFile(filename, unbundledProcessedAsset);
       return unbundledProcessedAsset;
@@ -102,7 +104,8 @@ class ContentScriptProcessor extends BaseScriptProcessor {
         inline: dep.inline,
         excludeFromHtml: dep.excludeFromHtml,
         packageRole: dep.packageRole,
-        groupedBundle: dep.groupedBundle
+        groupedBundle: dep.groupedBundle,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
       fileSystem.remove(tempFileName);
       this.writeCacheFile(filename, processedAsset);

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

@@ -24,13 +24,15 @@ class FileScriptProcessor extends BaseScriptProcessor {
       const outputFilepath = this.resolveHmrOutputFilepath(dep.filepath);
       return {
         filepath: outputFilepath ?? dep.filepath,
+        sourceFilepath: dep.filepath,
         srcUrl: outputUrl,
         kind: "script",
         position: dep.position,
         attributes: dep.attributes,
         inline: false,
         excludeFromHtml: dep.excludeFromHtml,
-        packageRole: dep.packageRole
+        packageRole: dep.packageRole,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
     }
     const content = fileSystem.readFileSync(dep.filepath);
@@ -53,13 +55,15 @@ class FileScriptProcessor extends BaseScriptProcessor {
         }
         return {
           filepath,
+          sourceFilepath: dep.filepath,
           content,
           kind: "script",
           position: dep.position,
           attributes: dep.attributes,
           inline: dep.inline,
           excludeFromHtml: dep.excludeFromHtml,
-          packageRole: dep.packageRole
+          packageRole: dep.packageRole,
+          bundledSourceFilepaths: dep.bundledSourceFilepaths
         };
       }
       const relativeFilepath = path.relative(this.appConfig.absolutePaths.srcDir, dep.filepath);
@@ -75,13 +79,15 @@ class FileScriptProcessor extends BaseScriptProcessor {
       });
       return {
         filepath: bundledFilePath,
+        sourceFilepath: dep.filepath,
         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
+        packageRole: dep.packageRole,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
     });
   }

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

@@ -21,7 +21,8 @@ class NodeModuleScriptProcessor extends BaseScriptProcessor {
           attributes: dep.attributes,
           inline: true,
           excludeFromHtml: dep.excludeFromHtml,
-          packageRole: dep.packageRole
+          packageRole: dep.packageRole,
+          bundledSourceFilepaths: dep.bundledSourceFilepaths
         };
       }
       const outdir = path.join(this.getAssetsDir(), "vendors");
@@ -40,7 +41,8 @@ class NodeModuleScriptProcessor extends BaseScriptProcessor {
         attributes: dep.attributes,
         inline: dep.inline,
         excludeFromHtml: dep.excludeFromHtml,
-        packageRole: dep.packageRole
+        packageRole: dep.packageRole,
+        bundledSourceFilepaths: dep.bundledSourceFilepaths
       };
     });
   }