@equinor/fusion-framework-vite-plugin-spa 4.0.16 → 4.0.17-next.1

package/dist/html/bootstrap.js

@@ -6314,7 +6314,7 @@ async function runDisposePhase(ctx, instance, ref) {
 }
 
 // Generated by genversion.
-const version$8 = '6.1.2';
+const version$8 = '6.1.3-next.0';
 
 // biome-ignore-all lint/suspicious/noExplicitAny: internal type-erased dispatch arrays — callbacks are registered with concrete module types but stored erased; the orchestrator never inspects these shapes itself
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -6449,7 +6449,34 @@ class ModulesConfigurator {
      * @param modules - Optional array of module descriptors to pre-register.
      */
     constructor(modules) {
-        this._modules = new Set(modules);
+        this._modules = new Set(modules ? this._dedupeModulesByName(modules) : []);
+    }
+    /**
+     * Keeps the last registration for each module name.
+     *
+     * @param modules - Module descriptors to deduplicate.
+     * @returns The deduplicated module descriptors.
+     */
+    _dedupeModulesByName(modules) {
+        const lastByName = new Map();
+        // Iterate in registration order so later descriptors intentionally override earlier ones.
+        for (const module of modules) {
+            lastByName.set(module.name, module);
+        }
+        return Array.from(lastByName.values());
+    }
+    /**
+     * Removes lifecycle callbacks belonging to a replaced module.
+     *
+     * @param moduleName - Name of the module whose callbacks are removed.
+     */
+    _removeModuleCallbacks(moduleName) {
+        // Remove callbacks from each lifecycle phase so replaced modules cannot run stale behavior.
+        this._configs = this._configs.filter((callback) => callback.moduleName !== moduleName);
+        // Keep cleanup callbacks aligned with the module replacement.
+        this._afterConfiguration = this._afterConfiguration.filter((callback) => callback.moduleName !== moduleName);
+        // Remove initialization callbacks as well, preventing the old module from being initialized.
+        this._afterInit = this._afterInit.filter((callback) => callback.moduleName !== moduleName);
     }
     /**
      * Returns all registered module descriptors as an ordered array.
@@ -6476,6 +6503,9 @@ class ModulesConfigurator {
     /**
      * Registers a single module configurator.
      *
+     * If a module with the same `name` was already registered, the previous
+     * registration is replaced so the last added module wins.
+     *
      * Adds the module to the known module set and registers the optional
      * `configure`, `afterConfig`, and `afterInit` callbacks into their
      * respective lifecycle phase arrays.
@@ -6486,7 +6516,26 @@ class ModulesConfigurator {
      */
     addConfig(config) {
         const { module, afterConfig, afterInit, configure } = config;
-        this._modules.add(module);
+        // Find an existing descriptor so re-registering a name can replace all of its lifecycle hooks.
+        const existingModule = Array.from(this._modules).find((m) => m.name === module.name);
+        // Only handle replacement/dedupe when a descriptor is already registered under this name.
+        if (existingModule) {
+            // Only a genuinely different descriptor for this name is a replacement that must
+            // discard the old callbacks. Re-registering the SAME descriptor object (as helpers
+            // like `configureHttpClient`/`useFrameworkServiceClient` do on every call, since they
+            // all share one module singleton) must stay additive so multiple calls can register
+            // multiple named clients without clobbering each other.
+            if (existingModule !== module) {
+                this._removeModuleCallbacks(module.name);
+                const modules = Array.from(this._modules)
+                    // Preserve every descriptor while substituting the newly registered module.
+                    .map((m) => (m.name === module.name ? module : m));
+                this._modules = new Set(modules);
+            }
+        }
+        else {
+            this._modules.add(module);
+        }
         this._registerEvent({
             level: ModuleEventLevel.Debug,
             name: ModuleConfiguratorEventName.ModuleConfigAdded,
@@ -6499,15 +6548,26 @@ class ModulesConfigurator {
                 afterInit: !!afterInit,
             },
         });
-        // Register each optional callback into its corresponding lifecycle phase array
-        if (configure)
-            this._configs.push((cfg, ref) => configure(cfg[module.name], ref));
-        // Register the afterConfig callback, if provided
-        if (afterConfig)
-            this._afterConfiguration.push((cfg) => afterConfig(cfg[module.name]));
-        // Register the afterInit callback, if provided
-        if (afterInit)
-            this._afterInit.push((instances) => afterInit(instances[module.name]));
+        // Register each optional callback into its corresponding lifecycle phase array.
+        // When the same module name is re-registered, previous callbacks are removed
+        // so the latest configuration wins.
+        if (configure) {
+            const callback = ((cfg, ref) => configure(cfg[module.name], ref));
+            callback.moduleName = module.name;
+            this._configs.push(callback);
+        }
+        // Register the afterConfig callback, if provided.
+        if (afterConfig) {
+            const callback = ((cfg) => afterConfig(cfg[module.name]));
+            callback.moduleName = module.name;
+            this._afterConfiguration.push(callback);
+        }
+        // Register the afterInit callback, if provided.
+        if (afterInit) {
+            const callback = ((instances) => afterInit(instances[module.name]));
+            callback.moduleName = module.name;
+            this._afterInit.push(callback);
+        }
     }
     /**
      * Registers a callback for the post-configure phase.
@@ -6929,6 +6989,49 @@ class HttpRequestHandler extends ProcessOperators {
 class HttpResponseHandler extends ProcessOperators {
 }
 
+/**
+ * Normalizes a step's result to a `Promise`, so a middleware calling `next(...)` never has to
+ * branch on whether the next step short-circuited with a plain `Response` or reached all the
+ * way to an Observable-returning network call.
+ */
+function toPromise(result) {
+    return result instanceof Response ? Promise.resolve(result) : firstValueFrom(from(result));
+}
+/**
+ * Composes registered {@link HttpMiddleware} into a single execution pipeline wrapping the
+ * network call, so retries, caching, telemetry, or circuit-breaking can wrap `_performFetch`
+ * without touching request or response payload transforms.
+ *
+ * @see {@link HttpClient}
+ */
+class HttpMiddlewareHandler {
+    #middleware;
+    /**
+     * Constructs a handler, optionally cloning another handler's registered middleware.
+     * @param source - An existing handler to clone the registered middleware from.
+     */
+    constructor(source) {
+        this.#middleware = source ? [...source.middleware] : [];
+    }
+    /** @inheritdoc */
+    get middleware() {
+        return this.#middleware;
+    }
+    /** @inheritdoc */
+    use(middleware) {
+        this.#middleware.push(middleware);
+        return this;
+    }
+    /** @inheritdoc */
+    process(uri, init, terminal) {
+        // wrap outward-in so the first-registered middleware is outermost, matching a conventional middleware chain
+        const chain = this.#middleware.reduceRight((next, middleware) => (nextUri, nextInit) => middleware(nextUri, nextInit, (u, i) => toPromise(next(u, i))), terminal);
+        const result = chain(uri, init);
+        // a middleware may short-circuit with a plain Response (no ObservableInput wrapping needed)
+        return result instanceof Response ? of(result) : from(result);
+    }
+}
+
 var _a$1;
 /** A special constant with type `never` */
 const NEVER = /*@__PURE__*/ Object.freeze({
@@ -22530,6 +22633,8 @@ class HttpClientConfigurator {
         // validate the request object
         'request-validation': requestValidationOperator(),
     });
+    /** Default middleware chain cloned into each created client instance. */
+    defaultHttpMiddlewareHandler = new HttpMiddlewareHandler();
     /**
      * Creates a configurator with the default client constructor.
      * @param client - The default client constructor used when `ctor` is not configured per client.
@@ -22542,6 +22647,11 @@ class HttpClientConfigurator {
         return Object.keys(this._clients).includes(name);
     }
     /** @inheritdoc */
+    addMiddleware(middleware) {
+        this.defaultHttpMiddlewareHandler.use(middleware);
+        return this;
+    }
+    /** @inheritdoc */
     configureClient(name, args) {
         const argFn = typeof args === 'string' ? { baseUri: args } : args;
         const options = typeof argFn === 'function' ? { onCreate: argFn } : argFn;
@@ -22556,7 +22666,7 @@ class HttpClientConfigurator {
 }
 
 // Generated by genversion.
-const version$6 = '8.0.5';
+const version$6 = '8.1.0-next.0';
 
 /** URL protocols accepted as valid ad-hoc base URIs. */
 const SUPPORTED_PROTOCOLS = ['http:', 'https:', 'ws:', 'wss:'];
@@ -22595,6 +22705,13 @@ class HttpClientProvider extends BaseModuleProvider {
     get defaultHttpRequestHandler() {
         return this.config.defaultHttpRequestHandler;
     }
+    /**
+     * Gets the default middleware chain for the HTTP client provider.
+     * @returns The default middleware chain.
+     */
+    get defaultHttpMiddlewareHandler() {
+        return this.config.defaultHttpMiddlewareHandler;
+    }
     /**
      * Creates a new `HttpClientProvider`.
      * @param config - The configurator providing client definitions and defaults.
@@ -22632,8 +22749,8 @@ class HttpClientProvider extends BaseModuleProvider {
      */
     createClient(keyOrConfig) {
         const config = this._resolveConfig(keyOrConfig);
-        const { baseUri, defaultScopes = [], onCreate, ctor = this.config.defaultHttpClientCtor, requestHandler = this.defaultHttpRequestHandler, responseHandler, } = config;
-        const options = { requestHandler, responseHandler };
+        const { baseUri, defaultScopes = [], onCreate, ctor = this.config.defaultHttpClientCtor, requestHandler = this.defaultHttpRequestHandler, responseHandler, middlewareHandler = this.defaultHttpMiddlewareHandler, } = config;
+        const options = { requestHandler, responseHandler, middlewareHandler };
         const instance = new ctor(baseUri || '', options);
         // attach the resolved default scopes onto the instance without overwriting other own properties
         Object.assign(instance, { defaultScopes });
@@ -22832,6 +22949,12 @@ class HttpClient {
      * This property is part of the `HttpClientCreateOptions` configuration object used to create an `HttpClient` instance.
      */
     responseHandler;
+    /**
+     * Middleware wrapping the network call, for cross-cutting concerns such as retries,
+     * caching, or telemetry. This property is part of the `HttpClientCreateOptions`
+     * configuration object used to create an `HttpClient` instance.
+     */
+    middlewareHandler;
     /**
      * A stream of requests that are about to be executed.
      * This property is used internally by the `HttpClient` class to manage the lifecycle of requests.
@@ -22870,6 +22993,7 @@ class HttpClient {
         this.uri = uri;
         this.requestHandler = new HttpRequestHandler(options?.requestHandler);
         this.responseHandler = new HttpResponseHandler(options?.responseHandler);
+        this.middlewareHandler = new HttpMiddlewareHandler(options?.middlewareHandler);
         this._init();
     }
     /**
@@ -23041,7 +23165,9 @@ class HttpClient {
     /**
      * Aborts any ongoing HTTP requests made by this `IHttpClient` instance.
      * This will trigger the `takeUntil` operator in the `_fetch$` method,
-     * causing any in-flight requests to be cancelled.
+     * causing any in-flight requests to be cancelled, and abort the
+     * per-request `AbortSignal` passed through to `_performFetch`, so the
+     * underlying network call is cancelled even behind registered middleware.
      */
     abort() {
         this._abort$.next();
@@ -23066,11 +23192,26 @@ class HttpClient {
      */
     _fetch$(path, args) {
         const { selector, ...options } = args || {};
+        // A registered middleware's `next(...)` resolves through a `Promise` (see
+        // `HttpMiddlewareHandler`), which `firstValueFrom` fulfils via its own independent
+        // subscription to `_performFetch` — one the `takeUntil(this._abort$)` below never reaches,
+        // since it sits outside the subscription tree that `takeUntil` tears down. Combining this
+        // controller's signal into the request `init` lets `_performFetch` (`fromFetch` by default)
+        // abort the underlying network call directly, regardless of whether middleware severed the
+        // RxJS teardown chain.
+        const abortController = new AbortController();
+        // abort only fires once per request; the subscription is torn down in `finalize` below
+        const abort = this._abort$.pipe(take(1)).subscribe(() => abortController.abort());
+        const callerSignal = options.signal;
+        const signal = callerSignal
+            ? AbortSignal.any([callerSignal, abortController.signal])
+            : abortController.signal;
         // `fromFetch` yields the raw fetch `Response`, but `responseHandler.process()` (called via
         // `_prepareResponse`) expects the pipeline's generic `TResponse` shape — cast through
         // `unknown` since the two are only compatible after that processing step.
         const response$ = of({
             ...options,
+            signal,
             path,
             uri: this._resolveUrl(path),
         }).pipe(
@@ -23078,8 +23219,8 @@ class HttpClient {
         switchMap((x) => this._prepareRequest(x)), 
         /** push request to event buss */
         tap((x) => this._request$.next(x)), 
-        /** execute request */
-        switchMap(({ uri, path: _path, ...init }) => fromFetch(uri, init)), 
+        /** execute request through registered middleware, terminating at _performFetch */
+        switchMap(({ uri, path: _path, ...init }) => this.middlewareHandler.process(uri, init, (u, i) => this._performFetch(u, i))), 
         /** prepare response, allow extensions to modify response  */
         switchMap((x) => this._prepareResponse(x)), 
         /** push response to event buss */
@@ -23100,11 +23241,30 @@ class HttpClient {
             return of(response);
         }), 
         /** cancel request on abort signal */
-        takeUntil(this._abort$));
+        takeUntil(this._abort$), 
+        /** the abort signal subscription only ever fires once; tear it down once this request settles either way */
+        finalize$2(() => abort.unsubscribe()));
         // The pipe above resolves to the per-call generic `T` (via the optional `selector`), but
         // the observable's static type tracks the class-level `TResponse` — cast to the caller's `T`.
         return response$;
     }
+    /**
+     * Performs the actual network call for a prepared request.
+     *
+     * @remarks
+     * Isolated from {@link _fetch$} so a test double can replace only this step —
+     * matching a request against registered route handlers instead of reaching
+     * the network — while everything around it (request preparation, the
+     * response pipeline, abort handling) runs unchanged. See
+     * `@equinor/fusion-framework-module-http/mock`.
+     *
+     * @param uri - The fully resolved URL for the request.
+     * @param init - The prepared `fetch` request options.
+     * @returns An observable of the raw `Response`, ahead of {@link _prepareResponse}.
+     */
+    _performFetch(uri, init) {
+        return fromFetch(uri, init);
+    }
     /**
      * Prepares the request by passing it through the `requestHandler.process()` method.
      * This method is an implementation detail of the `_fetch$()` method, and is not part of the public API.
@@ -25008,7 +25168,7 @@ class TelemetryConfigurator extends BaseConfigBuilder {
 }
 
 // Generated by genversion.
-const version$5 = '7.0.2';
+const version$5 = '8.0.0-next.1';
 
 /**
  * Enum representing the severity levels of telemetry items.
@@ -43861,7 +44021,7 @@ const createClientLogCallback = (provider, metadata, scope) => {
 };
 
 // Generated by genversion.
-const version$2 = '10.0.2';
+const version$2 = '11.0.0-next.0';
 
 /**
  * Zod schema for telemetry configuration validation.
@@ -43876,10 +44036,15 @@ const TelemetryConfigSchema = z.object({
     }),
     scope: z.array(z.string()).optional().default(['framework', 'authentication']),
 });
+
 /**
  * Zod schema for MSAL module configuration validation.
  *
- * @internal
+ * @remarks
+ * Kept in its own module so the configuration can be extended at its source.
+ * The schema itself describes what reaches `MsalProvider` and strips anything
+ * else; keys a variant of this module needs only while the configuration is
+ * being built are declared on {@link MsalConfigExtension} instead.
  */
 const MsalConfigSchema = z.object({
     client: z.custom().optional(),
@@ -43892,9 +44057,19 @@ const MsalConfigSchema = z.object({
         .custom((val) => typeof val === 'number' &&
         Object.values(CacheLookupPolicy).includes(val))
         .optional(),
-    version: z.string().transform((x) => String(semver.coerce(x))),
+    version: z.string().transform((value, ctx) => {
+        const coerced = semver.coerce(value);
+        // `semver.coerce` returns `null` for an unparseable version; without this guard it
+        // would silently become the literal string "null" instead of failing validation.
+        if (!coerced) {
+            ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'Invalid MSAL module version' });
+            return z.NEVER;
+        }
+        return coerced.version;
+    }),
     telemetry: TelemetryConfigSchema,
 });
+
 /**
  * Configuration builder for MSAL v4 authentication module.
  *
@@ -43910,6 +44085,7 @@ const MsalConfigSchema = z.object({
  */
 class MsalConfigurator extends BaseConfigBuilder {
     #msalConfig;
+    #client;
     /**
      * The MSAL module version being configured.
      *
@@ -43936,6 +44112,9 @@ class MsalConfigurator extends BaseConfigBuilder {
                 return telemetry;
             }
         });
+        // Always resolve the configured client instance through the builder.
+        // This keeps the client getter live and avoids re-registering the same config key.
+        this._set('client', async () => this.#client);
         // Default cache lookup policy to AccessTokenAndRefreshToken to avoid iframe fallback delays
         this._set('cacheLookupPolicy', async () => CacheLookupPolicy.AccessTokenAndRefreshToken);
     }
@@ -43963,6 +44142,22 @@ class MsalConfigurator extends BaseConfigBuilder {
         this.#msalConfig = config;
         return this;
     }
+    /**
+     * Returns the client configuration declared through
+     * {@link MsalConfigurator.setClientConfig | setClientConfig}, if any.
+     *
+     * @remarks
+     * This is the configuration as declared, not the resolved one a client is
+     * built from — see
+     * {@link MsalConfigurator._createClientConfig | _createClientConfig} for that.
+     * Reading it is how a subclass can tell "nothing was declared" apart from
+     * "declared, and here it is", without re-deriving that from a resolved value.
+     *
+     * @returns The declared client configuration, or `undefined` when none was declared.
+     */
+    getClientConfig() {
+        return this.#msalConfig;
+    }
     /**
      * Sets the cache lookup policy used for every silent token acquisition.
      *
@@ -44096,9 +44291,21 @@ class MsalConfigurator extends BaseConfigBuilder {
      * ```
      */
     setClient(client) {
-        this._set('client', async () => client);
+        this.#client = client;
         return this;
     }
+    /**
+     * Returns the currently configured MSAL client, if one has been set.
+     *
+     * @remarks
+     * This is useful in tests when a mock client has been provided and the test
+     * wants to adjust its state after it has been assigned to the configurator.
+     *
+     * @returns The configured client, or `undefined` when none has been set.
+     */
+    getClient() {
+        return this.#client;
+    }
     /**
      * Sets telemetry provider for MSAL authentication events.
      *
@@ -44146,64 +44353,151 @@ class MsalConfigurator extends BaseConfigBuilder {
     /**
      * Processes and validates the configuration.
      *
-     * @param config - Raw configuration object
+     * @param rawConfig - Raw configuration object
+     * @param init - The builder arguments, carrying the host reference when hoisted
      * @returns Processed and validated configuration
      */
-    async _processConfig(rawConfig) {
+    async _processConfig(rawConfig, init) {
         // Validate and coerce configuration using Zod schema
         const config = await MsalConfigSchema.parseAsync(rawConfig);
-        // Auto-create client if config provided but no client instance
+        // Auto-create client if no client instance was supplied
         // This allows users to provide configuration without manually instantiating the client
-        if (!config.client && this.#msalConfig) {
-            const clientConfig = this.#msalConfig;
-            config.telemetry.provider?.trackEvent({
-                name: 'module-msal.configurator._processConfig.creating-client',
+        // A hoisted module authenticates through the host's provider, so any client built here
+        // would be discarded — gate it here rather than in `_createClient`, so a substituted
+        // client (see `MsalMockConfigurator`) cannot shadow the host's signed-in user
+        if (!config.client && !this._isHoisted(init)) {
+            config.client = await this._createClient(config, init);
+        }
+        return config;
+    }
+    /**
+     * Creates the client to authenticate through, when none was supplied.
+     *
+     * @remarks
+     * Called by {@link MsalConfigurator._processConfig | _processConfig} only when
+     * no client was set, so a client supplied through
+     * {@link MsalConfigurator.setClient | setClient} always wins. It is likewise
+     * not called when the module is hoisted onto a host application's provider —
+     * see {@link MsalConfigurator._isHoisted | _isHoisted}.
+     *
+     * This is the seam for authenticating through something other than Entra ID.
+     * Overriding it replaces only the client, leaving the builder, the schema
+     * validation and `MsalProvider` untouched — which is how
+     * `MsalMockConfigurator` substitutes an in-process client for tests.
+     *
+     * An override normally builds from
+     * {@link MsalConfigurator._createClientConfig | _createClientConfig}, so it
+     * receives the same fully-resolved {@link MsalClientConfig} the real client is
+     * built from rather than re-deriving it.
+     *
+     * Returning `undefined` is legitimate and means "there is nothing to build a
+     * client from", which leaves the module without one.
+     *
+     * @param config - The validated configuration the client is built from.
+     * @param init - The builder arguments, carrying the host reference when hoisted.
+     * @returns The client, or `undefined` when there is nothing to build one from.
+     */
+    async _createClient(config, _init) {
+        const clientConfig = this._createClientConfig(config);
+        // A client can be omitted for a hoisted module or an intentionally incomplete setup.
+        if (!clientConfig) {
+            return undefined;
+        }
+        // Instantiate MSAL client with fully configured options
+        return new MsalClient(clientConfig);
+    }
+    /**
+     * Whether this module is hoisted onto a host application's authentication.
+     *
+     * @remarks
+     * When an application runs inside a host — a portal loading an app, or an app
+     * loading a widget — the module initializer returns a proxy of the host's
+     * provider instead of building its own (see the host-provider branch of the
+     * module initializer). A client built during configuration would therefore be
+     * constructed and immediately discarded.
+     *
+     * Detecting this during configuration lets the configurator skip building a
+     * client entirely, which matters most for substituted clients: a mock client
+     * built here would otherwise silently shadow the host's real signed-in user.
+     *
+     * @param init - The builder arguments, carrying the host reference when hoisted.
+     * @returns `true` when a host provider will be used instead of a locally built client.
+     */
+    _isHoisted(init) {
+        return !!init?.ref?.auth;
+    }
+    /**
+     * Resolves the full MSAL client configuration to build a client from.
+     *
+     * @remarks
+     * Applies the defaults a client is expected to be built with — authority
+     * derived from the tenant, cache location, telemetry-backed logging and the
+     * configured cache lookup policy.
+     *
+     * Kept separate from {@link MsalConfigurator._createClient | _createClient} so
+     * that substituting the client does not also mean re-implementing this
+     * resolution. `MsalMockConfigurator` relies on it to hand its mock client the
+     * very same configuration the real client would have received.
+     *
+     * @param config - The validated configuration.
+     * @returns The client configuration, or `undefined` when none was declared.
+     */
+    _createClientConfig(config) {
+        const declared = this.#msalConfig;
+        // Do not construct a client when configuration has not supplied client settings.
+        if (!declared) {
+            return undefined;
+        }
+        config.telemetry.provider?.trackEvent({
+            name: 'module-msal.configurator._processConfig.creating-client',
+            level: TelemetryLevel.Debug,
+            scope: config.telemetry.scope,
+            metadata: { ...config.telemetry.metadata, clientConfig: declared },
+        });
+        // Copied rather than enriched in place, so the object a caller passed to
+        // `setClientConfig` is never rewritten behind its back — a caller may well
+        // be reusing or asserting on it
+        const clientConfig = {
+            ...declared,
+            auth: { ...declared.auth },
+            // Default to localStorage: MSAL supports sessionStorage too, but
+            // localStorage is the standard for persistent auth in browsers
+            cache: declared.cache ?? { cacheLocation: 'localStorage' },
+        };
+        // Auto-generate authority URL from tenant ID if not explicitly provided
+        // This simplifies configuration for most common cases
+        if (!clientConfig.auth.authority && clientConfig.auth.tenantId) {
+            clientConfig.auth.authority = `https://login.microsoftonline.com/${clientConfig.auth.tenantId}`;
+        }
+        // Integrate framework telemetry with MSAL logging system
+        // This allows MSAL events to flow through the framework's telemetry pipeline
+        if (!clientConfig.system?.loggerOptions && config.telemetry?.provider) {
+            const { provider, metadata, scope } = config.telemetry;
+            provider.trackEvent({
+                name: 'module-msal.configurator._processConfig.client-telemetry-connected',
                 level: TelemetryLevel.Debug,
-                scope: config.telemetry.scope,
-                metadata: { ...config.telemetry.metadata, clientConfig },
+                scope,
+                metadata,
             });
-            // Auto-generate authority URL from tenant ID if not explicitly provided
-            // This simplifies configuration for most common cases
-            if (!clientConfig.auth.authority && clientConfig.auth.tenantId) {
-                clientConfig.auth.authority = `https://login.microsoftonline.com/${clientConfig.auth.tenantId}`;
-            }
-            // Set default cache location to localStorage for browser environments
-            // MSAL supports sessionStorage as well, but localStorage is the standard for persistent auth
-            if (!clientConfig.cache) {
-                clientConfig.cache = { cacheLocation: 'localStorage' };
-            }
-            // Integrate framework telemetry with MSAL logging system
-            // This allows MSAL events to flow through the framework's telemetry pipeline
-            if (!clientConfig.system?.loggerOptions && config.telemetry?.provider) {
-                const { provider, metadata, scope } = config.telemetry;
-                provider.trackEvent({
-                    name: 'module-msal.configurator._processConfig.client-telemetry-connected',
-                    level: TelemetryLevel.Debug,
-                    scope,
-                    metadata,
-                });
-                clientConfig.system = {
-                    ...clientConfig.system,
-                    loggerOptions: {
-                        // Only log PII in development to protect user privacy in production
-                        piiLoggingEnabled: process.env.NODE_ENV === 'development',
-                        // Bridge MSAL log events to framework telemetry system
-                        loggerCallback: createClientLogCallback(provider, metadata, [...scope, '3rd-party']),
-                        // Use Warning level by default - captures errors and warnings without being verbose
-                        logLevel: LogLevel.Warning,
-                        // Preserve any user-provided logger options (allows customization)
-                        ...clientConfig.system?.loggerOptions,
-                    },
-                };
-            }
-            // Apply silent cache lookup policy if configured
-            if (config.cacheLookupPolicy !== undefined) {
-                clientConfig.cacheLookupPolicy = config.cacheLookupPolicy;
-            }
-            // Instantiate MSAL client with fully configured options
-            config.client = new MsalClient(clientConfig);
+            clientConfig.system = {
+                ...clientConfig.system,
+                loggerOptions: {
+                    // Only log PII in development to protect user privacy in production
+                    piiLoggingEnabled: process.env.NODE_ENV === 'development',
+                    // Bridge MSAL log events to framework telemetry system
+                    loggerCallback: createClientLogCallback(provider, metadata, [...scope, '3rd-party']),
+                    // Use Warning level by default - captures errors and warnings without being verbose
+                    logLevel: LogLevel.Warning,
+                    // Preserve any user-provided logger options (allows customization)
+                    ...clientConfig.system?.loggerOptions,
+                },
+            };
         }
-        return config;
+        // Apply silent cache lookup policy if configured
+        if (config.cacheLookupPolicy !== undefined) {
+            clientConfig.cacheLookupPolicy = config.cacheLookupPolicy;
+        }
+        return clientConfig;
     }
 }
 
@@ -44321,7 +44615,6 @@ class VersionError extends Error {
  * ```
  */
 function mapVersionToEnumVersion(version) {
-    console.log('Resolving version:', version);
     const coercedVersion = semver.coerce(version);
     // An uncoercible version string cannot be mapped to a module version
     if (!coercedVersion) {
@@ -48208,7 +48501,7 @@ class ServiceDiscoveryConfigurator extends BaseConfigBuilder {
 }
 
 // Generated by genversion.
-const version$1 = '10.0.2';
+const version$1 = '10.1.0-next.0';
 
 /**
  * Default implementation of {@link IServiceDiscoveryProvider}.
@@ -48232,6 +48525,10 @@ class ServiceDiscoveryProvider extends BaseModuleProvider {
         this.config = config;
         this._http = _http;
     }
+    /** {@inheritDoc IServiceDiscoveryProvider.client} */
+    get client() {
+        return this.config.discoveryClient;
+    }
     /** {@inheritDoc IServiceDiscoveryProvider.resolveServices} */
     resolveServices() {
         return this.config.discoveryClient.resolveServices();
@@ -48346,8 +48643,9 @@ const configureServiceDiscovery = (callback) => ({
  *
  * @param configurator - The modules configurator to register the module on.
  *   Must already include {@link HttpModule}.
- * @param callback - Optional async callback receiving a
- *   {@link ServiceDiscoveryConfigurator} for advanced setup.
+ * @param callback - Optional callback receiving a
+ *   {@link ServiceDiscoveryConfigurator} for advanced setup. May be synchronous
+ *   or asynchronous.
  *
  * @example
  * ```typescript
@@ -48842,7 +49140,7 @@ async function registerServiceWorker(framework) {
 }
 
 // Generated by genversion.
-const version = '4.0.16';
+const version = '4.0.17-next.1';
 
 // Allow dynamic import without vite
 const importWithoutVite = (path) => import(/* @vite-ignore */ path);