@lwrjs/module-bundler 0.9.0-alpha.8 → 0.9.0

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

@@ -0,0 +1,56 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/module-bundler/src/amd-bundle-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => amd_bundle_provider_default
+});
+var import_amd_common = __toModule(require("./utils/amd-common.cjs"));
+var import_esbuild_utils = __toModule(require("./utils/esbuild-utils.cjs"));
+var AmdBundlerProvider = class {
+  constructor(options, {config, moduleRegistry}) {
+    this.name = "amd-bundle-provider";
+    this.config = config;
+    this.moduleRegistry = moduleRegistry;
+  }
+  async bundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
+    if (runtimeEnvironment.format === "amd") {
+      const {moduleRegistry, config} = this;
+      const bundle = await (0, import_amd_common.amdBundler)(moduleId, moduleRegistry, false, runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
+      const {
+        minify,
+        debug,
+        env: {NODE_ENV: envMode} = {NODE_ENV: "production"}
+      } = runtimeEnvironment;
+      const minified = !!minify && !debug;
+      if (minified) {
+        bundle.code = await (0, import_esbuild_utils.minifyJavascript)(bundle.code);
+      } else {
+        bundle.code = await (0, import_esbuild_utils.parseJavascript)(bundle.code, {envMode});
+      }
+      return bundle;
+    }
+  }
+};
+var amd_bundle_provider_default = AmdBundlerProvider;

package/build/cjs/amd-runtime-bundle-provider.cjs

@@ -0,0 +1,45 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/module-bundler/src/amd-runtime-bundle-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => amd_runtime_bundle_provider_default
+});
+var import_amd_common = __toModule(require("./utils/amd-common.cjs"));
+var AmdBundlerProvider = class {
+  constructor(options, {config, moduleRegistry}) {
+    this.name = "amd-runtime-bundle-provider";
+    this.config = config;
+    this.moduleRegistry = moduleRegistry;
+  }
+  async bundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
+    if (runtimeEnvironment.format === "amd") {
+      const {moduleRegistry, config} = this;
+      const {minify, debug} = runtimeEnvironment;
+      const minified = minify && !debug;
+      return await (0, import_amd_common.amdBundler)(moduleId, moduleRegistry, minified, runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
+    }
+  }
+};
+var amd_runtime_bundle_provider_default = AmdBundlerProvider;

package/build/cjs/{esm/esm-bundler.cjs → esm-bundle-provider.cjs}

@@ -21,15 +21,31 @@ var __toModule = (module2) => {
   return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
 };
 
-// packages/@lwrjs/module-bundler/src/esm/esm-bundler.ts
+// packages/@lwrjs/module-bundler/src/esm-bundle-provider.ts
 __markAsModule(exports);
 __export(exports, {
-  esmBundler: () => esmBundler
+  default: () => esm_bundle_provider_default
 });
 var import_rollup = __toModule(require("rollup"));
-var import_rollup_esm_bundler_plugin = __toModule(require("./rollup-esm-bundler-plugin.cjs"));
-async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, lwrConfig, bundleConfigOverride) {
-  const {exclude, external = {}, alias = {}} = bundleConfigOverride ?? lwrConfig.bundleConfig;
+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 EsmBundlerProvider = class {
+  constructor(options, {config, moduleRegistry}) {
+    this.name = "esm-bundle-provider";
+    this.config = config;
+    this.moduleRegistry = moduleRegistry;
+  }
+  async bundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
+    if (runtimeEnvironment.format === "esm") {
+      const {moduleRegistry, config} = this;
+      return await esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
+    }
+  }
+};
+var esm_bundle_provider_default = EsmBundlerProvider;
+async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, {bundleConfig}, bundleConfigOverrides) {
+  const {exclude, external = {}, alias = {}} = (0, import_bundle_common.overrideBundleConfig)(bundleConfig, bundleConfigOverrides);
   const {sourceMapUrl} = runtimeEnvironment;
   const requiredImports = new Map();
   const dynamicImports = new Map();
@@ -58,9 +74,14 @@ async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeP
   });
   const bundleCode = result.output[0].code;
   const bundleMap = result.output[0].map;
-  const code = sourceMapUrl ? `${bundleCode}
+  let code = sourceMapUrl ? `${bundleCode}
 //# sourceMappingURL=${sourceMapUrl}` : bundleCode;
   const {id, specifier, namespace, name, version} = rootModuleDef;
