@lwrjs/module-registry 0.12.0-alpha.20 → 0.12.0-alpha.22

package/build/cjs/externals-module-provider.cjs

@@ -0,0 +1,79 @@
+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-registry/src/externals-module-provider.ts
+__markAsModule(exports);
+__export(exports, {
+  default: () => externals_module_provider_default
+});
+var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
+var import_fs_extra = __toModule(require("fs-extra"));
+var import_url = __toModule(require("url"));
+var ExternalsModuleProvider = class {
+  constructor(_config, context) {
+    this.name = "externals-module-provider";
+    this.externals = context?.config.bundleConfig?.external || {};
+  }
+  async getModuleEntry(moduleId) {
+    const {specifier, version} = moduleId;
+    if (specifier && Object.prototype.hasOwnProperty.call(this.externals, specifier)) {
+      const entry = this.externals[specifier];
+      const resolvedVersion = version || import_shared_utils.VERSION_NOT_PROVIDED;
+      return {
+        virtual: true,
+        id: (0, import_shared_utils.getSpecifier)({...moduleId, version: resolvedVersion}),
+        entry,
+        specifier,
+        version: resolvedVersion
+      };
+    }
+    return void 0;
+  }
+  async getModule(moduleId) {
+    const moduleEntry = await this.getModuleEntry(moduleId);
+    if (moduleEntry) {
+      let originalSource = "";
+      let ownHash = "";
+      const srcUri = this.externals[moduleEntry.specifier];
+      if (srcUri && srcUri.startsWith(import_shared_utils.PROTOCOL_FILE)) {
+        const srcPath = import_url.default.fileURLToPath(srcUri);
+        originalSource = (await import_fs_extra.default.readFile(srcPath)).toString();
+        ownHash = (0, import_shared_utils.hashContent)(originalSource);
+      }
+      const {name, namespace} = (0, import_shared_utils.explodeSpecifier)(moduleEntry.specifier);
+      return {
+        id: moduleEntry.id,
+        moduleEntry,
+        specifier: moduleEntry.specifier,
+        name,
+        namespace,
+        version: moduleEntry.version,
+        compiledSource: originalSource,
+        ownHash,
+        originalSource
+      };
+    }
+    return void 0;
+  }
+};
+var externals_module_provider_default = ExternalsModuleProvider;

package/build/cjs/index.cjs

