@equinor/fusion-framework-vite-plugin-spa 3.1.12-next.0 → 4.0.1

package/dist/html/bootstrap.js

@@ -153,8 +153,8 @@ function requireRe () {
 
 		// ## Pre-release Version Identifier
 		// A numeric identifier, or a non-numeric identifier.
-		// Non-numberic identifiers include numberic identifiers but can be longer.
-		// Therefore non-numberic identifiers must go first.
+		// Non-numeric identifiers include numeric identifiers but can be longer.
+		// Therefore non-numeric identifiers must go first.
 
 		createToken('PRERELEASEIDENTIFIER', `(?:${src[t.NONNUMERICIDENTIFIER]
 		}|${src[t.NUMERICIDENTIFIER]})`);
@@ -850,7 +850,7 @@ function requireDiff () {
 	    return prefix + 'patch'
 	  }
 
-	  // high and low are preleases
+	  // high and low are prereleases
 	  return 'prerelease'
 	};
 
@@ -2409,7 +2409,7 @@ function requireSubset () {
 	// - If LT
 	//   - If LT.semver is greater than any < or <= comp in C, return false
 	//   - If LT is <=, and LT.semver does not satisfy every C, return false
-	//   - If GT.semver has a prerelease, and not in prerelease mode
+	//   - If LT.semver has a prerelease, and not in prerelease mode
 	//     - If no C has a prerelease and the LT.semver tuple, return false
 	// - Else return true
 
@@ -5239,9 +5239,31 @@ var ModuleEventLevel;
 })(ModuleEventLevel || (ModuleEventLevel = {}));
 
 /**
- * Base class for creating module provider
+ * Abstract base class for Fusion Framework module providers.
+ *
+ * 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}.
  *
- * this is the interface which is returned after enabling a module
+ * @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.7-next.0';
+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,16 +20736,234 @@ const requestValidationOperator = (options) => (request) => {
     }
 };
 
+/**
+ * Represents an error that occurs when handling an HTTP response.
+ * @template TResponse The type of the HTTP response.
+ */
+class HttpResponseError extends Error {
+    response;
+    static Name = 'HttpResponseError';
+    constructor(message, response, options) {
+        super(message, options);
+        this.response = response;
+    }
+}
+/**
+ * Represents an error that occurs when handling a JSON response in an HTTP request.
+ * Extends the base `HttpResponseError` class.
+ *
+ * @template TType - The type of the data associated with the error.
+ * @template TResponse - The type of the HTTP response.
+ */
+class HttpJsonResponseError extends HttpResponseError {
+    static Name = 'HttpJsonResponseError';
+    data;
+    /**
+     * Creates a new instance of `HttpJsonResponseError`.
+     *
+     * @param message - The error message.
+     * @param response - The HTTP response associated with the error.
+     * @param options - Additional options for the error, including the associated data.
+     */
+    constructor(message, response, options) {
+        super(message, response, options);
+        this.name = HttpJsonResponseError.Name;
+        this.data = options?.data;
+    }
+}
+/**
+ * Represents an error that occurs when handling a server-sent event (SSE) HTTP response.
+ *
+ * @template TType - The type of additional data associated with the error.
+ * @template TResponse - The type of the HTTP response object.
+ *
+ * @extends HttpResponseError<TResponse>
+ */
+class ServerSentEventResponseError extends HttpResponseError {
+    static Name = 'ServerSentEventResponseError';
+    /**
+     * Creates a new instance of the error.
+     *
+     * @param message - The error message describing the cause of the error.
+     * @param response - The HTTP response associated with the error.
+     * @param options - Optional error options, which may include additional data of type `TType`.
+     */
+    constructor(message, response, options) {
+        super(message, response, options);
+        this.name = ServerSentEventResponseError.Name;
+    }
+}
+
+const defaultDataParser = (data) => {
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return data;
+    }
+};
+/**
+ * Parses a string containing Server-Sent Events (SSE) data into individual event objects.
+ *
+ * @template TData - The type of the parsed `data` field in the event.
+ * @param text - The raw SSE data as a string, where events are separated by double newlines.
+ * @param options - Optional configuration for parsing the events.
+ * @param options.dataParser - A custom parser function for the `data` field. Defaults to JSON parsing,
+ *                             falling back to returning the raw string if parsing fails.
+ *
+ * @returns A generator that yields `ServerSentEvent` objects parsed from the input string.
+ *
+ * @remarks
+ * - Empty lines and events with no fields are ignored.
+ * - If the `data` field cannot be parsed as JSON, it is returned as a plain string.
+ * - Fields other than `data` are stored as strings in the resulting `ServerSentEvent` object.
+ *
+ * @example
+ * ```typescript
+ * const sseData = `
+ * id: 1
+ * event: message
+ * data: {"key":"value"}
+ *
+ * id: 2
+ * event: update
+ * data: plain text
+ * `;
+ *
+ * for (const event of parseEvents(sseData)) {
+ *   console.log(event);
+ * }
+ * // Output:
+ * // { id: "1", event: "message", data: { key: "value" } }
+ * // { id: "2", event: "update", data: "plain text" }
+ * ```
+ */
+function* parseEvents(text, options) {
+    // Split the input string into individual event strings using double newline as separator
+    const eventStrings = text.split('\n\n');
+    const dataParser = options?.dataParser || defaultDataParser;
+    // Iterate through each event string
+    for (const eventStr of eventStrings) {
+        // Skip empty event strings (after trimming whitespace)
+        if (!eventStr.trim())
+            continue;
+        // Split the event string into lines (fields) using single newline
+        const lines = eventStr.split('\n');
+        // Use reduce to process each line in the event string
+        const event = lines.reduce((event, line) => {
+            // Skip empty lines
+            if (!line)
+                return event;
+            // Find the index of the first colon, which separates field name and value
+            const colonIndex = line.indexOf(':');
+            // Skip lines without a colon (invalid format)
+            if (colonIndex === -1)
+                return event;
+            // Extract the field name (before colon) and trim whitespace
+            const field = line.slice(0, colonIndex).trim();
+            // Extract the field value (after colon) and trim whitespace
+            const value = line.slice(colonIndex + 1).trim();
+            // Handle the 'data' field specially, attempting JSON parsing
+            if (field === 'data') {
+                event.data = dataParser(value);
+            }
+            else {
+                // For non-data fields, assign the value as a string to the event object
+                event[field] = value;
+            }
+            return event;
+        }, {});
+        // Only emit the event to the results if it has at least one field
+        if (Object.keys(event).length) {
+            yield event;
+        }
+    }
+}
+async function* readStream(reader, options) {
+    const skipHeartbeats = !!options?.skipHeartbeats;
+    const eventFilter = options?.eventFilter
+        ? Array.isArray(options.eventFilter)
+            ? options.eventFilter
+            : [options.eventFilter]
+        : null;
+    const decoder = new TextDecoder();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        const text = decoder.decode(value, { stream: true });
+        const events = parseEvents(text, { dataParser: options?.dataParser });
+        for (const event of events) {
+            if (event.retry) {
+                await new Promise((resolve) => setTimeout(resolve, Number.parseInt(event.retry ?? '300', 10)));
+                continue;
+            }
+            if (skipHeartbeats) {
+                // Skip comment-based heartbeats (no event, data, or id)
+                if (!event.event && !event.data && !event.id) {
+                    continue;
+                }
+                // Skip named heartbeat events (e.g., event: heartbeat or event: ping)
+                if (event.event && ['heartbeat', 'ping'].includes(event.event)) {
+                    continue;
+                }
+            }
+            if (!eventFilter || (event.event && eventFilter.includes(event.event))) {
+                yield event;
+            }
+        }
+    }
+}
+/**
+ * Transforms an SSE response into an Observable stream of parsed events.
+ * @param response - The HTTP response with Content-Type: text/event-stream.
+ * @param options - Optional configuration for event filtering and heartbeat handling.
+ * @param options.eventFilter - Filter events by type (single string or array).
+ * @param options.skipHeartbeats - Skip empty/heartbeat events if true.
+ * @param options.dataParser - Custom parser for the data field.
+ * @param options.abortSignal - Abort signal to cancel the stream.
+ * @returns An Observable emitting parsed ServerSentEvent objects.
+ * @throws ServerSentEventResponseError if response is invalid or stream fails.
+ */
+const createSseSelector = (options) => {
+    return (response) => {
+        if (!response.ok) {
+            throw new ServerSentEventResponseError(`HTTP error! Status: ${response.status}`, response);
+        }
+        if (!response.body) {
+            throw new ServerSentEventResponseError('Response body is not readable', response);
+        }
+        if (!response.headers.get('Content-Type')?.includes('text/event-stream')) {
+            throw new ServerSentEventResponseError('Response is not a text/event-stream', response);
+        }
+        const reader = response.body.getReader();
+        return from(readStream(reader, {
+            dataParser: options?.dataParser,
+            skipHeartbeats: options?.skipHeartbeats,
+            eventFilter: options?.eventFilter,
+        })).pipe(
+        // Stop reading if the abort signal is triggered
+        takeUntil(options?.abortSignal ? fromEvent(options.abortSignal, 'abort') : EMPTY), finalize$2(async () => {
+            // cancel just in case of a pre-mature exit
+            await reader.cancel().catch(() => {
+                /** ignore cancellation errors */
+            });
+            reader.releaseLock();
+        }));
+    };
+};
+
 /** @inheritdoc */
 class HttpClientConfigurator {
     _clients = {};
-    /** Get a clone of all configured clients */
+    /** Gets a shallow clone of all named client configurations. */
     get clients() {
         return { ...this._clients };
     }
-    /** default class for creation of http clients */
+    /** Default constructor used when a client configuration does not provide `ctor`. */
     defaultHttpClientCtor;
-    /** default request handler for http clients, applied on creation */
+    /** Default request handler pipeline cloned into each created client instance. */
     defaultHttpRequestHandler = new HttpRequestHandler({
         // convert all request methods to uppercase
         'capitalize-method': capitalizeRequestMethodOperator(),
@@ -20691,8 +20971,8 @@ class HttpClientConfigurator {
         'request-validation': requestValidationOperator(),
     });
     /**
-     * Create a instance of http configuration
-     * @param client defaultHttpRequestHandler
+     * 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;
@@ -20714,32 +20994,40 @@ class HttpClientConfigurator {
 }
 
 // Generated by genversion.
-const version$6 = '7.0.9-next.0';
+const version$6 = '8.0.0';
 
 /**
- * Exception thrown when a client cannot be found.
+ * Thrown when `createClient(name)` is called with an unknown client key.
  *
- * 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}
+ * 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 URL.
- * @param url - The string to check for a valid URL.
- * @returns `true` if the input string is a valid URL, `false` otherwise.
+ * 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) => {
-    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);
+    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.
@@ -20769,7 +21057,7 @@ class HttpClientProvider extends BaseModuleProvider {
         return Object.keys(this.config.clients).includes(key);
     }
     /**
-     * Creates a new HTTP client instance with the specified configuration.
+     * 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.
@@ -20779,26 +21067,22 @@ class HttpClientProvider extends BaseModuleProvider {
      * 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 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, } = config;
-        const options = { requestHandler };
+        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 new HTTP client instance with the specified configuration.
+     * 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`.
@@ -20815,8 +21099,9 @@ class HttpClientProvider extends BaseModuleProvider {
     /**
      * 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.
+     * 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.
@@ -20827,6 +21112,12 @@ class HttpClientProvider extends BaseModuleProvider {
             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}]`);
             }
@@ -20886,64 +21177,6 @@ function fromFetch(input, initWithSelector) {
     });
 }
 
-/**
- * Represents an error that occurs when handling an HTTP response.
- * @template TResponse The type of the HTTP response.
- */
-class HttpResponseError extends Error {
-    response;
-    static Name = 'HttpResponseError';
-    constructor(message, response, options) {
-        super(message, options);
-        this.response = response;
-    }
-}
-/**
- * Represents an error that occurs when handling a JSON response in an HTTP request.
- * Extends the base `HttpResponseError` class.
- *
- * @template TType - The type of the data associated with the error.
- * @template TResponse - The type of the HTTP response.
- */
-class HttpJsonResponseError extends HttpResponseError {
-    static Name = 'HttpJsonResponseError';
-    data;
-    /**
-     * Creates a new instance of `HttpJsonResponseError`.
-     *
-     * @param message - The error message.
-     * @param response - The HTTP response associated with the error.
-     * @param options - Additional options for the error, including the associated data.
-     */
-    constructor(message, response, options) {
-        super(message, response, options);
-        this.name = HttpJsonResponseError.Name;
-        this.data = options?.data;
-    }
-}
-/**
- * Represents an error that occurs when handling a server-sent event (SSE) HTTP response.
- *
- * @template TType - The type of additional data associated with the error.
- * @template TResponse - The type of the HTTP response object.
- *
- * @extends HttpResponseError<TResponse>
- */
-class ServerSentEventResponseError extends HttpResponseError {
-    static Name = 'ServerSentEventResponseError';
-    /**
-     * Creates a new instance of the error.
-     *
-     * @param message - The error message describing the cause of the error.
-     * @param response - The HTTP response associated with the error.
-     * @param options - Optional error options, which may include additional data of type `TType`.
-     */
-    constructor(message, response, options) {
-        super(message, response, options);
-        this.name = ServerSentEventResponseError.Name;
-    }
-}
-
 /**
  * Asynchronously parses the JSON data from a given HTTP response.
  *
@@ -21018,166 +21251,6 @@ const blobSelector = async (response) => {
     }
 };
 
-const defaultDataParser = (data) => {
-    try {
-        return JSON.parse(data);
-    }
-    catch {
-        return data;
-    }
-};
-/**
- * Parses a string containing Server-Sent Events (SSE) data into individual event objects.
- *
- * @template TData - The type of the parsed `data` field in the event.
- * @param text - The raw SSE data as a string, where events are separated by double newlines.
- * @param options - Optional configuration for parsing the events.
- * @param options.dataParser - A custom parser function for the `data` field. Defaults to JSON parsing,
- *                             falling back to returning the raw string if parsing fails.
- *
- * @returns A generator that yields `ServerSentEvent` objects parsed from the input string.
- *
- * @remarks
- * - Empty lines and events with no fields are ignored.
- * - If the `data` field cannot be parsed as JSON, it is returned as a plain string.
- * - Fields other than `data` are stored as strings in the resulting `ServerSentEvent` object.
- *
- * @example
- * ```typescript
- * const sseData = `
- * id: 1
- * event: message
- * data: {"key":"value"}
- *
- * id: 2
- * event: update
- * data: plain text
- * `;
- *
- * for (const event of parseEvents(sseData)) {
- *   console.log(event);
- * }
- * // Output:
- * // { id: "1", event: "message", data: { key: "value" } }
- * // { id: "2", event: "update", data: "plain text" }
- * ```
- */
-function* parseEvents(text, options) {
-    // Split the input string into individual event strings using double newline as separator
-    const eventStrings = text.split('\n\n');
-    const dataParser = options?.dataParser || defaultDataParser;
-    // Iterate through each event string
-    for (const eventStr of eventStrings) {
-        // Skip empty event strings (after trimming whitespace)
-        if (!eventStr.trim())
-            continue;
-        // Split the event string into lines (fields) using single newline
-        const lines = eventStr.split('\n');
-        // Use reduce to process each line in the event string
-        const event = lines.reduce((event, line) => {
-            // Skip empty lines
-            if (!line)
-                return event;
-            // Find the index of the first colon, which separates field name and value
-            const colonIndex = line.indexOf(':');
-            // Skip lines without a colon (invalid format)
-            if (colonIndex === -1)
-                return event;
-            // Extract the field name (before colon) and trim whitespace
-            const field = line.slice(0, colonIndex).trim();
-            // Extract the field value (after colon) and trim whitespace
-            const value = line.slice(colonIndex + 1).trim();
-            // Handle the 'data' field specially, attempting JSON parsing
-            if (field === 'data') {
-                event.data = dataParser(value);
-            }
-            else {
-                // For non-data fields, assign the value as a string to the event object
-                event[field] = value;
-            }
-            return event;
-        }, {});
-        // Only emit the event to the results if it has at least one field
-        if (Object.keys(event).length) {
-            yield event;
-        }
-    }
-}
-async function* readStream(reader, options) {
-    const skipHeartbeats = !!options?.skipHeartbeats;
-    const eventFilter = options?.eventFilter
-        ? Array.isArray(options.eventFilter)
-            ? options.eventFilter
-            : [options.eventFilter]
-        : null;
-    const decoder = new TextDecoder();
-    while (true) {
-        const { done, value } = await reader.read();
-        if (done) {
-            break;
-        }
-        const text = decoder.decode(value, { stream: true });
-        const events = parseEvents(text, { dataParser: options?.dataParser });
-        for (const event of events) {
-            if (event.retry) {
-                await new Promise((resolve) => setTimeout(resolve, Number.parseInt(event.retry ?? '300', 10)));
-                continue;
-            }
-            if (skipHeartbeats) {
-                // Skip comment-based heartbeats (no event, data, or id)
-                if (!event.event && !event.data && !event.id) {
-                    continue;
-                }
-                // Skip named heartbeat events (e.g., event: heartbeat or event: ping)
-                if (event.event && ['heartbeat', 'ping'].includes(event.event)) {
-                    continue;
-                }
-            }
-            if (!eventFilter || (event.event && eventFilter.includes(event.event))) {
-                yield event;
-            }
-        }
-    }
-}
-/**
- * Transforms an SSE response into an Observable stream of parsed events.
- * @param response - The HTTP response with Content-Type: text/event-stream.
- * @param options - Optional configuration for event filtering and heartbeat handling.
- * @param options.eventFilter - Filter events by type (single string or array).
- * @param options.skipHeartbeats - Skip empty/heartbeat events if true.
- * @param options.dataParser - Custom parser for the data field.
- * @param options.abortSignal - Abort signal to cancel the stream.
- * @returns An Observable emitting parsed ServerSentEvent objects.
- * @throws ServerSentEventResponseError if response is invalid or stream fails.
- */
-const createSseSelector = (options) => {
-    return (response) => {
-        if (!response.ok) {
-            throw new ServerSentEventResponseError(`HTTP error! Status: ${response.status}`, response);
-        }
-        if (!response.body) {
-            throw new ServerSentEventResponseError('Response body is not readable', response);
-        }
-        if (!response.headers.get('Content-Type')?.includes('text/event-stream')) {
-            throw new ServerSentEventResponseError('Response is not a text/event-stream', response);
-        }
-        const reader = response.body.getReader();
-        return from(readStream(reader, {
-            dataParser: options?.dataParser,
-            skipHeartbeats: options?.skipHeartbeats,
-            eventFilter: options?.eventFilter,
-        })).pipe(
-        // Stop reading if the abort signal is triggered
-        takeUntil(options?.abortSignal ? fromEvent(options.abortSignal, 'abort') : EMPTY), finalize$2(async () => {
-            // cancel just in case of a pre-mature exit
-            await reader.cancel().catch(() => {
-                /** ignore cancellation errors */
-            });
-            reader.releaseLock();
-        }));
-    };
-};
-
 /** 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.5-next.0';
+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.2-next.0';
+const version$2 = '8.0.1';
 
 /**
  * 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.
  *
- * @param account - The current AccountInfo to convert
- * @returns The v2 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 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.
+ *
+ * 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 AuthenticationResult to convert
- * @returns The v2 AuthenticationResult format
+ * @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.
+ *
+ * @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';
  *
- * @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.
+ * 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.
+ * Zod schema for the service list returned by 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.
- *
- * @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.
+     *
+     * Use this method when you need full control over service resolution
+     * (e.g. a mock client for testing or a static service list).
      *
-     * @param discoveryClient - An instance of `IServiceDiscoveryClient` or a callback function that returns an instance of `IServiceDiscoveryClient`.
+     * @param discoveryClient - A client instance or an async factory function.
      *
-     * 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.
+     * @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.2-next.0';
+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.
+ *
+ * For the simpler "just enable it" path, prefer {@link enableServiceDiscovery}.
  *
- * @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.
+ * @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}.
+ *
+ * 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 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.
+ * @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.12-next.0';
+const version = '4.0.1';
 
 // Allow dynamic import without vite
 const importWithoutVite = (path) => import(/* @vite-ignore */ path);