@lwrjs/everywhere 0.22.12 → 0.23.0

package/build/__generated_site_amd_modules__/1/resource/amd/lwr-loader-shim.bundle.js/v/{0_22_12 → 0_23_0}/lwr-loader-shim.bundle.js

@@ -4,7 +4,7 @@
 * SPDX-License-Identifier: MIT
 * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
 */
-/* LWR Module Loader Shim v0.22.12 */
+/* LWR Module Loader Shim v0.23.0 */
 (function () {
   'use strict';
 
@@ -283,6 +283,7 @@
 
 
 
+
   /* eslint-disable lwr/no-unguarded-apis */
   const hasSetTimeout = typeof setTimeout === 'function';
   const hasConsole = typeof console !== 'undefined';
@@ -309,7 +310,7 @@
           // Parse configuration
           this.global = global;
           this.config = global.LWR ;
-          this.loaderSpecifier = 'lwr/loader/v/0_22_12';
+          this.loaderSpecifier = 'lwr/loader/v/0_23_0';
 
           // Set up error handler
           this.errorHandler = this.config.onError ;
@@ -317,7 +318,7 @@
           // Set up onAppInit handler
           this.initAppHandler = this.config.onInitApp ;
 
-          // Set up the temporary LWR.define function and customInit hook
+          // Set up the temporary LWR.define function
           const tempDefine = this.tempDefine.bind(this);
           global.LWR.define = tempDefine;
           this.bootReady = this.config.autoBoot;
@@ -474,7 +475,7 @@
           const exporter = (exports) => {
               Object.assign(exports, { logOperationStart, logOperationEnd });
           };
-          define('lwr/profiler/v/0_22_12', ['exports'], exporter);
+          define('lwr/profiler/v/0_23_0', ['exports'], exporter);
       }
 
       // Set up the application globals, import map, root custom element...
@@ -483,9 +484,13 @@
               this.config;
 
           const importsObj = imports || {};
-          // Set global LWR.define to loader.define
+
+          // Set global LWR.define to loader.define and expose the public-only importMap.
+          // The wrapper intentionally omits the internal rootSpecifiers parameter so external
+          // callers cannot bypass runtime validation by triggering the bootstrap path.
           this.global.LWR = Object.freeze({
               define: loader.define.bind(loader),
+              importMap: (update) => loader.importMap(update),
               rootComponent,
               rootComponents,
               serverData: serverData || {},
@@ -508,10 +513,7 @@
 
           // Load the import mappings and application bootstrap module
           loader
-              .registerImportMappings({ imports: importsObj, index }, [
-                  bootstrapModule,
-                  rootComponent ,
-              ])
+              .importMap({ imports: importsObj, index }, [bootstrapModule, rootComponent ])
               .then(() => {
                   // eslint-disable-next-line lwr/no-unguarded-apis
                   if (typeof window === 'undefined' || typeof document === 'undefined') {
@@ -574,14 +576,14 @@
   // The loader module is ALWAYS required
   const GLOBAL = globalThis ;
   GLOBAL.LWR.requiredModules = GLOBAL.LWR.requiredModules || [];
-  if (GLOBAL.LWR.requiredModules.indexOf('lwr/loader/v/0_22_12') < 0) {
-      GLOBAL.LWR.requiredModules.push('lwr/loader/v/0_22_12');
+  if (GLOBAL.LWR.requiredModules.indexOf('lwr/loader/v/0_23_0') < 0) {
+      GLOBAL.LWR.requiredModules.push('lwr/loader/v/0_23_0');
   }
   new LoaderShim(GLOBAL);
 
 })();
 
-LWR.define('lwr/loader/v/0_22_12', ['exports'], (function (exports) { 'use strict';
+LWR.define('lwr/loader/v/0_23_0', ['exports'], (function (exports) { 'use strict';
 
     const templateRegex = /\{([0-9]+)\}/g;
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1014,11 +1016,7 @@ LWR.define('lwr/loader/v/0_22_12', ['exports'], (function (exports) { 'use stric
             return this.config.baseUrl || '';
         }
 
-        registerImportMappings(newImportMetadata, rootSpecifiers) {
-            if (!rootSpecifiers || rootSpecifiers.length === 0) {
-                const imports = newImportMetadata ? JSON.stringify(newImportMetadata) : 'undefined';
-                throw new LoaderError(BAD_IMPORT_METADATA, [imports, rootSpecifiers ? '[]' : 'undefined']);
-            }
+        registerImportMappings(newImportMetadata, rootSpecifiers = []) {
             if (!newImportMetadata) {
                 throw new LoaderError(BAD_IMPORT_METADATA, ['undefined', JSON.stringify(rootSpecifiers)]);
             }
@@ -1028,6 +1026,8 @@ LWR.define('lwr/loader/v/0_22_12', ['exports'], (function (exports) { 'use stric
                     JSON.stringify(rootSpecifiers),
                 ]);
             }
+            // An empty rootSpecifiers list is valid for non-bootstrap registrations;
+            // any specifier not in the list receives isRoot: false.
             const index = newImportMetadata.index || {};
             for (const [uri, specifiers] of Object.entries(newImportMetadata.imports)) {
                 specifiers.forEach((specifier) => {
@@ -1050,6 +1050,16 @@ LWR.define('lwr/loader/v/0_22_12', ['exports'], (function (exports) { 'use stric
             }
         }
 
+        /**
+         * Returns the raw URI stored for a specifier, or `undefined` if not yet mapped.
+         * Used by the runtime `importMap()` path to detect cross-call duplicates while
+         * allowing truly idempotent re-registrations (same specifier, same URI) to pass
+         * through silently.
+         */
+        getMappingUri(specifier) {
+            return _optionalChain([this, 'access', _ => _.importURICache, 'access', _2 => _2.get, 'call', _3 => _3(specifier), 'optionalAccess', _4 => _4.uri]);
+        }
+
         // Get URL from the local cache or return undefiend
          getURI(specifier) {
             return this.importURICache && this.importURICache.has(specifier)
@@ -1147,7 +1157,7 @@ LWR.define('lwr/loader/v/0_22_12', ['exports'], (function (exports) { 'use stric
         }
 
          async fetchNewMappings(specifier) {
-            if (!hasSetTimeout || !_optionalChain([this, 'access', _ => _.config, 'optionalAccess', _2 => _2.flags, 'optionalAccess', _3 => _3.batchMappings])) {
+            if (!hasSetTimeout || !_optionalChain([this, 'access', _5 => _5.config, 'optionalAccess', _6 => _6.flags, 'optionalAccess', _7 => _7.batchMappings])) {
                 return this.fetchNewMappingsInner(specifier);
             }
 
@@ -2236,6 +2246,101 @@ LWR.define('lwr/loader/v/0_22_12', ['exports'], (function (exports) { 'use stric
         }
     }
 
+    /**
+     * Ensures the update object key is a safe, loader-supported script URL (not a bare specifier).
+     * Covers dangerous schemes and URL-key shape in one place.
+     */
+    function assertValidImportMapUrlKey(moduleScriptURL) {
+        const lowerUri = moduleScriptURL.toLowerCase();
+
+        if (lowerUri.startsWith('blob:')) {
+            throw new Error(`Cannot map ${moduleScriptURL} to blob: URL`);
+        }
+
+        if (lowerUri.startsWith('data:')) {
+            throw new Error(`Cannot map ${moduleScriptURL} to data: URL`);
+        }
+
+        if (!/^[./]|^https?:/.test(moduleScriptURL)) {
+            throw new Error(
+                `LWR.importMap(): "${moduleScriptURL}" is not a valid URL key. Keys must be URL paths (e.g. "/path/to/module.js"), not module specifiers. Transitive specifier aliasing is not supported by this loader.`,
+            );
+        }
+    }
+
+    /**
+     * Validates an ImportMapUpdate and wraps it as ImportMetadata for the fingerprints loader.
+     *
+     * Does not apply legacy-style protected-specifier blocking; system modules are expected to be
+     * defined at bootstrap, and `importMap` write-once semantics handle redundant runtime entries.
+     *
+     * Duplicate specifiers in the same update are de-duplicated silently (first occurrence wins).
+     * An empty object is a silent no-op (returns null).
+     */
+    function validateAndWrapAsImportMetadata(update) {
+        if (!update || typeof update !== 'object') {
+            throw new Error('LWR.importMap() requires an object argument');
+        }
+
+        const entries = Object.entries(update);
+        if (entries.length === 0) {
+            return null;
+        }
+
+        const seenSpecifiers = new Set();
+        const validatedImports = {};
+
+        for (const [moduleScriptURL, moduleNames] of entries) {
+            if (!moduleScriptURL || typeof moduleScriptURL !== 'string') {
+                throw new Error('moduleScriptURL must be a string');
+            }
+
+            if (!Array.isArray(moduleNames)) {
+                throw new Error('moduleNames must be an array');
+            }
+
+            assertValidImportMapUrlKey(moduleScriptURL);
+
+            const validatedNames = [];
+            for (const moduleName of moduleNames) {
+                if (typeof moduleName !== 'string' || moduleName.length === 0) {
+                    throw new Error('Specifier must be a non-empty string');
+                }
+
+                if (!seenSpecifiers.has(moduleName)) {
+                    seenSpecifiers.add(moduleName);
+                    validatedNames.push(moduleName);
+                }
+            }
+
+            if (validatedNames.length > 0) {
+                validatedImports[moduleScriptURL] = validatedNames;
+            }
+        }
+
+        if (Object.keys(validatedImports).length === 0) {
+            return null;
+        }
+
+        return { imports: validatedImports };
+    }
+
+    /**
+     * Returns true when `update` carries the `ImportMetadata` shape (an `imports` object key),
+     * signalling that it should be passed through to the resolver directly rather than treated
+     * as a public-API `ImportMapUpdate`.
+     */
+    function isImportMetadata(update) {
+        const candidate = update ;
+        return (
+            candidate !== null &&
+            typeof candidate === 'object' &&
+            'imports' in candidate &&
+            typeof candidate.imports === 'object' &&
+            !Array.isArray(candidate.imports)
+        );
+    }
+
     /**
      * The LWR loader is inspired and borrows from the algorithms and native browser principles of https://github.com/systemjs/systemjs
      */
@@ -2369,8 +2474,75 @@ LWR.define('lwr/loader/v/0_22_12', ['exports'], (function (exports) { 'use stric
             return this.registry.resolve(id, importer);
         }
 
+        /**
+         * Apply import map updates at runtime, or register bootstrap import mappings.
+         *
+         * **Runtime usage** (public API, consistent with `LWR.importMap()` on the legacy loader):
+         *   `importMap({ [moduleScriptURL]: [moduleName1, moduleName2, ...] })`
+         *   Validates the update and registers the new mappings dynamically.
+         *
+         * **Bootstrap / internal usage** (replaces `registerImportMappings`):
+         *   `importMap(importMetadata)` or `importMap(importMetadata, rootSpecifiers)`
+         *   Detected at runtime by the `ImportMetadata` shape (presence of an `imports` object).
+         *   This branch **does not** run `validateAndWrapAsImportMetadata` (URL-key checks /
+         *   runtime-payload dedupe). That is intentional: bootstrap must preserve
+         *   `index` fingerprints and use `ImportMetadataResolver.registerImportMappings` merge
+         *   semantics unchanged from the pre-`importMap` API.
+         *
+         *   **Who may use this branch:** Platform/shim code with trusted config (see
+         *   `shim/shim.ts`, which calls `loader.importMap({ imports, index }, roots)`). The
+         *   public `LWR.importMap` wrapper only forwards the flat runtime update shape; any
+         *   code with a direct `Loader` reference could still pass an `ImportMetadata`-shaped
+         *   object — same trust boundary as calling `registerImportMappings` before.
+         *
+         * @param update - Runtime: `ImportMapUpdate` mapping script URLs to the module names they define.
+         *                 Bootstrap: `ImportMetadata` with an `imports` object (and optional `index`).
+         * @param rootSpecifiers - Bootstrap only: root module specifiers for the initial registration.
+         *                         Optional — omit when the root specifiers are not known.
+         */
+        async importMap(update, rootSpecifiers) {
+            if (isImportMetadata(update)) {
+                this.registry.getImportMetadataResolver().registerImportMappings(update, rootSpecifiers);
+                return;
+            }
+            const resolver = this.registry.getImportMetadataResolver();
+            const importMetadata = validateAndWrapAsImportMetadata(update );
+            if (!importMetadata) {
+                return;
+            }
+
+            const dedupedImports = {};
+            for (const [uri, specifiers] of Object.entries(importMetadata.imports)) {
+                const newSpecifiers = [];
+                for (const specifier of specifiers) {
+                    const existingUri = resolver.getMappingUri(specifier);
+                    if (existingUri !== undefined) ; else {
+                        newSpecifiers.push(specifier);
+                    }
+                }
+                if (newSpecifiers.length > 0) {
+                    dedupedImports[uri] = newSpecifiers;
+                }
+            }
+
+            if (Object.keys(dedupedImports).length === 0) {
+                return;
+            }
+
+            const filtered = { imports: dedupedImports };
+            const specs = Object.values(filtered.imports).flat();
+            resolver.registerImportMappings(filtered, specs);
+        }
+
+        /**
+         * @deprecated Use `importMap(metadata, rootSpecifiers)` instead.
+         */
         async registerImportMappings(mappings, rootSpecifiers) {
-            this.registry.getImportMetadataResolver().registerImportMappings(mappings, rootSpecifiers);
+            if (hasConsole) {
+                // eslint-disable-next-line lwr/no-unguarded-apis
+                console.warn('registerImportMappings() is deprecated. Use importMap() instead.');
+            }
+            return this.importMap(mappings, rootSpecifiers);
         }
 
         /**

package/build/assets/amd/lwr-everywhere-debug.js

@@ -20,7 +20,7 @@ function getConfiguration(options) {
         : `${ORIGIN}${PREFIX}/module/${format}/${POSTFIX}/mi/`;
 
     // Component specifiers and URIs
-    const BOOT_MODULE = `lwr/everywhere${format === 'esm' ? 'Esm' : 'Amd'}/v/0_22_12`;
+    const BOOT_MODULE = `lwr/everywhere${format === 'esm' ? 'Esm' : 'Amd'}/v/0_23_0`;
     const BOOT_URI = `${ENDPOINT}${encodeURIComponent(BOOT_MODULE)}/latest${debug ? '?debug' : ''}`;
 
     // Client Bootstrap Config
@@ -52,7 +52,7 @@ function getConfiguration(options) {
 * SPDX-License-Identifier: MIT
 * For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/MIT
 */
-/* LWR Module Loader v0.22.12 */
+/* LWR Module Loader v0.23.0 */
 const templateRegex = /\{([0-9]+)\}/g;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function templateString(template, args) {
@@ -484,11 +484,7 @@ class ImportMetadataResolver {
         return this.config.baseUrl || '';
     }
 
-    registerImportMappings(newImportMetadata, rootSpecifiers) {
-        if (!rootSpecifiers || rootSpecifiers.length === 0) {
-            const imports = newImportMetadata ? JSON.stringify(newImportMetadata) : 'undefined';
-            throw new LoaderError(BAD_IMPORT_METADATA, [imports, rootSpecifiers ? '[]' : 'undefined']);
-        }
+    registerImportMappings(newImportMetadata, rootSpecifiers = []) {
         if (!newImportMetadata) {
             throw new LoaderError(BAD_IMPORT_METADATA, ['undefined', JSON.stringify(rootSpecifiers)]);
         }
@@ -498,6 +494,8 @@ class ImportMetadataResolver {
                 JSON.stringify(rootSpecifiers),
             ]);
         }
+        // An empty rootSpecifiers list is valid for non-bootstrap registrations;
+        // any specifier not in the list receives isRoot: false.
         const index = newImportMetadata.index || {};
         for (const [uri, specifiers] of Object.entries(newImportMetadata.imports)) {
             specifiers.forEach((specifier) => {
@@ -520,6 +518,16 @@ class ImportMetadataResolver {
         }
     }
 
+    /**
+     * Returns the raw URI stored for a specifier, or `undefined` if not yet mapped.
+     * Used by the runtime `importMap()` path to detect cross-call duplicates while
+     * allowing truly idempotent re-registrations (same specifier, same URI) to pass
+     * through silently.
+     */
+    getMappingUri(specifier) {
+        return _optionalChain$1([this, 'access', _ => _.importURICache, 'access', _2 => _2.get, 'call', _3 => _3(specifier), 'optionalAccess', _4 => _4.uri]);
+    }
+
     // Get URL from the local cache or return undefiend
      getURI(specifier) {
         return this.importURICache && this.importURICache.has(specifier)
@@ -617,7 +625,7 @@ class ImportMetadataResolver {
     }
 
      async fetchNewMappings(specifier) {
-        if (!hasSetTimeout || !_optionalChain$1([this, 'access', _ => _.config, 'optionalAccess', _2 => _2.flags, 'optionalAccess', _3 => _3.batchMappings])) {
+        if (!hasSetTimeout || !_optionalChain$1([this, 'access', _5 => _5.config, 'optionalAccess', _6 => _6.flags, 'optionalAccess', _7 => _7.batchMappings])) {
             return this.fetchNewMappingsInner(specifier);
         }
 
@@ -1707,6 +1715,101 @@ function validateLoadSpecifier(
     }
 }
 
+/**
+ * Ensures the update object key is a safe, loader-supported script URL (not a bare specifier).
+ * Covers dangerous schemes and URL-key shape in one place.
+ */
+function assertValidImportMapUrlKey(moduleScriptURL) {
+    const lowerUri = moduleScriptURL.toLowerCase();
+
+    if (lowerUri.startsWith('blob:')) {
+        throw new Error(`Cannot map ${moduleScriptURL} to blob: URL`);
+    }
+
+    if (lowerUri.startsWith('data:')) {
+        throw new Error(`Cannot map ${moduleScriptURL} to data: URL`);
+    }
+
+    if (!/^[./]|^https?:/.test(moduleScriptURL)) {
+        throw new Error(
+            `LWR.importMap(): "${moduleScriptURL}" is not a valid URL key. Keys must be URL paths (e.g. "/path/to/module.js"), not module specifiers. Transitive specifier aliasing is not supported by this loader.`,
+        );
+    }
+}
+
+/**
+ * Validates an ImportMapUpdate and wraps it as ImportMetadata for the fingerprints loader.
+ *
+ * Does not apply legacy-style protected-specifier blocking; system modules are expected to be
+ * defined at bootstrap, and `importMap` write-once semantics handle redundant runtime entries.
+ *
+ * Duplicate specifiers in the same update are de-duplicated silently (first occurrence wins).
+ * An empty object is a silent no-op (returns null).
+ */
+function validateAndWrapAsImportMetadata(update) {
+    if (!update || typeof update !== 'object') {
+        throw new Error('LWR.importMap() requires an object argument');
+    }
+
+    const entries = Object.entries(update);
+    if (entries.length === 0) {
+        return null;
+    }
+
+    const seenSpecifiers = new Set();
+    const validatedImports = {};
+
+    for (const [moduleScriptURL, moduleNames] of entries) {
+        if (!moduleScriptURL || typeof moduleScriptURL !== 'string') {
+            throw new Error('moduleScriptURL must be a string');
+        }
+
+        if (!Array.isArray(moduleNames)) {
+            throw new Error('moduleNames must be an array');
+        }
+
+        assertValidImportMapUrlKey(moduleScriptURL);
+
+        const validatedNames = [];
+        for (const moduleName of moduleNames) {
+            if (typeof moduleName !== 'string' || moduleName.length === 0) {
+                throw new Error('Specifier must be a non-empty string');
+            }
+
+            if (!seenSpecifiers.has(moduleName)) {
+                seenSpecifiers.add(moduleName);
+                validatedNames.push(moduleName);
+            }
+        }
+
+        if (validatedNames.length > 0) {
+            validatedImports[moduleScriptURL] = validatedNames;
+        }
+    }
+
+    if (Object.keys(validatedImports).length === 0) {
+        return null;
+    }
+
+    return { imports: validatedImports };
+}
+
+/**
+ * Returns true when `update` carries the `ImportMetadata` shape (an `imports` object key),
+ * signalling that it should be passed through to the resolver directly rather than treated
+ * as a public-API `ImportMapUpdate`.
+ */
+function isImportMetadata(update) {
+    const candidate = update ;
+    return (
+        candidate !== null &&
+        typeof candidate === 'object' &&
+        'imports' in candidate &&
+        typeof candidate.imports === 'object' &&
+        !Array.isArray(candidate.imports)
+    );
+}
+
 /**
  * The LWR loader is inspired and borrows from the algorithms and native browser principles of https://github.com/systemjs/systemjs
  */
@@ -1840,8 +1943,75 @@ class Loader {
         return this.registry.resolve(id, importer);
     }
 
+    /**
+     * Apply import map updates at runtime, or register bootstrap import mappings.
+     *
+     * **Runtime usage** (public API, consistent with `LWR.importMap()` on the legacy loader):
+     *   `importMap({ [moduleScriptURL]: [moduleName1, moduleName2, ...] })`
+     *   Validates the update and registers the new mappings dynamically.
+     *
+     * **Bootstrap / internal usage** (replaces `registerImportMappings`):
+     *   `importMap(importMetadata)` or `importMap(importMetadata, rootSpecifiers)`
+     *   Detected at runtime by the `ImportMetadata` shape (presence of an `imports` object).
+     *   This branch **does not** run `validateAndWrapAsImportMetadata` (URL-key checks /
+     *   runtime-payload dedupe). That is intentional: bootstrap must preserve
+     *   `index` fingerprints and use `ImportMetadataResolver.registerImportMappings` merge
+     *   semantics unchanged from the pre-`importMap` API.
+     *
+     *   **Who may use this branch:** Platform/shim code with trusted config (see
+     *   `shim/shim.ts`, which calls `loader.importMap({ imports, index }, roots)`). The
+     *   public `LWR.importMap` wrapper only forwards the flat runtime update shape; any
+     *   code with a direct `Loader` reference could still pass an `ImportMetadata`-shaped
+     *   object — same trust boundary as calling `registerImportMappings` before.
+     *
+     * @param update - Runtime: `ImportMapUpdate` mapping script URLs to the module names they define.
+     *                 Bootstrap: `ImportMetadata` with an `imports` object (and optional `index`).
+     * @param rootSpecifiers - Bootstrap only: root module specifiers for the initial registration.
+     *                         Optional — omit when the root specifiers are not known.
+     */
+    async importMap(update, rootSpecifiers) {
+        if (isImportMetadata(update)) {
+            this.registry.getImportMetadataResolver().registerImportMappings(update, rootSpecifiers);
+            return;
+        }
+        const resolver = this.registry.getImportMetadataResolver();
+        const importMetadata = validateAndWrapAsImportMetadata(update );
+        if (!importMetadata) {
+            return;
+        }
+
+        const dedupedImports = {};
+        for (const [uri, specifiers] of Object.entries(importMetadata.imports)) {
+            const newSpecifiers = [];
+            for (const specifier of specifiers) {
+                const existingUri = resolver.getMappingUri(specifier);
+                if (existingUri !== undefined) ; else {
+                    newSpecifiers.push(specifier);
+                }
+            }
+            if (newSpecifiers.length > 0) {
+                dedupedImports[uri] = newSpecifiers;
+            }
+        }
+
+        if (Object.keys(dedupedImports).length === 0) {
+            return;
+        }
+
+        const filtered = { imports: dedupedImports };
+        const specs = Object.values(filtered.imports).flat();
+        resolver.registerImportMappings(filtered, specs);
+    }
+
+    /**
+     * @deprecated Use `importMap(metadata, rootSpecifiers)` instead.
+     */
     async registerImportMappings(mappings, rootSpecifiers) {
-        this.registry.getImportMetadataResolver().registerImportMappings(mappings, rootSpecifiers);
+        if (hasConsole) {
+            // eslint-disable-next-line lwr/no-unguarded-apis
+            console.warn('registerImportMappings() is deprecated. Use importMap() instead.');
+        }
+        return this.importMap(mappings, rootSpecifiers);
     }
 
     /**
@@ -1869,7 +2039,7 @@ const { bootstrapModule, endpoints, baseUrl, imports, index } = configuration;
 
 // Initialize the AMD loader (its code is bundled into the LWR Everywhere module)
 const loader = new Loader({ endpoints, baseUrl });
-loader.define('lwr/loader/v/0_22_12', ['exports'], (exports) => {
+loader.define('lwr/loader/v/0_23_0', ['exports'], (exports) => {
     Object.assign(exports, {
         define: loader.define.bind(loader),
         load: loader.load.bind(loader),
@@ -1879,12 +2049,12 @@ await loader.registerImportMappings({ imports, index }, [bootstrapModule]);
 (globalThis ).LWR = Object.freeze({ define: loader.define.bind(loader) });
 
 // Define preload modules (ie: ABS, vault, etc) BEFORE loading them
-LWR.define('lwr/everywhereAmd/v/0_22_12', ['exports', 'lwr/vault/v/0_22_12'], (function (exports, _0_22_12) {
+LWR.define('lwr/everywhereAmd/v/0_23_0', ['exports', 'lwr/vault/v/0_23_0'], (function (exports, _0_23_0) {
   // IMPORTANT: Do not add any static imports to this file that are not bundled with the amd-client
 
   // Do an OAuthed fetch
   async function authFetch(url, accept = 'javascript') {
-    const authInfo = _0_22_12.getAuthInfo();
+    const authInfo = _0_23_0.getAuthInfo();
     if (authInfo) {
       return fetch(url, {
         headers: {
@@ -1933,7 +2103,7 @@ LWR.define('lwr/everywhereAmd/v/0_22_12', ['exports', 'lwr/vault/v/0_22_12'], (f
   function authenticate(authInfo) {
     // Put OAuth info into the vault
     if (authInfo) {
-      _0_22_12.setAuthInfo(authInfo);
+      _0_23_0.setAuthInfo(authInfo);
     }
   }
 
@@ -1943,7 +2113,7 @@ LWR.define('lwr/everywhereAmd/v/0_22_12', ['exports', 'lwr/vault/v/0_22_12'], (f
   Object.defineProperty(exports, '__esModule', { value: true });
 
 }));
-LWR.define('lwr/vault/v/0_22_12', ['exports'], (function (exports) {
+LWR.define('lwr/vault/v/0_23_0', ['exports'], (function (exports) {
   // Credential vault for storing setters and subscribers for OAuth info
   // This module is a SINGLETON and must be excluded from ESM bundling
 
@@ -1967,7 +2137,7 @@ LWR.define('lwr/vault/v/0_22_12', ['exports'], (function (exports) {
 
 // Set up the AMD loader hooks for OAuth
 const { initAmd, authenticate } = await loader.load(bootstrapModule);
-initAmd(loader.services, _optionalChain([endpoints, 'optionalAccess', _ => _.uris, 'access', _2 => _2.mapping]), '0_22_12');
+initAmd(loader.services, _optionalChain([endpoints, 'optionalAccess', _ => _.uris, 'access', _2 => _2.mapping]), '0_23_0');
 
 // Wrap the createComponent API to allow proper ordering of module definitions:
 //  1. LWRE module bundle (this): lwr/loader, lwr/everywhereAmd, lwr/vault