@@ -101,6 +101,11 @@ var LwrModuleRegistry = class {
   addModuleProviders(registries) {
     this.providers.push(...registries);
   }
+  getConfig() {
+    return {
+      bundleConfig: this.globalConfig.bundleConfig || {}
+    };
+  }
   getModuleEntry(moduleId, runtimeParams) {
     return this.delegateGetModuleEntryOnServices(moduleId, runtimeParams);
   }
@@ -152,7 +157,7 @@ var LwrModuleRegistry = class {
     }
     const moduleDef = await this.getModule(moduleId, runtimeParams);
     const moduleLinked = await this.createLinkedModuleDefinition(moduleDef, runtimeEnvironment, runtimeParams);
-    if (format === "amd" && !bundle) {
+    if (format === "amd" && !bundle && !(0, import_shared_utils.isExternalSpecifier)(moduleLinked.specifier, this.getConfig().bundleConfig)) {
       moduleLinked.linkedSource = (await (0, import_compiler.convertToAmd)(moduleLinked.linkedSource, {
         id: moduleLinked.id
       })).code;
@@ -209,7 +214,7 @@ var LwrModuleRegistry = class {
         linkedModuleRecord
       } = await (0, import_linker.link)(this, moduleDef, import_amd_strategy.default, import_esm_strategy.default, runtimeEnvironment, runtimeParams, loaderModuleEntry && {
         esmLoaderModule: loaderModuleEntry
-      }, this.interchangeableModules, this.globalConfig.bundleConfig?.exclude);
+      }, this.interchangeableModules, this.globalConfig.bundleConfig);
       linkedModuleRecord.dynamicImports = linkedModuleRecord.dynamicImports?.filter((imp) => imp.moduleNameType !== import_shared_utils.ModuleNameType.unresolved);
       return {
         ...moduleDef,
@@ -251,6 +256,7 @@ var LwrModuleRegistry = class {
       getModuleEntry: this.getModuleEntry.bind(this),
       getModule: this.getModule.bind(this),
       getLinkedModule: this.getLinkedModule.bind(this),
+      getConfig: this.getConfig.bind(this),
       resolveModuleUri: this.resolveModuleUri.bind(this)
     };
   }

package/build/cjs/linker/linker.cjs

@@ -29,9 +29,10 @@ __export(exports, {
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var import_shared_utils2 = __toModule(require("@lwrjs/shared-utils"));
 var import_signature = __toModule(require("../signature.cjs"));
-async function link(moduleRegistry, moduleDef, versionStrategy, uriStrategy, runtimeEnvironment, runtimeParams, config, interchangeableModules, exclude) {
+async function link(moduleRegistry, moduleDef, versionStrategy, uriStrategy, runtimeEnvironment, runtimeParams, config, interchangeableModules, bundleConfig) {
   const {specifier, version, compiledSource, moduleRecord} = moduleDef;
   const {imports, dynamicImports, importMeta} = moduleRecord;
+  const {exclude, external} = bundleConfig || {};
   const codeStringBuilder = (0, import_shared_utils.createStringBuilder)(compiledSource);
   const amdLoaderModule = config?.amdLoaderModule;
   const esmLoaderModule = config?.esmLoaderModule;
@@ -64,7 +65,7 @@ async function link(moduleRegistry, moduleDef, versionStrategy, uriStrategy, run
         signature = await (0, import_signature.getBundleSignature)(importRef, moduleRegistry, runtimeParams, exclude);
       }
       const {locations, sourceSpecifier} = importRef;
-      const link2 = strategy(importRef, runtimeEnvironment, runtimeParams, signature);
+      const link2 = strategy(importRef, runtimeEnvironment, runtimeParams, signature, void 0, external);
       const linkedLocations = locations.map((location) => {
         const {startColumn, endColumn} = location;
         codeStringBuilder.overwrite(startColumn, endColumn, link2);

package/build/cjs/linker/strategies/esm-strategy.cjs

@@ -29,9 +29,12 @@ __export(exports, {
 var import_shared_utils = __toModule(require("@lwrjs/shared-utils"));
 var SIGNATURE_SIGIL = "s";
 var LATEST_SIG = "latest";
-function linkEsm(moduleId, environment, params = {}, signature, bundleId) {
+function linkEsm(moduleId, environment, params = {}, signature, bundleId, external) {
   const {bundle, debug} = environment;
   const {specifier, version} = moduleId;
+  if (external && external[specifier]) {
+    return specifier;
+  }
   const uriPrefix = (0, import_shared_utils.getModuleUriPrefix)(environment, params, bundleId);
   const vSpecifier = (0, import_shared_utils.getSpecifier)({specifier, version: (0, import_shared_utils.normalizeVersionToUri)(version)});
   const encodedVSpecifier = encodeURIComponent(vSpecifier);

package/build/cjs/module-record.cjs

@@ -74,6 +74,8 @@ async function getModuleRecord(compiledModule, registry, runtimeParams) {
   const dynamicImports = [];
   const {compiledMetadata: defaultCompilerMetadata, moduleEntry, version} = compiledModule;
   const compiledMetadata = defaultCompilerMetadata || {};
+  const {bundleConfig} = registry.getConfig();
+  const {external: externalsConfig} = bundleConfig || {};
   const {
     imports: compiledModuleImports,
     dynamicImports: compiledModuleDynamicImports,
@@ -127,6 +129,20 @@ async function getModuleRecord(compiledModule, registry, runtimeParams) {
               }
             ]
           });
+        } else if (externalsConfig && externalsConfig[moduleSpecifier] !== void 0) {
+          dynamicImports.push({
+            specifier: moduleSpecifier,
+            sourceSpecifier: moduleSpecifier,
+            version: import_shared_utils.VERSION_NOT_PROVIDED,
+            name: moduleNameType,
+            moduleNameType,
+            locations: [
+              {
+                location,
+                importLocation
+              }
+            ]
+          });
         } else if (moduleSpecifier.startsWith(".")) {
           const {locations, ...resolvedImport} = await resolveRelativeImport(registry, moduleSpecifier, moduleEntry, version, location, runtimeParams);
           dynamicImports.push({

package/build/es/externals-module-provider.d.ts

@@ -0,0 +1,13 @@
+import type { AbstractModuleId, ModuleCompiled, ModuleEntry, ModuleProvider, ProviderContext } from '@lwrjs/types';
+/**
+ * Module provider to create module definitions based on the
+ * externals in the bundle configuration
+ */
+export default class ExternalsModuleProvider implements ModuleProvider {
+    name: string;
+    externals: Record<string, string>;
+    constructor(_config: never, context?: ProviderContext);
+    getModuleEntry(moduleId: AbstractModuleId): Promise<ModuleEntry | undefined>;
+    getModule(moduleId: AbstractModuleId): Promise<ModuleCompiled | undefined>;
+}
+//# sourceMappingURL=externals-module-provider.d.ts.map

package/build/es/externals-module-provider.js

@@ -0,0 +1,58 @@
+import { PROTOCOL_FILE, VERSION_NOT_PROVIDED, explodeSpecifier, getSpecifier, hashContent, } from '@lwrjs/shared-utils';
+import fs from 'fs-extra';
+import url from 'url';
+/**
+ * Module provider to create module definitions based on the
+ * externals in the bundle configuration
+ */
+export default class ExternalsModuleProvider {
+    constructor(_config, context) {
+        this.name = 'externals-module-provider';
+        this.externals = context?.config.bundleConfig?.external || {};
+    }
+    async getModuleEntry(moduleId) {
+        const { specifier, version } = moduleId;
+        // TODO We should upgrade the compiler to ES2022 and use Object.hasOwn()
+        if (specifier && Object.prototype.hasOwnProperty.call(this.externals, specifier)) {
+            const entry = this.externals[specifier];
+            const resolvedVersion = version || VERSION_NOT_PROVIDED;
+            return {
+                virtual: true,
+                id: getSpecifier({ ...moduleId, version: resolvedVersion }),
+                entry,
+                specifier: specifier,
+                version: resolvedVersion,
+            };
+        }
+        // proceed to next provider
+        return undefined;
+    }
+    async getModule(moduleId) {
+        const moduleEntry = await this.getModuleEntry(moduleId);
+        if (moduleEntry) {
+            let originalSource = '';
+            let ownHash = '';
+            const srcUri = this.externals[moduleEntry.specifier];
+            if (srcUri && srcUri.startsWith(PROTOCOL_FILE)) {
+                const srcPath = url.fileURLToPath(srcUri);
+                originalSource = (await fs.readFile(srcPath)).toString();
+                ownHash = hashContent(originalSource);
+            }
+            const { name, namespace } = explodeSpecifier(moduleEntry.specifier);
+            return {
+                id: moduleEntry.id,
+                moduleEntry,
+                specifier: moduleEntry.specifier,
+                name,
+                namespace,
+                version: moduleEntry.version,
+                compiledSource: originalSource,
+                ownHash,
+                originalSource,
+            };
+        }
+        // proceed to next provider
+        return undefined;
+    }
+}
+//# sourceMappingURL=externals-module-provider.js.map

package/build/es/index.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractModuleId, LinkedModuleDefinition, LwrAppEmitter, LwrAppObserver, ModuleDefinition, ModuleEntry, ModuleId, ModuleProvider, ModuleRegistry, NormalizedLwrGlobalConfig, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
+import type { AbstractModuleId, LinkedModuleDefinition, LwrAppEmitter, LwrAppObserver, ModuleDefinition, ModuleEntry, ModuleId, ModuleProvider, ModuleRegistry, ModuleRegistryConfig, NormalizedLwrGlobalConfig, PublicModuleRegistry, RuntimeEnvironment, RuntimeParams } from '@lwrjs/types';
 interface RegistryContext {
     appObserver: LwrAppObserver;
     appEmitter: LwrAppEmitter;
@@ -18,6 +18,7 @@ export declare class LwrModuleRegistry implements ModuleRegistry {
     resolveModuleUriSync<R extends RuntimeEnvironment, S extends string | undefined>(moduleId: Required<Pick<ModuleId, 'specifier' | 'version'>>, signature: S, runtimeEnvironment: R, runtimeParams: RuntimeParams): string;
     resolveModuleUri<R extends RuntimeEnvironment, S extends string | undefined>(moduleId: Required<Pick<ModuleId, 'specifier' | 'version'>>, runtimeEnvironment: R, runtimeParams: RuntimeParams, signature?: S): Promise<string>;
     addModuleProviders(registries: ModuleProvider[]): void;
+    getConfig(): ModuleRegistryConfig;
     getModuleEntry<T extends AbstractModuleId>(moduleId: T, runtimeParams: RuntimeParams): Promise<ModuleEntry>;
     getModule<T extends AbstractModuleId>(moduleId: T, runtimeParams: RuntimeParams): Promise<ModuleDefinition>;
     private createModuleDefinition;

package/build/es/index.js

@@ -1,5 +1,5 @@
 import { LwrUnresolvableError, createSingleDiagnosticError, descriptions, logger } from '@lwrjs/diagnostics';
-import { discoverInterchangeableModules, getCacheKeyFromJson, InflightTasks, LATEST_SIGNATURE, ModuleNameType, getGroupName, } from '@lwrjs/shared-utils';
+import { discoverInterchangeableModules, getCacheKeyFromJson, InflightTasks, LATEST_SIGNATURE, ModuleNameType, getGroupName, isExternalSpecifier, } from '@lwrjs/shared-utils';
 // dependencies @locker/compiler and rollup are in this package.json is to satisfy the shared-utils/compiler optional dependencies
 import { convertToAmd } from '@lwrjs/shared-utils/compiler';
 import { link } from './linker/linker.js';
@@ -90,6 +90,11 @@ export class LwrModuleRegistry {
     addModuleProviders(registries) {
         this.providers.push(...registries);
     }
+    getConfig() {
+        return {
+            bundleConfig: this.globalConfig.bundleConfig || {},
+        };
+    }
     getModuleEntry(moduleId, runtimeParams) {
         return this.delegateGetModuleEntryOnServices(moduleId, runtimeParams);
     }
@@ -143,7 +148,9 @@ export class LwrModuleRegistry {
         const moduleDef = await this.getModule(moduleId, runtimeParams);
         const moduleLinked = await this.createLinkedModuleDefinition(moduleDef, runtimeEnvironment, runtimeParams);
         // the bundler will convert the linked source to AMD when bundling is enabled
-        if (format === 'amd' && !bundle) {
+        if (format === 'amd' &&
+            !bundle &&
+            !isExternalSpecifier(moduleLinked.specifier, this.getConfig().bundleConfig)) {
             // convert the linkedSource to the transport AMD format
             moduleLinked.linkedSource = (await convertToAmd(moduleLinked.linkedSource, {
                 id: moduleLinked.id,
@@ -202,7 +209,7 @@ export class LwrModuleRegistry {
             }
             const { id, code: linkedSource, linkedModuleRecord, } = await link(this, moduleDef, amdLinkingStrategy, esmLinkingStrategy, runtimeEnvironment, runtimeParams, loaderModuleEntry && {
                 esmLoaderModule: loaderModuleEntry,
-            }, this.interchangeableModules, this.globalConfig.bundleConfig?.exclude);
+            }, this.interchangeableModules, this.globalConfig.bundleConfig);
             // Filter out variable dynamic imports
             linkedModuleRecord.dynamicImports = linkedModuleRecord.dynamicImports?.filter((imp) => imp.moduleNameType !== ModuleNameType.unresolved);
             return {
@@ -248,6 +255,7 @@ export class LwrModuleRegistry {
             getModuleEntry: this.getModuleEntry.bind(this),
             getModule: this.getModule.bind(this),
             getLinkedModule: this.getLinkedModule.bind(this),
+            getConfig: this.getConfig.bind(this),
             resolveModuleUri: this.resolveModuleUri.bind(this),
         };
     }

package/build/es/linker/linker.d.ts

@@ -1,10 +1,10 @@
-import type { ModuleRecord, ModuleEntry, ModuleDefinition, RuntimeEnvironment, Specifier, RuntimeParams, InterchangeableModuleMap } from '@lwrjs/types';
+import type { ModuleRecord, ModuleEntry, ModuleDefinition, RuntimeEnvironment, Specifier, RuntimeParams, InterchangeableModuleMap, BundleConfig } from '@lwrjs/types';
 import type { LwrModuleRegistry } from '../index.js';
 export interface LinkingStrategy {
     (moduleId: {
         specifier: Specifier;
         version: string;
-    }, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams, signature?: string): string;
+    }, runtimeEnvironment: RuntimeEnvironment, runtimeParams?: RuntimeParams, signature?: string, bundleId?: string, external?: Record<string, string>): string;
 }
 interface AmdLinkerConfig {
     amdLoaderModule: ModuleEntry;
@@ -24,6 +24,6 @@ export interface ModuleLinkResult {
  * @param moduleRecord
  * @param strategy
  */
-export declare function link(moduleRegistry: LwrModuleRegistry, moduleDef: ModuleDefinition, versionStrategy: LinkingStrategy, uriStrategy: LinkingStrategy, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams, config?: LinkerConfig, interchangeableModules?: InterchangeableModuleMap, exclude?: string[]): Promise<ModuleLinkResult>;
+export declare function link(moduleRegistry: LwrModuleRegistry, moduleDef: ModuleDefinition, versionStrategy: LinkingStrategy, uriStrategy: LinkingStrategy, runtimeEnvironment: RuntimeEnvironment, runtimeParams: RuntimeParams, config?: LinkerConfig, interchangeableModules?: InterchangeableModuleMap, bundleConfig?: BundleConfig): Promise<ModuleLinkResult>;
 export {};
 //# sourceMappingURL=linker.d.ts.map

package/build/es/linker/linker.js

@@ -7,9 +7,10 @@ import { getBundleSignature } from '../signature.js';
  * @param moduleRecord
  * @param strategy
  */
-export async function link(moduleRegistry, moduleDef, versionStrategy, uriStrategy, runtimeEnvironment, runtimeParams, config, interchangeableModules, exclude) {
+export async function link(moduleRegistry, moduleDef, versionStrategy, uriStrategy, runtimeEnvironment, runtimeParams, config, interchangeableModules, bundleConfig) {
     const { specifier, version, compiledSource, moduleRecord } = moduleDef;
     const { imports, dynamicImports, importMeta } = moduleRecord;
+    const { exclude, external } = bundleConfig || {};
     const codeStringBuilder = createStringBuilder(compiledSource);
     const amdLoaderModule = config?.amdLoaderModule;
     const esmLoaderModule = config?.esmLoaderModule;
@@ -40,14 +41,14 @@ export async function link(moduleRegistry, moduleDef, versionStrategy, uriStrate
                 }
             }
             let signature;
-            // get signature for external modules when bundling esm
+            // get signature for excluded modules when bundling esm
             if (runtimeEnvironment.bundle &&
                 runtimeEnvironment.format === 'esm' &&
                 exclude?.includes(importRef.specifier)) {
                 signature = await getBundleSignature(importRef, moduleRegistry, runtimeParams, exclude);
             }
             const { locations, sourceSpecifier } = importRef;
-            const link = strategy(importRef, runtimeEnvironment, runtimeParams, signature);
+            const link = strategy(importRef, runtimeEnvironment, runtimeParams, signature, undefined, external);
             // replace all locations of importee with the link
             const linkedLocations = locations.map((location) => {
                 const { startColumn, endColumn } = location;

package/build/es/linker/strategies/esm-strategy.d.ts

@@ -2,5 +2,5 @@ import type { RuntimeEnvironment, RuntimeParams, Specifier } from '@lwrjs/types'
 export default function linkEsm(moduleId: {
     specifier: Specifier;
     version: string;
-}, environment: RuntimeEnvironment, params?: RuntimeParams, signature?: string, bundleId?: string): string;
+}, environment: RuntimeEnvironment, params?: RuntimeParams, signature?: string, bundleId?: string, external?: Record<string, string>): string;
 //# sourceMappingURL=esm-strategy.d.ts.map

package/build/es/linker/strategies/esm-strategy.js

@@ -1,9 +1,12 @@
 import { getModuleUriPrefix, getSpecifier, normalizeVersionToUri, prettyModuleUriSuffix, } from '@lwrjs/shared-utils';
 const SIGNATURE_SIGIL = 's';
 const LATEST_SIG = 'latest';
-export default function linkEsm(moduleId, environment, params = {}, signature, bundleId) {
+export default function linkEsm(moduleId, environment, params = {}, signature, bundleId, external) {
     const { bundle, debug } = environment;
     const { specifier, version } = moduleId;
+    if (external && external[specifier]) {
+        return specifier;
+    }
     const uriPrefix = getModuleUriPrefix(environment, params, bundleId);
     const vSpecifier = getSpecifier({ specifier, version: normalizeVersionToUri(version) });
     const encodedVSpecifier = encodeURIComponent(vSpecifier);

package/build/es/module-record.js

@@ -1,5 +1,5 @@
 import path from 'path';
-import { explodeSpecifier, getImportMetadata, ModuleNameType } from '@lwrjs/shared-utils';
+import { explodeSpecifier, getImportMetadata, ModuleNameType, VERSION_NOT_PROVIDED, } from '@lwrjs/shared-utils';
 async function resolveRelativeImport(registry, moduleSpecifier, importeeEntry, version, location, runtimeParams) {
     // Resolve any relative parts in the import specifier
     // eg: "c/app#app.html" => "c/app"
@@ -56,6 +56,8 @@ export async function getModuleRecord(compiledModule, registry, runtimeParams) {
     const dynamicImports = [];
     const { compiledMetadata: defaultCompilerMetadata, moduleEntry, version } = compiledModule;
     const compiledMetadata = defaultCompilerMetadata || {};
+    const { bundleConfig } = registry.getConfig();
+    const { external: externalsConfig } = bundleConfig || {};
     // Get imports metadata and merge with rest of compiledModule metadata
     const { imports: compiledModuleImports, dynamicImports: compiledModuleDynamicImports, importMeta, } = await getImportMetadata(compiledModule.compiledSource);
     Object.assign(compiledMetadata, {
@@ -112,6 +114,21 @@ export async function getModuleRecord(compiledModule, registry, runtimeParams) {
                         ],
                     });
                 }
+                else if (externalsConfig && externalsConfig[moduleSpecifier] !== undefined) {
+                    dynamicImports.push({
+                        specifier: moduleSpecifier,
+                        sourceSpecifier: moduleSpecifier,
+                        version: VERSION_NOT_PROVIDED,
+                        name: moduleNameType,
+                        moduleNameType,
+                        locations: [
+                            {
+                                location,
+                                importLocation,
+                            },
+                        ],
+                    });
+                }
                 else if (moduleSpecifier.startsWith('.')) {
                     // eslint-disable-next-line no-await-in-loop
                     const { locations, ...resolvedImport } = await resolveRelativeImport(registry, moduleSpecifier, moduleEntry, version, location, runtimeParams);

package/package.json

@@ -4,7 +4,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "version": "0.12.0-alpha.20",
+    "version": "0.12.0-alpha.22",
     "homepage": "https://developer.salesforce.com/docs/platform/lwr/overview",
     "repository": {
         "type": "git",
@@ -22,6 +22,10 @@
         ".": {
             "import": "./build/es/index.js",
             "require": "./build/cjs/index.cjs"
+        },
+        "./externals-module-provider": {
+            "import": "./build/es/externals-module-provider.js",
+            "require": "./build/cjs/externals-module-provider.cjs"
         }
     },
     "files": [
@@ -30,16 +34,17 @@
         "build/**/*.d.ts"
     ],
     "dependencies": {
-        "@lwrjs/config": "0.12.0-alpha.20",
-        "@lwrjs/diagnostics": "0.12.0-alpha.20",
-        "@lwrjs/shared-utils": "0.12.0-alpha.20",
+        "@lwrjs/config": "0.12.0-alpha.22",
+        "@lwrjs/diagnostics": "0.12.0-alpha.22",
+        "@lwrjs/shared-utils": "0.12.0-alpha.22",
+        "fs-extra": "^11.1.1",
         "rollup": "^2.78.0"
     },
     "devDependencies": {
-        "@lwrjs/types": "0.12.0-alpha.20"
+        "@lwrjs/types": "0.12.0-alpha.22"
     },
     "engines": {
         "node": ">=18.0.0"
     },
-    "gitHead": "ae1793e34eaf4e9b97996d7aea9031908b23a13a"
+    "gitHead": "6eb804007e93e513d4eb60fd321c088bad3c698e"
 }