@equinor/fusion-framework-vite-plugin-spa 5.2.4-next.2 → 5.2.4

package/dist/html/bootstrap.js

@@ -1,21 +1,5 @@
-import { t as telemetryExportRequest, c as createErrorClass, _ as __extends, e as errorContext, E as EMPTY_SUBSCRIPTION, S as Subscription, O as Observable, a as __values, b as arrRemove, d as __spreadArray, f as __read, i as isFunction$1, g as SafeSubscriber, h as EmptyError, o as operate, j as executeSchedule, k as innerFrom, l as createOperatorSubscriber, m as map, n as mergeMap, p as identity, q as from, r as popScheduler, s as isArrayLike, u as isScheduler, v as popNumber, w as EMPTY, x as noop, y as mergeInternals, z as scanInternals, A as popResultSelector, B as reduce, C as lastValueFrom, M as ModuleEventLevel, D as filter, F as tap, G as BaseModuleProvider, H as catchError, I as of, J as object, K as _instanceof, L as _enum, N as string, P as boolean, Q as record, R as union, T as finalize$1, U as __rest, V as __assign, W as switchMap, X as observeOn, Y as deepmerge, Z as BaseConfigBuilder, $ as operationalIdentifier, a0 as defer, a1 as TelemetryExceptionSchema, a2 as TelemetryItemNames, a3 as TelemetryType, a4 as telemetryProviderActions, a5 as operationalScope, a6 as createOperationalTelemetry, a7 as TelemetryEventSchema, a8 as TelemetryMetricSchema, a9 as TelemetryCustomEventSchema, aa as createOperationalRecords, ab as TelemetryLevel, ac as createDiagnosticContext, ad as createAction, ae as createAsyncAction, af as array, ag as enableMSAL } from '../module-BnhyaZvt.js';
-import { B as BaseTelemetryAdapter } from '../TelemetryAdapter-C6KyX3cq.js';
-import '../trace-api-DzxUyN-s.js';
-
-/**
- * Marks request options as exporter-owned so operational instrumentation skips the export itself.
- * The marker applies only to this request, not unrelated concurrent traffic.
- * @param init - Options forwarded through the export transport's request pipeline.
- * @returns A copy retaining request options with the telemetry export request marker.
- * @template T - Request options type.
- * @example
- * ```ts
- * client.fetch('/v1/logs', markTelemetryExportRequest({ method: 'POST', body }));
- * ```
- */
-function markTelemetryExportRequest(init) {
-    return { ...init, [telemetryExportRequest]: true };
-}
+import { c as createErrorClass, _ as __extends, e as errorContext, E as EMPTY_SUBSCRIPTION, S as Subscription, O as Observable, a as __values, b as arrRemove, d as __spreadArray, f as __read, i as isFunction$1, g as SafeSubscriber, h as EmptyError, o as operate, j as executeSchedule, k as innerFrom, l as createOperatorSubscriber, m as map, n as mergeMap, p as identity, q as isArrayLike, r as isScheduler, s as popScheduler, t as popNumber, u as EMPTY, v as from, w as mergeInternals, x as scanInternals, y as noop, z as popResultSelector, A as reduce, B as lastValueFrom, M as ModuleEventLevel, C as filter, D as BaseModuleProvider, F as catchError, G as of, H as object, I as _instanceof, J as _enum, K as string, L as boolean, N as record, P as union, Q as __rest, R as __assign, T as switchMap, U as observeOn, V as BaseConfigBuilder, W as TelemetryExceptionSchema, X as TelemetryItemNames, Y as TelemetryType, Z as TelemetryEventSchema, $ as TelemetryMetricSchema, a0 as TelemetryCustomEventSchema, a1 as array, a2 as TelemetryLevel, a3 as enableMSAL } from '../module-9J9oqYEu.js';
+import { B as BaseTelemetryAdapter } from '../TelemetryAdapter-qfXdaj7x.js';
 
 var ObjectUnsubscribedError = createErrorClass(function (_super) {
     return function ObjectUnsubscribedErrorImpl() {
@@ -534,18 +518,6 @@ function mergeAll(concurrent) {
     return mergeMap(identity, concurrent);
 }
 
-function concatAll() {
-    return mergeAll(1);
-}
-
-function concat() {
-    var args = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        args[_i] = arguments[_i];
-    }
-    return concatAll()(from(args, popScheduler(args)));
-}
-
 var nodeEventEmitterMethods = ['addListener', 'removeListener'];
 var eventTargetMethods = ['addEventListener', 'removeEventListener'];
 var jqueryMethods = ['on', 'off'];
@@ -689,12 +661,6 @@ function take(count) {
         });
 }
 
-function ignoreElements() {
-    return operate(function (source, subscriber) {
-        source.subscribe(createOperatorSubscriber(subscriber, noop));
-    });
-}
-
 function distinctUntilChanged(comparator, keySelector) {
     if (keySelector === void 0) { keySelector = identity; }
     comparator = comparator !== null && comparator !== void 0 ? comparator : defaultCompare;
@@ -729,23 +695,14 @@ function defaultErrorFactory() {
     return new EmptyError();
 }
 
-function exhaustMap(project, resultSelector) {
+function finalize$1(callback) {
     return operate(function (source, subscriber) {
-        var index = 0;
-        var innerSub = null;
-        var isComplete = false;
-        source.subscribe(createOperatorSubscriber(subscriber, function (outerValue) {
-            if (!innerSub) {
-                innerSub = createOperatorSubscriber(subscriber, undefined, function () {
-                    innerSub = null;
-                    isComplete && subscriber.complete();
-                });
-                innerFrom(project(outerValue, index++)).subscribe(innerSub);
-            }
-        }, function () {
-            isComplete = true;
-            !innerSub && subscriber.complete();
-        }));
+        try {
+            source.subscribe(subscriber);
+        }
+        finally {
+            subscriber.add(callback);
+        }
     });
 }
 
@@ -923,6 +880,42 @@ function takeWhile(predicate, inclusive) {
     });
 }
 
