@lwrjs/module-bundler 0.12.0-alpha.2 → 0.12.0-alpha.21

package/build/cjs/esm-bundle-provider.cjs

@@ -27,11 +27,13 @@ __export(exports, {
   default: () => esm_bundle_provider_default
 });
 var import_rollup = __toModule(require("rollup"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_rollup_esm_bundler_plugin = __toModule(require("./utils/rollup-esm-bundler-plugin.cjs"));
 var import_esbuild_utils = __toModule(require("./utils/esbuild-utils.cjs"));
 var import_bundle_common = __toModule(require("./utils/bundle-common.cjs"));
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var EsmBundlerProvider = class {
-  constructor(options, {config, moduleRegistry}) {
+  constructor(_options, {config, moduleRegistry}) {
     this.name = "esm-bundle-provider";
     this.config = config;
     this.moduleRegistry = moduleRegistry;
@@ -50,27 +52,39 @@ async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeP
   const requiredImports = new Map();
   const dynamicImports = new Map();
   const rootModuleDef = await moduleRegistry.getLinkedModule(moduleId, runtimeEnvironment, runtimeParams);
-  const bundle = await (0, import_rollup.rollup)({
-    input: moduleId.specifier,
-    plugins: [
-      (0, import_rollup_esm_bundler_plugin.bundleDefinitions)({
-        rootModuleDef,
-        runtimeEnvironment,
-        moduleRegistry,
-        exclude,
-        alias,
-        runtimeParams,
-        requiredImports,
-        dynamicImports
-      })
-    ],
-    makeAbsoluteExternalsRelative: "ifRelativeSource"
-  });
-  const result = await bundle.generate({
-    paths: (id2) => {
-      return external[id2] || id2;
-    },
-    sourcemap: true
+  const result = await (0, import_instrumentation.getTracer)().trace({
+    name: import_instrumentation.BundleSpan.Rollup,
+    attributes: {
+      specifier: moduleId.specifier,
+      format: "esm"
+    }
+  }, async () => {
+    const bundle = await (0, import_rollup.rollup)({
+      input: moduleId.specifier,
+      plugins: [
+        (0, import_rollup_esm_bundler_plugin.bundleDefinitions)({
+          rootModuleDef,
+          runtimeEnvironment,
+          moduleRegistry,
+          exclude,
+          alias,
+          runtimeParams,
+          requiredImports,
+          dynamicImports
+        })
+      ],
+      external: Object.keys(external),
+      makeAbsoluteExternalsRelative: "ifRelativeSource"
+    });
+    return bundle.generate({
+      paths: (id2) => {
+        if (external[id2] && (external[id2].startsWith(import_shared_utils.PROTOCOL_HTTP) || external[id2].startsWith(import_shared_utils.PROTOCOL_HTTPS))) {
+          return external[id2];
+        }
+        return id2;
+      },
+      sourcemap: true
+    });
   });
   const bundleCode = result.output[0].code;
   const bundleMap = result.output[0].map;

package/build/cjs/index.cjs

@@ -26,9 +26,10 @@ __markAsModule(exports);
 __export(exports, {
   LwrModuleBundler: () => LwrModuleBundler
 });
+var import_path = __toModule(require("path"));
 var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-var import_path = __toModule(require("path"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var TASK_POOL = new import_shared_utils.TaskPool();
 var LwrModuleBundler = class {
   constructor(config, globalConfig) {
@@ -49,6 +50,9 @@ var LwrModuleBundler = class {
   addBundleTransformers(transformers) {
     this.transformers.push(...transformers);
   }
+  getConfig() {
+    return this.bundleConfig;
+  }
   async getModuleBundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
     const {format, minify, debug} = runtimeEnvironment;
     const cacheKey = `${moduleId.specifier}|${moduleId.version}|${(0, import_shared_utils.getCacheKeyFromJson)({
@@ -65,21 +69,28 @@ var LwrModuleBundler = class {
         return bundleDef;
       }
     }
-    return this.inflightBundleDefinitions.execute(cacheKey, () => {
-      return TASK_POOL.execute(async () => {
-        for (const bundler of this.providers) {
-          const bundleDef = await bundler.bundle(moduleId, runtimeEnvironment, runtimeParams, bundleConfigOverrides);
-          if (bundleDef) {
-            if (!cacheDisabled) {
-              this.cache.set(cacheKey, bundleDef);
+    return (0, import_instrumentation.getTracer)().trace({
+      name: import_instrumentation.BundleSpan.GetBundle,
+      attributes: {
+        specifier: moduleId.specifier
+      }
+    }, () => {
+      return this.inflightBundleDefinitions.execute(cacheKey, () => {
+        return TASK_POOL.execute(async () => {
+          for (const bundler of this.providers) {
+            const bundleDef = await bundler.bundle(moduleId, runtimeEnvironment, runtimeParams, bundleConfigOverrides);
+            if (bundleDef) {
+              if (!cacheDisabled) {
+                this.cache.set(cacheKey, bundleDef);
+              }
+              return bundleDef;
             }
-            return bundleDef;
           }
-        }
-        throw (0, import_diagnostics.createSingleDiagnosticError)({
-          description: import_diagnostics.descriptions.UNRESOLVABLE.BUNDLE(moduleId.specifier)
-        }, import_diagnostics.LwrUnresolvableError);
-      }, this);
+          throw (0, import_diagnostics.createSingleDiagnosticError)({
+            description: import_diagnostics.descriptions.UNRESOLVABLE.BUNDLE(moduleId.specifier)
+          }, import_diagnostics.LwrUnresolvableError);
+        }, this);
+      });
     });
   }
   async resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature) {
@@ -116,6 +127,7 @@ var LwrModuleBundler = class {
   }
   getPublicApi() {
     return {
+      getConfig: this.getConfig.bind(this),
       getModuleBundle: this.getModuleBundle.bind(this),
       resolveModuleUri: this.resolveModuleUri.bind(this)
     };

package/build/cjs/utils/amd-common.cjs

@@ -29,26 +29,31 @@ __export(exports, {
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_rollup = __toModule(require("rollup"));
 var import_plugin_replace = __toModule(require("@rollup/plugin-replace"));
+var import_instrumentation = __toModule(require("@lwrjs/instrumentation"));
 var import_rollup_amd_bundler_plugin = __toModule(require("./rollup-amd-bundler-plugin.cjs"));
 var import_bundle_common = __toModule(require("./bundle-common.cjs"));
 var AMD_DEFINE = "LWR.define";
 var groupieCodeCache = new Map();
 function includeIdFactory(graphSpecifier, external, exclude = [], requiredImports, groups) {
   return (moduleRef) => {
+    const moduleIsNotRoot = graphSpecifier !== moduleRef.specifier;
     if (external[moduleRef.specifier] !== void 0) {
+      moduleRef.externalSrc = external[moduleRef.specifier];
+      if (moduleIsNotRoot) {
+        requiredImports.set(`${moduleRef.specifier}_${moduleRef.version || import_shared_utils.VERSION_NOT_PROVIDED}`, moduleRef);
+      }
       return false;
     }
     const moduleRefIsGroupie = (0, import_shared_utils.isGroupie)(moduleRef.specifier, groups);
     const rootModuleIsGroupie = (0, import_shared_utils.isGroupie)(graphSpecifier, groups);
-    const moduleIsNotRoot = graphSpecifier !== moduleRef.specifier;
     if (moduleRefIsGroupie) {
       if (moduleIsNotRoot && !rootModuleIsGroupie) {
-        requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
+        requiredImports.set(`${moduleRef.specifier}_${moduleRef.version || import_shared_utils.VERSION_NOT_PROVIDED}`, moduleRef);
       }
       return false;
     } else if (exclude?.includes(moduleRef.specifier)) {
       if (moduleIsNotRoot) {
-        requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
+        requiredImports.set(`${moduleRef.specifier}_${moduleRef.version || import_shared_utils.VERSION_NOT_PROVIDED}`, moduleRef);
       }
       return false;
     }
@@ -61,11 +66,19 @@ async function bundle(id, moduleGraphs, minify = false, unVersionedAliases = fal
     "process.env.NODE_ENV": JSON.stringify("production"),
     preventAssignment: false
   }));
-  const bundler = await (0, import_rollup.rollup)({input: id, plugins});
-  const {output} = await bundler.generate({
-    amd: {id, define: AMD_DEFINE},
-    exports: "named",
-    format: "amd"
+  const {output} = await (0, import_instrumentation.getTracer)().trace({
+    name: import_instrumentation.BundleSpan.Rollup,
+    attributes: {
+      specifier: id,
+      format: "amd"
+    }
+  }, async () => {
+    const bundler = await (0, import_rollup.rollup)({input: id, plugins});
+    return bundler.generate({
+      amd: {id, define: AMD_DEFINE},
+      exports: "named",
+      format: "amd"
+    });
   });
   let code = output[0].code;
   if (unVersionedAliases) {
@@ -122,6 +135,9 @@ async function getBundleCode(rootModule, moduleGraphs, includedModules, bundleGr
     } else {
       bundleGroupsIncludedModules.push(id);
     }
+    if ((0, import_shared_utils.isExternalSpecifier)(id, moduleRegistry.getConfig().bundleConfig)) {
+      return linkedDefinition.linkedSource;
+    }
     return bundle(id, moduleGraphs, minify, unVersionedAliases);
   }))).filter((x) => typeof x === "string");
   return bundles;
@@ -166,8 +182,8 @@ async function amdBundler(rootModuleId, moduleRegistry, minify = false, runtimeE
       for (const rawGroupieSpecifier of groupies) {
         if (rawGroupieSpecifier !== rootModuleId.specifier) {
           const groupieModuleGraph = groupModuleGraphsMap.get(rawGroupieSpecifier);
-          const groupieSpecifer = groupieModuleGraph.graphs[0].specifier;
-          const groupieBundles = await getBundleCode(groupieSpecifer, groupieModuleGraph, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.EXPERIMENTAL_UNVERSIONED_ALIASES, includeIdFactory(rawGroupieSpecifier, external, exclude, requiredImports, groups), moduleRegistry, runtimeEnvironment, runtimeParams, bundledSpecifiersMap);
+          const groupieSpecifier = groupieModuleGraph.graphs[0].specifier;
+          const groupieBundles = await getBundleCode(groupieSpecifier, groupieModuleGraph, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.EXPERIMENTAL_UNVERSIONED_ALIASES, includeIdFactory(rawGroupieSpecifier, external, exclude, requiredImports, groups), moduleRegistry, runtimeEnvironment, runtimeParams, bundledSpecifiersMap);
           bundles.push(...groupieBundles);
         }
       }

package/build/es/esm-bundle-provider.d.ts

@@ -3,7 +3,7 @@ export default class EsmBundlerProvider implements BundleProvider {
     name: string;
     config: ProviderAppConfig;
     moduleRegistry: PublicModuleRegistry;
-    constructor(options: {}, { config, moduleRegistry }: ProviderContext);
+    constructor(_options: {}, { config, moduleRegistry }: ProviderContext);
     bundle<T extends AbstractModuleId, R extends RuntimeEnvironment>(moduleId: T, runtimeEnvironment: R, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfigOverrides): Promise<BundleDefinition | undefined>;
 }
 //# sourceMappingURL=esm-bundle-provider.d.ts.map

package/build/es/esm-bundle-provider.js

@@ -1,9 +1,11 @@
 import { rollup } from 'rollup';
+import { BundleSpan, getTracer } from '@lwrjs/instrumentation';
 import { bundleDefinitions } from './utils/rollup-esm-bundler-plugin.js';
 import { minifyJavascript } from './utils/esbuild-utils.js';
 import { overrideBundleConfig } from './utils/bundle-common.js';
+import { PROTOCOL_HTTP, PROTOCOL_HTTPS } from '@lwrjs/shared-utils';
 export default class EsmBundlerProvider {
-    constructor(options, { config, moduleRegistry }) {
+    constructor(_options, { config, moduleRegistry }) {
         this.name = 'esm-bundle-provider';
         this.config = config;
         this.moduleRegistry = moduleRegistry;
@@ -21,29 +23,43 @@ async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeP
     const requiredImports = new Map();
     const dynamicImports = new Map();
     const rootModuleDef = await moduleRegistry.getLinkedModule(moduleId, runtimeEnvironment, runtimeParams);
-    const bundle = await rollup({
-        input: moduleId.specifier,
-        plugins: [
-            bundleDefinitions({
-                rootModuleDef,
-                runtimeEnvironment,
-                moduleRegistry,
-                exclude,
-                alias,
-                runtimeParams,
-                requiredImports,
-                dynamicImports,
-            }),
-        ],
-        makeAbsoluteExternalsRelative: 'ifRelativeSource', // Fix for breaking changes in https://github.com/rollup/rollup/pull/4021
-    });
-    const result = await bundle.generate({
-        paths: (id) => {
-            // The fallback on id is important due to a rollup semantic issue:
-            // https://github.com/rollup/rollup/issues/3831
-            return external[id] || id;
+    const result = await getTracer().trace({
+        name: BundleSpan.Rollup,
+        attributes: {
+            specifier: moduleId.specifier,
+            format: 'esm',
         },
-        sourcemap: true,
+    }, async () => {
+        const bundle = await rollup({
+            input: moduleId.specifier,
+            plugins: [
+                bundleDefinitions({
+                    rootModuleDef,
+                    runtimeEnvironment,
+                    moduleRegistry,
+                    exclude,
+                    alias,
+                    runtimeParams,
+                    requiredImports,
+                    dynamicImports,
+                }),
+            ],
+            external: Object.keys(external),
+            makeAbsoluteExternalsRelative: 'ifRelativeSource', // Fix for breaking changes in https://github.com/rollup/rollup/pull/4021
+        });
+        return bundle.generate({
+            paths: (id) => {
+                // The fallback on id is important due to a rollup semantic issue:
+                // https://github.com/rollup/rollup/issues/3831
+                // If external is an http:// URL use that in the ESM Module
+                if (external[id] &&
+                    (external[id].startsWith(PROTOCOL_HTTP) || external[id].startsWith(PROTOCOL_HTTPS))) {
+                    return external[id];
+                }
+                return id;
+            },
+            sourcemap: true,
+        });
     });
     const bundleCode = result.output[0].code;
     const bundleMap = result.output[0].map;

package/build/es/index.d.ts

@@ -14,6 +14,7 @@ export declare class LwrModuleBundler implements ModuleBundler {
     constructor(config: LwrModuleBundlerConfig, globalConfig: NormalizedLwrGlobalConfig);
     addBundleProviders(providers: BundleProvider[]): void;
     addBundleTransformers(transformers: UriTransformPlugin[]): void;
+    getConfig(): BundleConfig;
     getModuleBundle<T extends AbstractModuleId>(moduleId: T, runtimeEnvironment: SourceMapRuntimeEnvironment, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfigOverrides): Promise<BundleDefinition>;
     /**
      * Resolve the URI to the bundle rooted at the `moduleId`

package/build/es/index.js

@@ -1,6 +1,7 @@
+import { join } from 'path';
 import { LwrUnresolvableError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
 import { getCacheKeyFromJson, InflightTasks, TaskPool } from '@lwrjs/shared-utils';
-import { join } from 'path';
+import { getTracer, BundleSpan } from '@lwrjs/instrumentation';
 const TASK_POOL = new TaskPool();
 export class LwrModuleBundler {
     constructor(config, globalConfig) {
@@ -27,6 +28,9 @@ export class LwrModuleBundler {
     addBundleTransformers(transformers) {
         this.transformers.push(...transformers);
     }
+    getConfig() {
+        return this.bundleConfig;
+    }
     async getModuleBundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
         const { format, minify, debug } = runtimeEnvironment;
         const cacheKey = `${moduleId.specifier}|${moduleId.version}|${getCacheKeyFromJson({
@@ -46,25 +50,30 @@ export class LwrModuleBundler {
                 return bundleDef;
             }
         }
-        return this.inflightBundleDefinitions.execute(cacheKey, () => {
-            // TODO add to profiling
-            // console.log('[INFO] Create Bundle: ', cacheKey);
-            // Run theses tasks in a task pool to throttle parallel requests.
-            return TASK_POOL.execute(async () => {
-                for (const bundler of this.providers) {
-                    // eslint-disable-next-line no-await-in-loop
-                    const bundleDef = await bundler.bundle(moduleId, runtimeEnvironment, runtimeParams, bundleConfigOverrides);
-                    if (bundleDef) {
-                        if (!cacheDisabled) {
-                            this.cache.set(cacheKey, bundleDef);
+        return getTracer().trace({
+            name: BundleSpan.GetBundle,
+            attributes: {
+                specifier: moduleId.specifier,
+            },
+        }, () => {
+            return this.inflightBundleDefinitions.execute(cacheKey, () => {
+                // Run theses tasks in a task pool to throttle parallel requests.
+                return TASK_POOL.execute(async () => {
+                    for (const bundler of this.providers) {
+                        // eslint-disable-next-line no-await-in-loop
+                        const bundleDef = await bundler.bundle(moduleId, runtimeEnvironment, runtimeParams, bundleConfigOverrides);
+                        if (bundleDef) {
+                            if (!cacheDisabled) {
+                                this.cache.set(cacheKey, bundleDef);
+                            }
+                            return bundleDef;
                         }
-                        return bundleDef;
                     }
-                }
-                throw createSingleDiagnosticError({
-                    description: descriptions.UNRESOLVABLE.BUNDLE(moduleId.specifier),
-                }, LwrUnresolvableError);
-            }, this);
+                    throw createSingleDiagnosticError({
+                        description: descriptions.UNRESOLVABLE.BUNDLE(moduleId.specifier),
+                    }, LwrUnresolvableError);
+                }, this);
+            });
         });
     }
     /**
@@ -115,6 +124,7 @@ export class LwrModuleBundler {
     }
     getPublicApi() {
         return {
+            getConfig: this.getConfig.bind(this),
             getModuleBundle: this.getModuleBundle.bind(this),
             resolveModuleUri: this.resolveModuleUri.bind(this),
         };

package/build/es/utils/amd-common.js

@@ -1,27 +1,34 @@
-import { GraphDepth, createAmdAlias, explodeSpecifier, getModuleGraphs, getSpecifier, getGroupName, isGroupie, getCacheKeyFromJson, } from '@lwrjs/shared-utils';
+import { GraphDepth, createAmdAlias, explodeSpecifier, getModuleGraphs, getSpecifier, getGroupName, isGroupie, getCacheKeyFromJson, VERSION_NOT_PROVIDED, isExternalSpecifier, } from '@lwrjs/shared-utils';
 import { rollup } from 'rollup';
 import replace from '@rollup/plugin-replace';
+import { BundleSpan, getTracer } from '@lwrjs/instrumentation';
 import { bundleDefinitions } from './rollup-amd-bundler-plugin.js';
 import { overrideBundleConfig } from './bundle-common.js';
 const AMD_DEFINE = 'LWR.define';
 const groupieCodeCache = new Map();
 function includeIdFactory(graphSpecifier, external, exclude = [], requiredImports, groups) {
     return (moduleRef) => {
+        const moduleIsNotRoot = graphSpecifier !== moduleRef.specifier;
         // Do not bundle externals, including the loader module, which is auto bundled
         // with the shim + loader combo
         if (external[moduleRef.specifier] !== undefined) {
-            // Do not include externals in the required imports but also return false to indicate it should not be in the bundle
+            // Include externals just mark them as such
+            moduleRef.externalSrc = external[moduleRef.specifier];
+            if (moduleIsNotRoot) {
+                // Include externals in the required imports
+                requiredImports.set(`${moduleRef.specifier}_${moduleRef.version || VERSION_NOT_PROVIDED}`, moduleRef);
+            }
+            // return false to indicate it should not be in the bundle
             return false;
         }
         const moduleRefIsGroupie = isGroupie(moduleRef.specifier, groups);
         const rootModuleIsGroupie = isGroupie(graphSpecifier, groups);
-        const moduleIsNotRoot = graphSpecifier !== moduleRef.specifier;
         if (moduleRefIsGroupie) {
             // If this is part of bundle group return false to indicate it should not be in the bundle
             // but add it to the requiredImports so it shows up as a static dependency of the bundle.
             // However, skip this if the requested specifier is also part of the same group.
             if (moduleIsNotRoot && !rootModuleIsGroupie) {
-                requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
+                requiredImports.set(`${moduleRef.specifier}_${moduleRef.version || VERSION_NOT_PROVIDED}`, moduleRef);
             }
             return false;
         }
@@ -29,7 +36,7 @@ function includeIdFactory(graphSpecifier, external, exclude = [], requiredImport
             // If this is a bundle exclude return false to indicate it should not be in the bundle
             // but add it to the requiredImports so it shows up as a static dependency of the bundle.
             if (moduleIsNotRoot) {
-                requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
+                requiredImports.set(`${moduleRef.specifier}_${moduleRef.version || VERSION_NOT_PROVIDED}`, moduleRef);
             }
             return false;
         }
@@ -45,11 +52,19 @@ async function bundle(id, moduleGraphs, minify = false, unVersionedAliases = fal
             'process.env.NODE_ENV': JSON.stringify('production'),
             preventAssignment: false,
         }));
-    const bundler = await rollup({ input: id, plugins });
-    const { output } = await bundler.generate({
-        amd: { id, define: AMD_DEFINE },
-        exports: 'named',
-        format: 'amd',
+    const { output } = await getTracer().trace({
+        name: BundleSpan.Rollup,
+        attributes: {
+            specifier: id,
+            format: 'amd',
+        },
+    }, async () => {
+        const bundler = await rollup({ input: id, plugins });
+        return bundler.generate({
+            amd: { id, define: AMD_DEFINE },
+            exports: 'named',
+            format: 'amd',
+        });
     });
     let code = output[0].code;
     if (unVersionedAliases) {
@@ -119,6 +134,10 @@ async function getBundleCode(rootModule, moduleGraphs, includedModules, bundleGr
             // we need to still keep track of roots for bundle groups
             bundleGroupsIncludedModules.push(id);
         }
+        // If this is a external dependency just return the linked source no need to bundle.
+        if (isExternalSpecifier(id, moduleRegistry.getConfig().bundleConfig)) {
+            return linkedDefinition.linkedSource;
+        }
         // bundle all dependencies for the linked definition and convert to AMD
         return bundle(id, moduleGraphs, minify, unVersionedAliases);
     }))).filter((x) => typeof x === 'string');
@@ -171,9 +190,9 @@ export async function amdBundler(rootModuleId, moduleRegistry, minify = false, r
             for (const rawGroupieSpecifier of groupies) {
                 if (rawGroupieSpecifier !== rootModuleId.specifier) {
                     const groupieModuleGraph = groupModuleGraphsMap.get(rawGroupieSpecifier);
-                    const groupieSpecifer = groupieModuleGraph.graphs[0].specifier;
+                    const groupieSpecifier = groupieModuleGraph.graphs[0].specifier;
                     // eslint-disable-next-line no-await-in-loop
-                    const groupieBundles = await getBundleCode(groupieSpecifer, groupieModuleGraph, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.EXPERIMENTAL_UNVERSIONED_ALIASES, includeIdFactory(rawGroupieSpecifier, external, exclude, requiredImports, groups), moduleRegistry, runtimeEnvironment, runtimeParams, bundledSpecifiersMap);
+                    const groupieBundles = await getBundleCode(groupieSpecifier, groupieModuleGraph, includedModules, bundleGroupsIncludedModules, dynamicImports, minify, !!runtimeEnvironment.featureFlags?.EXPERIMENTAL_UNVERSIONED_ALIASES, includeIdFactory(rawGroupieSpecifier, external, exclude, requiredImports, groups), moduleRegistry, runtimeEnvironment, runtimeParams, bundledSpecifiersMap);
                     bundles.push(...groupieBundles);
                 }
             }

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.12.0-alpha.2",
+    "version": "0.12.0-alpha.21",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -47,13 +47,14 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/diagnostics": "0.12.0-alpha.2",
-        "@lwrjs/shared-utils": "0.12.0-alpha.2",
+        "@lwrjs/diagnostics": "0.12.0-alpha.21",
+        "@lwrjs/instrumentation": "0.12.0-alpha.21",
+        "@lwrjs/shared-utils": "0.12.0-alpha.21",
         "@rollup/plugin-replace": "^2.4.2",
         "rollup": "^2.78.0"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.12.0-alpha.2",
+        "@lwrjs/types": "0.12.0-alpha.21",
         "jest": "^26.6.3",
         "ts-jest": "^26.5.6"
     },
@@ -69,5 +70,5 @@
     "volta": {
         "extends": "../../../package.json"
     },
-    "gitHead": "586a2aa659882483af9249dc3db7fe07bc842a25"
+    "gitHead": "3d77678ca2f568fcbe29efa2bf7e6f75778be50c"
 }