@equinor/fusion-framework-vite-plugin-spa 3.1.11 → 4.0.0

package/dist/html/bootstrap.js

@@ -5239,9 +5239,31 @@ var ModuleEventLevel;
 })(ModuleEventLevel || (ModuleEventLevel = {}));
 
 /**
- * Base class for creating module provider
+ * Abstract base class for Fusion Framework module providers.
  *
- * this is the interface which is returned after enabling a module
+ * Extend `BaseModuleProvider` to create the runtime instance that a module’s
+ * {@link Module.initialize | initialize} method returns. The base class
+ * handles version parsing, subscription lifecycle management, and duck-typed
+ * `instanceof` checks.
+ *
+ * Subclasses should register teardown callbacks via {@link _addTeardown} so
+ * that resources (subscriptions, timers, event listeners) are automatically
+ * cleaned up when the framework calls {@link dispose}.
+ *
+ * @template TConfig - The resolved configuration type for the module.
+ *
+ * @example
+ * ```typescript
+ * class MyProvider extends BaseModuleProvider<MyConfig> {
+ *   constructor(args: BaseModuleProviderCtorArgs<MyConfig>) {
+ *     super(args);
+ *     const sub = someObservable$.subscribe();
+ *     this._addTeardown(sub);
+ *   }
+ * }
+ * ```
+ *
+ * @see IModuleProvider
  */
 class BaseModuleProvider {
     /**
@@ -5273,6 +5295,11 @@ class BaseModuleProvider {
     get version() {
         return this.#version;
     }
+    /**
+     * Creates a new module provider.
+     *
+     * @param args - Version and resolved configuration for the module.
+     */
     constructor(args) {
         const { version } = args;
         this.#version = new SemanticVersion(version);
@@ -5288,13 +5315,18 @@ class BaseModuleProvider {
         this.#subscriptions.add(teardown);
         return () => this.#subscriptions.remove(teardown);
     }
+    /**
+     * Unsubscribes all registered teardowns and releases held resources.
+     *
+     * Called automatically by the framework during module disposal.
+     */
     dispose() {
         this.#subscriptions.unsubscribe();
     }
 }
 
 // Generated by genversion.
-const version$8 = '5.0.6';
+const version$8 = '6.0.0';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
@@ -5310,9 +5342,37 @@ class RequiredModuleTimeoutError extends Error {
     }
 }
 /**
- * Configurator class for modules.
- * @template TModules - Array of modules.
- * @template TRef - Reference type.
+ * Core orchestrator that drives the module lifecycle in Fusion Framework.
+ *
+ * `ModulesConfigurator` manages the full configure → initialize → dispose pipeline
+ * for a set of modules. Consumers register modules via {@link addConfig} or
+ * {@link configure}, then call {@link initialize} to produce a sealed
+ * {@link ModulesInstance} whose properties are the initialized module providers.
+ *
+ * The lifecycle phases executed during {@link initialize} are:
+ *
+ * 1. **Configure** – each module’s `configure()` factory creates a config builder;
+ *    registered callbacks mutate it; `postConfigure()` hooks run.
+ * 2. **Initialize** – modules are initialized concurrently via `initialize()`;
+ *    cross-module dependencies are resolved through `requireInstance()`.
+ * 3. **Post-initialize** – `postInitialize()` hooks and `onInitialized` callbacks run.
+ *
+ * All lifecycle transitions emit {@link ModuleEvent} entries on the {@link event$}
+ * observable for telemetry and debugging.
+ *
+ * @template TModules - Tuple of module types managed by this configurator.
+ * @template TRef - Reference type passed through configuration (usually a parent instance).
+ *
+ * @example
+ * ```typescript
+ * const configurator = new ModulesConfigurator([httpModule, authModule]);
+ * configurator.addConfig({
+ *   module: httpModule,
+ *   configure: (cfg) => cfg.setBaseUrl('https://api.example.com'),
+ * });
+ * const modules = await configurator.initialize();
+ * // modules.http, modules.auth are now available
+ * ```
  */
 class ModulesConfigurator {
     /**
@@ -5984,6 +6044,8 @@ class ModulesConfigurator {
             },
         });
     }
+    /**
+     * Disposes all modules managed by this configurator.\n   *\n   * Calls each module\u2019s `dispose` hook (if defined) and completes the\n   * internal event stream. After disposal the configurator should not be reused.\n   *\n   * @param instance - The initialized modules instance to tear down.\n   * @param ref - Optional reference object forwarded to module dispose hooks.\n   */
     async dispose(instance, ref) {
         this._registerEvent({
             level: ModuleEventLevel.Debug,
@@ -20674,218 +20736,6 @@ const requestValidationOperator = (options) => (request) => {
     }
 };
 
-/** @inheritdoc */
-class HttpClientConfigurator {
-    _clients = {};
-    /** Get a clone of all configured clients */
-    get clients() {
-        return { ...this._clients };
-    }
-    /** default class for creation of http clients */
-    defaultHttpClientCtor;
-    /** default request handler for http clients, applied on creation */
-    defaultHttpRequestHandler = new HttpRequestHandler({
-        // convert all request methods to uppercase
-        'capitalize-method': capitalizeRequestMethodOperator(),
-        // validate the request object
-        'request-validation': requestValidationOperator(),
-    });
-    /**
-     * Create a instance of http configuration
-     * @param client defaultHttpRequestHandler
-     */
-    constructor(client) {
-        this.defaultHttpClientCtor = client;
-    }
-    /** @inheritdoc */
-    hasClient(name) {
-        return Object.keys(this._clients).includes(name);
-    }
-    /** @inheritdoc */
-    configureClient(name, args) {
-        const argFn = typeof args === 'string' ? { baseUri: args } : args;
-        const options = typeof argFn === 'function' ? { onCreate: argFn } : argFn;
-        this._clients[name] = {
-            ...this._clients[name],
-            ...options,
-        };
-        return this;
-    }
-}
-
-// Generated by genversion.
-const version$6 = '7.0.8';
-
-/**
- * Exception thrown when a client cannot be found.
- *
- * This error is typically used to indicate that a requested client instance
- * does not exist or cannot be located within the current context.
- *
- * @extends {Error}
- */
-class ClientNotFoundException extends Error {
-}
-/**
- * Checks if a given string is a valid URL.
- * @param url - The string to check for a valid URL.
- * @returns `true` if the input string is a valid URL, `false` otherwise.
- */
-const isURL = (url) => {
-    const pattern = new RegExp('^(https?:\\/\\/)?' + // protocol
-        '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.?)+[a-z]{2,}|' + // domain name
-        '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
-        '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
-        '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
-        '(\\#[-a-z\\d_]*)?$', 'i'); // fragment locator
-    return pattern.test(url);
-};
-/**
- * The `HttpClientProvider` class is responsible for managing HTTP client instances and their configuration.
- * It provides methods to check if a client is configured, create new client instances, and create custom client instances.
- */
-class HttpClientProvider extends BaseModuleProvider {
-    config;
-    /**
-     * Gets the default HTTP request handler for the HTTP client provider.
-     * @returns The default HTTP request handler.
-     */
-    get defaultHttpRequestHandler() {
-        return this.config.defaultHttpRequestHandler;
-    }
-    constructor(config) {
-        super({
-            version: version$6,
-            config,
-        });
-        this.config = config;
-    }
-    /**
-     * Checks if a client with the given key is configured in the `HttpClientProvider`.
-     * @param key - The key of the HTTP client to check.
-     * @returns `true` if a client with the given key is configured, `false` otherwise.
-     */
-    hasClient(key) {
-        return Object.keys(this.config.clients).includes(key);
-    }
-    /**
-     * Creates a new HTTP client instance with the specified configuration.
-     *
-     * @param keyOrConfig - The key or configuration object for the HTTP client.
-     * @returns The created HTTP client instance.
-     *
-     * @remarks
-     * This method resolves the configuration for the HTTP client based on the provided `keyOrConfig` parameter.
-     * If a string is provided, it is treated as the key for a pre-configured client in the `HttpClientProvider`.
-     * If an `HttpClientOptions` object is provided, it is used as the configuration for the new client instance.
-     *
-     * The method sets up the HTTP client with the following options:
-     * - `baseUri`: The base URI for the HTTP client.
-     * - `defaultScopes`: The default scopes to be used for authentication.
-     * - `onCreate`: An optional callback function that is called when the client instance is created.
-     * - `ctor`: The constructor function for the HTTP client, defaulting to the configured `defaultHttpClientCtor`.
-     * - `requestHandler`: The HTTP request handler to be used by the client, defaulting to the `defaultHttpRequestHandler`.
-     *
-     * The created HTTP client instance is returned.
-     */
-    createClient(keyOrConfig) {
-        const config = this._resolveConfig(keyOrConfig);
-        const { baseUri, defaultScopes = [], onCreate, ctor = this.config.defaultHttpClientCtor, requestHandler = this.defaultHttpRequestHandler, } = config;
-        const options = { requestHandler };
-        const instance = new ctor(baseUri || '', options);
-        Object.assign(instance, { defaultScopes });
-        onCreate?.(instance);
-        return instance;
-    }
-    /**
-     * Creates a new HTTP client instance with the specified configuration.
-     *
-     * @param key - The key of the pre-configured HTTP client to create.
-     * @returns The created HTTP client instance, cast to the specified type `T`.
-     *
-     * @remarks
-     * This method delegates to the `createClient` method, but casts the returned
-     * instance to the specified type `T`. This can be useful when you need to
-     * work with a specific HTTP client implementation, but the `HttpClientProvider`
-     * is configured to use a different implementation.
-     */
-    createCustomClient(key) {
-        return this.createClient(key);
-    }
-    /**
-     * Resolves the configuration for an HTTP client based on the provided `keyOrConfig` parameter.
-     *
-     * If a string is provided, it is treated as the key for a pre-configured client in the `HttpClientProvider`.
-     * If an `HttpClientOptions` object is provided, it is used as the configuration for the new client instance.
-     *
-     * @param keyOrConfig - The key or configuration object for the HTTP client.
-     * @returns The resolved HTTP client configuration.
-     */
-    _resolveConfig(keyOrConfig) {
-        if (typeof keyOrConfig === 'string') {
-            const config = this.config.clients[keyOrConfig];
-            if (!config && isURL(keyOrConfig)) {
-                return { baseUri: keyOrConfig };
-            }
-            else if (!config) {
-                throw new ClientNotFoundException(`No registered http client for key [${keyOrConfig}]`);
-            }
-            return config;
-        }
-        return keyOrConfig;
-    }
-}
-
-function fromFetch(input, initWithSelector) {
-    if (initWithSelector === void 0) { initWithSelector = {}; }
-    var selector = initWithSelector.selector, init = __rest(initWithSelector, ["selector"]);
-    return new Observable(function (subscriber) {
-        var controller = new AbortController();
-        var signal = controller.signal;
-        var abortable = true;
-        var outerSignal = init.signal;
-        if (outerSignal) {
-            if (outerSignal.aborted) {
-                controller.abort();
-            }
-            else {
-                var outerSignalHandler_1 = function () {
-                    if (!signal.aborted) {
-                        controller.abort();
-                    }
-                };
-                outerSignal.addEventListener('abort', outerSignalHandler_1);
-                subscriber.add(function () { return outerSignal.removeEventListener('abort', outerSignalHandler_1); });
-            }
-        }
-        var perSubscriberInit = __assign(__assign({}, init), { signal: signal });
-        var handleError = function (err) {
-            abortable = false;
-            subscriber.error(err);
-        };
-        fetch(input, perSubscriberInit)
-            .then(function (response) {
-            if (selector) {
-                innerFrom(selector(response)).subscribe(createOperatorSubscriber(subscriber, undefined, function () {
-                    abortable = false;
-                    subscriber.complete();
-                }, handleError));
-            }
-            else {
-                abortable = false;
-                subscriber.next(response);
-                subscriber.complete();
-            }
-        })
-            .catch(handleError);
-        return function () {
-            if (abortable) {
-                controller.abort();
-            }
-        };
-    });
-}
-
 /**
  * Represents an error that occurs when handling an HTTP response.
  * @template TResponse The type of the HTTP response.
@@ -20944,80 +20794,6 @@ class ServerSentEventResponseError extends HttpResponseError {
     }
 }
 
-/**
- * Asynchronously parses the JSON data from a given HTTP response.
- *
- * If the response has a status code of 204 (No Content), this function will resolve with `undefined`.
- *
- * If the response is not successful (i.e. `response.ok` is `false`), this function will throw an `HttpJsonResponseError` with the response details and the parsed data (if any).
- *
- * If there is an error parsing the JSON data, this function will throw an `HttpJsonResponseError` with the parsing error and the original response.
- *
- * @template TType - The expected type of the parsed JSON data.
- * @template TResponse - The type of the HTTP response object.
- * @param response - The HTTP response to parse.
- * @returns A promise that resolves with the parsed JSON data, or rejects with an `HttpJsonResponseError`.
- */
-const jsonSelector = async (response) => {
-    /** Status code 204 indicates no content in the response */
-    if (response.status === 204) {
-        return Promise.resolve();
-    }
-    try {
-        // Parse the response JSON data
-        const data = await response.json();
-        // Check if the response was successful
-        if (!response.ok) {
-            // Throw an error with the response details
-            throw new HttpJsonResponseError('network response was not OK', response, { data });
-        }
-        // Return the parsed data
-        return data;
-    }
-    catch (cause) {
-        // If the cause is an HttpJsonResponseError, rethrow it
-        if (cause instanceof HttpJsonResponseError) {
-            throw cause;
-        }
-        // Otherwise, throw a new HttpJsonResponseError with the parsing error
-        throw new HttpJsonResponseError('failed to parse response', response, { cause });
-    }
-};
-
-/**
- * Extracts a blob and filename from a successful HTTP response.
- *
- * @param response - The HTTP response to extract the blob and filename from.
- * @returns A promise that resolves to an object containing the extracted blob and filename.
- * @throws {Error} If the response is not successful or if there is an error parsing the response.
- */
-const blobSelector = async (response) => {
-    if (!response.ok) {
-        // Throw an error if the network response is not successful
-        throw new Error('network response was not OK');
-    }
-    // Status code 204 indicates no content, so throw an error
-    if (response.status === 204) {
-        throw new Error('no content');
-    }
-    // Extract the filename from the 'content-disposition' header
-    const filename = response.headers
-        .get('content-disposition')
-        ?.split(';')
-        .find((n) => n.includes('filename='))
-        ?.replace('filename=', '')
-        ?.trim();
-    try {
-        // Convert the response to a Blob and return the filename and Blob
-        const blob = await response.blob();
-        return { filename, blob };
-    }
-    catch (err) {
-        // Throw an error if there's a problem parsing the response
-        throw Error('failed to parse response');
-    }
-};
-
 const defaultDataParser = (data) => {
     try {
         return JSON.parse(data);
@@ -21178,6 +20954,303 @@ const createSseSelector = (options) => {
     };
 };
 
+/** @inheritdoc */
+class HttpClientConfigurator {
+    _clients = {};
+    /** Gets a shallow clone of all named client configurations. */
+    get clients() {
+        return { ...this._clients };
+    }
+    /** Default constructor used when a client configuration does not provide `ctor`. */
+    defaultHttpClientCtor;
+    /** Default request handler pipeline cloned into each created client instance. */
+    defaultHttpRequestHandler = new HttpRequestHandler({
+        // convert all request methods to uppercase
+        'capitalize-method': capitalizeRequestMethodOperator(),
+        // validate the request object
+        'request-validation': requestValidationOperator(),
+    });
+    /**
+     * Creates a configurator with the default client constructor.
+     * @param client - The default client constructor used when `ctor` is not configured per client.
+     */
+    constructor(client) {
+        this.defaultHttpClientCtor = client;
+    }
+    /** @inheritdoc */
+    hasClient(name) {
+        return Object.keys(this._clients).includes(name);
+    }
+    /** @inheritdoc */
+    configureClient(name, args) {
+        const argFn = typeof args === 'string' ? { baseUri: args } : args;
+        const options = typeof argFn === 'function' ? { onCreate: argFn } : argFn;
+        this._clients[name] = {
+            ...this._clients[name],
+            ...options,
+        };
+        return this;
+    }
+}
+
+// Generated by genversion.
+const version$6 = '8.0.0';
+
+/**
+ * Thrown when `createClient(name)` is called with an unknown client key.
+ *
+ * This is only used when the provided string is neither a registered client name
+ * nor an absolute `http:` or `https:` URL.
+ */
+class ClientNotFoundException extends Error {
+}
+/** URL protocols accepted as valid ad-hoc base URIs. */
+const SUPPORTED_PROTOCOLS = ['http:', 'https:', 'ws:', 'wss:'];
+/**
+ * Checks if a given string is a valid absolute URL with a supported protocol.
+ * @param url - The string to check.
+ * @returns `true` when the string uses one of {@link SUPPORTED_PROTOCOLS}.
+ */
+const isURL = (url) => {
+    try {
+        const parsed = new URL(url);
+        return SUPPORTED_PROTOCOLS.includes(parsed.protocol);
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Heuristic check for strings that look like a bare hostname or URL without a
+ * protocol prefix (e.g. `api.example.com` or `api.example.com/v1`).
+ *
+ * Used to emit a deprecation warning when callers rely on the old (pre-patch)
+ * behaviour that accepted protocol-less URLs.
+ */
+const looksLikeURL = (value) => !value.includes(' ') && /^[a-z\d]([a-z\d-]*\.)+[a-z]{2,}/i.test(value);
+/**
+ * The `HttpClientProvider` class is responsible for managing HTTP client instances and their configuration.
+ * It provides methods to check if a client is configured, create new client instances, and create custom client instances.
+ */
+class HttpClientProvider extends BaseModuleProvider {
+    config;
+    /**
+     * Gets the default HTTP request handler for the HTTP client provider.
+     * @returns The default HTTP request handler.
+     */
+    get defaultHttpRequestHandler() {
+        return this.config.defaultHttpRequestHandler;
+    }
+    constructor(config) {
+        super({
+            version: version$6,
+            config,
+        });
+        this.config = config;
+    }
+    /**
+     * Checks if a client with the given key is configured in the `HttpClientProvider`.
+     * @param key - The key of the HTTP client to check.
+     * @returns `true` if a client with the given key is configured, `false` otherwise.
+     */
+    hasClient(key) {
+        return Object.keys(this.config.clients).includes(key);
+    }
+    /**
+     * Creates a fresh HTTP client instance from a named or ad-hoc configuration.
+     *
+     * @param keyOrConfig - The key or configuration object for the HTTP client.
+     * @returns The created HTTP client instance.
+     *
+     * @remarks
+     * This method resolves the configuration for the HTTP client based on the provided `keyOrConfig` parameter.
+     * If a string is provided, it is treated as the key for a pre-configured client in the `HttpClientProvider`.
+     * If an `HttpClientOptions` object is provided, it is used as the configuration for the new client instance.
+     *
+     * The method applies `baseUri`, `defaultScopes`, `requestHandler`, `responseHandler`,
+     * a custom `ctor` when configured, and finally runs `onCreate` for the newly created instance.
+     *
+     * The created HTTP client instance is returned.
+     */
+    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 instance = new ctor(baseUri || '', options);
+        Object.assign(instance, { defaultScopes });
+        onCreate?.(instance);
+        return instance;
+    }
+    /**
+     * Creates a client instance and returns it as the requested custom client type.
+     *
+     * @param key - The key of the pre-configured HTTP client to create.
+     * @returns The created HTTP client instance, cast to the specified type `T`.
+     *
+     * @remarks
+     * This method delegates to the `createClient` method, but casts the returned
+     * instance to the specified type `T`. This can be useful when you need to
+     * work with a specific HTTP client implementation, but the `HttpClientProvider`
+     * is configured to use a different implementation.
+     */
+    createCustomClient(key) {
+        return this.createClient(key);
+    }
+    /**
+     * Resolves the configuration for an HTTP client based on the provided `keyOrConfig` parameter.
+     *
+     * If a string is provided, it is treated as either a pre-configured client key or,
+     * when it is an absolute `http:` or `https:` URL, as an ad-hoc `baseUri`.
+     * If an `HttpClientOptions` object is provided, it is used directly as the configuration for the new client instance.
+     *
+     * @param keyOrConfig - The key or configuration object for the HTTP client.
+     * @returns The resolved HTTP client configuration.
+     */
+    _resolveConfig(keyOrConfig) {
+        if (typeof keyOrConfig === 'string') {
+            const config = this.config.clients[keyOrConfig];
+            if (!config && isURL(keyOrConfig)) {
+                return { baseUri: keyOrConfig };
+            }
+            else if (!config && looksLikeURL(keyOrConfig)) {
+                console.warn(`[HttpClientProvider] "${keyOrConfig}" looks like a URL but is missing the http:// or https:// protocol. ` +
+                    `Treating it as "https://${keyOrConfig}". ` +
+                    `Pass a fully-qualified URL to silence this warning.`);
+                return { baseUri: `https://${keyOrConfig}` };
+            }
+            else if (!config) {
+                throw new ClientNotFoundException(`No registered http client for key [${keyOrConfig}]`);
+            }
+            return config;
+        }
+        return keyOrConfig;
+    }
+}
+
+function fromFetch(input, initWithSelector) {
+    if (initWithSelector === void 0) { initWithSelector = {}; }
+    var selector = initWithSelector.selector, init = __rest(initWithSelector, ["selector"]);
+    return new Observable(function (subscriber) {
+        var controller = new AbortController();
+        var signal = controller.signal;
+        var abortable = true;
+        var outerSignal = init.signal;
+        if (outerSignal) {
+            if (outerSignal.aborted) {
+                controller.abort();
+            }
+            else {
+                var outerSignalHandler_1 = function () {
+                    if (!signal.aborted) {
+                        controller.abort();
+                    }
+                };
+                outerSignal.addEventListener('abort', outerSignalHandler_1);
+                subscriber.add(function () { return outerSignal.removeEventListener('abort', outerSignalHandler_1); });
+            }
+        }
+        var perSubscriberInit = __assign(__assign({}, init), { signal: signal });
+        var handleError = function (err) {
+            abortable = false;
+            subscriber.error(err);
+        };
+        fetch(input, perSubscriberInit)
+            .then(function (response) {
+            if (selector) {
+                innerFrom(selector(response)).subscribe(createOperatorSubscriber(subscriber, undefined, function () {
+                    abortable = false;
+                    subscriber.complete();
+                }, handleError));
+            }
+            else {
+                abortable = false;
+                subscriber.next(response);
+                subscriber.complete();
+            }
+        })
+            .catch(handleError);
+        return function () {
+            if (abortable) {
+                controller.abort();
+            }
+        };
+    });
+}
+
+/**
+ * Asynchronously parses the JSON data from a given HTTP response.
+ *
+ * If the response has a status code of 204 (No Content), this function will resolve with `undefined`.
+ *
+ * If the response is not successful (i.e. `response.ok` is `false`), this function will throw an `HttpJsonResponseError` with the response details and the parsed data (if any).
+ *
+ * If there is an error parsing the JSON data, this function will throw an `HttpJsonResponseError` with the parsing error and the original response.
+ *
+ * @template TType - The expected type of the parsed JSON data.
+ * @template TResponse - The type of the HTTP response object.
+ * @param response - The HTTP response to parse.
+ * @returns A promise that resolves with the parsed JSON data, or rejects with an `HttpJsonResponseError`.
+ */
+const jsonSelector = async (response) => {
+    /** Status code 204 indicates no content in the response */
+    if (response.status === 204) {
+        return Promise.resolve();
+    }
+    try {
+        // Parse the response JSON data
+        const data = await response.json();
+        // Check if the response was successful
+        if (!response.ok) {
+            // Throw an error with the response details
+            throw new HttpJsonResponseError('network response was not OK', response, { data });
+        }
+        // Return the parsed data
+        return data;
+    }
+    catch (cause) {
+        // If the cause is an HttpJsonResponseError, rethrow it
+        if (cause instanceof HttpJsonResponseError) {
+            throw cause;
+        }
+        // Otherwise, throw a new HttpJsonResponseError with the parsing error
+        throw new HttpJsonResponseError('failed to parse response', response, { cause });
+    }
+};
+
+/**
+ * Extracts a blob and filename from a successful HTTP response.
+ *
+ * @param response - The HTTP response to extract the blob and filename from.
+ * @returns A promise that resolves to an object containing the extracted blob and filename.
+ * @throws {Error} If the response is not successful or if there is an error parsing the response.
+ */
+const blobSelector = async (response) => {
+    if (!response.ok) {
+        // Throw an error if the network response is not successful
+        throw new Error('network response was not OK');
+    }
+    // Status code 204 indicates no content, so throw an error
+    if (response.status === 204) {
+        throw new Error('no content');
+    }
+    // Extract the filename from the 'content-disposition' header
+    const filename = response.headers
+        .get('content-disposition')
+        ?.split(';')
+        .find((n) => n.includes('filename='))
+        ?.replace('filename=', '')
+        ?.trim();
+    try {
+        // Convert the response to a Blob and return the filename and Blob
+        const blob = await response.blob();
+        return { filename, blob };
+    }
+    catch (err) {
+        // Throw an error if there's a problem parsing the response
+        throw Error('failed to parse response');
+    }
+};
+
 /** Base http client for executing requests */
 class HttpClient {
     uri;
@@ -21332,15 +21405,15 @@ class HttpClient {
      * @returns A `StreamResponse` that emits `ServerSentEvent<T>` objects as they are received from the server.
      *
      * @example
-     * const sse$ = httpClient.sse(
-     *  '/events',
-     *  { method: 'POST', body: JSON.stringify({ prompt: 'tell me a joke' }) },
-     *  { eventFilter: ['message'] }
+     * const sse$ = httpClient.sse$(
+     *   '/events',
+     *   { method: 'POST', body: JSON.stringify({ prompt: 'tell me a joke' }) },
+     *   { eventFilter: ['message'] },
      * );
      * sse$.subscribe({
-     *  next: (event) => console.log(event),
-     *  error: (err) => console.error(err),
-     *  complete: () => console.log('Completed'),
+     *   next: (event) => console.log(event),
+     *   error: (err) => console.error(err),
+     *   complete: () => console.log('Completed'),
      * });
      */
     sse$(path, args, options) {
@@ -21397,6 +21470,7 @@ class HttpClient {
         const { selector, ...options } = args || {};
         const response$ = of({
             ...options,
+            path,
             uri: this._resolveUrl(path),
         }).pipe(
         /** prepare request, allow extensions to modify request  */
@@ -21503,16 +21577,21 @@ class HttpClientMsal extends HttpClient {
          * Merges the default scopes defined in the `HttpClientMsal` class with the scopes provided in the `init` parameter, if any.
          * This ensures that the request includes the necessary scopes for MSAL authentication.
          */
-        const args = Object.assign(init || {}, {
+        const args = {
+            ...init,
             scopes: this.defaultScopes.concat(init?.scopes || []),
-        });
+        };
         return super._fetch$(path, args);
     }
 }
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
- * HTTP module with MSAL authentication.
+ * Default HTTP module definition for Fusion Framework applications.
+ *
+ * The module uses `HttpClientMsal` as the default client implementation and,
+ * when the auth module is available, installs a request handler that can acquire
+ * bearer tokens for scoped requests.
  */
 const module$4 = {
     name: 'http',
@@ -21561,15 +21640,14 @@ const module$4 = {
     },
 };
 /**
- * Configures the HTTP client with MSAL authentication.
+ * Creates a module configurator that registers one named HTTP client.
  *
- * This function creates a module configurator that can be used to configure the HTTP module
- * with MSAL authentication. The configurator takes a name and a set of HTTP client options,
- * and returns a module configurator that can be used to configure the HTTP module.
+ * This is the convenience API for the common case where a setup step only needs to
+ * register one client with `baseUri`, `defaultScopes`, handlers, or a custom constructor.
  *
- * @param name - The name of the HTTP client configuration.
- * @param args - The HTTP client options, including the MSAL configuration.
- * @returns A module configurator that can be used to configure the HTTP module.
+ * @param name - The client key used later with `createClient(name)`.
+ * @param args - The named client configuration.
+ * @returns A module configurator that registers the named client.
  */
 const configureHttpClient = (name, args) => ({
     module: module$4,
@@ -22437,12 +22515,58 @@ var immer = new Immer2();
 var produce = immer.produce;
 var castDraft = (value) => value;
 
+/**
+ * RxJS operator that filters an action stream to only emit actions matching
+ * one or more specified action types.
+ *
+ * @template TAction - The union of possible action types in the stream.
+ * @template TType - The specific action type constant(s) to filter for.
+ * @param types - One or more action type strings to filter by.
+ * @returns An `OperatorFunction` that narrows the stream to matching actions.
+ *
+ * @example
+ * ```ts
+ * import { filterAction } from '@equinor/fusion-observable/operators';
+ *
+ * action$.pipe(
+ *   filterAction('increment', 'decrement'),
+ * ).subscribe((action) => {
+ *   // action is narrowed to increment | decrement
+ * });
+ * ```
+ */
 const filterAction = (...types) => filter((x) => types.includes(x.type));
 
 /**
- * A specialized Observable that maintains internal state, which can be mutated by dispatching actions.
+ * A specialized Observable that maintains internal state mutated by dispatching actions.
+ *
  * Actions are processed sequentially by a reducer function to produce new state values.
- * This class extends from Observable to allow subscribers to react to state changes over time.
+ * Extends `Observable` so subscribers react to state changes over time.
+ *
+ * Inspired by Redux-style state management but built on top of RxJS, `FlowSubject`
+ * combines a `BehaviorSubject` for state with a `Subject` for actions, providing
+ * a reactive, observable state container.
+ *
+ * @template S - The state type managed by this subject.
+ * @template A - The action type dispatched to this subject.
+ *
+ * @example
+ * ```ts
+ * import { FlowSubject, createReducer } from '@equinor/fusion-observable';
+ *
+ * type State = { count: number };
+ * type Action = { type: 'increment' } | { type: 'decrement' };
+ *
+ * const reducer = createReducer<State, Action>({ count: 0 }, (builder) =>
+ *   builder
+ *     .addCase('increment', (state) => { state.count += 1; })
+ *     .addCase('decrement', (state) => { state.count -= 1; }),
+ * );
+ *
+ * const subject = new FlowSubject(reducer);
+ * subject.subscribe((state) => console.log(state.count));
+ * subject.next({ type: 'increment' }); // logs: 1
+ * ```
  */
 class FlowSubject extends Observable {
     /**
@@ -22539,21 +22663,38 @@ class FlowSubject extends Observable {
             .subscribe(this.#action);
     }
     /**
-     * Deprecated. Use `addFlow` instead.
+     * @deprecated Use {@link FlowSubject.addFlow} instead.
      *
-     * @deprecated use `addFlow`
-     *
-     * @param fn The flow function to execute.
+     * @param fn - The flow function to execute.
      * @returns A subscription to the flow.
      */
     addEpic(fn) {
         return this.addFlow(fn);
     }
     /**
-     * Adds a flow that listens for actions and performs side effects.
+     * Adds a flow (epic-style) that transforms the action stream and optionally
+     * reads state, then emits new actions back into the subject.
      *
-     * @param fn The flow function to execute.
-     * @returns A subscription to the flow.
+     * Flows receive the full `action$` stream and the state observable, and must
+     * return an `Observable<A>`. This is useful for complex async orchestration.
+     *
+     * @param fn - The flow function that receives `(action$, state$)` and returns an action observable.
+     * @returns A subscription to the flow. Unsubscribe to remove the flow.
+     * @throws {TypeError} If the flow function does not return an observable.
+     *
+     * @example
+     * ```ts
+     * subject.addFlow((action$) =>
+     *   action$.pipe(
+     *     filterAction('fetchData'),
+     *     switchMap((action) =>
+     *       fetchApi(action.payload).pipe(
+     *         map((data) => ({ type: 'fetchSuccess', payload: data })),
+     *       ),
+     *     ),
+     *   ),
+     * );
+     * ```
      */
     addFlow(fn) {
         const epic$ = fn(this.action$, this);
@@ -22568,23 +22709,27 @@ class FlowSubject extends Observable {
             .subscribe(this.#action);
     }
     /**
-     * Unsubscribes from actions and removes subscribers.
+     * Tears down the subject by unsubscribing both the action and state subjects.
+     *
+     * After calling this method, the subject is no longer usable.
      */
     unsubscribe() {
         this.#action.unsubscribe();
         this.#state.unsubscribe();
     }
     /**
-     * Finalizes the subject and completes observers.
+     * Completes both the action and state subjects, signalling to all
+     * subscribers that no further values will be emitted.
      */
     complete() {
         this.#action.complete();
         this.#state.complete();
     }
     /**
-     * Clones the subject to a simple observable.
+     * Returns a plain `Observable` of the state, hiding the subject's
+     * `next`, `complete`, and other mutation methods.
      *
-     * @returns An observable of the state.
+     * @returns A read-only observable of the state.
      */
     asObservable() {
         return this.#state.asObservable();
@@ -23158,7 +23303,7 @@ class TelemetryConfigurator extends BaseConfigBuilder {
 }
 
 // Generated by genversion.
-const version$5 = '4.6.4';
+const version$5 = '5.0.0';
 
 /**
  * Enum representing the severity levels of telemetry items.
@@ -23310,6 +23455,12 @@ class FrameworkEvent {
     #cancelable;
     #canBubble;
     #created = Date.now();
+    /**
+     * Creates a new framework event.
+     *
+     * @param __type - The event name used for listener matching.
+     * @param args - Initialization options including detail payload, source, and flags.
+     */
     constructor(__type, args) {
         this.__type = __type;
         this.#detail = args.detail;
@@ -23568,6 +23719,16 @@ class Measurement {
     }
 }
 
+/**
+ * Resolves metadata from a {@link MetadataExtractor} into an observable stream.
+ *
+ * Converts the extractor (which may be a static value, promise, function, or observable)
+ * into a normalised `Observable` that emits the resolved metadata record.
+ *
+ * @param metadata - The metadata extractor to resolve.
+ * @param args - Context passed to the extractor, including the telemetry item and optional module instances.
+ * @returns An `Observable` emitting the resolved metadata record.
+ */
 const resolveMetadata = (metadata, args) => {
     return toObservable(metadata, args);
 };
@@ -24043,6 +24204,21 @@ configurator) => {
  * `attachConfiguratorEvents` allows for the automatic attachment of configurator events to the telemetry builder,
  * ensuring that relevant events are captured and processed. __NOTE__ if the configurator crashes before the telemetry
  * builder is fully initialized, some events may be missed.
+ *
+ * @example
+ * ```typescript
+ * import { enableTelemetry } from '@equinor/fusion-framework-module-telemetry';
+ *
+ * const configure = (configurator) => {
+ *   enableTelemetry(configurator, {
+ *     attachConfiguratorEvents: true,
+ *     configure: (builder) => {
+ *       builder.setAdapter('console', new ConsoleAdapter());
+ *       builder.setMetadata(() => ({ appVersion: '1.0.0' }));
+ *     },
+ *   });
+ * };
+ * ```
  */
 const enableTelemetry = (
 // biome-ignore lint/suspicious/noExplicitAny: must be any to support all module types
@@ -40555,7 +40731,7 @@ const createClientLogCallback = (provider, metadata, scope) => {
 };
 
 // Generated by genversion.
-const version$2 = '7.3.1';
+const version$2 = '8.0.0';
 
 /**
  * Zod schema for telemetry configuration validation.
@@ -40727,7 +40903,12 @@ class MsalConfigurator extends BaseConfigBuilder {
         return this;
     }
     /**
-     * @deprecated - since version 5.1.0, use setClient instead
+     * Sets a pre-configured MSAL provider instance directly.
+     *
+     * @deprecated Since version 5.1.0. Use {@link MsalConfigurator.setClient | setClient} instead.
+     *
+     * @param provider - Pre-configured provider instance, or undefined to clear
+     * @returns The configurator instance for method chaining
      */
     setProvider(provider) {
         this._set('provider', async () => provider);
@@ -40769,7 +40950,11 @@ class MsalConfigurator extends BaseConfigBuilder {
     }
     /**
      * Sets optional metadata to be included on all MSAL telemetry events.
-     * @deprecated Use setTelemetry({ metadata }) instead
+     *
+     * @deprecated Use {@link MsalConfigurator.setTelemetry | setTelemetry} instead.
+     *
+     * @param metadata - Key-value metadata to attach to telemetry events, or undefined to clear
+     * @returns The configurator instance for method chaining
      */
     setTelemetryMetadata(metadata) {
         this._set('telemetry.metadata', async () => metadata);
@@ -41062,10 +41247,13 @@ function resolveVersion(version) {
 }
 
 /**
- * Maps current AccountInfo to v2 AccountInfo format.
+ * Maps a current (v4/v5) `AccountInfo` object to the v2-compatible `AccountInfo` format.
+ *
+ * Strips properties that don't exist in v2, ensuring backward-compatible serialization
+ * and type safety when passing account data through the v2 proxy layer.
  *
- * @param account - The current AccountInfo to convert
- * @returns The v2 AccountInfo format
+ * @param account - The current MSAL v4/v5 `AccountInfo` to convert
+ * @returns A v2-compatible `AccountInfo` containing only fields recognised by MSAL v2 consumers
  */
 function mapAccountInfo(account) {
     return {
@@ -41080,10 +41268,14 @@ function mapAccountInfo(account) {
 }
 
 /**
- * Maps current AuthenticationResult to v2 AuthenticationResult format.
+ * Maps a current (v4/v5) `AuthenticationResult` to the v2-compatible format.
  *
- * @param result - The current AuthenticationResult to convert
- * @returns The v2 AuthenticationResult format
+ * Converts the full authentication result — including the nested account object —
+ * to the subset of fields that MSAL v2 consumers expect. This enables the v2 proxy
+ * layer to return type-safe results without exposing v4/v5-only properties.
+ *
+ * @param result - The current MSAL v4/v5 `AuthenticationResult` to convert
+ * @returns A v2-compatible `AuthenticationResult` with mapped account and token fields
  */
 function mapAuthenticationResult(result) {
     return {
@@ -41101,22 +41293,24 @@ function mapAuthenticationResult(result) {
 }
 
 /**
- * Creates a v2-compatible proxy for MSAL PublicClientApplication.
+ * Creates a v2-compatible proxy wrapper around an MSAL v4 client.
  *
- * This function creates a proxy that wraps the MSAL v4 PublicClientApplication
- * and provides v2-compatible method signatures and return types.
+ * The proxy intercepts property access on the v4 `IMsalClient` and adapts method
+ * signatures, return types, and account data to match the v2 `IAuthClient` interface.
+ * This allows consumer code written against MSAL v2 to continue working unchanged
+ * while the underlying implementation uses MSAL v4/v5.
  *
- * @param client - The MSAL v4 PublicClientApplication instance
- * @returns A proxy client with v2-compatible interface
+ * @param client - The MSAL v4 `IMsalClient` instance to wrap
+ * @returns A proxy implementing the v2-compatible `IAuthClient` interface
  *
  * @example
  * ```typescript
- * const v4Client = new PublicClientApplication(config);
- * const v2Client = createProxyClient_v2(v4Client);
+ * const v4Client = new MsalClient(config);
+ * const v2Client = createProxyClient(v4Client);
  *
  * // Use v2-compatible methods
  * const accounts = v2Client.getAllAccounts();
- * const token = await v2Client.acquireTokenSilent({ scopes: ['User.Read'], account });
+ * const result = await v2Client.acquireTokenSilent({ scopes: ['User.Read'], account });
  * ```
  */
 function createProxyClient(client) {
@@ -41691,6 +41885,19 @@ class MsalProvider extends BaseModuleProvider {
      * Apps should call acquireToken with actual scopes after initialization completes.
      */
     async initialize() {
+        // Guard: skip authentication when running inside MSAL's hidden iframe.
+        // MSAL uses a hidden iframe for silent token renewal (acquireTokenSilent).
+        // The iframe loads the app URL, which would re-initialize MSAL and attempt
+        // loginRedirect(), causing the "block_iframe_reload" error.  Detect this
+        // by checking if we're in an iframe and the URL contains MSAL's hash params.
+        if (typeof window !== 'undefined' && window !== window.parent) {
+            // Running inside an iframe — let the parent handle authentication.
+            // Still initialize the client so handleRedirectPromise can process
+            // the auth response and post it back to the parent frame.
+            await this.#client.initialize();
+            await this.#client.handleRedirectPromise();
+            return;
+        }
         const measurement = this._trackMeasurement('initialize', TelemetryLevel.Debug);
         // Initialize the underlying MSAL client first
         await this.#client.initialize();
@@ -41826,10 +42033,14 @@ class MsalProvider extends BaseModuleProvider {
      * ```
      */
     async acquireToken(options) {
+        // Guard: when running inside MSAL's hidden iframe, only attempt silent
+        // acquisition.  Interactive flows (redirect/popup) must never be triggered
+        // from an iframe — MSAL will throw "block_iframe_reload".
+        const inIframe = typeof window !== 'undefined' && window !== window.parent;
         // Determine behavior and silent options, with defaults (redirect and true respectively)
-        const behavior = options?.behavior ?? 'redirect';
-        // Silent mode defaults to true, meaning the provider will attempt silent token acquisition first
-        const silent = options?.silent ?? true;
+        const behavior = inIframe ? 'redirect' : (options?.behavior ?? 'redirect');
+        // When in an iframe, force silent-only to prevent interactive fallback
+        const silent = inIframe ? true : (options?.silent ?? true);
         const defaultScopes = this.defaultScopes;
         const inputRequest = options?.request;
         // Determine the account to use for token acquisition, prioritizing request-specific account, then active account
@@ -41877,6 +42088,15 @@ class MsalProvider extends BaseModuleProvider {
             return result;
         }
         catch (error) {
+            // Inside MSAL's hidden iframe, silent acquisition may fail and the client
+            // would fall back to acquireTokenRedirect which throws "block_iframe_reload".
+            // Suppress this — the parent frame handles interactive auth.
+            if (inIframe) {
+                this._trackEvent('acquireToken.suppressed-in-iframe', TelemetryLevel.Debug, {
+                    properties: telemetryProperties,
+                });
+                return undefined;
+            }
             this._trackException('acquireToken-failed', TelemetryLevel.Error, {
                 exception: error,
                 properties: telemetryProperties,
@@ -41932,6 +42152,10 @@ class MsalProvider extends BaseModuleProvider {
      * ```
      */
     async login(options) {
+        // Guard: never attempt interactive login inside MSAL's hidden iframe.
+        if (typeof window !== 'undefined' && window !== window.parent) {
+            return undefined;
+        }
         const { behavior = 'redirect', silent = true, request } = options;
         request.loginHint ??=
             this.#loginHint ?? this.account?.username ?? this.account?.loginHint ?? undefined;
@@ -42309,11 +42533,26 @@ const mergeQueue = (...args) => (source$) => source$.pipe(mergeMap(...args));
  */
 const switchQueue = (...args) => (source$) => source$.pipe(switchMap(...args));
 /**
- * Transforms an Observable stream of `QueryTaskValue<TType>` into an Observable stream of `TType`.
- * It extracts the `value` property from each `QueryTaskValue<TType>` in the stream.
+ * Transforms a query result Observable into a plain value Observable by extracting the `value` property.
+ *
+ * Use this operator to strip query metadata (status, transaction, timestamps) from
+ * the result stream when only the raw data is needed.
  *
- * @param source$ - An Observable stream of `QueryTaskValue<TType>`.
- * @returns An Observable stream of `TType` where each emitted item is the `value` property from the input stream.
+ * @template TType - The type of the data value extracted from the query result.
+ * @template TArgs - The type of the query arguments.
+ *
+ * @param source$ - An Observable stream of query task results (cached or completed).
+ * @returns An Observable stream of `TType` where each emission is the extracted value.
+ *
+ * @example
+ * ```typescript
+ * import { Query, operators } from '@equinor/fusion-query';
+ *
+ * const query = new Query({ client: { fn: fetchUser }, key: (args) => args.id });
+ * query.query({ id: '123' }).pipe(operators.queryValue).subscribe(user => {
+ *   console.log(user.name);
+ * });
+ * ```
  */
 const queryValue = (source$) => source$.pipe(map$1((entry) => entry.value));
 
@@ -43175,6 +43414,12 @@ class QueryClient extends Observable {
     getRequest(transaction) {
         return this.#state.value[transaction];
     }
+    /**
+     * Retrieves the request associated with the specified reference string.
+     *
+     * @param ref - The reference identifier to search for.
+     * @returns The request matching the reference, or `undefined` if not found.
+     */
     getRequestByRef(ref) {
         return Object.values(this.#state.value).find((x) => x.ref === ref);
     }
@@ -43715,7 +43960,13 @@ class QueryTask extends Subject {
 }
 
 /**
- * Base class for Query events
+ * Concrete event class emitted by the {@link Query} instance itself.
+ *
+ * Represents lifecycle events for query creation, completion, caching, and job management.
+ * Subscribers can use `instanceof QueryEvent` to filter for query-level events
+ * when the aggregated `event$` stream also contains client and cache events.
+ *
+ * @template TData - The type of data payload carried by this event.
  */
 class QueryEvent {
     type;
@@ -43835,8 +44086,12 @@ const getQueueOperator = (type = 'switch') => {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 class Query {
     /**
-     * A static method that extracts the value from a query task.
-     * It is a utility function that can be used externally to access the result of a task.
+     * Static utility that extracts the raw value from a query result Observable.
+     *
+     * Transforms a stream of `QueryTaskValue<TType>` into a plain `Observable<TType>`,
+     * stripping away query metadata such as status, transaction, and timestamps.
+     *
+     * @see {@link queryValue} for the standalone operator function.
      */
     static extractQueryValue = queryValue;
     /**
@@ -44109,6 +44364,21 @@ class Query {
             fn(this._query(payload, args).pipe(throwIfEmpty())).then(resolve, reject);
         });
     }
+    /**
+     * Executes a query that remains subscribed to cache mutations after the initial fetch completes.
+     *
+     * Unlike {@link Query.query}, which completes after emitting the result, `persistentQuery`
+     * continues to emit whenever the underlying cache entry is updated or mutated.
+     * This is useful for scenarios where the UI must reflect optimistic updates,
+     * background refetches, or external cache mutations in real time.
+     *
+     * The returned Observable deduplicates emissions based on the transaction identifier
+     * and mutation timestamp, so subscribers only receive meaningful state changes.
+     *
+     * @param args - The arguments to pass to the query function.
+     * @param options - Optional query options including signal, retry, and cache validation overrides.
+     * @returns An Observable that emits cached and completed results, and continues emitting on cache mutations.
+     */
     persistentQuery(args, options) {
         const key = this.#generateCacheKey(args);
         const original = this._query(args, options);
@@ -44340,7 +44610,12 @@ class Query {
 }
 
 /**
- * Represents a service from the service discovery API.
+ * Zod schema for a single service object returned by the service
+ * discovery API.
+ *
+ * Validates required fields (`key`, `uri`) and optional metadata, then
+ * transforms the result to include a backward-compatible `defaultScopes`
+ * accessor.
  */
 const ApiService = z
     .object({
@@ -44361,26 +44636,29 @@ const ApiService = z
     },
 }));
 /**
- * Represents a list of services from the service discovery API.
- *
- * This constant is an array of `ApiService` objects, which are defined
- * elsewhere in the codebase. It uses the `z.array` method from the Zod
- * library to enforce that the array contains only `ApiService` objects.
+ * Zod schema for the service list returned by the service discovery API.
  *
- * @constant
- * @description A list of services from the service discovery API.
+ * Parses and validates an array of service objects, each conforming to the
+ * `ApiService` schema above. Used internally by
+ * {@link ServiceDiscoveryClient} to validate API responses.
  */
 const ApiServices = z
     .array(ApiService)
     .describe('A list of services from the service discovery API');
 
+/** Cache key used by the internal {@link Query} instance. */
 const queryKey = 'services';
 /**
- * Transforms a Response object into an ObservableInput of Service arrays.
+ * Transforms a fetch {@link Response} into an observable that emits a
+ * validated array of {@link Service} objects.
+ *
+ * The response body is parsed as JSON, validated against the
+ * {@link ApiServices} Zod schema, and optionally piped through a
+ * `postProcess` operator (used for session overrides).
  *
- * @param response - The Response object to be transformed.
- * @param postProcess - Optional callback to process the value.
- * @returns An ObservableInput that emits an array of Service objects.
+ * @param response - Raw fetch response from the service discovery API.
+ * @param postProcess - Optional RxJS operator to transform the parsed list.
+ * @returns An `ObservableInput` emitting the final `Service[]`.
  */
 const serviceResponseSelector = (response, postProcess) => {
     // parse response by using the jsonSelector
@@ -44392,12 +44670,26 @@ const serviceResponseSelector = (response, postProcess) => {
     }
     return result$;
 };
+/**
+ * Default service discovery client that fetches endpoints from a remote API,
+ * validates the response with Zod, caches results via {@link Query}, and
+ * supports `sessionStorage`-based overrides.
+ *
+ * @remarks
+ * Results are cached for 5 minutes. When `allow_cache` is `true`,
+ * {@link resolveServices} returns the first cached value immediately;
+ * otherwise it waits for the latest API response.
+ */
 class ServiceDiscoveryClient {
     #query;
-    /** Endpoint for fetching services from API  */
+    /** Sub-path appended to the HTTP client's base URI when fetching services. */
     endpoint;
-    /** HTTP client for fetching services */
+    /** HTTP client used to call the service discovery API. */
     http;
+    /**
+     * @param options - Construction options including the HTTP client,
+     *   optional endpoint path, and optional post-processing operator.
+     */
     constructor(options) {
         this.http = options.http;
         this.endpoint = options.endpoint;
@@ -44414,10 +44706,14 @@ class ServiceDiscoveryClient {
             expire: 5 * 60 * 1000,
         });
     }
+    /** {@inheritDoc IServiceDiscoveryClient.resolveServices} */
     resolveServices(allow_cache) {
+        // firstValueFrom returns the cached snapshot; lastValueFrom waits for
+        // the freshest value from the query
         const fn = allow_cache ? firstValueFrom : lastValueFrom;
         return fn(Query.extractQueryValue(this.#query.query()));
     }
+    /** {@inheritDoc IServiceDiscoveryClient.resolveService} */
     async resolveService(key, allow_cache) {
         const services = await this.resolveServices(allow_cache);
         const service = services.find((s) => s.key === key);
@@ -44428,7 +44724,38 @@ class ServiceDiscoveryClient {
     }
 }
 
+/**
+ * Configuration builder for the Service Discovery module.
+ *
+ * Provides a fluent API to set up how service endpoints are resolved.
+ * The simplest path is to call
+ * {@link ServiceDiscoveryConfigurator.configureServiceDiscoveryClientByClientKey | configureServiceDiscoveryClientByClientKey}
+ * with the HTTP client key that points to the service discovery backend.
+ *
+ * For full control, use
+ * {@link ServiceDiscoveryConfigurator.setServiceDiscoveryClient | setServiceDiscoveryClient}
+ * to supply a custom {@link IServiceDiscoveryClient} implementation.
+ *
+ * @example
+ * ```typescript
+ * enableServiceDiscovery(configurator, async (builder) => {
+ *   builder.configureServiceDiscoveryClientByClientKey('sd_custom', '/services/v2');
+ * });
+ * ```
+ */
 class ServiceDiscoveryConfigurator extends BaseConfigBuilder {
+    /**
+     * Creates the final {@link ServiceDiscoveryConfig}.
+     *
+     * When no explicit discovery client has been registered, this method
+     * auto-detects an HTTP client with key `"service_discovery"` and uses it
+     * as the default transport.
+     *
+     * @param init - Builder callback arguments providing module accessors.
+     * @param initial - Optional partial config inherited from a parent module.
+     * @returns The fully resolved configuration.
+     * @throws {Error} When the HTTP module is not registered.
+     */
     async _createConfig(init, initial) {
         if (!init.hasModule('http')) {
             throw new Error('http module is required');
@@ -44445,12 +44772,12 @@ class ServiceDiscoveryConfigurator extends BaseConfigBuilder {
         return lastValueFrom(from(super._createConfig(init, initial)));
     }
     /**
-     * Processes the service discovery configuration.
+     * Validates and finalizes the service discovery configuration.
      *
-     * @param config - A partial configuration object for service discovery.
-     * @param init - Initialization arguments for the configuration builder callback.
-     * @returns An observable input of the complete service discovery configuration.
-     * @throws Will throw an error if `discoveryClient` is not configured.
+     * @param config - Partial configuration assembled by the builder.
+     * @param init - Builder callback arguments.
+     * @returns An observable that emits the complete {@link ServiceDiscoveryConfig}.
+     * @throws {Error} When `discoveryClient` has not been configured.
      */
     _processConfig(config, init) {
         if (!config.discoveryClient) {
@@ -44459,22 +44786,50 @@ class ServiceDiscoveryConfigurator extends BaseConfigBuilder {
         return super._processConfig(config, init);
     }
     /**
-     * Sets the service discovery client.
+     * Sets the service discovery client directly.
+     *
+     * Accepts either a ready-made {@link IServiceDiscoveryClient} instance or a
+     * {@link ConfigBuilderCallback} that will be invoked during module
+     * initialization to produce one.
      *
-     * @param discoveryClient - An instance of `IServiceDiscoveryClient` or a callback function that returns an instance of `IServiceDiscoveryClient`.
+     * Use this method when you need full control over service resolution
+     * (e.g. a mock client for testing or a static service list).
      *
-     * This method configures the service discovery client by either directly setting the provided instance or by invoking the provided callback function to obtain the instance.
+     * @param discoveryClient - A client instance or an async factory function.
+     *
+     * @example
+     * ```typescript
+     * // Static / mock client
+     * builder.setServiceDiscoveryClient({
+     *   resolveServices: async () => [{ key: 'api', uri: 'https://localhost:5000', defaultScopes: [] }],
+     *   resolveService: async (key) => ({ key, uri: 'https://localhost:5000', defaultScopes: [] }),
+     * });
+     * ```
      */
     setServiceDiscoveryClient(discoveryClient) {
         this._set('discoveryClient', typeof discoveryClient === 'function' ? discoveryClient : async () => discoveryClient);
     }
     /**
-     * Configures the Service Discovery Client with the provided configuration callback.
+     * Configures a {@link ServiceDiscoveryClient} with a custom HTTP client and
+     * optional endpoint path.
+     *
+     * This is the mid-level configuration path: you supply the transport
+     * details and the module constructs a standard
+     * {@link ServiceDiscoveryClient} with built-in caching, response parsing,
+     * and `sessionStorage` override support.
      *
-     * @param configCallback - A callback function that takes an argument of type `{ httpClient: IHttpClient; endpoint?: string }`
-     * and returns a configuration object. The `httpClient` is required, while the `endpoint` is optional.
+     * @param configCallback - Async factory that must return
+     *   `{ httpClient, endpoint? }`. The `httpClient` is used to call the
+     *   service discovery API at the given `endpoint` (defaults to `""`).
+     * @throws {Error} When the factory does not return an `httpClient`.
      *
-     * @throws {Error} Throws an error if `httpClient` is not provided in the configuration.
+     * @example
+     * ```typescript
+     * builder.configureServiceDiscoveryClient(async ({ requireInstance }) => {
+     *   const http = await requireInstance('http');
+     *   return { httpClient: http.createClient('sd'), endpoint: '/services/v2' };
+     * });
+     * ```
      */
     configureServiceDiscoveryClient(configCallback) {
         this.setServiceDiscoveryClient(async (args) => {
@@ -44484,9 +44839,16 @@ class ServiceDiscoveryConfigurator extends BaseConfigBuilder {
                     http: httpClient,
                     endpoint,
                     postProcess: map$1((input) => {
+                        // Get a reference to sessionStorage from globalThis
+                        const storage = typeof globalThis !== 'undefined' ? globalThis.sessionStorage : undefined;
+                        // Check if sessionStorage is available before attempting to access it.
+                        // If sessionStorage is not available, return the input as is without attempting to apply any overrides.
+                        if (!storage) {
+                            return input;
+                        }
                         // Check if there are any session overrides in session storage.
                         try {
-                            const sessionOverrides = JSON.parse(sessionStorage.getItem('overriddenServiceDiscoveryUrls') || '{}');
+                            const sessionOverrides = JSON.parse(storage.getItem('overriddenServiceDiscoveryUrls') || '{}');
                             for (const [key, { url, scopes }] of Object.entries(sessionOverrides)) {
                                 const service = input.find((service) => service.key === key);
                                 // If the service can be found, override the values with the values
@@ -44509,17 +44871,24 @@ class ServiceDiscoveryConfigurator extends BaseConfigBuilder {
         });
     }
     /**
-     * Configures a service discovery client using the provided client key and optional endpoint.
+     * Configures service discovery using a named HTTP client key.
      *
-     * @param clientKey - The key used to identify the client.
-     * @param endpoint - An optional endpoint to be used by the service discovery client.
+     * This is the simplest configuration path. The HTTP module must already
+     * have a client registered under `clientKey`. If `endpoint` is omitted
+     * the client calls the root path of the HTTP client's base URI.
      *
-     * @remarks
-     * The http module must have a configured client which match provided `clientKey`.
+     * @param clientKey - Key of the HTTP client to use for service discovery
+     *   requests (must match an entry in the HTTP module configuration).
+     * @param endpoint - Optional sub-path appended to the client's base URI
+     *   when fetching the service list.
      *
-     * This method sets up the service discovery client by requiring an HTTP provider instance,
-     * creating an HTTP client with the given client key, and returning an object containing
-     * the HTTP client and the optional endpoint.
+     * @example
+     * ```typescript
+     * builder.configureServiceDiscoveryClientByClientKey(
+     *   'service_discovery',
+     *   '/custom/services',
+     * );
+     * ```
      */
     configureServiceDiscoveryClientByClientKey(clientKey, endpoint) {
         this.configureServiceDiscoveryClient(async ({ requireInstance }) => {
@@ -44534,11 +44903,22 @@ class ServiceDiscoveryConfigurator extends BaseConfigBuilder {
 }
 
 // Generated by genversion.
-const version$1 = '9.1.1';
+const version$1 = '10.0.0';
 
+/**
+ * Default implementation of {@link IServiceDiscoveryProvider}.
+ *
+ * Created during module initialization and delegates service resolution to
+ * the underlying {@link IServiceDiscoveryClient} while using the
+ * {@link HttpModule} to construct pre-configured HTTP clients.
+ */
 class ServiceDiscoveryProvider extends BaseModuleProvider {
     config;
     _http;
+    /**
+     * @param config - Resolved service discovery configuration.
+     * @param _http - HTTP module instance used to create clients.
+     */
     constructor(config, _http) {
         super({
             version: version$1,
@@ -44547,12 +44927,15 @@ class ServiceDiscoveryProvider extends BaseModuleProvider {
         this.config = config;
         this._http = _http;
     }
+    /** {@inheritDoc IServiceDiscoveryProvider.resolveServices} */
     resolveServices() {
         return this.config.discoveryClient.resolveServices();
     }
+    /** {@inheritDoc IServiceDiscoveryProvider.resolveService} */
     async resolveService(key) {
         return this.config.discoveryClient.resolveService(key);
     }
+    /** {@inheritDoc IServiceDiscoveryProvider.createClient} */
     async createClient(name, opt) {
         const service = await this.resolveService(name);
         if (!service) {
@@ -44564,6 +44947,7 @@ class ServiceDiscoveryProvider extends BaseModuleProvider {
             defaultScopes: service.scopes,
         });
     }
+    /** {@inheritDoc IServiceDiscoveryProvider.configureClient} */
     async configureClient(serviceName, config) {
         const { key, alias } = typeof serviceName === 'string' ? { key: serviceName, alias: serviceName } : serviceName;
         const { uri: baseUri, scopes: defaultScopes } = await this.resolveService(key);
@@ -44571,25 +44955,27 @@ class ServiceDiscoveryProvider extends BaseModuleProvider {
     }
 }
 
+/**
+ * Module identifier used to register and look up the Service Discovery module
+ * within the Fusion Framework module system.
+ */
 const moduleName = 'serviceDiscovery';
 /**
- * Represents the Service Discovery module configuration.
+ * Service Discovery module definition.
  *
- * @remarks
- * This module is responsible for configuring and initializing the service discovery mechanism.
- * It ensures that the service discovery configuration is created and the necessary dependencies
- * are initialized before providing the service discovery provider.
+ * Configures and initializes the service discovery mechanism within the
+ * Fusion Framework module system. During initialization the module:
  *
- * @returns {Promise<ServiceDiscoveryProvider>} - Returns a promise that resolves to the service discovery provider.
+ * 1. Creates the {@link ServiceDiscoveryConfig} (optionally inheriting the
+ *    parent module's discovery client so sub-modules share cache).
+ * 2. Resolves the required {@link HttpModule} instance.
+ * 3. Returns a {@link ServiceDiscoveryProvider} ready to resolve endpoints.
  *
  * @remarks
- * The initialization process involves creating the service discovery configuration, which may include
- * inheriting configurations from a parent module. This pattern, while allowing reuse of cache and ensuring
- * up-to-date configurations, can be risky as it exposes the child module to potential breaking changes
- * from the parent module's client.
- *
- * Additionally, the service discovery module requires the HTTP module to be initialized before it can
- * function properly.
+ * When a parent module exposes its own `serviceDiscovery` config, the child
+ * module reuses that configuration by default. This enables shared caching
+ * and consistent service resolution but means breaking changes in the
+ * parent's client can affect child modules.
  */
 const module$1 = {
     name: moduleName,
@@ -44613,20 +44999,31 @@ const module$1 = {
     },
 };
 /**
- * Configures the Service Discovery module.
+ * Creates a module configurator object for the Service Discovery module.
+ *
+ * Use this when you need to add service discovery to a
+ * {@link ModulesConfigurator} via `addConfig` and want full control over
+ * the configuration callback.
  *
- * @template TRef - The type reference for the module configurator.
- * @param callback - A function that takes a `ServiceDiscoveryConfigurator` and returns a promise that resolves when the configuration is complete.
- * @returns An object implementing `IModuleConfigurator` for the `ServiceDiscoveryModule` with the provided configuration.
+ * For the simpler "just enable it" path, prefer {@link enableServiceDiscovery}.
+ *
+ * @template TRef - Module reference type forwarded to the configurator.
+ * @param callback - Receives a {@link ServiceDiscoveryConfigurator} and must
+ *   return a `Promise` that resolves when configuration is complete.
+ * @returns An `IModuleConfigurator` that can be passed to
+ *   `ModulesConfigurator.addConfig`.
  *
  * @example
  * ```typescript
  * import { configureServiceDiscovery } from '@equinor/fusion-framework-module-service-discovery';
  *
- * const config = (configurator: ModuleConfigurator) => {
- *  configurator.addConfig(configureServiceDiscovery(async (config) => {
- *      // custom configuration
- * });
+ * const configure = (configurator: ModulesConfigurator) => {
+ *   configurator.addConfig(
+ *     configureServiceDiscovery(async (builder) => {
+ *       builder.configureServiceDiscoveryClientByClientKey('my_sd_key');
+ *     }),
+ *   );
+ * };
  * ```
  */
 const configureServiceDiscovery = (callback) => ({
@@ -44634,24 +45031,29 @@ const configureServiceDiscovery = (callback) => ({
     configure: (config) => callback(config),
 });
 /**
- * Enables the service discovery module by adding its configuration to the provided configurator.
+ * Enables the Service Discovery module on a {@link ModulesConfigurator}.
  *
- * @param configurator - The configurator to which the service discovery configuration will be added.
- * @param callback - An optional callback function that can be used to customize the service discovery configuration.
+ * This is the recommended entry point for most consumers. When called
+ * without a callback the module auto-detects an HTTP client registered
+ * under the key `"service_discovery"`. Pass a callback to override the
+ * client key, endpoint, or provide a fully custom discovery client.
+ *
+ * @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.
  *
  * @example
  * ```typescript
  * import { enableServiceDiscovery } from '@equinor/fusion-framework-module-service-discovery';
  *
- * const config = (configurator: ModuleConfigurator) => {
- *     // simple
- *     enableServiceDiscovery(configurator);
+ * // Simplest usage — auto-detects the 'service_discovery' HTTP client
+ * enableServiceDiscovery(configurator);
  *
- *     // with custom configuration
- *     enableServiceDiscovery(configurator, async (config) => {
- *         config.configureServiceDiscoveryClientByClientKey('service-discovery-custom');
- *     });
- * };
+ * // Custom HTTP client key
+ * enableServiceDiscovery(configurator, async (builder) => {
+ *   builder.configureServiceDiscoveryClientByClientKey('sd_custom');
+ * });
  * ```
  */
 const enableServiceDiscovery = (configurator, callback) => {
@@ -44749,7 +45151,20 @@ class BaseTelemetryAdapter {
 
 /**
  * Telemetry adapter that outputs telemetry data to the browser console
- * with formatted titles and color-coded log levels
+ * with formatted titles and colour-coded log levels.
+ *
+ * Each telemetry item is logged using the console method that matches its
+ * {@link TelemetryLevel} (e.g. `console.error` for `Error` / `Critical`,
+ * `console.warn` for `Warning`). Event names are prefixed with a styled
+ * application title badge.
+ *
+ * @example
+ * ```typescript
+ * import { ConsoleAdapter } from '@equinor/fusion-framework-module-telemetry/console-adapter';
+ *
+ * const adapter = new ConsoleAdapter({ title: 'MyApp' });
+ * configurator.setAdapter(ConsoleAdapter.Identifier, adapter);
+ * ```
  */
 class ConsoleAdapter extends BaseTelemetryAdapter {
     /** Default identifier for console adapter instances */
@@ -44893,6 +45308,36 @@ class ConsoleAdapter extends BaseTelemetryAdapter {
     }
 }
 
+/**
+ * Registers the Fusion SPA service worker and wires token acquisition.
+ *
+ * @remarks
+ * The service worker intercepts outgoing fetch requests that match
+ * the configured {@link ResourceConfiguration | resource patterns},
+ * rewrites URLs, and injects Bearer tokens obtained from the MSAL
+ * module. This function:
+ *
+ * 1. Registers `/@fusion-spa-sw.js` as a module service worker.
+ * 2. Listens for `GET_TOKEN` messages from the worker and responds
+ *    with MSAL access tokens.
+ * 3. Sends the `INIT_CONFIG` message containing resource configurations
+ *    to the active worker once it is ready and controlling the page.
+ *
+ * @param framework - An initialized Fusion Framework instance that
+ *   includes the {@link MsalModule} (for token acquisition) and
+ *   {@link TelemetryModule} (for structured logging).
+ * @throws {Error} When service workers are not supported by the browser.
+ * @throws {Error} When the `FUSION_SPA_SERVICE_WORKER_RESOURCES`
+ *   environment variable is not defined.
+ *
+ * @example
+ * ```ts
+ * import { registerServiceWorker } from '@equinor/fusion-framework-vite-plugin-spa/html';
+ *
+ * const framework = await configurator.initialize();
+ * await registerServiceWorker(framework);
+ * ```
+ */
 async function registerServiceWorker(framework) {
     const telemetry = framework.telemetry;
     if ('serviceWorker' in navigator === false) {
@@ -45053,7 +45498,7 @@ async function registerServiceWorker(framework) {
 }
 
 // Generated by genversion.
-const version = '3.1.11';
+const version = '4.0.0';
 
 // Allow dynamic import without vite
 const importWithoutVite = (path) => import(/* @vite-ignore */ path);