+function tap(observerOrNext, error, complete) {
+    var tapObserver = isFunction$1(observerOrNext) || error || complete
+        ?
+            { next: observerOrNext, error: error, complete: complete }
+        : observerOrNext;
+    return tapObserver
+        ? operate(function (source, subscriber) {
+            var _a;
+            (_a = tapObserver.subscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+            var isUnsub = true;
+            source.subscribe(createOperatorSubscriber(subscriber, function (value) {
+                var _a;
+                (_a = tapObserver.next) === null || _a === void 0 ? void 0 : _a.call(tapObserver, value);
+                subscriber.next(value);
+            }, function () {
+                var _a;
+                isUnsub = false;
+                (_a = tapObserver.complete) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                subscriber.complete();
+            }, function (err) {
+                var _a;
+                isUnsub = false;
+                (_a = tapObserver.error) === null || _a === void 0 ? void 0 : _a.call(tapObserver, err);
+                subscriber.error(err);
+            }, function () {
+                var _a, _b;
+                if (isUnsub) {
+                    (_a = tapObserver.unsubscribe) === null || _a === void 0 ? void 0 : _a.call(tapObserver);
+                }
+                (_b = tapObserver.finalize) === null || _b === void 0 ? void 0 : _b.call(tapObserver);
+            }));
+        })
+        :
+            identity;
+}
+
 function withLatestFrom() {
     var inputs = [];
     for (var _i = 0; _i < arguments.length; _i++) {
@@ -984,19 +977,13 @@ const ModuleConfiguratorEventBaseName = 'ModuleConfigurator';
  */
 const ModuleConfiguratorEventName = {
     ModuleConfigAdded: `${ModuleConfiguratorEventBaseName}.module.configAdded`,
-    PreparedConfigReplaced: `${ModuleConfiguratorEventBaseName}.module.preparedConfigReplaced`,
     OnConfiguredAdded: `${ModuleConfiguratorEventBaseName}.onConfigured.added`,
     OnInitializedAdded: `${ModuleConfiguratorEventBaseName}.onInitialized.added`,
     PluginAdded: `${ModuleConfiguratorEventBaseName}.plugin.added`,
     InitializeConfigLoaded: `${ModuleConfiguratorEventBaseName}.config.loaded`,
     InitializeInstanceInitialized: `${ModuleConfiguratorEventBaseName}.instance.initialized`,
     Initialize: `${ModuleConfiguratorEventBaseName}.initialize.complete`,
-    HostInitializeStarted: `${ModuleConfiguratorEventBaseName}.host.initializeStarted`,
-    HostInitialized: `${ModuleConfiguratorEventBaseName}.host.initialized`,
-    HostInitializeError: `${ModuleConfiguratorEventBaseName}.host.initializeError`,
     ConfiguratorCreated: `${ModuleConfiguratorEventBaseName}.configurator.created`,
-    ConfiguratorPrepared: `${ModuleConfiguratorEventBaseName}.configurator.prepared`,
-    ConfiguratorPrepareError: `${ModuleConfiguratorEventBaseName}.configurator.prepareError`,
     ConfiguratorFailed: `${ModuleConfiguratorEventBaseName}.configurator.failed`,
     ModulePostConfigured: `${ModuleConfiguratorEventBaseName}.module.postConfigured`,
     ModulePostConfigureError: `${ModuleConfiguratorEventBaseName}.module.postConfigureError`,
@@ -1061,10 +1048,7 @@ async function createModuleConfigs(ctx, ref) {
     const config$ = from(modules).pipe(mergeMap(async (module) => {
         const configStart = performance.now();
         try {
-            // Explicitly registered builders must not be replaced by another factory-created instance.
-            const configurator = ctx.configurators?.has(module)
-                ? ctx.configurators.get(module)
-                : await module.configure?.(ref);
+            const configurator = await module.configure?.(ref);
             const configLoadTime = Math.round(performance.now() - configStart);
             registerEvent({
                 level: ModuleEventLevel.Debug,
@@ -1204,8 +1188,8 @@ config) {
  * Runs the full configure lifecycle phase for a set of modules.
  *
  * Orchestrates three sub-steps in order:
- * 1. {@link createModuleConfigs} — reuse prepared builders or call `configure(ref)` factories.
- * 2. Apply all user-registered config callbacks (`_configs`) concurrently.
+ * 1. {@link createModuleConfigs} — call each module's `configure(ref)` factory.
+ * 2. Apply all user-registered config callbacks (`_configs`) sequentially.
  * 3. {@link runPostConfigureHooks} — call `postConfigure` and `afterConfiguration` hooks.
  *
  * @param ctx - The configure phase context.
@@ -1225,81 +1209,6 @@ async function runConfigurePhase(ctx, ref) {
     return config;
 }
 
-/**
- * Rejects asynchronous preparation without leaving rejected promises unobserved.
- * @param result - Factory or preparation callback result.
- * @param moduleName - Module to identify in the preparation error.
- * @throws {TypeError} When preparation returned a promise or thenable.
- */
-function assertSynchronous(result, moduleName) {
-    // Preparation must finish before control returns to host configuration.
-    if (result !== null &&
-        (typeof result === 'object' || typeof result === 'function') &&
-        'then' in result &&
-        typeof result.then === 'function') {
-        // Invalid async work cannot be canceled, but its eventual rejection must remain visible.
-        void Promise.resolve(result).catch(() => console.warn(`Asynchronous preparation failed for module "${moduleName}"`));
-        throw new TypeError(`Preparation for module "${moduleName}" must be synchronous`);
-    }
-}
-/**
- * Runs synchronous preparation at the registration boundary, without exposing stored builders.
- * Supplied builders bypass factories; opt-in factories run once per registered descriptor.
- * The ordinary configure phase later receives the same object.
- *
- * Preparation does not mutate orchestrator state: it returns the builder to commit, so a
- * failure leaves the previous registration untouched.
- *
- * @param ctx - Registration and the host's already prepared builders.
- * @returns The builder to commit, or `undefined` for an ordinary, unprepared registration.
- * @template TModule - Registered module descriptor.
- * @template TConfig - Configuration callback type associated with the registration.
- * @throws Rethrows preparation errors after emitting a lifecycle failure event.
- * @internal
- */
-function runPreparePhase(ctx) {
-    const { registration, configurators, registerEvent } = ctx;
-    const { module, configurator, prepare } = registration;
-    // Ordinary registrations keep factory creation in the existing configure phase.
-    if (configurator === undefined && !prepare) {
-        return undefined;
-    }
-    try {
-        // An explicit builder wins; otherwise reuse this descriptor's prepared builder.
-        let builder = configurator ?? configurators.get(module);
-        // Only opted-in, reference-independent factories may run before initialize(ref).
-        if (builder === undefined) {
-            // Never freeze an ordinary factory's missing parent reference by invoking it early.
-            if (!module.prepare) {
-                throw new TypeError(`Module "${module.name}" requires a prepare factory or an explicit configurator for preparation`);
-            }
-            builder = module.prepare();
-            assertSynchronous(builder, module.name);
-        }
-        // Registered callbacks receive their module's builder only within this lifecycle boundary.
-        if (prepare) {
-            assertSynchronous(prepare(builder), module.name);
-        }
-        registerEvent({
-            level: ModuleEventLevel.Debug,
-            name: ModuleConfiguratorEventName.ConfiguratorPrepared,
-            message: `Configuration prepared for ${module.name}`,
-            properties: { moduleName: module.name },
-        });
-        return { configurator: builder };
-    }
-    catch (error) {
-        registerEvent({
-            level: ModuleEventLevel.Error,
-            name: ModuleConfiguratorEventName.ConfiguratorPrepareError,
-            message: `Configuration preparation failed for ${module.name}`,
-            properties: { moduleName: module.name },
-            error,
-        });
-        throw error;
-    }
-}
-
 /**
  * Creates a `requireInstance` resolver for use during module initialization.
  *
@@ -1403,7 +1312,6 @@ function createRequireInstance(moduleNames, instance$, registerEvent) {
 async function initializeModule(module, ctx) {
     const { config, ref, requireInstance, hasModule, registerEvent } = ctx;
     const key = module.name;
-    const moduleInitStart = performance.now();
     // Modules must expose an initialize method to participate in the initialize phase
     if (!module.initialize) {
         const error = new Error(`Module ${module.name} does not have initialize method`);
@@ -1417,7 +1325,6 @@ async function initializeModule(module, ctx) {
                 moduleVersion: module.version?.toString() || 'unknown',
             },
             error,
-            metric: performance.now() - moduleInitStart,
         });
         throw error;
     }
@@ -1430,26 +1337,13 @@ async function initializeModule(module, ctx) {
             moduleVersion: module.version?.toString() || 'unknown',
         },
     });
-    let instance;
-    try {
-        instance = await module.initialize({
-            ref,
-            config: config[key],
-            requireInstance,
-            hasModule,
-        });
-    }
-    catch (error) {
-        registerEvent({
-            level: ModuleEventLevel.Error,
-            name: ModuleConfiguratorEventName.ModuleInitializeError,
-            message: 'Module initialization failed',
-            properties: { moduleName: module.name },
-            metric: performance.now() - moduleInitStart,
-            error,
-        });
-        throw error;
-    }
+    const moduleInitStart = performance.now();
+    const instance = await module.initialize({
+        ref,
+        config: config[key],
+        requireInstance,
+        hasModule,
+    });
     // Warn when providers deviate from the expected base class — these modules
     // may lack version tracking and standard provider interfaces.
     if (!(instance instanceof BaseModuleProvider)) {
@@ -1497,8 +1391,7 @@ async function initializeModule(module, ctx) {
 /**
  * Runs the initialize lifecycle phase for all registered modules.
  *
- * Initializes all modules concurrently and rejects on the first failure; providers that
- * finish afterwards are passed to `onLateProvider` for cleanup. Cross-module
+ * Initializes all modules **concurrently** using `mergeMap`. Cross-module
  * dependency ordering is handled lazily through `requireInstance`, which
  * waits for a peer module's `initialize` call to complete before resolving.
  *
@@ -1515,11 +1408,11 @@ async function initializeModule(module, ctx) {
  *   initialize within its timeout window.
  */
 async function runInitializePhase(ctx, config, ref) {
-    const { modules, registerEvent, instances = {}, onLateProvider } = ctx;
+    const { modules, registerEvent } = ctx;
     // Fast-path: no modules registered — return a sealed empty instance immediately
     // to avoid a subscribe/lastValueFrom race on an already-completed observable.
     if (modules.length === 0) {
-        return Object.seal(instances);
+        return Object.seal({});
     }
     // Extract module names for dependency lookups before any module has initialized
     const moduleNames = modules.map((m) => m.name);
@@ -1530,56 +1423,55 @@ async function runInitializePhase(ctx, config, ref) {
     const requireInstance = createRequireInstance(moduleNames, instance$, registerEvent);
     // Initialize all modules concurrently; modules that depend on peers will
     // suspend inside requireInstance until the dependency resolves.
+    const init$ = from(modules).pipe(mergeMap((module) => initializeModule(module, { config, ref, requireInstance, hasModule, registerEvent })));
     const initStart = performance.now();
-    let failed = false;
-    // Start every initializer at once; peers wait on each other through requireInstance.
-    const initializers = modules.map(async (module) => {
-        const [name, provider] = await initializeModule(module, {
-            config,
-            ref,
-            requireInstance,
-            hasModule,
-            registerEvent,
-        });
-        // Rollback already owns `instances`; a late provider is handed off rather than leaked.
-        if (failed) {
-            onLateProvider?.(module, provider);
-            return;
-        }
-        instances[name] = provider;
-        instance$.next({ ...instances });
-    });
-    try {
-        // Reject on the first failure: a sibling that never settles must not hang startup.
-        await Promise.all(initializers);
-    }
-    catch (error) {
-        failed = true;
-        // Reject outstanding dependency waits instead of waiting for their timeout.
-        instance$.error(error);
-        throw error;
-    }
-    instance$.complete();
-    const initTime = Math.round(performance.now() - initStart);
-    registerEvent({
-        level: ModuleEventLevel.Debug,
-        name: ModuleConfiguratorEventName.ModuleInitializeComplete,
-        message: 'All modules initialized',
-        properties: { modules: Object.keys(instances).join(', '), loadTime: initTime },
-        metric: initTime,
+    // Accumulate module providers into the shared instance subject as each resolves.
+    // Completing the subject signals that all modules are initialized.
+    init$.subscribe({
+        next: ([name, module]) => {
+            // Merge the newly initialized module into the shared instance map without dropping peers
+            const nextInstance = Object.assign(instance$.value, { [name]: module });
+            instance$.next(nextInstance);
+        },
+        error: (err) => {
+            registerEvent({
+                level: ModuleEventLevel.Error,
+                name: ModuleConfiguratorEventName.ModuleInitializeError,
+                message: `Failed to initialize module ${err.name || 'unknown'}`,
+                error: err,
+            });
+            instance$.error(err);
+        },
+        complete: () => {
+            const loadTime = Math.round(performance.now() - initStart);
+            registerEvent({
+                level: ModuleEventLevel.Debug,
+                name: ModuleConfiguratorEventName.ModuleInitializeComplete,
+                message: `All modules initialized in ${loadTime}ms`,
+                properties: {
+                    modules: Object.keys(instance$.value).join(', '),
+                    loadTime,
+                },
+                metric: loadTime,
+            });
+            instance$.complete();
+        },
     });
+    const instanceInitStart = performance.now();
+    const instance = await lastValueFrom(instance$);
+    const initTime = Math.round(performance.now() - instanceInitStart);
     registerEvent({
         level: ModuleEventLevel.Debug,
         name: ModuleConfiguratorEventName.InitializeComplete,
         message: `Modules instance created in ${initTime}ms`,
         properties: {
-            modules: Object.keys(instances).join(', '),
+            modules: Object.keys(instance).join(', '),
             initTime,
         },
         metric: initTime,
     });
-    Object.seal(instances);
-    return instances;
+    Object.seal(instance);
+    return instance;
 }
 
 // biome-ignore-all lint/suspicious/noExplicitAny: internal type-erased dispatch — the post-initialize phase forwards opaque instances without inspecting their concrete shapes
@@ -1818,8 +1710,6 @@ async function runPluginPhase(ctx, modules, ref) {
     });
 }
 
-/** Fixed teardown order: ordinary modules first, so diagnostics and events can still record them. */
-const disposePhaseOrder = ['default', 'diagnostics', 'events'];
 function getPluginTeardownName(teardown) {
     return typeof teardown === 'function' ? teardown.name || 'anonymous' : 'dispose';
 }
@@ -1834,9 +1724,9 @@ async function runPluginTeardown(teardown) {
 /**
  * Runs the dispose lifecycle phase for all registered modules.
  *
- * Calls module `dispose` hooks concurrently within each fixed phase:
- * default, diagnostics, then events. Rejections are isolated through
- * `Promise.allSettled`. After all hooks settle, the event stream is completed.
+ * Calls each module's `dispose` hook (if defined) concurrently via
+ * `Promise.allSettled` so one failing module cannot block others from
+ * being torn down. After all hooks settle, the event stream is completed.
  *
  * @param ctx - The dispose phase context.
  * @param instance - The initialized module instance map to tear down.
@@ -1846,8 +1736,6 @@ async function runPluginTeardown(teardown) {
  */
 async function runDisposePhase(ctx, instance, ref) {
     const { modules, registerEvent, event$, pluginTeardowns = [] } = ctx;
-    const start = performance.now();
-    let failed = false;
     registerEvent({
         level: ModuleEventLevel.Debug,
         name: ModuleConfiguratorEventName.Dispose,
@@ -1876,7 +1764,6 @@ async function runDisposePhase(ctx, instance, ref) {
                 });
             }
             catch (err) {
-                failed = true;
                 registerEvent({
                     level: ModuleEventLevel.Warning,
                     name: ModuleConfiguratorEventName.PluginDisposeError,
@@ -1893,98 +1780,65 @@ async function runDisposePhase(ctx, instance, ref) {
         message: 'Disposing modules',
         properties: { count: modules.length },
     });
-    const groups = {
-        default: [],
-        diagnostics: [],
-        events: [],
-    };
-    // Partition once so invalid runtime input cannot silently omit a provider's cleanup.
-    for (const module of modules) {
-        const phase = module.disposePhase ?? 'default';
-        // Only named lifecycle phases may delay cleanup until infrastructure shutdown.
-        if (disposePhaseOrder.includes(phase)) {
-            groups[phase].push(module);
-        }
-        else {
-            failed = true;
+    // Dispose all modules concurrently; failures are isolated per module so
+    // one bad teardown cannot leave other modules in an inconsistent state.
+    await Promise.allSettled(modules
+        // Only process modules that define a dispose hook
+        .filter((module) => !!module.dispose)
+        // Dispose each module that defines the hook
+        .map(async (module) => {
+        // Narrow the type for TypeScript; the filter above already guarantees this
+        if (!module.dispose)
+            return;
+        try {
+            await module.dispose({
+                ref,
+                modules: instance,
+                instance: instance[module.name],
+            });
             registerEvent({
-                level: ModuleEventLevel.Warning,
-                name: ModuleConfiguratorEventName.ModulesDispose,
-                message: `Unsupported disposal phase for module ${module.name}; disposing during the default phase`,
-                properties: { moduleName: module.name },
-                error: new TypeError('Unsupported module disposal phase'),
+                level: ModuleEventLevel.Debug,
+                name: ModuleConfiguratorEventName.ModuleDisposed,
+                message: `Module ${module.name} disposed successfully`,
+                properties: {
+                    moduleName: module.name,
+                    moduleVersion: module.version?.toString() || 'unknown',
+                },
             });
-            groups.default.push(module);
-        }
-    }
-    // Diagnostic infrastructure stays alive through ordinary module teardown.
-    for (const phase of disposePhaseOrder) {
-        await Promise.allSettled(groups[phase]
-            // Only process modules that define a dispose hook
-            .filter((module) => !!module.dispose)
-            // Dispose each module that defines the hook
-            .map(async (module) => {
-            // Narrow the type for TypeScript; the filter above already guarantees this
-            if (!module.dispose)
-                return;
-            const moduleStart = performance.now();
-            try {
-                await module.dispose({
-                    ref,
-                    modules: instance,
-                    instance: instance[module.name],
-                });
-                registerEvent({
-                    level: ModuleEventLevel.Debug,
-                    name: ModuleConfiguratorEventName.ModuleDisposed,
-                    metric: performance.now() - moduleStart,
-                    message: `Module ${module.name} disposed successfully`,
-                    properties: {
-                        moduleName: module.name,
-                        moduleVersion: module.version?.toString() || 'unknown',
-                    },
-                });
-            }
-            catch (err) {
-                failed = true;
-                registerEvent({
-                    level: ModuleEventLevel.Warning,
-                    name: ModuleConfiguratorEventName.ModuleDisposeError,
-                    metric: performance.now() - moduleStart,
-                    message: `Module ${module.name} dispose failed`,
-                    properties: {
-                        moduleName: module.name,
-                        moduleVersion: module.version?.toString() || 'unknown',
-                    },
-                    error: err,
-                });
-            }
-        }));
-        // Emit exactly one host outcome before flushing sinks, including when no sinks exist.
-        if (phase === 'default') {
+        }
+        catch (err) {
             registerEvent({
-                level: failed ? ModuleEventLevel.Warning : ModuleEventLevel.Information,
-                name: ModuleConfiguratorEventName.ModulesDisposed,
-                message: 'Default module disposal complete; flushing lifecycle sinks',
-                metric: performance.now() - start,
-                properties: { count: modules.length, failed },
+                level: ModuleEventLevel.Warning,
+                name: ModuleConfiguratorEventName.ModuleDisposeError,
+                message: `Module ${module.name} dispose failed`,
+                properties: {
+                    moduleName: module.name,
+                    moduleVersion: module.version?.toString() || 'unknown',
+                },
+                error: err,
             });
         }
-    }
+    }));
+    registerEvent({
+        level: ModuleEventLevel.Debug,
+        name: ModuleConfiguratorEventName.ModulesDisposed,
+        message: 'Module dispose complete',
+        properties: { count: modules.length },
+    });
     // Complete the event stream last so all dispose events are captured before
     // any subscriber teardown triggered by completion.
     event$.complete();
 }
 
 // Generated by genversion.
-const version$4 = '6.2.0-next.0';
+const version$4 = '6.1.6';
 
 // biome-ignore-all lint/suspicious/noExplicitAny: internal type-erased dispatch arrays — callbacks are registered with concrete module types but stored erased; the orchestrator never inspects these shapes itself
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
  * Core orchestrator that drives the module lifecycle in Fusion Framework.
  *
- * `ModulesConfigurator` manages the full **prepare → configure → post-configure → initialize →
+ * `ModulesConfigurator` manages the full **configure → post-configure → initialize →
  * post-initialize → plugin → 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
@@ -1994,7 +1848,6 @@ const version$4 = '6.2.0-next.0';
  *
  * | # | Phase | Entry point | Description |
  * |---|-------|-------------|-------------|
- * | 0 | **Prepare** | `addConfig` | Opt-in synchronous preparation runs during registration, before startup callbacks can fail. |
  * | 1 | **Configure** | `_configure` | Each module's `configure()` factory creates a config builder; registered callbacks mutate it. |
  * | 2 | **Post-configure** | `_postConfigure` (inside `_configure`) | `postConfigure()` hooks and `onConfigured` callbacks run. |
  * | 3 | **Initialize** | `_initialize` | Modules are initialized concurrently; cross-module dependencies are resolved through `requireInstance`. |
@@ -2046,10 +1899,6 @@ class ModulesConfigurator {
     // configuration before telemetry is wired up.
     // Memory bound: ~24 KB at ~240 bytes/event × 100 events.
     #event$ = new ReplaySubject(100);
-    /** Shared disposal per initialized instance, so repeated calls join instead of re-running hooks. */
-    #disposals = new WeakMap();
-    /** Builders supplied or created during preparation, keyed by their exact module descriptor. */
-    #configurators = new Map();
     /**
      * Stream of lifecycle events emitted while modules are configured, initialized,
      * and disposed.
@@ -2100,14 +1949,10 @@ class ModulesConfigurator {
      * Teardown callbacks returned by registered plugins.
      *
      * Consumed during dispose and cleared after execution so repeated dispose calls
-     * do not run plugin cleanup more than once. Initialization now records teardowns per
-     * instance; this list only collects those from `_registerPlugins` overrides that do not
-     * forward the attempt's list.
+     * do not run plugin cleanup more than once.
      * @protected
      */
     _pluginTeardowns = [];
-    /** Plugin teardowns owned by each initialized instance, so disposing one never tears down another. */
-    #instanceTeardowns = new WeakMap();
     /**
      * Set of all registered module descriptors.
      * Uses a `Set` for automatic deduplication — the same module registered twice
@@ -2180,22 +2025,14 @@ class ModulesConfigurator {
      *
      * Adds the module to the known module set and registers the optional
      * `configure`, `afterConfig`, and `afterInit` callbacks into their
-     * respective lifecycle phase arrays. An optional `prepare` callback runs
-     * synchronously during registration against the same builder.
+     * respective lifecycle phase arrays.
      *
      * @param config - The module configurator descriptor to register.
      * @template T - The module type being registered.
      * @template TConfig - The resolved configuration type for the module.
-     * @throws Rethrows preparation failures; async preparation and unprepared ordinary factories are rejected.
      */
     addConfig(config) {
         const { module, afterConfig, afterInit, configure } = config;
-        // Prepare before touching registration state, so a failed preparation changes nothing.
-        const prepared = runPreparePhase({
-            registration: config,
-            configurators: this.#configurators,
-            registerEvent: (event) => this._registerEvent(event),
-        });
         // Find an existing descriptor so re-registering a name can replace all of its lifecycle hooks.
         const existingModule = Array.from(this._modules).find((m) => m.name === module.name);
         // Only handle replacement/dedupe when a descriptor is already registered under this name.
@@ -2206,19 +2043,7 @@ class ModulesConfigurator {
             // all share one module singleton) must stay additive so multiple calls can register
             // multiple named clients without clobbering each other.
             if (existingModule !== module) {
-                // A host-prepared builder (for example telemetry identity and startup capture) is lost
-                // with the old descriptor; duplicate package copies make this easy to miss, so say so.
-                if (this.#configurators.has(existingModule)) {
-                    console.warn(`Prepared configuration for module "${module.name}" was replaced`);
-                    this._registerEvent({
-                        level: ModuleEventLevel.Warning,
-                        name: ModuleConfiguratorEventName.PreparedConfigReplaced,
-                        message: `Prepared configuration for module ${module.name} was replaced by a different descriptor`,
-                        properties: { moduleName: module.name },
-                    });
-                }
                 this._removeModuleCallbacks(module.name);
-                this.#configurators.delete(existingModule);
                 const modules = Array.from(this._modules)
                     // Preserve every descriptor while substituting the newly registered module.
                     .map((m) => (m.name === module.name ? module : m));
@@ -2228,10 +2053,6 @@ class ModulesConfigurator {
         else {
             this._modules.add(module);
         }
-        // Commit the prepared builder only once the registration itself is in place.
-        if (prepared) {
-            this.#configurators.set(module, prepared.configurator);
-        }
         this._registerEvent({
             level: ModuleEventLevel.Debug,
             name: ModuleConfiguratorEventName.ModuleConfigAdded,
@@ -2354,64 +2175,8 @@ class ModulesConfigurator {
      * @returns A promise resolving to the sealed, initialized module instance.
      * @template T - Additional modules to merge into the instance type.
      * @template R - The reference type, narrowed to `TRef`.
-     * @throws Rethrows the original configuration or initialization error after partial cleanup.
      */
     async initialize(ref) {
-        const start = performance.now();
-        const instances = {};
-        // Plugin cleanup belongs to this attempt, so rollback never drains another instance's.
-        const teardowns = [];
-        this._registerEvent({
-            level: ModuleEventLevel.Debug,
-            name: ModuleConfiguratorEventName.HostInitializeStarted,
-            message: 'Starting host initialization',
-        });
-        try {
-            const instance = await this._initializeModules(instances, teardowns, ref);
-            this._registerEvent({
-                level: ModuleEventLevel.Information,
-                name: ModuleConfiguratorEventName.HostInitialized,
-                message: 'Host initialized',
-                metric: performance.now() - start,
-            });
-            return instance;
-        }
-        catch (error) {
-            this._registerEvent({
-                level: ModuleEventLevel.Error,
-                name: ModuleConfiguratorEventName.HostInitializeError,
-                message: 'Host initialization failed',
-                metric: performance.now() - start,
-                error,
-            });
-            // Rollback owns the same provider map as this attempt, even when startup cannot return it.
-            try {
-                // Never call disposal hooks for modules that did not produce a provider.
-                const initializedModules = this.modules.filter((module) => Object.hasOwn(instances, module.name));
-                await runDisposePhase({
-                    modules: initializedModules,
-                    registerEvent: this._registerEvent.bind(this),
-                    event$: this.#event$,
-                    pluginTeardowns: teardowns,
-                }, instances, ref);
-            }
-            catch {
-                // Cleanup health is secondary; callers must receive the original startup rejection.
-                console.warn('Module initialization rollback failed');
-            }
-            throw error;
-        }
-    }
-    /**
-     * Runs initialization inside the host diagnostic boundary.
-     * @param instances - Attempt-owned provider map shared by initialization and rollback.
-     * @param teardowns - Attempt-owned plugin teardowns shared by rollback and disposal.
-     * @param ref - Reference forwarded to module lifecycle hooks.
-     * @returns The sealed module map.
-     * @template T - Additional modules in the resulting instance.
-     * @template R - Reference type accepted by this host.
-     */
-    async _initializeModules(instances, teardowns, ref) {
         const configStart = performance.now();
         const config = await this._configure(ref);
         const configLoadTime = Math.round(performance.now() - configStart);
@@ -2430,7 +2195,7 @@ class ModulesConfigurator {
             metric: configLoadTime,
         });
         const instanceStart = performance.now();
-        const instance = await this._initialize(config, ref, instances);
+        const instance = await this._initialize(config, ref);
         const instanceLoadTime = Math.round(performance.now() - instanceStart);
         // Build a comma-separated module name list for telemetry properties
         // Extract just the module names before joining into a display string
@@ -2465,13 +2230,10 @@ class ModulesConfigurator {
         await this._postInitialize(instance, ref);
         // `instance` is the freshly built module instance record, which is structurally compatible
         // with `ModulesInstance<TModules>` but not nominally assignable across the generic params.
-        // The shorthand disposes the returned map itself, so it shares disposal with
-        // `configurator.dispose(modules)` and teardown never runs twice or concurrently.
         const modules = Object.seal(Object.assign({}, instance, {
-            dispose: () => this.dispose(modules),
+            dispose: () => this.dispose(instance),
         }));
-        this.#instanceTeardowns.set(modules, teardowns);
-        await this._registerPlugins(modules, ref, teardowns);
+        await this._registerPlugins(modules, ref);
         return modules;
     }
     /**
@@ -2509,7 +2271,6 @@ class ModulesConfigurator {
     async _configure(ref) {
         return runConfigurePhase({
             modules: this.modules,
-            configurators: this.#configurators,
             configs: this._configs,
             afterConfiguration: this._afterConfiguration,
             afterInit: this._afterInit,
@@ -2526,39 +2287,17 @@ class ModulesConfigurator {
      *
      * @param config - The merged module config map from the configure phase.
      * @param ref - Optional reference forwarded to each module's `initialize` call.
-     * @param instances - Attempt-owned provider map; forward to `super` when overriding to preserve rollback ownership.
      * @returns A promise resolving to the sealed map of initialized module providers.
      * @template T - Additional modules to merge into the instance type.
      * @template R - The reference type. Defaults to `TRef`.
      * @protected
      */
-    async _initialize(config, ref, instances = {}) {
+    async _initialize(config, ref) {
         return runInitializePhase({
             modules: this.modules,
             registerEvent: this._registerEvent.bind(this),
-            instances,
-            onLateProvider: (module, provider) => {
-                void ModulesConfigurator.#disposeLateProvider(module, provider, ref);
-            },
         }, config, ref);
     }
-    /**
-     * Disposes a provider that finished initializing after startup already rejected.
-     * The rollback has completed the event stream by then, so failures are only logged.
-     * @param module - Module whose initializer resolved after the rejection.
-     * @param provider - The late provider to dispose.
-     * @param ref - Reference forwarded to the module dispose hook.
-     * @returns A promise resolving once the dispose hook has settled.
-     */
-    static async #disposeLateProvider(module, provider, ref) {
-        try {
-            await module.dispose?.({ ref, modules: { [module.name]: provider }, instance: provider });
-        }
-        catch {
-            // Startup already rejected with the original error; a late cleanup failure must not surface.
-            console.warn('Module initialization rollback failed');
-        }
-    }
     /**
      * Runs the post-initialize lifecycle phase.
      *
@@ -2590,16 +2329,14 @@ class ModulesConfigurator {
      *
      * @param instance - The sealed module instance from the initialize phase.
      * @param ref - Optional reference forwarded to each plugin callback.
-     * @param teardowns - Attempt-owned teardown list; forward to `super` when overriding so
-     *   disposing this instance runs only its own plugin cleanup.
      * @template T - Additional modules to merge into the instance type.
      * @template R - The reference type, narrowed to `TRef`.
      * @protected
      */
-    async _registerPlugins(instance, ref, teardowns = this._pluginTeardowns) {
+    async _registerPlugins(instance, ref) {
         return runPluginPhase({
             plugins: this._plugins,
-            teardowns,
+            teardowns: this._pluginTeardowns,
             registerEvent: this._registerEvent.bind(this),
         }, instance, ref);
     }
@@ -2613,26 +2350,14 @@ class ModulesConfigurator {
      * @param ref - Optional reference forwarded to module dispose hooks.
      * @returns A promise resolving when all modules have been disposed.
      */
-    dispose(instance, ref) {
-        // Idempotence belongs to each initialized instance; another instance must still be disposed.
-        let disposal = this.#disposals.get(instance);
-        // First disposal of this instance starts teardown; later calls join it.
-        if (!disposal) {
-            // Own teardowns first; the shared list only holds those from non-forwarding overrides.
-            const pluginTeardowns = [
-                ...(this.#instanceTeardowns.get(instance)?.splice(0) ?? []),
-                ...this._pluginTeardowns.splice(0),
-            ];
-            disposal = runDisposePhase({
-                modules: this.modules,
-                registerEvent: this._registerEvent.bind(this),
-                // ReplaySubject extends Subject — dispose only needs .complete() which both have.
-                event$: this.#event$,
-                pluginTeardowns,
-            }, instance, ref);
-            this.#disposals.set(instance, disposal);
-        }
-        return disposal;
+    async dispose(instance, ref) {
+        return runDisposePhase({
+            modules: this.modules,
+            registerEvent: this._registerEvent.bind(this),
+            // ReplaySubject extends Subject — dispose only needs .complete() which both have.
+            event$: this.#event$,
+            pluginTeardowns: this._pluginTeardowns,
+        }, instance, ref);
     }
 }
 
@@ -3269,7 +2994,7 @@ class HttpClientConfigurator {
 }
 
 // Generated by genversion.
-const version$3 = '8.1.5-next.0';
+const version$3 = '8.1.4';
 
 /** URL protocols accepted as valid ad-hoc base URIs. */
 const SUPPORTED_PROTOCOLS = ['http:', 'https:', 'ws:', 'wss:'];
@@ -3995,10 +3720,9 @@ const module$3 = {
                 // only attempt to acquire a token when the request actually declares scopes
                 if (scopes.length) {
                     /** TODO(#5143): should be try catch, check caller for handling */
-                    const options = { request: { scopes } };
-                    // A token for telemetry delivery belongs to the export, so it carries the same
-                    // request-local marker; auth telemetry then skips it instead of recording the export.
-                    const accessToken = await authProvider.acquireAccessToken(telemetryExportRequest in request ? markTelemetryExportRequest(options) : options);
+                    const accessToken = await authProvider.acquireAccessToken({
+                        request: { scopes },
+                    });
                     // without a token there's nothing to attach, fall through to the default request
                     if (accessToken) {
                         const headers = new Headers(request.headers);
@@ -5134,6 +4858,84 @@ class FlowSubject extends Observable {
     }
 }
 
+/**
+ * Internal helper utilities for constructing and inspecting Redux-style
+ * lifecycle action types (`::request`, `::success`, `::failure`).
+ */
+/**
+ * Separates an action's base type from its lifecycle suffix.
+ */
+const actionSuffixDivider = '::';
+
+// biome-ignore-all lint/suspicious/noExplicitAny: ported redux-toolkit conditional-type dispatch logic (e.g. IsAny<T, ...>) requires real `any`, not `unknown`, to distinguish the two at the type level
+// biome-ignore-all lint/suspicious/noConfusingVoidType: `void` here is the ported redux-toolkit sentinel meaning "no payload type provided", distinct from `undefined` (see IfVoid in ts-helpers.ts) — replacing with `undefined` would change dispatch semantics
+/**
+ * taken from https://github.com/reduxjs/redux-toolkit/tree/master/packages/toolkit/src
+ */
+/**
+ * Creates the runtime action creator implementation shared by the overloads above.
+ *
+ * @param type - The action type to assign to created actions.
+ * @param prepareAction - An optional function that prepares payload, metadata, and errors.
+ * @returns A callable action creator with type and matching metadata.
+ * @throws {Error} When the prepare callback does not return an action object.
+ */
+function createAction(type, prepareAction) {
+    function actionCreator(...args) {
+        // Use the prepare callback when the caller needs custom payload construction.
+        if (prepareAction) {
+            const prepared = prepareAction(...args);
+            // Reject invalid prepare callbacks before reading their action fields.
+            if (!prepared) {
+                throw new Error('prepareAction did not return an object');
+            }
+            // Merge optional metadata and error fields into the prepared action.
+            return {
+                type,
+                payload: prepared.payload,
+                ...('meta' in prepared && { meta: prepared.meta }),
+                ...('error' in prepared && { error: prepared.error }),
+            };
+        }
+        return { type, payload: args[0] };
+    }
+    actionCreator.toString = () => `${type}`;
+    actionCreator.type = type;
+    actionCreator.match = (action) => action.type === type;
+    return actionCreator;
+}
+
+// biome-ignore-all lint/suspicious/noExplicitAny: generic constraints mirror create-action.ts's ported redux-toolkit PrepareAction<any> dispatch pattern
+/**
+ * Creates the runtime async action implementation shared by the overloads above.
+ *
+ * @param type - The base action type string.
+ * @param request - A prepare function for the request action payload.
+ * @param success - A prepare function for the success action payload.
+ * @param failure - An optional prepare function for the failure action payload.
+ * @returns An action creator with request, success, and optional failure actions.
+ */
+function createAsyncAction(type, request, success, failure) {
+    const action = createAction([type, 'request'].join(actionSuffixDivider), request);
+    // Attach the success action only when the caller supplied its prepare function.
+    if (success) {
+        // Add the success action while preserving the request creator's identity.
+        Object.assign(action, {
+            success: createAction([type, 'success'].join(actionSuffixDivider), success),
+        });
+    }
+    // Attach the failure action only for async workflows that support failure results.
+    if (failure) {
+        // Add the failure action alongside the existing request and success actions.
+        Object.assign(action, {
+            failure: createAction([type, 'failure'].join(actionSuffixDivider), failure),
+        });
+    }
+    // `action` is progressively mutated with `success`/`failure` properties above, so its static
+    // type can't reflect the final shape declared by this function's overload signatures.
+    return action;
+}
+
 function freezeDraftable(val) {
     return isDraftable(val) ? produce(val, () => { }) : val;
 }
@@ -5374,11 +5176,89 @@ function toObservable(input, ...args) {
     return of(input);
 }
 
+/**
+ * Checks whether a metadata value is an object literal that should merge key by key.
+ * Arrays and class instances such as `Error` are excluded so they are kept intact.
+ *
+ * @param value - Metadata value to inspect.
+ * @returns `true` when the value is a plain object.
+ */
+const isPlainMetadata = (value) => {
+    // Primitives and null are kept as-is
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};
+/**
+ * Lists a metadata object's entries without `__proto__`, which would replace the prototype of an
+ * object it is assigned to (GHSA-gcqx-w48m-w2h4).
+ *
+ * @param value - Metadata object whose entries are listed.
+ * @returns The entries that are safe to assign.
+ */
+const safeEntries = (value) => 
+// `JSON.parse` keeps `__proto__` as an own key, so untrusted metadata can carry one
+Object.entries(value).filter(([key]) => key !== '__proto__');
+/**
+ * Copies plain objects and arrays from incoming metadata, dropping `__proto__` keys at any depth
+ * so a value with no existing counterpart is cleaned the same way as a merged one.
+ *
+ * @param value - Incoming metadata value.
+ * @returns A cleaned copy of plain objects and arrays; any other value as-is.
+ */
+const sanitizeMetadata = (value) => {
+    // Arrays may contain plain objects that carry `__proto__` keys
+    if (Array.isArray(value)) {
+        // Clean every item, since items never merge with an existing value
+        return value.map(sanitizeMetadata);
+    }
+    // Class instances such as `Error` and primitives are kept as-is
+    if (!isPlainMetadata(value)) {
+        return value;
+    }
+    // Clean each nested value too, since none of them has an existing value to merge with
+    const entries = safeEntries(value).map(([key, entryValue]) => [
+        key,
+        sanitizeMetadata(entryValue),
+    ]);
+    return Object.fromEntries(entries);
+};
+/**
+ * Merges one metadata value into another: plain objects merge recursively, arrays are appended,
+ * and any other value from `override` wins.
+ *
+ * @param base - Existing metadata value.
+ * @param override - Metadata value that takes precedence.
+ * @returns The merged value, as a new object or array when anything was merged.
+ */
+const mergeMetadataValue = (base, override) => {
+    // Lists of values accumulate rather than replace each other
+    if (Array.isArray(base) && Array.isArray(override)) {
+        // Clean incoming items before appending them to the existing list
+        return base.concat(override.map(sanitizeMetadata));
+    }
+    // Anything other than two plain objects is replaced by the override
+    if (!isPlainMetadata(base) || !isPlainMetadata(override)) {
+        return sanitizeMetadata(override);
+    }
+    // Start from the base keys so keys absent from the override survive
+    const result = Object.fromEntries(safeEntries(base));
+    // Overlay each override key, recursing where both sides define it
+    for (const [key, value] of safeEntries(override)) {
+        result[key] = Object.hasOwn(base, key)
+            ? mergeMetadataValue(base[key], value)
+            : sanitizeMetadata(value);
+    }
+    return result;
+};
 /**
  * Merges two `MetaData` objects into a single object.
  *
  * If both `source` and `target` are undefined, returns `undefined`.
  * Otherwise, performs a deep merge of the two objects, with properties from `target` overriding those in `source`.
+ * Neither input is mutated.
  *
  * @param source - The base `MetaData` object to merge from.
  * @param target - The `MetaData` object whose properties will override those in `source`.
@@ -5389,7 +5269,7 @@ const mergeMetadata = (source, target) => {
     if (!source && !target) {
         return undefined;
     }
-    return deepmerge(source ?? {}, target ?? {});
+    return mergeMetadataValue(source ?? {}, target ?? {});
 };
 /**
  * Merges two partial `TelemetryItem` objects into a single `TelemetryItem`.
@@ -5430,14 +5310,12 @@ const mergeTelemetryItem = (target, source) => {
  * Configures telemetry settings for the application.
  *
  * The `TelemetryConfigurator` class extends `BaseConfigBuilder` to provide a fluent API for
- * setting up telemetry adapters, metadata, default scopes, parent providers, host identity and
- * lifecycle records. Every setter records configuration; nothing is resolved until the
- * telemetry module builds its configuration.
+ * setting up telemetry adapters, metadata, default scopes, and parent providers.
  *
  * @example
  * ```typescript
  * const configurator = new TelemetryConfigurator()
- *   .setAdapter('console', consoleAdapter)
+ *   .setAdapter(myAdapter)
  *   .setMetadata({ app: 'my-app' })
  *   .setDefaultScope(['user', 'session'])
  *   .setParent(parentProvider);
@@ -5453,7 +5331,7 @@ const mergeTelemetryItem = (target, source) => {
  * @see ITelemetryConfigurator
  */
 class TelemetryConfigurator extends BaseConfigBuilder {
-    #adapters = {};
+    #adaptersCallbacks = {};
     #metadata = [];
     /**
      * Creates a new `TelemetryConfigurator` and wires up the async adapter
@@ -5464,56 +5342,40 @@ class TelemetryConfigurator extends BaseConfigBuilder {
         // Configure async adapter resolution using mergeMap to handle Promise/Observable adapter factories
         this._set('adapters', (args) => {
             // Resolve every adapter factory concurrently and merge them into a single record
-            return from(Object.entries(this.#adapters)).pipe(mergeMap(([identifier, { configure }]) => 
+            return from(Object.entries(this.#adaptersCallbacks)).pipe(mergeMap(([identifier, adapterFn]) => 
             // Drop adapters whose factory resolved to a falsy value
-            defer(() => from(configure(args))).pipe(filter((adapter) => !!adapter), map((adapter) => [identifier, adapter]), catchError(() => {
-                // Factory errors may carry credentials or URLs, so only the failure is reported.
-                console.warn('Telemetry adapter factory failed');
-                return EMPTY;
-            }))), scan((acc, [identifier, adapter]) => {
+            from(adapterFn(args)).pipe(filter((adapter) => !!adapter), map((adapter) => [identifier, adapter]))), scan((acc, [identifier, adapter]) => {
                 acc[identifier] = adapter;
                 return acc;
             }, {}), defaultIfEmpty({}), shareReplay({ bufferSize: 1, refCount: true }));
         });
-        // Ownership is declared configuration: a failed explicit exporter still owns delivery,
-        // so its failure can never activate an ancestor's fallback exporter.
-        this._set('ownsExport', async () => 
-        // Any explicit declaration owns delivery.
-        Object.values(this.#adapters).some(({ explicit }) => explicit));
         // Configure metadata merging - handles multiple sync/async metadata sources
         this._set('metadata', async () => {
             const metadataItems = this.#metadata;
             return (...args) => 
             // Merge every registered metadata source in order, emitting the final accumulated result
-            from(metadataItems).pipe(concatMap((metadata) => toObservable(metadata, ...args)), scan((acc, current) => mergeMetadata(acc, current) ?? {}, {}), defaultIfEmpty({}), last(), shareReplay({ bufferSize: 1, refCount: true }));
+            from(metadataItems).pipe(concatMap((metadata) => toObservable(metadata, ...args)), scan((acc, current) => mergeMetadata(acc, current) ?? {}, {}), last(), shareReplay({ bufferSize: 1, refCount: true }));
         });
     }
     /**
      * Registers a telemetry adapter with the configurator.
      *
-     * A non-fallback adapter is an explicit exporter: it owns delivery, so the parent's fallback
-     * exporters skip records this provider relays.
-     *
      * @param identifier - The key used to register and later resolve this adapter.
-     * @param adapter - The telemetry adapter to be added.
+     * @param adapter - The telemetry adapter to be added. The adapter's identifier is used as the key.
      * @returns The current instance of the configurator for method chaining.
      */
     setAdapter(identifier, adapter) {
-        this.#adapters[identifier] = { configure: async () => adapter, explicit: !adapter.fallback };
-        return this;
+        return this.configureAdapter(identifier, async () => adapter);
     }
     /**
      * Configures a telemetry adapter with the configurator.
      *
-     * A factory's adapter is unknown until it resolves, so it is declared as an explicit exporter;
-     * register fallback adapters with `setAdapter`.
-     *
      * @param identifier - The key used to register and later resolve this adapter.
      * @param adapterFn - A callback function that returns a telemetry adapter instance
      * @returns The current instance for method chaining
      */
     configureAdapter(identifier, adapterFn) {
-        this.#adapters[identifier] = { configure: adapterFn, explicit: true };
+        this.#adaptersCallbacks[identifier] = adapterFn;
         return this;
     }
     /**
@@ -5549,15 +5411,6 @@ class TelemetryConfigurator extends BaseConfigBuilder {
         this._set('parent', parent);
         return this;
     }
-    /** @inheritdoc */
-    setSource(source) {
-        // Fail at configuration time; an invalid label would otherwise drop every built-in record.
-        if (source.source !== undefined && !operationalIdentifier.safeParse(source.source).success) {
-            throw new RangeError('Telemetry source kind must be a lowercase kebab-case identifier, such as "portal"');
-        }
-        this._set('source', Object.freeze({ ...source }));
-        return this;
-    }
     /**
      * Attaches an observable stream of telemetry items to the configurator.
      *
@@ -5568,20 +5421,6 @@ class TelemetryConfigurator extends BaseConfigBuilder {
         this._set('items$', item$);
         return this;
     }
-    /** @inheritdoc */
-    attachLifecycleItems(item$) {
-        this._set('lifecycleItems$', item$);
-        return this;
-    }
-    /** @inheritdoc */
-    hasLifecycleItems() {
-        return this._has('lifecycleItems$');
-    }
-    /** @inheritdoc */
-    setLifecycleItemsEnabled(enabled) {
-        this._set('lifecycleItemsEnabled', enabled);
-        return this;
-    }
     /**
      * Sets the filter configuration for telemetry items.
      *
@@ -5597,158 +5436,13 @@ class TelemetryConfigurator extends BaseConfigBuilder {
 }
 
 // Generated by genversion.
-const version$2 = '8.0.0-next.3';
+const version$2 = '7.2.3';
 
 /**
- * Represents a telemetry measurement that tracks elapsed time and reports measurement data
- * to a telemetry provider. Supports cloning, resetting, and marking measurements as completed.
+ * Represents a framework event with customizable details and behavior.
  *
- * @remarks
- * - The measurement starts timing upon instantiation.
- * - Provides methods to measure elapsed time, reset the timer, clone the measurement, and
- *   automatically measure on disposal if not already measured.
- * - Can be used to wrap asynchronous operations and automatically record their duration.
- *
- * @example
- * ```typescript
- * const measurement = new Measurement(provider, { name: 'operation' });
- * // ... perform operation ...
- * measurement.measure();
- * ```
- *
- * @public
- */
-class Measurement {
-    #provider;
-    #data;
-    #startTime;
-    #measured;
-    /**
-     * Initializes a new instance of the Measurement class.
-     *
-     * @param provider - The telemetry provider responsible for handling telemetry data.
-     * @param data - The measurement data to be associated with this instance.
-     */
-    constructor(provider, data) {
-        this.#data = data;
-        this.#provider = provider;
-        this.#startTime = performance.now();
-    }
-    /**
-     * Creates a new `Measurement` instance that is a copy of the current one.
-     *
-     * @param resetOptions - Options to control which properties are preserved in the clone.
-     *   - `preserveStartTime`: If `true`, the start time of the measurement is preserved in the clone.
-     * @returns A new `Measurement` instance with copied data and optionally preserved start time.
-     */
-    clone(resetOptions = {}) {
-        const clonedMeasurement = new Measurement(this.#provider, this.#data);
-        // Preserve the original start time when requested, otherwise the clone starts fresh
-        if (resetOptions.preserveStartTime) {
-            clonedMeasurement.#startTime = this.#startTime;
-        }
-        return clonedMeasurement;
-    }
-    /**
-     * Resets the measurement state.
-     *
-     * @param options - Optional settings for the reset operation.
-     * @param options.preserveStartTime - If true, the start time will not be reset; otherwise, it will be set to the current time.
-     *
-     * Resets the measured flag and, unless `preserveStartTime` is true, updates the start time to the current performance time.
-     */
-    reset(options) {
-        // Keep the existing start time when preserving, otherwise restart the clock
-        if (!options?.preserveStartTime) {
-            this.#startTime = performance.now();
-        }
-        this.#measured = false;
-    }
-    /**
-     * Measures the elapsed time since the last start time and sends the measurement data
-     * to the telemetry provider. Optionally marks the measurement as completed and/or
-     * resets the start time for subsequent measurements.
-     *
-     * @param data - Optional additional measurement data to merge with the existing data.
-     * @param options - Optional measurement options.
-     * @param options.markAsMeasured - If true, marks this measurement as completed.
-     * @param options.resetStartTime - If true, resets the start time after measuring.
-     * @returns The elapsed duration in milliseconds since the last start time.
-     */
-    measure(data, options) {
-        const measuredData = mergeTelemetryItem(this.#data, data ?? {});
-        const duration = performance.now() - this.#startTime;
-        this.#provider.trackMetric({
-            ...measuredData,
-            value: duration,
-        });
-        // Mark as measured only when explicitly requested by the caller
-        if (options?.markAsMeasured) {
-            this.#measured = true;
-        }
-        // Restart the clock only when explicitly requested by the caller
-        if (options?.resetStartTime) {
-            this.#startTime = performance.now();
-        }
-        return duration;
-    }
-    /**
-     * Resolves a given promise, measures the result using the provided options, and returns the resolved value.
-     *
-     * @template T - The type of the resolved value from the promise.
-     * @param promise - The promise to resolve.
-     * @param options - Optional configuration for resolving and measuring:
-     *   - `data`: A value or a function that receives the resolved result and returns measurement data.
-     *   - `options`: Additional options to pass to the `measure` method.
-     * @returns A promise that resolves to the value of the input promise.
-     */
-    async resolve(promise, options) {
-        const result = await promise;
-        const endData = typeof options?.data === 'function' ? options?.data(result) : options?.data;
-        this.measure(await Promise.resolve(endData), options?.options);
-        return result;
-    }
-    /**
-     * Executes the provided function and resolves its result using the `resolve` method.
-     * The function `fn` can return either a value of type `T` or a Promise of type `T`.
-     * Optionally, resolution options can be provided.
-     *
-     * @template T - The return type of the function to execute.
-     * @param fn - A function that returns a value or a Promise to be resolved.
-     * @param options - Optional resolution options to customize the resolve behavior.
-     * @returns A Promise that resolves to the result of the executed function.
-     */
-    exec(fn, options) {
-        return this.resolve(Promise.resolve(fn()), options);
-    }
-    /**
-     * Disposes of the measurement instance. If the measurement has not yet been taken,
-     * this method ensures that it is performed before disposal.
-     *
-     * This method is intended to be used with the ECMAScript `Symbol.dispose` protocol,
-     * allowing for automatic resource management when used in a `using` statement.
-     *
-     * @see https://github.com/tc39/proposal-explicit-resource-management
-     */
-    [Symbol.dispose]() {
-        // Ensure a measurement is always taken before the instance is discarded
-        if (!this.#measured) {
-            try {
-                this.measure();
-            }
-            catch {
-                // Silently handle errors during disposal to ensure cleanup always completes
-                // The measurement failure should not prevent proper resource disposal
-            }
-        }
-    }
-}
-
-/**
- * Represents a framework event with customizable details and behavior.
- *
- * The `FrameworkEvent` class implements the `IFrameworkEvent` interface and provides a way to create and manage events
- * with custom details and behavior. It allows you to:
+ * The `FrameworkEvent` class implements the `IFrameworkEvent` interface and provides a way to create and manage events
+ * with custom details and behavior. It allows you to:
  *
  * - Specify the event type and initial event details
  * - Access the event details
@@ -5906,34 +5600,148 @@ class TelemetryEvent extends FrameworkEvent {
 }
 
 /**
- * Relays one record to a parent provider under the child's routing policy.
+ * Represents a telemetry measurement that tracks elapsed time and reports measurement data
+ * to a telemetry provider. Supports cloning, resetting, and marking measurements as completed.
  *
- * Shared by live provider relay and startup recovery, so both honour the same relay filter
- * and exporter ownership.
+ * @remarks
+ * - The measurement starts timing upon instantiation.
+ * - Provides methods to measure elapsed time, reset the timer, clone the measurement, and
+ *   automatically measure on disposal if not already measured.
+ * - Can be used to wrap asynchronous operations and automatically record their duration.
+ *
+ * @example
+ * ```typescript
+ * const measurement = new Measurement(provider, { name: 'operation' });
+ * // ... perform operation ...
+ * measurement.measure();
+ * ```
  *
- * @param target - Parent provider.
- * @param item - Record to relay.
- * @param policy - Child exporter ownership and relay filter.
- * @returns `true` when the parent accepted the record or the filter intentionally rejected it;
- *   `false` when the parent cannot honour ownership (a legacy parent and an owned record).
- * @throws Rethrows relay filter and parent delivery errors for the caller's health reporting.
+ * @public
  */
-function relayRecord(target, item, policy) {
-    // Reject intentionally filtered records without changing export ownership.
-    if (policy.relay && !policy.relay(item)) {
-        return true;
+class Measurement {
+    #provider;
+    #data;
+    #startTime;
+    #measured;
+    /**
+     * Initializes a new instance of the Measurement class.
+     *
+     * @param provider - The telemetry provider responsible for handling telemetry data.
+     * @param data - The measurement data to be associated with this instance.
+     */
+    constructor(provider, data) {
+        this.#data = data;
+        this.#provider = provider;
+        this.#startTime = performance.now();
     }
-    // Ownership-aware parents suppress their fallback exporters for records a child owns.
-    if (target.trackRelayed) {
-        target.trackRelayed(item, policy.ownsExport);
-        return true;
+    /**
+     * Creates a new `Measurement` instance that is a copy of the current one.
+     *
+     * @param resetOptions - Options to control which properties are preserved in the clone.
+     *   - `preserveStartTime`: If `true`, the start time of the measurement is preserved in the clone.
+     * @returns A new `Measurement` instance with copied data and optionally preserved start time.
+     */
+    clone(resetOptions = {}) {
+        const clonedMeasurement = new Measurement(this.#provider, this.#data);
+        // Preserve the original start time when requested, otherwise the clone starts fresh
+        if (resetOptions.preserveStartTime) {
+            clonedMeasurement.#startTime = this.#startTime;
+        }
+        return clonedMeasurement;
     }
-    // Legacy parents cannot honour ownership, so they only receive records no child owns.
-    if (!policy.ownsExport) {
-        target.track(item);
-        return true;
+    /**
+     * Resets the measurement state.
+     *
+     * @param options - Optional settings for the reset operation.
+     * @param options.preserveStartTime - If true, the start time will not be reset; otherwise, it will be set to the current time.
+     *
+     * Resets the measured flag and, unless `preserveStartTime` is true, updates the start time to the current performance time.
+     */
+    reset(options) {
+        // Keep the existing start time when preserving, otherwise restart the clock
+        if (!options?.preserveStartTime) {
+            this.#startTime = performance.now();
+        }
+        this.#measured = false;
+    }
+    /**
+     * Measures the elapsed time since the last start time and sends the measurement data
+     * to the telemetry provider. Optionally marks the measurement as completed and/or
+     * resets the start time for subsequent measurements.
+     *
+     * @param data - Optional additional measurement data to merge with the existing data.
+     * @param options - Optional measurement options.
+     * @param options.markAsMeasured - If true, marks this measurement as completed.
+     * @param options.resetStartTime - If true, resets the start time after measuring.
+     * @returns The elapsed duration in milliseconds since the last start time.
+     */
+    measure(data, options) {
+        const measuredData = mergeTelemetryItem(this.#data, data ?? {});
+        const duration = performance.now() - this.#startTime;
+        this.#provider.trackMetric({
+            ...measuredData,
+            value: duration,
+        });
+        // Mark as measured only when explicitly requested by the caller
+        if (options?.markAsMeasured) {
+            this.#measured = true;
+        }
+        // Restart the clock only when explicitly requested by the caller
+        if (options?.resetStartTime) {
+            this.#startTime = performance.now();
+        }
+        return duration;
+    }
+    /**
+     * Resolves a given promise, measures the result using the provided options, and returns the resolved value.
+     *
+     * @template T - The type of the resolved value from the promise.
+     * @param promise - The promise to resolve.
+     * @param options - Optional configuration for resolving and measuring:
+     *   - `data`: A value or a function that receives the resolved result and returns measurement data.
+     *   - `options`: Additional options to pass to the `measure` method.
+     * @returns A promise that resolves to the value of the input promise.
+     */
+    async resolve(promise, options) {
+        const result = await promise;
+        const endData = typeof options?.data === 'function' ? options?.data(result) : options?.data;
+        this.measure(await Promise.resolve(endData), options?.options);
+        return result;
+    }
+    /**
+     * Executes the provided function and resolves its result using the `resolve` method.
+     * The function `fn` can return either a value of type `T` or a Promise of type `T`.
+     * Optionally, resolution options can be provided.
+     *
+     * @template T - The return type of the function to execute.
+     * @param fn - A function that returns a value or a Promise to be resolved.
+     * @param options - Optional resolution options to customize the resolve behavior.
+     * @returns A Promise that resolves to the result of the executed function.
+     */
+    exec(fn, options) {
+        return this.resolve(Promise.resolve(fn()), options);
+    }
+    /**
+     * Disposes of the measurement instance. If the measurement has not yet been taken,
+     * this method ensures that it is performed before disposal.
+     *
+     * This method is intended to be used with the ECMAScript `Symbol.dispose` protocol,
+     * allowing for automatic resource management when used in a `using` statement.
+     *
+     * @see https://github.com/tc39/proposal-explicit-resource-management
+     */
+    [Symbol.dispose]() {
+        // Ensure a measurement is always taken before the instance is discarded
+        if (!this.#measured) {
+            try {
+                this.measure();
+            }
+            catch {
+                // Silently handle errors during disposal to ensure cleanup always completes
+                // The measurement failure should not prevent proper resource disposal
+            }
+        }
     }
-    return false;
 }
 
 /**
@@ -5976,656 +5784,80 @@ const applyMetadata = (metadata, args) => {
     // resolved metadata is always target, else item metadata would be overwritten
     map((data) => mergeTelemetryItem({ metadata: data }, args.item)), catchError((error) => {
         const errorItem = TelemetryExceptionSchema.parse({
-            type: TelemetryType.Exception,
-            name: TelemetryItemNames.MetadataError,
-            exception: error,
-            properties: {
-                sourceMetricName: args.item.name,
-                sourceMetricType: args.item.type,
-            },
-        });
-        return merge(of(errorItem), of(args.item));
-    }));
-};
-
-/**
- * Creates the reducer recording telemetry provider transitions.
- * @returns A reducer with a fresh idle initial snapshot.
- */
-function createTelemetryProviderReducer() {
-    return createReducer$2(() => ({
-        status: 'idle',
-        enrichment: { pending: 0, builtIn: 0 },
-        processing: {},
-        failures: {},
-    }), (builder) => builder
-        .addCase(telemetryProviderActions.initialize, (state, { meta }) => {
-        state.initialization = meta.operation;
-        // Only an idle provider starts; disposal already in progress keeps its status.
-        if (state.status === 'idle') {
-            state.status = 'initializing';
-        }
-    })
-        .addCase(telemetryProviderActions.initialize.success, (state) => {
-        // Disposal requested during initialization wins over late readiness.
-        if (state.status === 'initializing') {
-            state.status = 'ready';
-        }
-    })
-        .addCase(telemetryProviderActions.dispose, (state, { meta }) => {
-        state.disposal = meta.operation;
-        state.status = 'disposing';
-    })
-        .addCase(telemetryProviderActions.close, (state) => {
-        state.status = 'disposed';
-    })
-        .addCase(telemetryProviderActions.enrichmentStarted, (state, { payload }) => {
-        state.enrichment.pending++;
-        // Only bounded built-in enrichment delays shutdown; custom enrichment is canceled.
-        if (payload.builtIn) {
-            state.enrichment.builtIn++;
-        }
-    })
-        .addCase(telemetryProviderActions.enrichmentSettled, (state, { payload }) => {
-        state.enrichment.pending--;
-        // Mirror the start transition so the shutdown drain condition stays exact.
-        if (payload.builtIn) {
-            state.enrichment.builtIn--;
-        }
-    })
-        .addCase(telemetryProviderActions.processingStarted, (state, { payload }) => {
-        state.processing[payload] = (state.processing[payload] ?? 0) + 1;
-    })
-        .addCase(telemetryProviderActions.processingSettled, (state, { payload }) => {
-        state.processing[payload] = (state.processing[payload] ?? 1) - 1;
-    })
-        .addCase(telemetryProviderActions.failed, (state, { payload }) => {
-        const failure = state.failures[payload.message];
-        // The first occurrence is retained for reporting; repeats only count.
-        if (failure) {
-            failure.count++;
-        }
-        else {
-            state.failures[payload.message] = { error: payload, count: 1 };
-        }
-    }));
-}
-
-/**
- * Emits once state satisfies a condition, immediately when it already does.
- * @param state$ - Provider state stream.
- * @param predicate - Condition over the snapshot.
- * @returns A single emission of the first matching snapshot.
- */
-const whenState = (state$, predicate) => 
-// Only the first matching snapshot gates the next step.
-state$.pipe(filter(predicate), take(1));
-/**
- * Connects the provider once per initialize request and settles the shared operation.
- * @param handlers - Engine work.
- * @returns A flow emitting `initialize.success` or `initialize.failure`.
- */
-const initializeFlow = (handlers) => (action$) => 
-// Repeated requests join the running operation, so ignore them while it is in flight.
-action$.pipe(filter(telemetryProviderActions.initialize.match), exhaustMap(({ payload }) => 
-// Connecting is the operation; its outcome settles every joined caller.
-from(handlers.connect(payload)).pipe(map(() => telemetryProviderActions.initialize.success()), catchError((error) => of(telemetryProviderActions.initialize.failure(error))))));
-/**
- * Drains owned work in order, closes delivery and shuts down exporters once.
- *
- * Order: initialization settles → bounded built-in enrichment drains → delivery closes
- * (canceling custom enrichment) → asynchronous adapter processing drains → repeated failures
- * are summarized → exporters shut down.
- *
- * @param handlers - Engine work.
- * @returns A flow emitting `close`, then `dispose.success` or `dispose.failure`.
- */
-const disposeFlow = (handlers) => (action$, state$) => 
-// Disposal runs once; later requests join the same operation instead.
-action$.pipe(filter(telemetryProviderActions.dispose.match), exhaustMap(() => {
-    // An in-flight initialization finishes before anything is torn down.
-    const initialized$ = whenState(state$, () => true).pipe(exhaustMap(({ initialization }) => from(Promise.allSettled([initialization]))), ignoreElements());
-    // Built-in enrichment has a deadline; retain terminal teardown records before closing.
-    const closed$ = whenState(state$, ({ enrichment }) => enrichment.builtIn === 0).pipe(tap(() => handlers.close()), map(() => telemetryProviderActions.close()));
-    // Accepted asynchronous processing is owned and must settle before exporters shut down.
-    const drained$ = whenState(state$, ({ processing }) => 
-    // Every adapter must be drained, not just the one that settled last.
-    Object.values(processing).every((pending) => !pending)).pipe(tap(({ failures }) => {
-        // Repeated failures stay visible without one event per failed record.
-        for (const [failure, { count }] of Object.entries(failures)) {
-            // A single occurrence was already reported; summarize only repeats.
-            if (count > 1) {
-                console.warn('Telemetry pipeline failure summary', { failure, count });
-            }
-        }
-    }), ignoreElements());
-    // Shutdown is attempted for every exporter; its outcome settles the operation.
-    const shutdown$ = defer(() => from(handlers.shutdown())).pipe(map(() => telemetryProviderActions.dispose.success()), catchError((error) => of(telemetryProviderActions.dispose.failure(error))));
-    return concat(initialized$, closed$, drained$, shutdown$);
-}));
-/**
- * Reports each pipeline failure once, when it first appears in state.
- * @param handlers - Engine work.
- * @returns A flow that only performs reporting and emits no actions.
- */
-const failureFlow = (handlers) => (action$, state$) => 
-// Pair each failure with the snapshot that already counted it.
-action$.pipe(filter(telemetryProviderActions.failed.match), withLatestFrom(state$), 
-// Only the first occurrence is actionable; repeats are summarized at teardown.
-filter(([{ payload }, { failures }]) => failures[payload.message]?.count === 1), tap(([{ payload }, { status }]) => handlers.report(payload, status)), ignoreElements());
-/**
- * Creates the flows driving a telemetry provider's operations and health reporting.
- * @param handlers - Engine work the flows delegate to.
- * @returns Flows to register on provider state.
- */
-function createTelemetryProviderFlows(handlers) {
-    return [initializeFlow(handlers), disposeFlow(handlers), failureFlow(handlers)];
-}
-
-/** Pending metadata enrichment allowed per provider before built-in records skip enrichment. */
-const METADATA_CAPACITY = 256;
-/** Deadline for built-in enrichment; on expiry the original safe record is emitted. */
-const BUILT_IN_METADATA_TIMEOUT_MS = 1_000;
-/** Pending asynchronous processing allowed per adapter before records are dropped for it. */
-const ADAPTER_PROCESSING_CAPACITY = 256;
-/**
- * The telemetry engine behind a `TelemetryProvider`.
- *
- * Owns the record pipeline (scope, built-in envelope protection, bounded metadata enrichment,
- * adapter delivery, parent relay and event dispatch) and a reactive state of lifecycle,
- * in-flight work and health. `initialize` and `dispose` are async actions whose flows perform
- * the work; failures are recorded in state and reported once by a flow.
- *
- * Records stay on a synchronous stream rather than becoming actions, so adapter delivery
- * happens within `track`. Operation outcomes are delivered as actions on the `asyncScheduler`,
- * so with fake timers, advance timers to settle `initialize` or `dispose`.
- *
- * @example
- * ```ts
- * const state = new TelemetryProviderState({ config, owner: provider });
- * await state.initialize({ parent });
- * state.track(record);
- * await state.dispose();
- * ```
- */
-class TelemetryProviderState {
-    #subject;
-    #records = new Subject();
-    /** Delivery subscriptions, released together when delivery closes. */
-    #connections = new Subscription();
-    #config;
-    #context;
-    #modules;
-    /**
-     * Creates the engine and registers the flows driving its operations.
-     * @param context - Configuration, event bus and the public provider.
-     */
-    constructor({ config, ...context }) {
-        const adapters = config?.adapters ?? {};
-        // Configuration, not delivery success, determines inherited fallback suppression.
-        const ownsExport = config?.ownsExport ?? Object.values(adapters).some((adapter) => !adapter.fallback);
-        this.#config = Object.freeze({
-            ...config,
-            adapters,
-            defaultScope: config?.defaultScope ?? [],
-            ownsExport,
-        });
-        this.#context = context;
-        this.#subject = new FlowSubject(createTelemetryProviderReducer());
-        const flows = createTelemetryProviderFlows({
-            connect: (args) => this.#connect(args),
-            close: () => this.#close(),
-            shutdown: () => this.#shutdown(),
-            report: (error, status) => this.#report(error, status),
-        });
-        // Every operation and health reaction is a flow over this state's actions.
-        for (const flow of flows) {
-            this.#subject.addFlow(flow);
-        }
-    }
-    /**
-     * Current snapshot of lifecycle, in-flight work and health.
-     * @returns The latest reduced snapshot.
-     */
-    get value() {
-        return this.#subject.value;
-    }
-    /**
-     * Every record tracked by the provider, after scope and enrichment.
-     * @returns The record stream without its internal ownership envelope.
-     */
-    get items() {
-        // Expose records without their internal ownership envelope.
-        return this.#records.pipe(map(({ item }) => item));
-    }
-    /**
-     * Exporters configured for this provider, keyed by identifier.
-     * @returns The resolved adapters.
-     */
-    get adapters() {
-        return this.#config.adapters;
-    }
-    /**
-     * Sets the resolved framework module instances used to resolve metadata.
-     * @param value - The resolved framework module instances.
-     */
-    set modules(value) {
-        this.#modules = value;
-    }
-    /**
-     * Selects a derived value, emitting the current value and then only changes.
-     * @param selector - Projection of the snapshot.
-     * @returns The selected value stream.
-     * @template T - Selected value type.
-     */
-    select(selector) {
-        return this.#subject.select(selector);
-    }
-    /**
-     * Emits once when the snapshot satisfies a condition, immediately when it already does.
-     * @param predicate - Condition over the snapshot.
-     * @returns A single-emission stream suited to cancellation with `takeUntil`.
-     */
-    when(predicate) {
-        // Only the first matching transition matters for cancellation.
-        return this.select(predicate).pipe(filter((matched) => matched), take(1));
-    }
-    /**
-     * Connects exporters, the parent relay and startup streams once; repeated calls join.
-     * @param args - Optional parent provider and startup records.
-     * @returns Resolves when the provider is connected.
-     * @throws {Error} When the provider has already been disposed.
-     */
-    initialize(args) {
-        const { status, initialization } = this.value;
-        // A disposed provider must not reconnect exporters or event subscriptions.
-        if (status === 'disposed') {
-            return Promise.reject(new Error('Cannot initialize disposed telemetry'));
-        }
-        // Repeated and reentrant initialization joins the same operation.
-        if (initialization) {
-            return initialization;
-        }
-        const operation = this.#settled(telemetryProviderActions.initialize.success.match, telemetryProviderActions.initialize.failure.match);
-        this.#subject.next(telemetryProviderActions.initialize(args, operation));
-        return operation;
-    }
-    /**
-     * Drains owned work, closes delivery and shuts down exporters once; repeated calls join.
-     * @returns Resolves after every exporter has shut down.
-     * @throws {AggregateError} When any exporter fails to shut down; all are still attempted.
-     */
-    dispose() {
-        const { disposal } = this.value;
-        // Direct disposal and module disposal must join the same pending shutdown.
-        if (disposal) {
-            return disposal;
-        }
-        const operation = this.#settled(telemetryProviderActions.dispose.success.match, telemetryProviderActions.dispose.failure.match);
-        // Dispatch before any exporter callback runs, so reentrant disposal joins this operation.
-        this.#subject.next(telemetryProviderActions.dispose(operation));
-        return operation;
-    }
-    /**
-     * Records a pipeline health failure; the first occurrence of each is reported.
-     * @param error - Controlled failure description; never a raw business error.
-     */
-    fail(error) {
-        this.#subject.next(telemetryProviderActions.failed(error));
-    }
-    /**
-     * Tracks a validated record: applies scope, protects built-in envelopes, enriches metadata
-     * within bounds and emits it to adapters, the parent and the event bus.
-     *
-     * @param item - Validated telemetry record.
-     * @param handledByChild - Whether an explicit child exporter already handled the record.
-     */
-    track(item, handledByChild = false) {
-        const { status, enrichment } = this.value;
-        // Stop accepting records before flushing, while allowing already-owned enrichment to settle.
-        if (status === 'disposing' || status === 'disposed') {
-            return;
-        }
-        const mergedItem = mergeTelemetryItem(item, {
-            scope: item.diagnostic ? undefined : this.#config.defaultScope,
-        });
-        // Snapshot before invoking consumer metadata; neither enrichment nor adapters may rewrite origin.
-        const diagnostic = mergedItem.diagnostic
-            ? Object.freeze({ ...mergedItem.diagnostic })
-            : undefined;
-        const operational = diagnostic
-            ? {
-                ...mergedItem,
-                diagnostic,
-                metadata: undefined,
-                scope: [...mergedItem.scope],
-                properties: mergedItem.properties ? { ...mergedItem.properties } : undefined,
-            }
-            : undefined;
-        // Immutable built-in envelopes keep one adapter from contaminating sibling or parent delivery.
-        if (operational) {
-            Object.freeze(operational.scope);
-            Object.freeze(operational.properties);
-            Object.freeze(operational);
-        }
-        const emit = (nextItem) => {
-            // Late custom metadata emissions cannot revive a completed provider.
-            if (this.value.status !== 'disposed') {
-                // Dynamic metadata is consumer-controlled; built-in records export only their safe envelope.
-                this.#records.next({ item: operational ?? nextItem, handledByChild });
-            }
-        };
-        const { metadata } = this.#config;
-        // Skip metadata application for TelemetryMetadataError items to prevent infinite recursion
-        if (!metadata || mergedItem.name === TelemetryItemNames.MetadataError) {
-            // Providers without metadata still need the same fallback precedence.
-            emit(mergedItem);
-            return;
-        }
-        // Bounded built-in enrichment degrades to the safe original instead of dropping the outcome.
-        if (diagnostic && enrichment.pending >= METADATA_CAPACITY) {
-            this.fail(new Error('Built-in telemetry metadata capacity exceeded'));
-            emit(mergedItem);
-            return;
-        }
-        const builtIn = diagnostic !== undefined;
-        this.#subject.next(telemetryProviderActions.enrichmentStarted(builtIn));
-        const metadata$ = defer(() => applyMetadata(metadata, { modules: this.#modules, item: mergedItem }));
-        // Enrichment is a bounded, cancellable stage whose in-flight work is provider state.
-        metadata$
-            .pipe(
-        // Custom records retain their legacy timing; built-in outcomes have a finite enrichment deadline.
-        builtIn ? timeout({ first: BUILT_IN_METADATA_TIMEOUT_MS }) : (source$) => source$, 
-        // Failure recovery preserves the terminal outcome even when metadata throws or times out.
-        catchError(() => {
-            this.fail(new Error('Telemetry metadata resolution failed'));
-            return of(mergedItem);
-        }), 
-        // Closing cancels custom enrichment; built-in enrichment has already drained by then.
-        takeUntil(this.when((snapshot) => snapshot.status === 'disposed')), 
-        // Leaving flight is state, so disposal can wait on the drained condition.
-        finalize$1(() => this.#subject.next(telemetryProviderActions.enrichmentSettled(builtIn))))
-            .subscribe({
-            next: (nextItem) => {
-                // Raw enrichment errors are health failures, not exportable built-in exceptions.
-                if (diagnostic && nextItem.name === TelemetryItemNames.MetadataError) {
-                    this.fail(new Error('Telemetry metadata resolution failed'));
-                    return;
-                }
-                emit(nextItem);
-            },
-            error: () => {
-                this.fail(new Error('Telemetry metadata resolution failed'));
-                emit(mergedItem);
-            },
-        });
-    }
-    /**
-     * Settles an operation from its outcome action.
-     * @param succeeded - Matches the operation's success action.
-     * @param failed - Matches the operation's failure action.
-     * @returns Resolves on success; rejects with the failure payload.
-     * @throws The failure action's payload, normally the original operation error.
-     */
-    #settled(succeeded, failed) {
-        // The first outcome of this operation settles every joined caller.
-        const outcome$ = this.#subject.action$.pipe(filter((action) => succeeded(action) || failed(action)));
-        return firstValueFrom(outcome$).then((action) => {
-            // A failure outcome carries the original error as its payload.
-            if (failed(action)) {
-                throw 'payload' in action ? action.payload : action;
-            }
-        });
-    }
-    /**
-     * Initializes exporters, then connects delivery, the parent relay and startup streams.
-     * @param args - Optional parent provider and startup records.
-     */
-    async #connect(args) {
-        const { parent, initialItems } = args ?? {};
-        const exporters = Object.entries(this.#config.adapters);
-        // Exporters initialize concurrently; one failing exporter must not block the others.
-        const results = await Promise.allSettled(
-        // Start every exporter's initialization; async wrapping turns synchronous throws into rejections.
-        exporters.map(async ([, adapter]) => adapter.initialize()));
-        // Report each exporter that failed to initialize, without its raw error.
-        for (const [index, result] of results.entries()) {
-            // Fulfilled exporters need no action.
-            if (result.status === 'rejected') {
-                this.fail(new Error(`Failed to initialize telemetry adapter "${exporters[index][0]}"`));
-            }
-        }
-        // Disposal may have closed delivery while an asynchronous exporter initialized.
-        if (this.value.status === 'disposed') {
-            return;
-        }
-        this.#connections.add(this.#records.subscribe((record) => this.#deliver(record)));
-        // Only a configured parent receives relayed records.
-        if (parent) {
-            this.#connections.add(this.#records.subscribe((record) => this.#relay(parent, record)));
-        }
-        this.#connections.add(this.#records.subscribe(({ item }) => this.#dispatchEvent(item)));
-        // Keep subscriptions independent so a failed custom stream cannot terminate host lifecycle capture.
-        // A disabled capture stays attached but unconsumed, so the host can still recover it on failure.
-        if (this.#config.lifecycleItems$ && this.#config.lifecycleItemsEnabled !== false) {
-            // The provider is the authority on host identity once it exists.
-            this.#connections.add(this.#track(from(this.#config.lifecycleItems$).pipe(map((item) => this.#stamp(item)))));
-        }
-        // Startup records passed at initialization are tracked as given.
-        if (initialItems) {
-            this.#connections.add(this.#track(initialItems));
-        }
-    }
-    /**
-     * Stamps this provider's host identity on a built-in lifecycle record, so records captured
-     * before the provider existed share its source and host ID.
-     * @param item - Captured lifecycle record.
-     * @returns The record carrying this provider's identity and scope.
-     */
-    #stamp(item) {
-        const source = this.#context.owner.source;
-        // Custom records and providers without identity are left as captured.
-        if (!item.diagnostic || !source) {
-            return item;
-        }
-        const { source: kind, hostId, hostName, hostVersion } = source;
-        return {
-            ...item,
-            scope: operationalScope(source),
-            diagnostic: { ...item.diagnostic, source: kind, hostId, hostName, hostVersion },
-        };
-    }
-    /**
-     * Tracks a startup stream through the public provider so each record is validated.
-     * @param items - Startup records.
-     * @returns The owned subscription.
-     */
-    #track(items) {
-        return from(items).subscribe({
-            next: (item) => this.#context.owner.track(item),
-            error: () => this.fail(new Error('Initial telemetry stream failed')),
-        });
-    }
-    /**
-     * Delivers one record to every eligible exporter within per-exporter capacity.
-     * @param record - Record and its fallback ownership.
-     */
-    #deliver({ item, handledByChild }) {
-        const { adapter: adapterFilter } = this.#config.filter ?? {};
-        try {
-            // A host-level adapter filter intentionally rejects delivery without enabling fallback.
-            if (adapterFilter && !adapterFilter(item)) {
-                return;
-            }
-        }
-        catch {
-            this.fail(new Error('Telemetry adapter filter failed'));
-            return;
-        }
-        // Every exporter is attempted independently.
-        for (const [identifier, adapter] of Object.entries(this.#config.adapters)) {
-            // Explicit child exporters take precedence over inherited development exporters.
-            if (adapter.fallback && handledByChild) {
-                // Keep application-owned records out of parent fallback exporters.
-                continue;
-            }
-            // A slow exporter cannot consume a healthy sibling exporter's processing capacity.
-            if ((this.value.processing[identifier] ?? 0) >= ADAPTER_PROCESSING_CAPACITY) {
-                this.fail(new Error('Telemetry adapter processing capacity exceeded'));
-                // Keep attempting sibling adapters even when this destination is saturated.
-                continue;
-            }
-            try {
-                const result = adapter.processItem(item);
-                // Only asynchronous processing needs shutdown ownership and bounded pending capacity.
-                if (result) {
-                    this.#subject.next(telemetryProviderActions.processingStarted(identifier));
-                    Promise.resolve(result)
-                        .catch(() => this.fail(new Error(`Failed to process telemetry item with adapter "${identifier}"`)))
-                        .finally(() => this.#subject.next(telemetryProviderActions.processingSettled(identifier)));
-                }
-            }
-            catch {
-                this.fail(new Error(`Failed to process telemetry item with adapter "${identifier}"`));
-            }
-        }
-    }
-    /**
-     * Relays one record to the parent, carrying exporter ownership.
-     * @param target - Parent provider.
-     * @param record - Record and its fallback ownership.
-     */
-    #relay(target, { item, handledByChild }) {
-        const policy = {
-            // Carry exporter ownership across intermediate providers without changing record metadata.
-            ownsExport: handledByChild || this.#config.ownsExport,
-            relay: this.#config.filter?.relay,
-        };
-        try {
-            // Legacy parents predate ownership; live relay keeps sending them every record.
-            if (!relayRecord(target, item, policy)) {
-                target.track(item);
-            }
-        }
-        catch {
-            this.fail(new Error('Telemetry parent relay failed'));
-        }
-    }
-    /**
-     * Dispatches one record as an event when an event bus is configured.
-     * @param item - Delivered record.
-     */
-    #dispatchEvent(item) {
-        const { event, owner } = this.#context;
-        // Only dispatch when an event provider is configured
-        if (!event) {
-            return;
-        }
-        try {
-            Promise.resolve(event.dispatchEvent(new TelemetryEvent(item, owner))).catch(() => this.fail(new Error('Telemetry event dispatch failed')));
-        }
-        catch {
-            this.fail(new Error('Telemetry event dispatch failed'));
-        }
-    }
-    /** Releases delivery subscriptions and completes the record stream. */
-    #close() {
-        this.#connections.unsubscribe();
-        this.#records.complete();
-    }
-    /**
-     * Shuts down every exporter, even when one rejects or throws synchronously.
-     * @throws {AggregateError} When any exporter fails to shut down.
-     */
-    async #shutdown() {
-        // Attempt every exporter; one failure must not skip the others.
-        const shutdowns = Object.entries(this.#config.adapters).map(async ([identifier, adapter]) => {
-            try {
-                await adapter.shutdown?.();
-            }
-            catch (cause) {
-                throw new Error(`Failed to shut down telemetry adapter "${identifier}"`, { cause });
-            }
-        });
-        const results = await Promise.allSettled(shutdowns);
-        // Keep only failures for the module lifecycle's structured disposal error event.
-        const errors = results.flatMap((result) => 
-        // Successful shutdowns must not obscure another exporter's failure.
-        result.status === 'rejected' ? [result.reason] : []);
-        // Reject only after every exporter had a chance to release its resources.
-        if (errors.length) {
-            throw new AggregateError(errors, 'Failed to shut down telemetry adapters');
-        }
-    }
-    /**
-     * Reports a newly observed failure through the out-of-band health channel.
-     * @param error - First occurrence of the failure.
-     * @param status - Provider status when the failure was recorded.
-     */
-    #report(error, status) {
-        const { event, owner } = this.#context;
-        // The event bus is an out-of-band health sink, never an automatic telemetry exporter.
-        if (event && status !== 'disposed') {
-            try {
-                Promise.resolve(event.dispatchEvent(new TelemetryErrorEvent(error, owner))).catch(() => console.warn('Telemetry health event delivery failed'));
-            }
-            catch {
-                // A failed health channel must remain visible without recursively dispatching another event.
-                console.warn('Telemetry health event delivery failed');
-            }
-        }
-        else {
-            console.warn(error.message);
-        }
-    }
-}
+            type: TelemetryType.Exception,
+            name: TelemetryItemNames.MetadataError,
+            exception: error,
+            properties: {
+                sourceMetricName: args.item.name,
+                sourceMetricType: args.item.type,
+            },
+        });
+        return merge(of(errorItem), of(args.item));
+    }));
+};
 
 /**
- * The telemetry provider applications and modules use to track events, exceptions, metrics
- * and custom telemetry.
+ * Provides telemetry tracking, event dispatching, and adapter integration for application instrumentation.
+ *
+ * The `TelemetryProvider` class is responsible for collecting, processing, and relaying telemetry data such as events,
+ * exceptions, metrics, and custom events. It supports adapter-based processing, event provider integration, and
+ * hierarchical telemetry relaying to parent providers. Telemetry items are validated and dispatched to registered
+ * adapters and event providers, with robust error handling and metadata merging.
  *
- * `TelemetryProvider` is a thin, consumer-facing facade: it validates input against the item
- * schemas and delegates everything else (scope, enrichment, exporter delivery, parent relay,
- * lifecycle and health) to its {@link TelemetryProviderState} engine.
+ * @remarks
+ * - Integrates with adapters for extensible telemetry processing.
+ * - Supports event provider for dispatching telemetry as events.
+ * - Allows relaying telemetry data to a parent provider, merging metadata as needed.
+ * - Provides utility methods for tracking and measuring telemetry items.
+ * - Handles error reporting via telemetry error events.
  *
  * @example
  * ```typescript
  * const provider = new TelemetryProvider(config, { event: eventProvider });
- * await provider.initialize({ parent });
- * provider.trackEvent({ name: 'user_login', metadata: { userId: '123' } });
+ * provider.track({ type: TelemetryType.Event, name: 'user_login', metadata: { userId: '123' } });
  * const end = provider.measure({ name: 'load_time' });
  * // ... do work ...
  * end();
- * await provider.dispose();
  * ```
+ *
+ * @typeParam TelemetryConfig - The configuration type for telemetry.
+ * @implements ITelemetryProvider
+ * @extends BaseModuleProvider<TelemetryConfig>
  */
 class TelemetryProvider extends BaseModuleProvider {
-    /** Immutable composition-root origin used by optional infrastructure reporters. */
-    source;
-    #state;
+    #items = new Subject();
+    #initialized = false;
+    #disposal;
+    #adapters = {};
+    #handledByChild = new WeakSet();
+    #filters;
+    #defaultScope;
+    #eventProvider;
     /**
      * Stream of every telemetry item tracked by this provider.
      *
      * @returns An observable emitting each tracked `TelemetryItem`.
      */
     get items() {
-        return this.#state.items;
+        return this.#items.asObservable();
     }
     /**
-     * Returns true once initialization has started.
+     * Returns true if the provider has been initialized.
      *
-     * @returns `true` once {@link initialize} has been called, otherwise `false`.
+     * @returns `true` when {@link initialize} has completed, otherwise `false`.
      */
     get initialized() {
-        return this.#state.value.status !== 'idle';
+        return this.#initialized;
     }
+    #metadata;
+    #modules;
     /**
      * Sets the resolved framework module instances used to resolve metadata.
      *
      * @param value - The resolved framework module instances.
      */
     set modules(value) {
-        this.#state.modules = value;
+        this.#modules = value;
     }
     /**
      * Creates a new `TelemetryProvider`.
@@ -6636,27 +5868,51 @@ class TelemetryProvider extends BaseModuleProvider {
      */
     constructor(config, deps) {
         super({ version: version$2, config });
-        this.source = Object.freeze(config?.source ?? { hostId: crypto.randomUUID() });
-        this.#state = new TelemetryProviderState({ config, event: deps?.event, owner: this });
+        this.#adapters = config?.adapters ?? {};
+        this.#metadata = config?.metadata;
+        this.#defaultScope = config?.defaultScope ?? [];
+        this.#eventProvider = deps?.event;
+        this.#filters = config?.filter;
     }
     /**
-     * Connects exporters, the parent relay and startup streams. Exporter initialization failures
-     * are reported but do not prevent the provider from becoming usable.
+     * Initializes the telemetry provider with adapters, parent provider, and optional initial items.
      *
-     * Repeated and reentrant calls return the same promise.
+     * This method sets up the provider for operation by:
+     * 1. Storing the provided adapters
+     * 2. Initializing all adapters that support async initialization (failures are logged but don't prevent initialization)
+     * 3. Setting up subscriptions for telemetry processing
+     * 4. Handling initial telemetry items if provided
      *
-     * @param args - Optional parent provider to relay to, and startup records to track.
-     * @returns Resolves when the provider is connected.
-     * @throws {Error} When the provider has already been disposed.
+     * @param args - Initialization arguments
+     * @param args.adapters - Array of telemetry adapters to use
+     * @param args.parent - Optional parent telemetry provider for relaying data
+     * @param args.initialItems - Optional observable of initial telemetry items to process
+     * @returns A promise that resolves when initialization is complete
      */
-    initialize(args) {
-        return this.#state.initialize(args);
-    }
-    /** {@inheritDoc ITelemetryProvider.scope} */
-    scope(module, options) {
-        const scope = createOperationalTelemetry(module, options);
-        scope.connect(this);
-        return scope;
+    async initialize(args) {
+        const { parent, initialItems } = args ?? {};
+        // Mark as initialized early to allow adapter connections
+        this.#initialized = true;
+        // Initialize all adapters that support async initialization
+        await this._initializeAdapters();
+        // Connect adapters to the telemetry items, processing each item as it is emitted
+        this._addTeardown(this._connectAdapters());
+        // If a parent telemetry provider is provided, relay telemetry data to it
+        if (parent) {
+            this._addTeardown(this._relayTelemetryData(parent));
+        }
+        // Emit telemetry items as events if an event provider is available
+        this._addTeardown(this.#items.subscribe(this._dispatchEntityEvent.bind(this)));
+        // Handle initial telemetry items if provided
+        if (initialItems) {
+            this._addTeardown(from(initialItems).subscribe((item) => {
+                this.track(item);
+            }));
+        }
+        // Ensure the subject is completed when the provider is destroyed
+        this._addTeardown(() => {
+            this.#items.complete();
+        });
     }
     /**
      * Stops telemetry subscriptions and waits for every adapter to flush and shut down.
@@ -6672,7 +5928,158 @@ class TelemetryProvider extends BaseModuleProvider {
      * ```
      */
     dispose() {
-        return this.#state.dispose();
+        // Direct disposal and module disposal must join the same pending shutdown.
+        if (this.#disposal) {
+            return this.#disposal;
+        }
+        super.dispose();
+        // Defer adapter callbacks until the shared promise is assigned, including reentrant disposal.
+        this.#disposal = Promise.resolve().then(async () => {
+            // Shut down all exporters even when one rejects or throws synchronously.
+            const results = await Promise.allSettled(Object.entries(this.#adapters).map(async ([identifier, adapter]) => {
+                try {
+                    await adapter.shutdown?.();
+                }
+                catch (cause) {
+                    throw new Error(`Failed to shut down telemetry adapter "${identifier}"`, { cause });
+                }
+            }));
+            const errors = [];
+            // Retain each failure for the module lifecycle's structured disposal error event.
+            for (const result of results) {
+                // Successful shutdowns must not obscure another exporter's failure.
+                if (result.status === 'rejected') {
+                    errors.push(result.reason);
+                }
+            }
+            // Reject only after all exporters have had a chance to release their resources.
+            if (errors.length) {
+                throw new AggregateError(errors, 'Failed to shut down telemetry adapters');
+            }
+        });
+        return this.#disposal;
+    }
+    /**
+     * Initializes all telemetry adapters that support async initialization.
+     * Uses Promise.allSettled to ensure all adapters attempt initialization,
+     * with individual error reporting for any failures.
+     * Subclasses can override this method to customize adapter initialization behavior.
+     *
+     * @protected
+     */
+    async _initializeAdapters() {
+        // Initialize all adapters, do it in parallel
+        const adapterEntries = Object.entries(this.#adapters);
+        // Kick off every adapter's initialize() concurrently
+        const initializationPromises = adapterEntries.map(([_identifier, adapter]) => adapter.initialize());
+        // Wait for all adapters to settle (either resolve or reject)
+        const results = await Promise.allSettled(initializationPromises);
+        // Check each result and dispatch errors for failed initializations
+        for (const [index, result] of results.entries()) {
+            // Only rejected adapters need an error dispatched; fulfilled ones need no action
+            if (result.status === 'rejected') {
+                const [identifier] = adapterEntries[index];
+                this._dispatchError(new Error(`Failed to initialize telemetry adapter "${identifier}"`, {
+                    cause: result.reason,
+                }));
+            }
+        }
+    }
+    /**
+     * Subscribes all adapters to the telemetry item stream.
+     * Each adapter processes every telemetry item as it is emitted.
+     * If an adapter filter is configured, only items that pass the filter will be sent to adapters.
+     * If an adapter throws, the error is dispatched as a telemetry error event.
+     *
+     * @returns Subscription to the telemetry item stream
+     * @protected
+     * @throws {Error} When the provider has not been initialized yet.
+     */
+    _connectAdapters() {
+        // Adapters can only be connected after the provider has completed initialization
+        if (!this.#initialized) {
+            throw new Error('TelemetryProvider is not initialized');
+        }
+        return this.#items.subscribe((item) => {
+            const { adapter: adapterFilter } = this.#filters ?? {};
+            // Apply adapter filter if configured - skip item if filter returns false
+            if (adapterFilter && !adapterFilter(item)) {
+                return;
+            }
+            // Iterate through all registered adapters
+            for (const [identifier, adapter] of Object.entries(this.#adapters)) {
+                // Explicit child exporters take precedence over inherited development exporters.
+                if (adapter.fallback && this.#handledByChild.has(item)) {
+                    // Keep application-owned records out of parent fallback exporters.
+                    continue;
+                }
+                try {
+                    // Let the adapter process the telemetry item
+                    Promise.resolve(adapter.processItem(item));
+                }
+                catch (error) {
+                    // If processing fails, dispatch an error event
+                    this._dispatchError(new Error(`Failed to process telemetry item with adapter "${identifier}"`, {
+                        cause: error,
+                    }));
+                }
+            }
+        });
+    }
+    /**
+     * Relays telemetry data items to a target telemetry provider.
+     *
+     * Subscribes to the internal telemetry item stream and forwards each processed item
+     * to the specified target provider by invoking its `track` method.
+     * If a relay filter is configured, only items that pass the filter will be relayed.
+     *
+     * @param target - The telemetry provider to which telemetry data should be relayed.
+     * @returns A Subscription object that can be used to unsubscribe from the relay.
+     */
+    _relayTelemetryData(target) {
+        // Subscribe to the processed stream and forward each item to the parent provider
+        return this.#items.subscribe((item) => {
+            const { relay: relayFilter } = this.#filters ?? {};
+            // Apply relay filter if configured - skip item if filter returns false
+            if (relayFilter && !relayFilter(item)) {
+                return;
+            }
+            // Older/custom providers retain the original track-only relay contract.
+            if (target.trackRelayed) {
+                // Carry exporter ownership across intermediate providers without changing record metadata.
+                const hasAdapters = this.#handledByChild.has(item) ||
+                    Object.values(this.#adapters).some((adapter) => !adapter.fallback);
+                target.trackRelayed(item, hasAdapters);
+            }
+            else {
+                target.track(item);
+            }
+        });
+    }
+    /**
+     * Dispatches a telemetry event to the event provider, if available.
+     *
+     * @param item - The telemetry item to dispatch as an event
+     * @protected
+     */
+    _dispatchEntityEvent(item) {
+        // Only dispatch when an event provider is configured
+        if (this.#eventProvider) {
+            // Wrap the telemetry item in a TelemetryEvent and dispatch it
+            this.#eventProvider.dispatchEvent(new TelemetryEvent(item, this));
+        }
+    }
+    /**
+     * Dispatches a telemetry error event using the internal event provider, if available.
+     *
+     * @param error - The error instance to be dispatched with the telemetry error event.
+     * @protected
+     */
+    _dispatchError(error) {
+        // Only dispatch when an event provider is configured
+        if (this.#eventProvider) {
+            this.#eventProvider.dispatchEvent(new TelemetryErrorEvent(error, this));
+        }
     }
     /**
      * Tracks a telemetry item by type, merging the default scope with the provided scope.
@@ -6710,7 +6117,44 @@ class TelemetryProvider extends BaseModuleProvider {
      * @param hasAdapters - Whether an explicit child adapter has already handled this record.
      */
     trackRelayed(item, hasAdapters) {
-        this.#state.track(item, hasAdapters);
+        this._track(item, hasAdapters);
+    }
+    /**
+     * Tracks a telemetry item by merging the default scope with the item's scope (if provided),
+     * ensuring that all telemetry items have the correct scope context. The merged item is then
+     * emitted to downstream handlers.
+     *
+     * @param item - The telemetry item to be tracked, conforming to the input schema of `TelemetryItemSchema`.
+     * @param handledByChild - Whether fallback adapters should skip this relayed item.
+     *
+     * @protected
+     */
+    async _track(item, handledByChild = false) {
+        const mergedItem = mergeTelemetryItem(item, {
+            scope: this.#defaultScope,
+        });
+        // Skip metadata application for TelemetryMetadataError items to prevent infinite recursion
+        if (this.#metadata && mergedItem.name !== TelemetryItemNames.MetadataError) {
+            applyMetadata(this.#metadata, {
+                modules: this.#modules,
+                item: mergedItem,
+            }).subscribe((nextItem) => {
+                // Async metadata resolution creates new objects; retain ownership on the emitted record.
+                if (handledByChild) {
+                    this.#handledByChild.add(nextItem);
+                }
+                // Emit the item after applying metadata
+                this.#items.next(nextItem);
+            });
+        }
+        else {
+            // Providers without metadata still need the same fallback precedence.
+            if (handledByChild) {
+                this.#handledByChild.add(mergedItem);
+            }
+            // If no metadata extractor is provided or item is TelemetryMetadataError, emit directly
+            this.#items.next(mergedItem);
+        }
     }
     /**
      * Starts a metric measurement and returns a function to end the measurement.
@@ -6736,7 +6180,7 @@ class TelemetryProvider extends BaseModuleProvider {
      * provider.trackEvent({ name: 'button_click', metadata: { button: 'save' } });
      */
     trackEvent(data) {
-        this.#state.track(TelemetryEventSchema.parse({ ...data, type: TelemetryType.Event }));
+        this._track(TelemetryEventSchema.parse({ ...data, type: TelemetryType.Event }));
     }
     /**
      * Tracks a telemetry exception.
@@ -6750,7 +6194,7 @@ class TelemetryProvider extends BaseModuleProvider {
      * });
      */
     trackException(data) {
-        this.#state.track(TelemetryExceptionSchema.parse({ ...data, type: TelemetryType.Exception }));
+        this._track(TelemetryExceptionSchema.parse({ ...data, type: TelemetryType.Exception }));
     }
     /**
      * Tracks a telemetry metric.
@@ -6760,7 +6204,7 @@ class TelemetryProvider extends BaseModuleProvider {
      * provider.trackMetric({ name: 'response_time', value: 123 });
      */
     trackMetric(data) {
-        this.#state.track(TelemetryMetricSchema.parse({ ...data, type: TelemetryType.Metric }));
+        this._track(TelemetryMetricSchema.parse({ ...data, type: TelemetryType.Metric }));
     }
     /**
      * Tracks a custom telemetry event.
@@ -6770,7 +6214,7 @@ class TelemetryProvider extends BaseModuleProvider {
      * provider.trackCustom({ name: 'custom_event', metadata: { foo: 'bar' } });
      */
     trackCustom(data) {
-        this.#state.track(TelemetryCustomEventSchema.parse({ ...data, type: TelemetryType.Custom }));
+        this._track(TelemetryCustomEventSchema.parse({ ...data, type: TelemetryType.Custom }));
     }
     /**
      * Retrieves a telemetry adapter by its identifier.
@@ -6780,7 +6224,7 @@ class TelemetryProvider extends BaseModuleProvider {
      * @returns The telemetry adapter corresponding to the given identifier, or `undefined` if not found.
      */
     getAdapter(identifier) {
-        const adapter = this.#state.adapters[identifier];
+        const adapter = this.#adapters[identifier];
         // Report a missing adapter as a telemetry exception rather than throwing
         if (!adapter) {
             this.trackException({
@@ -6799,17 +6243,10 @@ class TelemetryProvider extends BaseModuleProvider {
      * @returns True if the adapter exists, false otherwise.
      */
     hasAdapter(identifier) {
-        return identifier in this.#state.adapters;
+        return identifier in this.#adapters;
     }
 }
 
-/**
- * Creates a reference-independent builder for either preparation or normal configuration.
- * @returns A fresh telemetry configuration builder.
- */
-function createTelemetryConfigurator() {
-    return new TelemetryConfigurator();
-}
 /**
  * Telemetry module definition for the Fusion Framework.
  *
@@ -6827,9 +6264,7 @@ function createTelemetryConfigurator() {
  */
 const module$2 = {
     name: 'telemetry',
-    disposePhase: 'diagnostics',
-    prepare: createTelemetryConfigurator,
-    configure: createTelemetryConfigurator,
+    configure: () => new TelemetryConfigurator(),
     initialize: async (args) => {
         const config = await args.config.createConfigAsync(args);
         const event = args.hasModule('event') ? await args.requireInstance('event') : undefined;
@@ -6852,399 +6287,69 @@ const module$2 = {
 };
 
 /**
- * Allowlist of terminal lifecycle events. Every other event, including dependency waits and
- * configuration chatter, is dropped rather than projected.
- */
-const terminalBoundaries = new Map([
-    [
-        ModuleConfiguratorEventName.ModuleInitialized,
-        { operation: 'initialize', perModule: true, failure: false },
-    ],
-    [
-        ModuleConfiguratorEventName.ModuleInitializeError,
-        { operation: 'initialize', perModule: true, failure: true },
-    ],
-    [
-        ModuleConfiguratorEventName.ModuleDisposed,
-        { operation: 'dispose', perModule: true, failure: false },
-    ],
-    [
-        ModuleConfiguratorEventName.ModuleDisposeError,
-        { operation: 'dispose', perModule: true, failure: true },
-    ],
-    [
-        ModuleConfiguratorEventName.HostInitialized,
-        { operation: 'initialize', perModule: false, failure: false },
-    ],
-    [
-        ModuleConfiguratorEventName.HostInitializeError,
-        { operation: 'initialize', perModule: false, failure: true },
-    ],
-    [
-        ModuleConfiguratorEventName.ModulesDisposed,
-        { operation: 'dispose', perModule: false, failure: false },
-    ],
-]);
-/**
- * Projects only terminal lifecycle events into allowlisted operational records.
- * Raw messages, arbitrary properties, errors, and dependency-wait chatter are never forwarded.
- * @param configurator - Lifecycle stream to observe, preferably before user configuration runs.
- * @param source - Host identity, or a lookup into the owning configuration before each record is captured.
- * @returns Terminal duration metrics and controlled failure exceptions.
- */
-const mapConfiguratorEvents = (configurator, source = { hostId: crypto.randomUUID() }) => {
-    // Project before buffering so raw lifecycle payloads never enter the diagnostic queue.
-    return configurator.event$.pipe(mergeMap((event) => {
-        // Hosts prefix event names with their class name; the boundary is the unprefixed name.
-        const boundary = terminalBoundaries.get(event.name.split('::').at(-1) ?? '');
-        // Only measured terminal boundaries belong to foundational operational telemetry.
-        if (!boundary) {
-            return [];
-        }
-        // Zero is a valid measurement; missing or invalid timings cannot form a duration record.
-        if (event.metric === undefined || !Number.isFinite(event.metric) || event.metric < 0) {
-            return [];
-        }
-        let module = 'host';
-        // Module boundaries are attributed to a static, kebab-case module label.
-        if (boundary.perModule) {
-            const moduleName = event.properties?.moduleName;
-            // Aggregate legacy errors cannot be attributed to an individual module.
-            if (typeof moduleName !== 'string') {
-                return [];
-            }
-            module = moduleName.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
-            // Reject dynamic labels rather than admitting paths or payloads into record names.
-            if (!operationalIdentifier.safeParse(module).success) {
-                console.warn('Unsupported module identifier in lifecycle telemetry');
-                return [];
-            }
-        }
-        return createOperationalRecords({
-            source: typeof source === 'function' ? source() : source,
-            module,
-            operation: boundary.operation,
-            // Error boundaries fail by kind; host disposal isolates module failures and reports `failed`.
-            outcome: boundary.failure || event.properties?.failed ? 'failure' : 'success',
-            duration: event.metric,
-        });
-    }));
-};
-
-/**
- * Startup records retained before a provider exists. One further slot is reserved for the
- * overflow summary, so a startup burst never retains more than 256 records.
- */
-const STARTUP_RECORD_CAPACITY = 255;
-/**
- * Failure evidence: an error-level record, or a measurement whose outcome failed even though
- * the measurement itself is reported at a lower level.
- * @param record - Buffered startup record.
- * @returns Whether the record documents a failure.
- */
-const isFailure = (record) => record.level >= TelemetryLevel.Error || record.diagnostic?.outcome === 'failure';
-/**
- * Bounded buffer for records captured before a telemetry provider exists.
+ * Transforms events emitted by a given modules configurator into standardized telemetry items.
  *
- * At capacity, a failure record replaces the oldest record that is not failure evidence, so
- * failures survive a startup burst; everything else is dropped and counted for an overflow
- * summary.
+ * @param configurator - The modules configurator instance emitting events to be mapped.
+ * @returns An observable stream of `TelemetryItem` objects, each representing a mapped event.
  *
- * @example
- * ```ts
- * const buffer = new StartupBuffer();
- * buffer.push(record);
- * const { items, dropped } = buffer.drain();
- * ```
- */
-class StartupBuffer {
-    capacity;
-    #items = [];
-    #dropped = 0;
-    /**
-     * Creates an empty buffer.
-     * @param capacity - Records retained before records are dropped.
-     */
-    constructor(capacity = STARTUP_RECORD_CAPACITY) {
-        this.capacity = capacity;
-    }
-    /**
-     * Retains a record, preferring failure records once the buffer is full.
-     * @param item - Sanitized startup record.
-     */
-    push(item) {
-        // Retain records until capacity.
-        if (this.#items.length < this.capacity) {
-            this.#items.push(item);
-            return;
-        }
-        // Prefer failure evidence over successful startup measurements when capacity is exhausted.
-        const replace = this.#items.findIndex((record) => !isFailure(record));
-        // Replacing only non-failure entries prevents later successes from evicting failures.
-        if (isFailure(item) && replace >= 0) {
-            this.#items.splice(replace, 1, item);
-        }
-        this.#dropped++;
-    }
-    /**
-     * Takes every retained record and the dropped count, leaving the buffer empty.
-     * @returns Retained records, oldest first, and how many were dropped.
-     */
-    drain() {
-        const drained = { items: this.#items, dropped: this.#dropped };
-        this.#items = [];
-        this.#dropped = 0;
-        return drained;
-    }
-}
-
-/**
- * Captures safe host lifecycle outcomes from before any telemetry provider exists.
- *
- * Telemetry is itself a module, so it cannot observe the startup it is part of. A host creates
- * a capture as soon as it is configured, before any user code runs, and attaches its
- * {@link items} to the telemetry configurator with `attachLifecycleItems`. The capture:
- * - buffers sanitized terminal records (bounded, failures preferred) until the provider
- *   consumes {@link items}, then forwards live;
- * - when startup fails before any provider exists, hands the buffer to the host's parent,
- *   creating the host failure record when the host never emitted one (for example, a failing
- *   host configuration callback). The child's exporters and relay filter are not known yet,
- *   so recovery relays without ownership; nothing is dropped.
+ * The function listens to the `event$` observable of the configurator and maps each event to a `TelemetryItem`.
+ * - If the event contains an `error`, the item is marked as an exception.
+ * - If the event contains a `metric`, the item is marked as a metric with its value.
+ * - Otherwise, the item is treated as a standard event.
  *
- * @example
- * ```ts
- * const source = { source: 'portal', hostId: crypto.randomUUID() };
- * const capture = new StartupCapture(configurator, { source, parent });
- * configurator.addConfig({
- *   module: telemetryModule,
- *   prepare: (builder) => builder.setSource(source).setParent(parent).attachLifecycleItems(capture.items),
- * });
- * try {
- *   await configureHost(configurator);
- * } catch (error) {
- *   capture.fail();
- *   throw error;
- * }
- * ```
+ * The resulting telemetry items include event name, type, level, message, properties, and a fixed scope of `['configuration']`.
  */
-class StartupCapture {
-    /** Startup records followed by live outcomes, for the provider that consumes the capture. */
-    items;
-    #options;
-    #buffer = new StartupBuffer();
-    #live = new Subject();
-    /** Buffering until a provider consumes, then live; closed once nothing more is captured. */
-    #status = 'capturing';
-    /** The host reported its own initialize outcome, so a failure must not create another. */
-    #hostReported = false;
-    #subscription;
-    #startedAt = performance.now();
-    /**
-     * Starts capture immediately, not when the telemetry configuration eventually resolves.
-     * @param host - Host lifecycle stream.
-     * @param options - Host identity and the parent receiving records if startup fails.
-     */
-    constructor(host, options = {}) {
-        this.#options = { ...options, source: options.source ?? { hostId: crypto.randomUUID() } };
-        this.items = new Observable((subscriber) => {
-            const closed = this.#status === 'closed';
-            // Join live delivery first, so nothing captured while the buffer drains is lost. A closed
-            // capture's live subject is complete and would end the subscriber before the drain.
-            const live = closed ? undefined : this.#live.subscribe(subscriber);
-            // A capture that already closed stays closed; an active one now forwards live.
-            if (!closed) {
-                this.#status = 'live';
-            }
-            const { items, dropped } = this.#buffer.drain();
-            // Release the bounded startup buffer exactly once, to the provider that consumes it.
-            for (const item of items) {
-                subscriber.next(item);
-            }
-            // Overflow is reported once, alongside the records that survived it.
-            if (dropped) {
-                subscriber.next(this.#overflowSummary(dropped));
-            }
-            // A late consumer of a closed capture receives the buffer and nothing more.
-            if (closed) {
-                subscriber.complete();
-            }
-            return () => {
-                live?.unsubscribe();
-                this.#close();
-            };
-        });
-        this.#subscription = mapConfiguratorEvents(host, this.#options.source).subscribe({
-            next: (item) => {
-                this.#capture(item);
-                // Recover synchronously: a host rolling back completes its stream right after this record.
-                if (item.name === 'fusion.host.initialize.failure') {
-                    this.fail();
-                }
-            },
-            error: () => {
-                console.warn('Startup telemetry capture failed');
-                this.fail();
-            },
-            complete: () => {
-                // Keep the buffer: a provider created after completion may still drain it.
-                this.#status = 'closed';
-                this.#live.complete();
+const mapConfiguratorEvents = (
+// biome-ignore lint/suspicious/noExplicitAny: must be any to support all module types
+configurator) => {
+    // Map each configurator event into a standardized telemetry item shape
+    return configurator.event$.pipe(map((event) => {
+        const item = {
+            name: event.name,
+            type: TelemetryType.Event,
+            level: Number(event.level),
+            properties: {
+                message: event.message,
+                ...event.properties,
             },
-        });
-        // Synchronous replay can close capture before the subscription is assigned.
-        if (this.#status === 'closed') {
-            this.#subscription.unsubscribe();
-        }
-    }
-    /** Reports buffered startup outcomes once if no provider ever consumed the capture. */
-    fail() {
-        // Host failure callbacks and stream failures may converge on this same capture.
-        if (this.#status === 'closed') {
-            return;
-        }
-        // Configuration callback errors occur before the module host can emit its own boundary.
-        if (!this.#hostReported) {
-            // Keep the failure duration and sanitized exception together.
-            for (const record of createOperationalRecords({
-                source: this.#options.source,
-                module: 'host',
-                operation: 'initialize',
-                outcome: 'failure',
-                duration: performance.now() - this.#startedAt,
-            })) {
-                this.#capture(record);
-            }
-        }
-        // An attached provider keeps its records through partial cleanup and sink flush.
-        if (this.#status === 'live') {
-            return;
-        }
-        const { items, dropped } = this.#buffer.drain();
-        this.#close();
-        this.#recover(items, dropped);
-    }
-    /** Stops capture when configuration explicitly opts out before initialization. */
-    stop() {
-        this.#buffer.drain();
-        this.#close();
-    }
-    /**
-     * Records one sanitized record: buffered until a provider consumes, then forwarded live.
-     * @param item - Sanitized lifecycle record.
-     */
-    #capture(item) {
-        // Avoid manufacturing a second host outcome once the host reported its own.
-        if (item.diagnostic?.module === 'host' && item.diagnostic.operation === 'initialize') {
-            this.#hostReported = true;
-        }
-        // Live delivery avoids retaining records after the provider is ready.
-        if (this.#status === 'live') {
-            this.#live.next(item);
-        }
-        else if (this.#status === 'capturing') {
-            this.#buffer.push(item);
-        }
-    }
-    /** Ends capture: releases the host subscription and completes live delivery. */
-    #close() {
-        this.#status = 'closed';
-        this.#subscription?.unsubscribe();
-        this.#live.complete();
-    }
-    /**
-     * Hands buffered startup records to the parent after startup failed before a provider existed.
-     * @param items - Records retained before recovery.
-     * @param dropped - Records discarded at capacity.
-     */
-    #recover(items, dropped) {
-        const { parent } = this.#options;
-        let fallbackFailureReported = false;
-        // Route only the already sanitized, bounded buffer.
-        for (const item of items) {
-            // Delivered or intentionally filtered records need no local fallback.
-            if (this.#relayToParent(item)) {
-                // Move on to the next buffered record.
-                continue;
-            }
-            // A parent that cannot honour ownership is reported once, not once per record.
-            if (parent && !fallbackFailureReported) {
-                fallbackFailureReported = true;
-                console.warn('Startup telemetry fallback delivery failed or could not preserve ownership');
-            }
-            else if (!parent && item.name === 'fusion.host.initialize.failure') {
-                console.warn('Host initialization failed before telemetry became available');
-            }
-        }
-        // Make overflow visible without retaining or forwarding dropped payloads.
-        if (dropped) {
-            const summary = this.#overflowSummary(dropped);
-            // Local, sanitized health reporting is the last resort when no parent can take it.
-            if (!this.#relayToParent(summary)) {
-                console.warn('Startup telemetry queue overflow', summary.properties);
-            }
-        }
-    }
-    /**
-     * Delivers one startup record to the host's parent.
-     * @param item - Sanitized startup record.
-     * @returns Whether the record was delivered or intentionally filtered.
-     */
-    #relayToParent(item) {
-        const { parent } = this.#options;
-        // Without a parent there is nowhere to recover to.
-        if (!parent) {
-            return false;
-        }
-        try {
-            // The child's exporters are not configured yet, so it cannot claim ownership.
-            return relayRecord(parent, item, { ownsExport: false });
+            scope: ['configuration'],
+        };
+        // An event carrying an error is reported as a telemetry exception
+        if (event.error) {
+            return {
+                ...item,
+                type: TelemetryType.Exception,
+                exception: event.error,
+            };
         }
-        catch {
-            // Parent delivery failures fall through to local health reporting.
-            return false;
+        // An event carrying a metric value is reported as a telemetry metric
+        if (event.metric) {
+            return {
+                ...item,
+                type: TelemetryType.Metric,
+                value: event.metric,
+            };
         }
-    }
-    /**
-     * Creates the summary standing in for records dropped at startup capacity.
-     * @param dropped - Number of records discarded.
-     * @returns A safe overflow event carrying only the dropped count.
-     */
-    #overflowSummary(dropped) {
-        const { source } = this.#options;
-        return {
-            name: 'fusion.telemetry.startup-overflow',
-            type: TelemetryType.Event,
-            level: TelemetryLevel.Warning,
-            properties: { dropped },
-            // Scope the summary like the records it stands in for.
-            scope: operationalScope(source),
-            diagnostic: createDiagnosticContext({
-                source,
-                module: 'telemetry',
-                operation: 'startup-overflow',
-                outcome: 'failure',
-            }),
-        };
-    }
-}
+        return item;
+    }));
+};
 
 /**
  * Enables telemetry for a given module configurator.
  *
- * Registers the telemetry module and an optional configuration callback. Framework, app and
- * widget hosts already capture their own startup lifecycle; `attachConfiguratorEvents` only
- * matters for custom hosts and for opting out.
- *
  * @param configurator - The module configurator instance to which telemetry should be attached.
  * @param options - Optional configuration for telemetry setup.
- * @param options.attachConfiguratorEvents - `true` captures this configurator's lifecycle unless
- *   its host already does; `false` stops lifecycle records reaching this provider. A host still
- *   reports a failed startup to its parent.
+ * @param options.attachConfiguratorEvents - If true, attaches configurator events to the telemetry builder.
  * @param options.configure - An optional callback to further configure the telemetry builder. Can be synchronous or asynchronous.
  *
  * @remarks
- * The lifecycle option applies synchronously when this is called, so capture starts before any
- * later configuration code runs. The `configure` callback is deferred until module initialization.
+ * This function adds telemetry configuration to the provided configurator. It supports attaching configurator events
+ * and allows for additional custom configuration via the `configure` callback.
+ *
+ * @remarks
+ * `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
@@ -7264,19 +6369,18 @@ class StartupCapture {
 const enableTelemetry = (
 // biome-ignore lint/suspicious/noExplicitAny: must be any to support all module types
 configurator, options) => {
-    const attach = options?.attachConfiguratorEvents;
     configurator.addConfig({
         module: module$2,
-        // Lifecycle capture must start now, before later configuration code can run.
-        prepare: (builder) => {
-                // Opting out keeps the host's capture attached, so a later `true` restores it.
-                builder.setLifecycleItemsEnabled(attach);
-                // Hosts own their startup capture; only capture here when no host already does.
-                if (!builder.hasLifecycleItems()) {
-                    builder.attachLifecycleItems(new StartupCapture(configurator).items);
-                }
-            },
-        configure: options?.configure,
+        configure: async (builder, ref) => {
+            // Attach configurator events to the telemetry builder only when opted in
+            {
+                builder.attachItems(mapConfiguratorEvents(configurator));
+            }
+            // Run the caller-supplied configure callback when one was provided
+            if (options?.configure) {
+                await Promise.resolve(options.configure(builder, ref));
+            }
+        },
     });
 };
 
@@ -9610,9 +8714,6 @@ class ServiceDiscoveryClient {
     #query;
     #failure;
     #lastKnownGood;
-    #diagnostic = new Subject();
-    /** {@inheritDoc IServiceDiscoveryClient.diagnostic$} */
-    diagnostic$ = this.#diagnostic.asObservable();
     /** Sub-path appended to the HTTP client's base URI when fetching services. */
     endpoint;
     /** HTTP client used to call the service discovery API. */
@@ -9639,40 +8740,32 @@ class ServiceDiscoveryClient {
     }
     /** {@inheritDoc IServiceDiscoveryClient.resolveServices} */
     async resolveServices(allow_cache) {
-        const started = performance.now();
         // Fail fast while cooling down so retry/reload/render loops never reach the network
         if (this.#failure && Date.now() < this.#failure.retryAt) {
             return this.#resolveFallback(new ServiceDiscoveryUnavailableError({
                 cause: this.#failure.error,
                 retryAt: this.#failure.retryAt,
                 attempt: this.#failure.attempt,
-            }), started, 'cooldown');
+            }));
         }
         const startedAt = Date.now();
-        let record;
         try {
             // firstValueFrom returns the cached snapshot; lastValueFrom waits for
             // the freshest value from the query
             const fn = allow_cache ? firstValueFrom : lastValueFrom;
-            record = await fn(this.#query.query());
+            const record = await fn(this.#query.query());
+            // Only a fresh response proves discovery works; a cached (possibly expired) snapshot must
+            // not reset the failure streak or renew the age of the fallback list
+            if (record.status === 'complete') {
+                this.#failure = undefined;
+                this.#lastKnownGood = { services: record.value, receivedAt: Date.now() };
+            }
+            return record.value;
         }
         catch (error) {
             this.#registerFailure(error, startedAt);
-            return this.#resolveFallback(error, started, 'network');
-        }
-        // Only a fresh response proves discovery works; a cached (possibly expired) snapshot must
-        // not reset the failure streak or renew the age of the fallback list
-        if (record.status === 'complete') {
-            this.#failure = undefined;
-            this.#lastKnownGood = { services: record.value, receivedAt: Date.now() };
-        }
-        this.#emit({
-            type: 'resolve',
-            outcome: 'success',
-            origin: record.status === 'complete' ? 'network' : 'cache',
-            duration: performance.now() - started,
-        });
-        return record.value;
+            return this.#resolveFallback(error);
+        }
     }
     /**
      * Records a failed request and schedules the next allowed request time.
@@ -9705,43 +8798,17 @@ class ServiceDiscoveryClient {
      * otherwise rethrows the given error.
      *
      * @param error - Error to throw when no usable fallback exists.
-     * @param started - `performance.now()` timestamp when resolution started.
-     * @param failedOrigin - Classification reported when no fallback can be served.
      * @returns The last known good service list.
      * @throws The provided `error` when no service list younger than 24 hours exists.
      */
-    #resolveFallback(error, started, failedOrigin) {
+    #resolveFallback(error) {
         const lastKnownGood = this.#lastKnownGood;
         // Prefer a recent service list over an error so callers have nothing to retry
         if (lastKnownGood && Date.now() - lastKnownGood.receivedAt <= staleIfErrorMs) {
-            this.#emit({
-                type: 'resolve',
-                outcome: 'success',
-                origin: 'fallback',
-                duration: performance.now() - started,
-            });
             return lastKnownGood.services;
         }
-        this.#emit({
-            type: 'resolve',
-            outcome: 'failure',
-            origin: failedOrigin,
-            duration: performance.now() - started,
-        });
         throw error;
     }
-    /**
-     * Publishes a safe diagnostic outcome without letting an observer affect resolution.
-     * @param diagnostic - Classified outcome without keys, URIs, scopes or errors.
-     */
-    #emit(diagnostic) {
-        try {
-            this.#diagnostic.next(diagnostic);
-        }
-        catch {
-            // Observers are diagnostic only; resolution results must stay unchanged.
-        }
-    }
     /** {@inheritDoc IServiceDiscoveryClient.resolveService} */
     async resolveService(key, allow_cache) {
         const services = await this.resolveServices(allow_cache);
@@ -9749,7 +8816,6 @@ class ServiceDiscoveryClient {
         const service = services.find((s) => s.key === key);
         // Fail loudly when the requested key doesn't resolve to a known service
         if (!service) {
-            this.#emit({ type: 'unknown-service' });
             throw Error(`Failed to resolve service, invalid key [${key}]`);
         }
         return service;
@@ -9943,7 +9009,7 @@ class ServiceDiscoveryConfigurator extends BaseConfigBuilder {
 }
 
 // Generated by genversion.
-const version$1 = '10.3.0-next.1';
+const version$1 = '10.2.0';
 
 /**
  * Default implementation of {@link IServiceDiscoveryProvider}.
@@ -9966,67 +9032,6 @@ class ServiceDiscoveryProvider extends BaseModuleProvider {
         });
         this.config = config;
         this._http = _http;
-        this._addTeardown(() => {
-            this.#diagnostics?.unsubscribe();
-            this.#telemetry.disconnect();
-        });
-    }
-    #telemetry = createOperationalTelemetry('service-discovery');
-    #diagnostics;
-    /**
-     * Connects optional operational telemetry for the client this provider owns.
-     *
-     * Records one `fusion.service-discovery.resolve.duration` per network, fallback or cooldown
-     * resolution, plus `fallback`, `cooldown` and `unknown-service` notifications. Cached
-     * resolutions record only a Debug-level `cache-hit` notification, so hosts filtering at
-     * Information or above export nothing for them. No keys,
-     * URIs, scopes or errors are recorded, and HTTP attempts are left to HTTP telemetry.
-     * Calling it again replaces the provider; `undefined` records nothing until reconnected.
-     *
-     * @param telemetry - Host telemetry provider, or `undefined` to record nothing.
-     */
-    connectTelemetry(telemetry) {
-        this.#telemetry.connect(telemetry);
-        const diagnostic$ = this.client.diagnostic$;
-        // One subscription serves every connection; custom clients without a stream are skipped.
-        if (this.#diagnostics || !this.#telemetry.connected || !diagnostic$) {
-            return;
-        }
-        const report = this.#telemetry.report;
-        this.#diagnostics = diagnostic$.subscribe((diagnostic) => {
-            // An unmatched key is a notification only; it has no measured resolution of its own.
-            if (diagnostic.type === 'unknown-service') {
-                report({
-                    notification: true,
-                    operation: 'unknown-service',
-                    outcome: 'failure',
-                    level: TelemetryLevel.Warning,
-                });
-                return;
-            }
-            const { outcome, origin, duration } = diagnostic;
-            // Cache hits dominate lookup volume and carry no diagnostic value at default levels,
-            // so they are a single Debug notification rather than a measured resolution.
-            if (origin === 'cache') {
-                report({
-                    notification: true,
-                    operation: 'cache-hit',
-                    outcome,
-                    level: TelemetryLevel.Debug,
-                });
-                return;
-            }
-            report({ operation: 'resolve', outcome, duration });
-            // Network resolutions are fully described by the measurement and the HTTP attempt.
-            if (origin !== 'network') {
-                report({
-                    notification: true,
-                    operation: origin,
-                    outcome,
-                    level: TelemetryLevel.Warning,
-                });
-            }
-        });
     }
     /** {@inheritDoc IServiceDiscoveryProvider.client} */
     get client() {
@@ -10061,11 +9066,6 @@ class ServiceDiscoveryProvider extends BaseModuleProvider {
     }
 }
 
-/**
- * Providers this module created, so host disposal tears down only its own instances and
- * their telemetry, never a provider supplied or shared by another host.
- */
-const ownedProviders = new WeakMap();
 /**
  * Module identifier used to register and look up the Service Discovery module
  * within the Fusion Framework module system.
@@ -10106,20 +9106,7 @@ const module$1 = {
         // service discovery requires http module to be initialized
         const httpModule = await requireInstance('http');
         // return service discovery provider
-        const provider = new ServiceDiscoveryProvider(config, httpModule);
-        ownedProviders.set(provider, provider);
-        return provider;
-    },
-    postInitialize: async ({ instance, modules, ref }) => {
-        // A child reusing its parent's client leaves reporting to the parent, so each
-        // resolution is recorded once, by the host that owns the client.
-        if (instance.client !== ref?.serviceDiscovery?.client) {
-            instance.connectTelemetry?.(modules.telemetry);
-        }
-    },
-    dispose: ({ instance }) => {
-        ownedProviders.get(instance)?.dispose();
-        ownedProviders.delete(instance);
+        return new ServiceDiscoveryProvider(config, httpModule);
     },
 };
 /**
@@ -10622,7 +9609,7 @@ async function registerServiceWorker(framework) {
 }
 
 // Generated by genversion.
-const version = '5.2.4-next.2';
+const version = '5.2.4';
 
 // Allow dynamic import without vite
 const importWithoutVite = (path) => import(/* @vite-ignore */ path);
@@ -10642,7 +9629,7 @@ enableServiceDiscovery(configurator, async (builder) => {
 });
 // Avoid interactive Entra ID authentication when the SPA runs in CI or Playwright.
 if (isEnabledEnvValue(import.meta.env.FUSION_SPA_MSAL_MOCK)) {
-    const { enableMsalMock } = await import('../index-By7EVum8.js');
+    const { enableMsalMock } = await import('../mock-Do8FKTMU.js');
     const mockServerUrl = import.meta.env.FUSION_SPA_MSAL_MOCK_SERVER_URL;
     enableMsalMock(configurator, (builder) => {
         // The SPA owns the HTTP adapter; MSAL owns applying the returned token and account.
@@ -10665,12 +9652,12 @@ else {
 }
 // Initialize tracing before app startup so network requests and logs share active trace context.
 if (import.meta.env.FUSION_SPA_TELEMETRY_OTLP_TRACES_ENDPOINT) {
-    const { enableDevServerTracing } = await import('../enable-dev-server-tracing-ac1hNKwa.js');
+    const { enableDevServerTracing } = await import('../enable-dev-server-tracing-B9rBXrzF.js');
     enableDevServerTracing(new URL(import.meta.env.FUSION_SPA_TELEMETRY_OTLP_TRACES_ENDPOINT, window.location.origin).href);
 }
 // The dev-server environment bridge owns activation; the SPA only consumes its endpoint.
 const devServerOtlpAdapter = import.meta.env.FUSION_SPA_TELEMETRY_OTLP_ENDPOINT
-    ? new (await import('../index-CYwi54x_.js')).OtlpAdapter({
+    ? new (await import('../otlp-Dq76ZTYm.js')).OtlpAdapter({
         url: new URL(import.meta.env.FUSION_SPA_TELEMETRY_OTLP_ENDPOINT, window.location.origin).href,
         fallback: true,
         serviceName: 'fusion.dev-server',