+  const {minify, debug} = runtimeEnvironment;
+  const minified = !!minify && !debug;
+  if (minified) {
+    code = await (0, import_esbuild_utils.minifyJavascript)(code);
+  }
   return {
     id,
     specifier,

package/build/cjs/index.cjs

@@ -26,24 +26,25 @@ __markAsModule(exports);
 __export(exports, {
   LwrModuleBundler: () => LwrModuleBundler
 });
+var import_diagnostics = __toModule(require("@lwrjs/diagnostics"));
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
-var import_amd_bundler = __toModule(require("./amd/amd-bundler.cjs"));
-var import_esm_bundler = __toModule(require("./esm/esm-bundler.cjs"));
 var TASK_POOL = new import_shared_utils.TaskPool();
 var LwrModuleBundler = class {
   constructor(config, globalConfig) {
     this.cache = new Map();
+    this.providers = [];
     this.inflightBundleDefinitions = new import_shared_utils.InflightTasks();
-    this.config = globalConfig;
     this.moduleRegistry = config.moduleRegistry;
     this.appObserver = config.appObserver;
-    this.compiler = config.compiler;
+    this.bundleConfig = Object.freeze(globalConfig.bundleConfig);
     this.appObserver?.onModuleDefinitionChange(() => {
       this.cache.clear();
     });
   }
+  addBundleProviders(providers) {
+    this.providers.push(...providers);
+  }
   async getModuleBundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
-    const {moduleRegistry} = this;
     const {format, minify, debug} = runtimeEnvironment;
     const cacheKey = `${moduleId.specifier}|${moduleId.version}|${(0, import_shared_utils.getCacheKeyFromJson)({
       locale: runtimeParams.locale,
@@ -61,18 +62,45 @@ var LwrModuleBundler = class {
     }
     return this.inflightBundleDefinitions.execute(cacheKey, () => {
       return TASK_POOL.execute(async () => {
-        const pendingBundleDef = format === "amd" ? (0, import_amd_bundler.amdBundler)(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config, bundleConfigOverrides) : (0, import_esm_bundler.esmBundler)(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config, bundleConfigOverrides);
-        return pendingBundleDef.then(async (bundleDef) => {
-          const minified = !!minify && !debug;
-          if (minified) {
-            bundleDef.code = (await this.compiler.minifyJavascript(bundleDef.code)).code;
-          }
-          if (!cacheDisabled) {
-            this.cache.set(cacheKey, bundleDef);
+        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);
     });
   }
+  async resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature) {
+    const bundleDefinition = await this.getModuleBundle(moduleId, runtimeEnvironment, runtimeParams);
+    if (!bundleDefinition) {
+      throw (0, import_diagnostics.createSingleDiagnosticError)({
+        description: import_diagnostics.descriptions.UNRESOLVABLE.BUNDLE(moduleId.specifier)
+      }, import_diagnostics.LwrUnresolvableError);
+    }
+    let uri;
+    if (bundleDefinition.src) {
+      uri = bundleDefinition.src;
+    } else {
+      let resolvedVersion = moduleId.version || bundleDefinition.version;
+      if (!resolvedVersion) {
+        const {version} = await this.moduleRegistry.getModuleEntry(moduleId);
+        resolvedVersion = version;
+      }
+      uri = String(await this.moduleRegistry.resolveModuleUri({...moduleId, version: resolvedVersion}, runtimeEnvironment, runtimeParams, signature));
+    }
+    return uri;
+  }
+  getPublicApi() {
+    return {
+      getModuleBundle: this.getModuleBundle.bind(this),
+      resolveModuleUri: this.resolveModuleUri.bind(this)
+    };
+  }
 };

package/build/cjs/{amd/amd-bundler.cjs → utils/amd-common.cjs}

@@ -21,33 +21,34 @@ var __toModule = (module2) => {
   return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
 };
 
-// packages/@lwrjs/module-bundler/src/amd/amd-bundler.ts
+// packages/@lwrjs/module-bundler/src/utils/amd-common.ts
 __markAsModule(exports);
 __export(exports, {
   amdBundler: () => amdBundler
 });
-var import_compiler = __toModule(require("@lwrjs/compiler"));
 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_rollup_amd_bundler_plugin = __toModule(require("./rollup-amd-bundler-plugin.cjs"));
-async function bundle(id, moduleGraphs) {
-  const bundler = await (0, import_rollup.rollup)({
-    input: id,
-    plugins: [
-      (0, import_rollup_amd_bundler_plugin.bundleDefinitions)({
-        moduleGraphs
-      })
-    ]
-  });
+var import_bundle_common = __toModule(require("./bundle-common.cjs"));
+var AMD_DEFINE = "LWR.define";
+async function bundle(id, moduleGraphs, minify = false) {
+  const plugins = [(0, import_rollup_amd_bundler_plugin.bundleDefinitions)({moduleGraphs})];
+  minify && plugins.push((0, import_plugin_replace.default)({
+    "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: import_compiler.AMD_DEFINE},
+    amd: {id, define: AMD_DEFINE},
     exports: "named",
     format: "amd"
   });
   return output[0].code;
 }
-async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, {bundleConfig, amdLoader}, bundleConfigOverride) {
-  const {exclude, external} = bundleConfigOverride ?? bundleConfig;
+async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, {bundleConfig}, bundleConfigOverrides) {
+  const {exclude, external = {}} = (0, import_bundle_common.overrideBundleConfig)(bundleConfig, bundleConfigOverrides);
+  const externalsArray = Object.keys(external);
   const requiredImports = new Map();
   const dynamicImports = new Map();
   const includedModules = [];
@@ -57,8 +58,10 @@ async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeP
       static: import_shared_utils.GraphDepth.ALL,
       dynamic: 0,
       includeId: (moduleRef) => {
-        if (exclude?.includes(moduleRef.specifier) || moduleRef.specifier === amdLoader) {
-          requiredImports.set(`${moduleId.specifier}_${moduleId.version}`, moduleRef);
+        if (externalsArray.includes(moduleRef.specifier)) {
+          return false;
+        } else if (exclude?.includes(moduleRef.specifier)) {
+          requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
           return false;
         }
         return true;
@@ -88,7 +91,7 @@ async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeP
     if (id2 !== rootModule.specifier) {
       includedModules.push(id2);
     }
-    return bundle(id2, moduleGraphs);
+    return bundle(id2, moduleGraphs, minify);
   }));
   const {id, name, namespace, version, specifier} = moduleGraphs.linkedDefinitions[rootModule.specifier];
   return {

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

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+
+// packages/@lwrjs/module-bundler/src/utils/bundle-common.ts
+__markAsModule(exports);
+__export(exports, {
+  overrideBundleConfig: () => overrideBundleConfig
+});
+function overrideBundleConfig(bundleConfig, bundleConfigOverrides) {
+  if (!bundleConfigOverrides) {
+    return bundleConfig;
+  }
+  const newBundleConfig = {
+    UNSAFE_lwrDefaultExclude: [
+      ...bundleConfigOverrides.UNSAFE_lwrDefaultExclude || [
+        ...bundleConfig.UNSAFE_lwrDefaultExclude || []
+      ]
+    ],
+    external: {...bundleConfigOverrides.external || {...bundleConfig.external || {}}},
+    alias: {...bundleConfigOverrides.alias || {...bundleConfig.alias || {}}}
+  };
+  if (bundleConfigOverrides.appendExcludes) {
+    newBundleConfig.exclude = appendAndDedupArrays(bundleConfig.exclude, bundleConfigOverrides.exclude);
+  } else {
+    newBundleConfig.exclude = [...bundleConfigOverrides.exclude || [...bundleConfig.exclude || []]];
+  }
+  return newBundleConfig;
+}
+function appendAndDedupArrays(a1, a2) {
+  let ret;
+  if (!a1 && a2) {
+    return a2.filter((item, pos) => a2.indexOf(item) === pos);
+  } else if (!a2 && a1) {
+    return a1.filter((item, pos) => a1.indexOf(item) === pos);
+  } else if (a1 && a2) {
+    const c = a1?.concat(a2);
+    return c.filter((item, pos) => c.indexOf(item) === pos);
+  }
+  return ret;
+}

package/build/cjs/utils/esbuild-utils.cjs

@@ -0,0 +1,73 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __markAsModule = (target) => __defProp(target, "__esModule", {value: true});
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {get: all[name], enumerable: true});
+};
+var __exportStar = (target, module2, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && key !== "default")
+        __defProp(target, key, {get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable});
+  }
+  return target;
+};
+var __toModule = (module2) => {
+  return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
+};
+
+// packages/@lwrjs/module-bundler/src/utils/esbuild-utils.ts
+__markAsModule(exports);
+__export(exports, {
+  minifyJavascript: () => minifyJavascript,
+  parseJavascript: () => parseJavascript
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_esbuild = __toModule(require("esbuild"));
+var import_features = __toModule(require("@lwc/features"));
+var lwcFeatureFlags = "default" in import_features.default ? import_features.default.default : import_features.default;
+var lwcFeatureFlagDefinitions = Object.fromEntries(Object.keys(lwcFeatureFlags).map((feature) => [`lwcRuntimeFlags.${feature}`, "false"]));
+var esbuild = import_esbuild.default;
+if (!import_esbuild.default) {
+  try {
+    esbuild = require("esbuild");
+  } catch {
+  }
+}
+async function minifyJavascript(source) {
+  try {
+    const {code} = await esbuild.transform(source, {
+      loader: "js",
+      minify: true,
+      define: {
+        "process.env.NODE_ENV": JSON.stringify("production"),
+        ...lwcFeatureFlagDefinitions
+      }
+    });
+    return code;
+  } catch (error) {
+    import_shared_utils.logger.debug(error);
+    throw error;
+  }
+}
+async function parseJavascript(source, options) {
+  try {
+    const {code} = await esbuild.transform(source, {
+      loader: "js",
+      minify: false,
+      define: {
+        "process.env.NODE_ENV": JSON.stringify(options.envMode),
+        ...lwcFeatureFlagDefinitions
+      }
+    });
+    return code;
+  } catch (error) {
+    import_shared_utils.logger.debug(error);
+    throw error;
+  }
+}

package/build/cjs/{amd → utils}/rollup-amd-bundler-plugin.cjs

@@ -5,7 +5,7 @@ var __export = (target, all) => {
     __defProp(target, name, {get: all[name], enumerable: true});
 };
 
-// packages/@lwrjs/module-bundler/src/amd/rollup-amd-bundler-plugin.ts
+// packages/@lwrjs/module-bundler/src/utils/rollup-amd-bundler-plugin.ts
 __markAsModule(exports);
 __export(exports, {
   bundleDefinitions: () => bundleDefinitions

package/build/cjs/{esm → utils}/rollup-esm-bundler-plugin.cjs

@@ -21,7 +21,7 @@ var __toModule = (module2) => {
   return __exportStar(__markAsModule(__defProp(module2 != null ? __create(__getProtoOf(module2)) : {}, "default", module2 && module2.__esModule && "default" in module2 ? {get: () => module2.default, enumerable: true} : {value: module2, enumerable: true})), module2);
 };
 
-// packages/@lwrjs/module-bundler/src/esm/rollup-esm-bundler-plugin.ts
+// packages/@lwrjs/module-bundler/src/utils/rollup-esm-bundler-plugin.ts
 __markAsModule(exports);
 __export(exports, {
   bundleDefinitions: () => bundleDefinitions

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

@@ -0,0 +1,9 @@
+import { AbstractModuleId, BundleConfigOverrides, BundleDefinition, BundleProvider, ProviderAppConfig, ProviderContext, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+export default class AmdBundlerProvider implements BundleProvider {
+    name: string;
+    config: ProviderAppConfig;
+    moduleRegistry: PublicModuleRegistry;
+    constructor(options: {}, { config, moduleRegistry }: ProviderContext);
+    bundle<T extends AbstractModuleId, R extends RuntimeEnvironment>(moduleId: T, runtimeEnvironment: R, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfigOverrides): Promise<BundleDefinition | undefined>;
+}
+//# sourceMappingURL=amd-bundle-provider.d.ts.map

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

@@ -0,0 +1,27 @@
+import { amdBundler } from './utils/amd-common.js';
+import { minifyJavascript, parseJavascript } from './utils/esbuild-utils.js';
+export default class AmdBundlerProvider {
+    constructor(options, { config, moduleRegistry }) {
+        this.name = 'amd-bundle-provider';
+        this.config = config;
+        this.moduleRegistry = moduleRegistry;
+    }
+    async bundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
+        if (runtimeEnvironment.format === 'amd') {
+            const { moduleRegistry, config } = this;
+            const bundle = await amdBundler(moduleId, moduleRegistry, false, // we NEVER want to minify via rollup/terser with this bundler; it's too slow
+            runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
+            // Minification via esbuild for performance
+            const { minify, debug, env: { NODE_ENV: envMode } = { NODE_ENV: 'production' }, } = runtimeEnvironment;
+            const minified = !!minify && !debug;
+            if (minified) {
+                bundle.code = await minifyJavascript(bundle.code);
+            }
+            else {
+                bundle.code = await parseJavascript(bundle.code, { envMode });
+            }
+            return bundle;
+        }
+    }
+}
+//# sourceMappingURL=amd-bundle-provider.js.map

package/build/es/amd-runtime-bundle-provider.d.ts

@@ -0,0 +1,9 @@
+import { AbstractModuleId, BundleConfigOverrides, BundleDefinition, BundleProvider, ProviderAppConfig, ProviderContext, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+export default class AmdBundlerProvider implements BundleProvider {
+    name: string;
+    config: ProviderAppConfig;
+    moduleRegistry: PublicModuleRegistry;
+    constructor(options: {}, { config, moduleRegistry }: ProviderContext);
+    bundle<T extends AbstractModuleId, R extends RuntimeEnvironment>(moduleId: T, runtimeEnvironment: R, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfigOverrides): Promise<BundleDefinition | undefined>;
+}
+//# sourceMappingURL=amd-runtime-bundle-provider.d.ts.map

package/build/es/amd-runtime-bundle-provider.js

@@ -0,0 +1,18 @@
+import { amdBundler } from './utils/amd-common.js';
+export default class AmdBundlerProvider {
+    constructor(options, { config, moduleRegistry }) {
+        this.name = 'amd-runtime-bundle-provider';
+        this.config = config;
+        this.moduleRegistry = moduleRegistry;
+    }
+    async bundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
+        if (runtimeEnvironment.format === 'amd') {
+            const { moduleRegistry, config } = this;
+            const { minify, debug } = runtimeEnvironment;
+            const minified = minify && !debug;
+            return await amdBundler(moduleId, moduleRegistry, minified, // will minify using rollup/terser if true - MRT runtime friendly
+            runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
+        }
+    }
+}
+//# sourceMappingURL=amd-runtime-bundle-provider.js.map

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

@@ -0,0 +1,9 @@
+import type { AbstractModuleId, BundleConfigOverrides, BundleDefinition, BundleProvider, ProviderAppConfig, ProviderContext, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+export default class EsmBundlerProvider implements BundleProvider {
+    name: string;
+    config: ProviderAppConfig;
+    moduleRegistry: PublicModuleRegistry;
+    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/esm-bundler.js → esm-bundle-provider.js}

@@ -1,7 +1,22 @@
 import { rollup } from 'rollup';
-import { bundleDefinitions } from './rollup-esm-bundler-plugin.js';
-export async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, lwrConfig, bundleConfigOverride) {
-    const { exclude, external = {}, alias = {} } = bundleConfigOverride ?? lwrConfig.bundleConfig;
+import { bundleDefinitions } from './utils/rollup-esm-bundler-plugin.js';
+import { minifyJavascript } from './utils/esbuild-utils.js';
+import { overrideBundleConfig } from './utils/bundle-common.js';
+export default class EsmBundlerProvider {
+    constructor(options, { config, moduleRegistry }) {
+        this.name = 'esm-bundle-provider';
+        this.config = config;
+        this.moduleRegistry = moduleRegistry;
+    }
+    async bundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
+        if (runtimeEnvironment.format === 'esm') {
+            const { moduleRegistry, config } = this;
+            return await esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, config, bundleConfigOverrides);
+        }
+    }
+}
+async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, { bundleConfig }, bundleConfigOverrides) {
+    const { exclude, external = {}, alias = {} } = overrideBundleConfig(bundleConfig, bundleConfigOverrides);
     const { sourceMapUrl } = runtimeEnvironment;
     const requiredImports = new Map();
     const dynamicImports = new Map();
@@ -32,8 +47,13 @@ export async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, r
     });
     const bundleCode = result.output[0].code;
     const bundleMap = result.output[0].map;
-    const code = sourceMapUrl ? `${bundleCode}\n//# sourceMappingURL=${sourceMapUrl}` : bundleCode;
+    let code = sourceMapUrl ? `${bundleCode}\n//# sourceMappingURL=${sourceMapUrl}` : bundleCode;
     const { id, specifier, namespace, name, version } = rootModuleDef;
+    const { minify, debug } = runtimeEnvironment;
+    const minified = !!minify && !debug;
+    if (minified) {
+        code = await minifyJavascript(code);
+    }
     return {
         id,
         specifier,
@@ -50,4 +70,4 @@ export async function esmBundler(moduleId, moduleRegistry, runtimeEnvironment, r
         },
     };
 }
-//# sourceMappingURL=esm-bundler.js.map
+//# sourceMappingURL=esm-bundle-provider.js.map

package/build/es/index.d.ts

@@ -1,18 +1,28 @@
-import { AbstractModuleId, BundleConfig, BundleDefinition, LwrAppObserver, ModuleBundler, ModuleRegistry, NormalizedLwrGlobalConfig, RuntimeParams, SourceMapRuntimeEnvironment, Compiler } from '@lwrjs/types';
+import { AbstractModuleId, BundleConfig, BundleConfigOverrides, BundleDefinition, BundleProvider, LwrAppObserver, ModuleBundler, ModuleId, ModuleRegistry, NormalizedLwrGlobalConfig, PublicModuleBundler, RuntimeEnvironment, RuntimeParams, SourceMapRuntimeEnvironment } from '@lwrjs/types';
 interface LwrModuleBundlerConfig {
-    compiler: Compiler;
     moduleRegistry: ModuleRegistry;
     appObserver?: LwrAppObserver;
 }
 export declare class LwrModuleBundler implements ModuleBundler {
-    compiler: Compiler;
     moduleRegistry: ModuleRegistry;
     appObserver: LwrAppObserver | undefined;
-    config: NormalizedLwrGlobalConfig;
     cache: Map<string, BundleDefinition>;
+    providers: BundleProvider[];
+    bundleConfig: BundleConfig;
     private inflightBundleDefinitions;
     constructor(config: LwrModuleBundlerConfig, globalConfig: NormalizedLwrGlobalConfig);
-    getModuleBundle<T extends AbstractModuleId>(moduleId: T, runtimeEnvironment: SourceMapRuntimeEnvironment, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfig): Promise<BundleDefinition>;
+    addBundleProviders(providers: BundleProvider[]): void;
+    getModuleBundle<T extends AbstractModuleId>(moduleId: T, runtimeEnvironment: SourceMapRuntimeEnvironment, runtimeParams?: RuntimeParams, bundleConfigOverrides?: BundleConfigOverrides): Promise<BundleDefinition>;
+    /**
+     * Resolve the URI to the bundle rooted at the `moduleId`
+     * @param moduleId - The id of the root module for the bundle
+     * @param runtimeEnvironment  - The runtime operating environnment
+     * @param runtimeParams  - The available runtime parameters provided in context to the request
+     * @param signature - The signature of the bundle instance being referenced
+     * @returns the URI
+     */
+    resolveModuleUri(moduleId: Required<Pick<ModuleId, 'specifier' | 'version'>>, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams, signature?: string): Promise<string>;
+    getPublicApi(): PublicModuleBundler;
 }
 export {};
 //# sourceMappingURL=index.d.ts.map

package/build/es/index.js

@@ -1,26 +1,28 @@
+import { LwrUnresolvableError, createSingleDiagnosticError, descriptions } from '@lwrjs/diagnostics';
 import { getCacheKeyFromJson, InflightTasks, TaskPool } from '@lwrjs/shared-utils';
-import { amdBundler } from './amd/amd-bundler.js';
-import { esmBundler } from './esm/esm-bundler.js';
 const TASK_POOL = new TaskPool();
 export class LwrModuleBundler {
     constructor(config, globalConfig) {
         this.cache = new Map();
+        this.providers = [];
         // Pending bundle definitions are tracked to prevent concurrent resolution of the same bundle.
         // Subsequent requests for the same bundle will await the original promise.
         // Cache entries will be removed once the bundle is resolved.
         this.inflightBundleDefinitions = new InflightTasks();
-        this.config = globalConfig;
         this.moduleRegistry = config.moduleRegistry;
         this.appObserver = config.appObserver;
-        this.compiler = config.compiler;
+        // Freeze the bundle config to make sure it is not modified
+        this.bundleConfig = Object.freeze(globalConfig.bundleConfig);
         this.appObserver?.onModuleDefinitionChange(() => {
             // TODO: This is a very naive approach however
             // this would only happen in non-prod environments
             this.cache.clear();
         });
     }
+    addBundleProviders(providers) {
+        this.providers.push(...providers);
+    }
     async getModuleBundle(moduleId, runtimeEnvironment, runtimeParams = {}, bundleConfigOverrides) {
-        const { moduleRegistry } = this;
         const { format, minify, debug } = runtimeEnvironment;
         const cacheKey = `${moduleId.specifier}|${moduleId.version}|${getCacheKeyFromJson({
             locale: runtimeParams.locale,
@@ -44,21 +46,59 @@ export class LwrModuleBundler {
             // console.log('[INFO] Create Bundle: ', cacheKey);
             // Run theses tasks in a task pool to throttle parallel requests.
             return TASK_POOL.execute(async () => {
-                const pendingBundleDef = format === 'amd'
-                    ? amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config, bundleConfigOverrides)
-                    : esmBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams, this.config, bundleConfigOverrides);
-                return pendingBundleDef.then(async (bundleDef) => {
-                    const minified = !!minify && !debug;
-                    if (minified) {
-                        bundleDef.code = (await this.compiler.minifyJavascript(bundleDef.code)).code;
-                    }
-                    if (!cacheDisabled) {
-                        this.cache.set(cacheKey, bundleDef);
+                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);
         });
     }
+    /**
+     * Resolve the URI to the bundle rooted at the `moduleId`
+     * @param moduleId - The id of the root module for the bundle
+     * @param runtimeEnvironment  - The runtime operating environnment
+     * @param runtimeParams  - The available runtime parameters provided in context to the request
+     * @param signature - The signature of the bundle instance being referenced
+     * @returns the URI
+     */
+    async resolveModuleUri(moduleId, runtimeEnvironment, runtimeParams, signature) {
+        // First get the bundle definition to see if a src attribute is set.
+        const bundleDefinition = await this.getModuleBundle(moduleId, runtimeEnvironment, runtimeParams);
+        if (!bundleDefinition) {
+            throw createSingleDiagnosticError({
+                description: descriptions.UNRESOLVABLE.BUNDLE(moduleId.specifier),
+            }, LwrUnresolvableError);
+        }
+        let uri;
+        if (bundleDefinition.src) {
+            // If source is provided on the bundle definition use that
+            uri = bundleDefinition.src;
+        }
+        else {
+            let resolvedVersion = moduleId.version || bundleDefinition.version;
+            // If we do not know the verison, look it up.
+            if (!resolvedVersion) {
+                const { version } = await this.moduleRegistry.getModuleEntry(moduleId);
+                resolvedVersion = version;
+            }
+            uri = String(await this.moduleRegistry.resolveModuleUri({ ...moduleId, version: resolvedVersion }, runtimeEnvironment, runtimeParams, signature));
+        }
+        return uri;
+    }
+    getPublicApi() {
+        return {
+            getModuleBundle: this.getModuleBundle.bind(this),
+            resolveModuleUri: this.resolveModuleUri.bind(this),
+        };
+    }
 }
 //# sourceMappingURL=index.js.map

package/build/es/utils/amd-common.d.ts

@@ -0,0 +1,3 @@
+import type { AbstractModuleId, BundleConfigOverrides, BundleDefinition, ModuleRegistry, ProviderAppConfig, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+export declare function amdBundler(moduleId: AbstractModuleId, moduleRegistry: ModuleRegistry, minify: boolean | undefined, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams | undefined, { bundleConfig }: ProviderAppConfig, bundleConfigOverrides?: BundleConfigOverrides): Promise<BundleDefinition>;
+//# sourceMappingURL=amd-common.d.ts.map

package/build/es/{amd/amd-bundler.js → utils/amd-common.js}

@@ -1,16 +1,20 @@
-import { AMD_DEFINE } from '@lwrjs/compiler';
 import { GraphDepth, getModuleGraphs, getSpecifier } from '@lwrjs/shared-utils';
 import { rollup } from 'rollup';
+import replace from '@rollup/plugin-replace';
+// import { terser } from 'rollup-plugin-terser';
 import { bundleDefinitions } from './rollup-amd-bundler-plugin.js';
-async function bundle(id, moduleGraphs) {
-    const bundler = await rollup({
-        input: id,
-        plugins: [
-            bundleDefinitions({
-                moduleGraphs,
-            }),
-        ],
-    });
+import { overrideBundleConfig } from './bundle-common.js';
+const AMD_DEFINE = 'LWR.define';
+async function bundle(id, moduleGraphs, minify = false) {
+    const plugins = [bundleDefinitions({ moduleGraphs })];
+    minify &&
+        plugins.push(
+        // terser(), // Do not minify until needed for client modules. Server/SSR modules do not need to be minifed.
+        replace({
+            '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',
@@ -18,8 +22,9 @@ async function bundle(id, moduleGraphs) {
     });
     return output[0].code;
 }
-export async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, runtimeParams = {}, { bundleConfig, amdLoader }, bundleConfigOverride) {
-    const { exclude, external } = bundleConfigOverride ?? bundleConfig;
+export async function amdBundler(moduleId, moduleRegistry, minify = false, runtimeEnvironment, runtimeParams = {}, { bundleConfig }, bundleConfigOverrides) {
+    const { exclude, external = {} } = overrideBundleConfig(bundleConfig, bundleConfigOverrides);
+    const externalsArray = Object.keys(external);
     const requiredImports = new Map();
     const dynamicImports = new Map();
     const includedModules = [];
@@ -29,9 +34,16 @@ export async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, r
             static: GraphDepth.ALL,
             dynamic: 0,
             includeId: (moduleRef) => {
-                // loader should be auto bundled with shim already
-                if (exclude?.includes(moduleRef.specifier) || moduleRef.specifier === amdLoader) {
-                    requiredImports.set(`${moduleId.specifier}_${moduleId.version}`, moduleRef);
+                // Do not bundle externals, including the loader module, which is auto bundled
+                // with the shim + loader combo
+                if (externalsArray.includes(moduleRef.specifier)) {
+                    // Do not include externals in the required imports but also return false to indicate it should not be in the bundle
+                    return false;
+                }
+                else if (exclude?.includes(moduleRef.specifier)) {
+                    // If this is a bundle exclude return false to indicate it should not be in the bundle
+                    // but add it to the requriedImports so it shows up as a static dependency of the bundle.
+                    requiredImports.set(`${moduleRef.specifier}_${moduleRef.version}`, moduleRef);
                     return false;
                 }
                 return true;
@@ -68,7 +80,7 @@ export async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, r
             includedModules.push(id);
         }
         // bundle all dependencies for the linked definition and convert to AMD
-        return bundle(id, moduleGraphs);
+        return bundle(id, moduleGraphs, minify);
     }));
     const { id, name, namespace, version, specifier } = moduleGraphs.linkedDefinitions[rootModule.specifier];
     return {
@@ -86,4 +98,4 @@ export async function amdBundler(moduleId, moduleRegistry, runtimeEnvironment, r
         },
     };
 }
-//# sourceMappingURL=amd-bundler.js.map
+//# sourceMappingURL=amd-common.js.map

package/build/es/utils/bundle-common.d.ts

@@ -0,0 +1,3 @@
+import type { BundleConfig, BundleConfigOverrides } from '@lwrjs/types';
+export declare function overrideBundleConfig(bundleConfig: BundleConfig, bundleConfigOverrides?: BundleConfigOverrides): BundleConfig;
+//# sourceMappingURL=bundle-common.d.ts.map

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

@@ -0,0 +1,39 @@
+export function overrideBundleConfig(bundleConfig, bundleConfigOverrides) {
+    if (!bundleConfigOverrides) {
+        return bundleConfig;
+    }
+    // Replace properties that are overridden
+    const newBundleConfig = {
+        UNSAFE_lwrDefaultExclude: [
+            ...(bundleConfigOverrides.UNSAFE_lwrDefaultExclude || [
+                ...(bundleConfig.UNSAFE_lwrDefaultExclude || []),
+            ]),
+        ],
+        external: { ...(bundleConfigOverrides.external || { ...(bundleConfig.external || {}) }) },
+        alias: { ...(bundleConfigOverrides.alias || { ...(bundleConfig.alias || {}) }) },
+    };
+    // Append Excludes
+    if (bundleConfigOverrides.appendExcludes) {
+        newBundleConfig.exclude = appendAndDedupArrays(bundleConfig.exclude, bundleConfigOverrides.exclude);
+        // or Replace Excludes
+    }
+    else {
+        newBundleConfig.exclude = [...(bundleConfigOverrides.exclude || [...(bundleConfig.exclude || [])])];
+    }
+    return newBundleConfig;
+}
+function appendAndDedupArrays(a1, a2) {
+    let ret;
+    if (!a1 && a2) {
+        return a2.filter((item, pos) => a2.indexOf(item) === pos);
+    }
+    else if (!a2 && a1) {
+        return a1.filter((item, pos) => a1.indexOf(item) === pos);
+    }
+    else if (a1 && a2) {
+        const c = a1?.concat(a2);
+        return c.filter((item, pos) => c.indexOf(item) === pos);
+    }
+    return ret;
+}
+//# sourceMappingURL=bundle-common.js.map

package/build/es/utils/esbuild-utils.d.ts

@@ -0,0 +1,14 @@
+interface ParseOptions {
+    envMode: string;
+}
+/**
+ * Minification via esbuild.
+ * When importing this module make sure the optional library 'esbuild' is installed.
+ */
+export declare function minifyJavascript(source: string): Promise<string>;
+/**
+ * Parse source to remove process.env.NODE_ENV without minify
+ */
+export declare function parseJavascript(source: string, options: ParseOptions): Promise<string>;
+export {};
+//# sourceMappingURL=esbuild-utils.d.ts.map

package/build/es/utils/esbuild-utils.js

@@ -0,0 +1,63 @@
+import { logger } from '@lwrjs/shared-utils';
+import esbuildEsm from 'esbuild';
+import features from '@lwc/features';
+// In certain envs, this default import is not compiled correctly
+const lwcFeatureFlags = 'default' in features ? features.default : features;
+// Set every LWC feature flag to false, so that the unused code can be tree-shaken
+const lwcFeatureFlagDefinitions = Object.fromEntries(Object.keys(lwcFeatureFlags).map((feature) => [`lwcRuntimeFlags.${feature}`, 'false']));
+// https://github.com/evanw/esbuild/issues/706
+// Fixed in 0.11.0 but upgrading past 0.9.7 has caused breaking changes for consumers...
+// https://github.com/salesforce-experience-platform-emu/lwr/issues/1014
+let esbuild = esbuildEsm;
+if (!esbuildEsm) {
+    try {
+        esbuild = require('esbuild');
+    }
+    catch {
+        /* this is to support mjs/cjs dual impl */
+    }
+}
+/**
+ * Minification via esbuild.
+ * When importing this module make sure the optional library 'esbuild' is installed.
+ */
+export async function minifyJavascript(source) {
+    try {
+        const { code } = await esbuild.transform(source, {
+            loader: 'js',
+            minify: true,
+            // Remove assertions by tree shaking the computed expression
+            define: {
+                'process.env.NODE_ENV': JSON.stringify('production'),
+                ...lwcFeatureFlagDefinitions,
+            },
+        });
+        return code;
+    }
+    catch (error) {
+        logger.debug(error);
+        throw error;
+    }
+}
+/**
+ * Parse source to remove process.env.NODE_ENV without minify
+ */
+export async function parseJavascript(source, options) {
+    try {
+        const { code } = await esbuild.transform(source, {
+            loader: 'js',
+            minify: false,
+            // Remove assertions by tree shaking the computed expression
+            define: {
+                'process.env.NODE_ENV': JSON.stringify(options.envMode),
+                ...lwcFeatureFlagDefinitions,
+            },
+        });
+        return code;
+    }
+    catch (error) {
+        logger.debug(error);
+        throw error;
+    }
+}
+//# sourceMappingURL=esbuild-utils.js.map

package/package.json

@@ -4,15 +4,15 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.9.0-alpha.8",
+    "version": "0.9.0",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
-        "url": "https://github.com/salesforce/lwr.git",
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr.git",
         "directory": "packages/@lwrjs/module-registry"
     },
     "bugs": {
-        "url": "https://github.com/salesforce/lwr/issues"
+        "url": "https://github.com/salesforce-experience-platform-emu/lwr/issues"
     },
     "type": "module",
     "types": "build/es/index.d.ts",
@@ -22,23 +22,42 @@
         ".": {
             "import": "./build/es/index.js",
             "require": "./build/cjs/index.cjs"
+        },
+        "./amd-bundle-provider": {
+            "import": "./build/es/amd-bundle-provider.js",
+            "require": "./build/cjs/amd-bundle-provider.cjs"
+        },
+        "./amd-runtime-bundle-provider": {
+            "import": "./build/es/amd-runtime-bundle-provider.js",
+            "require": "./build/cjs/amd-runtime-bundle-provider.cjs"
+        },
+        "./esm-bundle-provider": {
+            "import": "./build/es/esm-bundle-provider.js",
+            "require": "./build/cjs/esm-bundle-provider.cjs"
         }
     },
+    "scripts": {
+        "build": "tsc -b"
+    },
     "files": [
         "build/**/*.js",
         "build/**/*.cjs",
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/compiler": "0.9.0-alpha.8",
-        "@lwrjs/shared-utils": "0.9.0-alpha.8",
+        "@lwc/features": "2.38.1",
+        "@lwrjs/shared-utils": "0.9.0",
+        "@rollup/plugin-replace": "^2.4.2",
         "rollup": "~2.45.2"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.9.0-alpha.8"
+        "@lwrjs/types": "0.9.0"
+    },
+    "optionalDependencies": {
+        "esbuild": "^0.9.7"
     },
     "engines": {
-        "node": ">=14.15.4 <19"
+        "node": ">=16.0.0 <20"
     },
-    "gitHead": "013fcee240ff2e1c23ef304e70fc39d6ef13fb8b"
+    "gitHead": "4e42b0dc5453f92b36b42aa8132c5bc281e616b7"
 }

package/build/es/amd/amd-bundler.d.ts

@@ -1,3 +0,0 @@
-import { AbstractModuleId, BundleConfig, BundleDefinition, ModuleRegistry, NormalizedLwrGlobalConfig, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
-export declare function amdBundler(moduleId: AbstractModuleId, moduleRegistry: ModuleRegistry, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams | undefined, { bundleConfig, amdLoader }: NormalizedLwrGlobalConfig, bundleConfigOverride?: BundleConfig): Promise<BundleDefinition>;
-//# sourceMappingURL=amd-bundler.d.ts.map

package/build/es/esm/esm-bundler.d.ts

@@ -1,3 +0,0 @@
-import { AbstractModuleId, ModuleRegistry, BundleDefinition, RuntimeParams, SourceMapRuntimeEnvironment, BundleConfig, NormalizedLwrGlobalConfig } from '@lwrjs/types';
-export declare function esmBundler(moduleId: AbstractModuleId, moduleRegistry: ModuleRegistry, runtimeEnvironment: SourceMapRuntimeEnvironment, runtimeParams: RuntimeParams | undefined, lwrConfig: NormalizedLwrGlobalConfig, bundleConfigOverride?: BundleConfig): Promise<BundleDefinition>;
-//# sourceMappingURL=esm-bundler.d.ts.map