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

package/dist/html/bootstrap.js

@@ -1,5 +1,21 @@
-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 deepmerge, W as BaseConfigBuilder, X as TelemetryExceptionSchema, Y as TelemetryItemNames, Z as TelemetryType, $ as TelemetryEventSchema, a0 as TelemetryMetricSchema, a1 as TelemetryCustomEventSchema, a2 as array, a3 as TelemetryLevel, a4 as enableMSAL } from '../module-BR47HvRl.js';
-import { B as BaseTelemetryAdapter } from '../TelemetryAdapter-B6JH_RXA.js';
+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 };
+}
 
 var ObjectUnsubscribedError = createErrorClass(function (_super) {
     return function ObjectUnsubscribedErrorImpl() {
@@ -518,6 +534,18 @@ 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'];
@@ -661,6 +689,12 @@ 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;
@@ -695,14 +729,23 @@ function defaultErrorFactory() {
     return new EmptyError();
 }
 
-function finalize$1(callback) {
+function exhaustMap(project, resultSelector) {
     return operate(function (source, subscriber) {
-        try {
-            source.subscribe(subscriber);
-        }
-        finally {
-            subscriber.add(callback);
-        }
+        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();
+        }));
     });
 }
 
@@ -880,42 +923,6 @@ 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++) {
@@ -977,13 +984,19 @@ 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`,
@@ -1048,7 +1061,10 @@ async function createModuleConfigs(ctx, ref) {
     const config$ = from(modules).pipe(mergeMap(async (module) => {
         const configStart = performance.now();
         try {
-            const configurator = await module.configure?.(ref);
+            // 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 configLoadTime = Math.round(performance.now() - configStart);
             registerEvent({
                 level: ModuleEventLevel.Debug,
@@ -1188,8 +1204,8 @@ config) {
  * Runs the full configure lifecycle phase for a set of modules.
  *
  * Orchestrates three sub-steps in order:
- * 1. {@link createModuleConfigs} — call each module's `configure(ref)` factory.
- * 2. Apply all user-registered config callbacks (`_configs`) sequentially.
+ * 1. {@link createModuleConfigs} — reuse prepared builders or call `configure(ref)` factories.
+ * 2. Apply all user-registered config callbacks (`_configs`) concurrently.
  * 3. {@link runPostConfigureHooks} — call `postConfigure` and `afterConfiguration` hooks.
  *
  * @param ctx - The configure phase context.
@@ -1209,6 +1225,81 @@ 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.
  *
@@ -1312,6 +1403,7 @@ 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`);
@@ -1325,6 +1417,7 @@ async function initializeModule(module, ctx) {
                 moduleVersion: module.version?.toString() || 'unknown',
             },
             error,
+            metric: performance.now() - moduleInitStart,
         });
         throw error;
     }
@@ -1337,13 +1430,26 @@ async function initializeModule(module, ctx) {
             moduleVersion: module.version?.toString() || 'unknown',
         },
     });
-    const moduleInitStart = performance.now();
-    const instance = await module.initialize({
-        ref,
-        config: config[key],
-        requireInstance,
-        hasModule,
-    });
+    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;
+    }
     // Warn when providers deviate from the expected base class — these modules
     // may lack version tracking and standard provider interfaces.
     if (!(instance instanceof BaseModuleProvider)) {
@@ -1391,7 +1497,8 @@ async function initializeModule(module, ctx) {
 /**
  * Runs the initialize lifecycle phase for all registered modules.
  *
- * Initializes all modules **concurrently** using `mergeMap`. Cross-module
+ * Initializes all modules concurrently and rejects on the first failure; providers that
+ * finish afterwards are passed to `onLateProvider` for cleanup. Cross-module
  * dependency ordering is handled lazily through `requireInstance`, which
  * waits for a peer module's `initialize` call to complete before resolving.
  *
@@ -1408,11 +1515,11 @@ async function initializeModule(module, ctx) {
  *   initialize within its timeout window.
  */
 async function runInitializePhase(ctx, config, ref) {
-    const { modules, registerEvent } = ctx;
+    const { modules, registerEvent, instances = {}, onLateProvider } = 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({});
+        return Object.seal(instances);
     }
     // Extract module names for dependency lookups before any module has initialized
     const moduleNames = modules.map((m) => m.name);
@@ -1423,55 +1530,56 @@ 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();
-    // 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();
-        },
+    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,
     });
-    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(instance).join(', '),
+            modules: Object.keys(instances).join(', '),
             initTime,
         },
         metric: initTime,
     });
-    Object.seal(instance);
-    return instance;
+    Object.seal(instances);
+    return instances;
 }
 
 // biome-ignore-all lint/suspicious/noExplicitAny: internal type-erased dispatch — the post-initialize phase forwards opaque instances without inspecting their concrete shapes
@@ -1710,6 +1818,8 @@ 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';
 }
@@ -1724,9 +1834,9 @@ async function runPluginTeardown(teardown) {
 /**
  * Runs the dispose lifecycle phase for all registered modules.
  *
- * 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.
+ * 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.
  *
  * @param ctx - The dispose phase context.
  * @param instance - The initialized module instance map to tear down.
@@ -1736,6 +1846,8 @@ 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,
@@ -1764,6 +1876,7 @@ async function runDisposePhase(ctx, instance, ref) {
                 });
             }
             catch (err) {
+                failed = true;
                 registerEvent({
                     level: ModuleEventLevel.Warning,
                     name: ModuleConfiguratorEventName.PluginDisposeError,
@@ -1780,65 +1893,98 @@ async function runDisposePhase(ctx, instance, ref) {
         message: 'Disposing modules',
         properties: { count: modules.length },
     });
-    // 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.Debug,
-                name: ModuleConfiguratorEventName.ModuleDisposed,
-                message: `Module ${module.name} disposed successfully`,
-                properties: {
-                    moduleName: module.name,
-                    moduleVersion: module.version?.toString() || 'unknown',
-                },
-            });
+    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);
         }
-        catch (err) {
+        else {
+            failed = true;
             registerEvent({
                 level: ModuleEventLevel.Warning,
-                name: ModuleConfiguratorEventName.ModuleDisposeError,
-                message: `Module ${module.name} dispose failed`,
-                properties: {
-                    moduleName: module.name,
-                    moduleVersion: module.version?.toString() || 'unknown',
-                },
-                error: err,
+                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'),
+            });
+            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') {
+            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 },
             });
         }
-    }));
-    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.1.6';
+const version$4 = '6.2.0-next.0';
 
 // biome-ignore-all lint/suspicious/noExplicitAny: internal type-erased dispatch arrays — callbacks are registered with concrete module types but stored erased; the orchestrator never inspects these shapes itself
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
  * Core orchestrator that drives the module lifecycle in Fusion Framework.
  *
- * `ModulesConfigurator` manages the full **configure → post-configure → initialize →
+ * `ModulesConfigurator` manages the full **prepare → 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
@@ -1848,6 +1994,7 @@ const version$4 = '6.1.6';
  *
  * | # | 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`. |
@@ -1899,6 +2046,10 @@ 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.
@@ -1949,10 +2100,14 @@ 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.
+     * 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.
      * @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
@@ -2025,14 +2180,22 @@ 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.
+     * respective lifecycle phase arrays. An optional `prepare` callback runs
+     * synchronously during registration against the same builder.
      *
      * @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.
@@ -2043,7 +2206,19 @@ 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));
@@ -2053,6 +2228,10 @@ 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,
@@ -2175,8 +2354,64 @@ 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);
@@ -2195,7 +2430,7 @@ class ModulesConfigurator {
             metric: configLoadTime,
         });
         const instanceStart = performance.now();
-        const instance = await this._initialize(config, ref);
+        const instance = await this._initialize(config, ref, instances);
         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
@@ -2230,10 +2465,13 @@ 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(instance),
+            dispose: () => this.dispose(modules),
         }));
-        await this._registerPlugins(modules, ref);
+        this.#instanceTeardowns.set(modules, teardowns);
+        await this._registerPlugins(modules, ref, teardowns);
         return modules;
     }
     /**
@@ -2271,6 +2509,7 @@ class ModulesConfigurator {
     async _configure(ref) {
         return runConfigurePhase({
             modules: this.modules,
+            configurators: this.#configurators,
             configs: this._configs,
             afterConfiguration: this._afterConfiguration,
             afterInit: this._afterInit,
@@ -2287,17 +2526,39 @@ 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) {
+    async _initialize(config, ref, instances = {}) {
         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.
      *
@@ -2329,14 +2590,16 @@ 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) {
+    async _registerPlugins(instance, ref, teardowns = this._pluginTeardowns) {
         return runPluginPhase({
             plugins: this._plugins,
-            teardowns: this._pluginTeardowns,
+            teardowns,
             registerEvent: this._registerEvent.bind(this),
         }, instance, ref);
     }
@@ -2350,14 +2613,26 @@ class ModulesConfigurator {
      * @param ref - Optional reference forwarded to module dispose hooks.
      * @returns A promise resolving when all modules have been disposed.
      */
-    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);
+    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;
     }
 }
 
@@ -2994,7 +3269,7 @@ class HttpClientConfigurator {
 }
 
 // Generated by genversion.
-const version$3 = '8.1.4';
+const version$3 = '8.1.5-next.0';
 
 /** URL protocols accepted as valid ad-hoc base URIs. */
 const SUPPORTED_PROTOCOLS = ['http:', 'https:', 'ws:', 'wss:'];
@@ -3720,9 +3995,10 @@ 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 accessToken = await authProvider.acquireAccessToken({
-                        request: { scopes },
-                    });
+                    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);
                     // without a token there's nothing to attach, fall through to the default request
                     if (accessToken) {
                         const headers = new Headers(request.headers);
@@ -4353,7 +4629,7 @@ function peek(draft, prop) {
   return source[prop];
 }
 function isRelocatedBaseRef(state, prop, value) {
-  if (state.type_ !== 1 /* Array */ || !state.allIndicesReassigned_ || state.assigned_?.get(prop) || !isDraftable(value) || value[DRAFT_STATE]) {
+  if (state.type_ !== 1 /* Array */ || !state.allIndicesReassigned_ || !isDraftable(value) || value[DRAFT_STATE]) {
     return false;
   }
   return state.baseRefs_.has(value);
@@ -4599,8 +4875,11 @@ function currentImpl(value) {
   } else {
     copy = shallowCopy(value, true);
   }
+  const source = copy;
+  if (isSet(copy))
+    copy = /* @__PURE__ */ new Set();
   each(
-    copy,
+    source,
     (key, childValue) => {
       set(copy, key, currentImpl(childValue));
     },
@@ -4855,84 +5134,6 @@ 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;
 }
@@ -5229,12 +5430,14 @@ 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, and parent providers.
+ * 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.
  *
  * @example
  * ```typescript
  * const configurator = new TelemetryConfigurator()
- *   .setAdapter(myAdapter)
+ *   .setAdapter('console', consoleAdapter)
  *   .setMetadata({ app: 'my-app' })
  *   .setDefaultScope(['user', 'session'])
  *   .setParent(parentProvider);
@@ -5250,7 +5453,7 @@ const mergeTelemetryItem = (target, source) => {
  * @see ITelemetryConfigurator
  */
 class TelemetryConfigurator extends BaseConfigBuilder {
-    #adaptersCallbacks = {};
+    #adapters = {};
     #metadata = [];
     /**
      * Creates a new `TelemetryConfigurator` and wires up the async adapter
@@ -5261,40 +5464,56 @@ 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.#adaptersCallbacks)).pipe(mergeMap(([identifier, adapterFn]) => 
+            return from(Object.entries(this.#adapters)).pipe(mergeMap(([identifier, { configure }]) => 
             // Drop adapters whose factory resolved to a falsy value
-            from(adapterFn(args)).pipe(filter((adapter) => !!adapter), map((adapter) => [identifier, adapter]))), scan((acc, [identifier, adapter]) => {
+            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]) => {
                 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) ?? {}, {}), last(), shareReplay({ bufferSize: 1, refCount: true }));
+            from(metadataItems).pipe(concatMap((metadata) => toObservable(metadata, ...args)), scan((acc, current) => mergeMetadata(acc, current) ?? {}, {}), defaultIfEmpty({}), 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. The adapter's identifier is used as the key.
+     * @param adapter - The telemetry adapter to be added.
      * @returns The current instance of the configurator for method chaining.
      */
     setAdapter(identifier, adapter) {
-        return this.configureAdapter(identifier, async () => adapter);
+        this.#adapters[identifier] = { configure: async () => adapter, explicit: !adapter.fallback };
+        return this;
     }
     /**
      * 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.#adaptersCallbacks[identifier] = adapterFn;
+        this.#adapters[identifier] = { configure: adapterFn, explicit: true };
         return this;
     }
     /**
@@ -5330,6 +5549,15 @@ 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.
      *
@@ -5340,6 +5568,20 @@ 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.
      *
@@ -5355,27 +5597,172 @@ class TelemetryConfigurator extends BaseConfigBuilder {
 }
 
 // Generated by genversion.
-const version$2 = '7.2.2';
+const version$2 = '8.0.0-next.0';
 
 /**
- * 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:
+ * Represents a telemetry measurement that tracks elapsed time and reports measurement data
+ * to a telemetry provider. Supports cloning, resetting, and marking measurements as completed.
  *
- * - Specify the event type and initial event details
- * - Access the event details
- * - Check if the event is cancelable and whether it has been canceled
- * - Control whether the event can bubble up the event hierarchy
+ * @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.
  *
- * The `FrameworkEvent` class is designed to be used as a base class for creating custom event types that fit the needs
- * of your application or framework.
+ * @example
+ * ```typescript
+ * const measurement = new Measurement(provider, { name: 'operation' });
+ * // ... perform operation ...
+ * measurement.measure();
+ * ```
  *
- * @template TInit The type of the event details.
- * @template TType The type of the event type.
+ * @public
  */
-class FrameworkEvent {
-    __type;
+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:
+ *
+ * - Specify the event type and initial event details
+ * - Access the event details
+ * - Check if the event is cancelable and whether it has been canceled
+ * - Control whether the event can bubble up the event hierarchy
+ *
+ * The `FrameworkEvent` class is designed to be used as a base class for creating custom event types that fit the needs
+ * of your application or framework.
+ *
+ * @template TInit The type of the event details.
+ * @template TType The type of the event type.
+ */
+class FrameworkEvent {
+    __type;
     #detail;
     #source;
     #canceled = false;
@@ -5519,148 +5906,34 @@ class TelemetryEvent extends FrameworkEvent {
 }
 
 /**
- * Represents a telemetry measurement that tracks elapsed time and reports measurement data
- * to a telemetry provider. Supports cloning, resetting, and marking measurements as completed.
+ * Relays one record to a parent provider under the child's routing policy.
  *
- * @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.
+ * Shared by live provider relay and startup recovery, so both honour the same relay filter
+ * and exporter ownership.
  *
- * @example
- * ```typescript
- * const measurement = new Measurement(provider, { name: 'operation' });
- * // ... perform operation ...
- * measurement.measure();
- * ```
- *
- * @public
+ * @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.
  */
-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;
+function relayRecord(target, item, policy) {
+    // Reject intentionally filtered records without changing export ownership.
+    if (policy.relay && !policy.relay(item)) {
+        return true;
     }
-    /**
-     * 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);
+    // Ownership-aware parents suppress their fallback exporters for records a child owns.
+    if (target.trackRelayed) {
+        target.trackRelayed(item, policy.ownsExport);
+        return true;
     }
-    /**
-     * 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
-            }
-        }
+    // Legacy parents cannot honour ownership, so they only receive records no child owns.
+    if (!policy.ownsExport) {
+        target.track(item);
+        return true;
     }
+    return false;
 }
 
 /**
@@ -5716,67 +5989,643 @@ const applyMetadata = (metadata, args) => {
 };
 
 /**
- * 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.
+ * 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);
+        }
+    }
+}
+
+/**
+ * The telemetry provider applications and modules use to track events, exceptions, metrics
+ * and custom telemetry.
  *
- * @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.
+ * `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.
  *
  * @example
  * ```typescript
  * const provider = new TelemetryProvider(config, { event: eventProvider });
- * provider.track({ type: TelemetryType.Event, name: 'user_login', metadata: { userId: '123' } });
+ * await provider.initialize({ parent });
+ * provider.trackEvent({ 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 {
-    #items = new Subject();
-    #initialized = false;
-    #disposal;
-    #adapters = {};
-    #handledByChild = new WeakSet();
-    #filters;
-    #defaultScope;
-    #eventProvider;
+    /** Immutable composition-root origin used by optional infrastructure reporters. */
+    source;
+    #state;
     /**
      * Stream of every telemetry item tracked by this provider.
      *
      * @returns An observable emitting each tracked `TelemetryItem`.
      */
     get items() {
-        return this.#items.asObservable();
+        return this.#state.items;
     }
     /**
-     * Returns true if the provider has been initialized.
+     * Returns true once initialization has started.
      *
-     * @returns `true` when {@link initialize} has completed, otherwise `false`.
+     * @returns `true` once {@link initialize} has been called, otherwise `false`.
      */
     get initialized() {
-        return this.#initialized;
+        return this.#state.value.status !== 'idle';
     }
-    #metadata;
-    #modules;
     /**
      * Sets the resolved framework module instances used to resolve metadata.
      *
      * @param value - The resolved framework module instances.
      */
     set modules(value) {
-        this.#modules = value;
+        this.#state.modules = value;
     }
     /**
      * Creates a new `TelemetryProvider`.
@@ -5787,51 +6636,27 @@ class TelemetryProvider extends BaseModuleProvider {
      */
     constructor(config, deps) {
         super({ version: version$2, config });
-        this.#adapters = config?.adapters ?? {};
-        this.#metadata = config?.metadata;
-        this.#defaultScope = config?.defaultScope ?? [];
-        this.#eventProvider = deps?.event;
-        this.#filters = config?.filter;
+        this.source = Object.freeze(config?.source ?? { hostId: crypto.randomUUID() });
+        this.#state = new TelemetryProviderState({ config, event: deps?.event, owner: this });
     }
     /**
-     * Initializes the telemetry provider with adapters, parent provider, and optional initial items.
+     * Connects exporters, the parent relay and startup streams. Exporter initialization failures
+     * are reported but do not prevent the provider from becoming usable.
      *
-     * 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
+     * Repeated and reentrant calls return the same promise.
      *
-     * @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
+     * @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.
      */
-    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();
-        });
+    initialize(args) {
+        return this.#state.initialize(args);
+    }
+    /** {@inheritDoc ITelemetryProvider.scope} */
+    scope(module, options) {
+        const scope = createOperationalTelemetry(module, options);
+        scope.connect(this);
+        return scope;
     }
     /**
      * Stops telemetry subscriptions and waits for every adapter to flush and shut down.
@@ -5847,158 +6672,7 @@ class TelemetryProvider extends BaseModuleProvider {
      * ```
      */
     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));
-        }
+        return this.#state.dispose();
     }
     /**
      * Tracks a telemetry item by type, merging the default scope with the provided scope.
@@ -6036,44 +6710,7 @@ class TelemetryProvider extends BaseModuleProvider {
      * @param hasAdapters - Whether an explicit child adapter has already handled this record.
      */
     trackRelayed(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);
-        }
+        this.#state.track(item, hasAdapters);
     }
     /**
      * Starts a metric measurement and returns a function to end the measurement.
@@ -6099,7 +6736,7 @@ class TelemetryProvider extends BaseModuleProvider {
      * provider.trackEvent({ name: 'button_click', metadata: { button: 'save' } });
      */
     trackEvent(data) {
-        this._track(TelemetryEventSchema.parse({ ...data, type: TelemetryType.Event }));
+        this.#state.track(TelemetryEventSchema.parse({ ...data, type: TelemetryType.Event }));
     }
     /**
      * Tracks a telemetry exception.
@@ -6113,7 +6750,7 @@ class TelemetryProvider extends BaseModuleProvider {
      * });
      */
     trackException(data) {
-        this._track(TelemetryExceptionSchema.parse({ ...data, type: TelemetryType.Exception }));
+        this.#state.track(TelemetryExceptionSchema.parse({ ...data, type: TelemetryType.Exception }));
     }
     /**
      * Tracks a telemetry metric.
@@ -6123,7 +6760,7 @@ class TelemetryProvider extends BaseModuleProvider {
      * provider.trackMetric({ name: 'response_time', value: 123 });
      */
     trackMetric(data) {
-        this._track(TelemetryMetricSchema.parse({ ...data, type: TelemetryType.Metric }));
+        this.#state.track(TelemetryMetricSchema.parse({ ...data, type: TelemetryType.Metric }));
     }
     /**
      * Tracks a custom telemetry event.
@@ -6133,7 +6770,7 @@ class TelemetryProvider extends BaseModuleProvider {
      * provider.trackCustom({ name: 'custom_event', metadata: { foo: 'bar' } });
      */
     trackCustom(data) {
-        this._track(TelemetryCustomEventSchema.parse({ ...data, type: TelemetryType.Custom }));
+        this.#state.track(TelemetryCustomEventSchema.parse({ ...data, type: TelemetryType.Custom }));
     }
     /**
      * Retrieves a telemetry adapter by its identifier.
@@ -6143,7 +6780,7 @@ class TelemetryProvider extends BaseModuleProvider {
      * @returns The telemetry adapter corresponding to the given identifier, or `undefined` if not found.
      */
     getAdapter(identifier) {
-        const adapter = this.#adapters[identifier];
+        const adapter = this.#state.adapters[identifier];
         // Report a missing adapter as a telemetry exception rather than throwing
         if (!adapter) {
             this.trackException({
@@ -6162,10 +6799,17 @@ class TelemetryProvider extends BaseModuleProvider {
      * @returns True if the adapter exists, false otherwise.
      */
     hasAdapter(identifier) {
-        return identifier in this.#adapters;
+        return identifier in this.#state.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.
  *
@@ -6183,7 +6827,9 @@ class TelemetryProvider extends BaseModuleProvider {
  */
 const module$2 = {
     name: 'telemetry',
-    configure: () => new TelemetryConfigurator(),
+    disposePhase: 'diagnostics',
+    prepare: createTelemetryConfigurator,
+    configure: createTelemetryConfigurator,
     initialize: async (args) => {
         const config = await args.config.createConfigAsync(args);
         const event = args.hasModule('event') ? await args.requireInstance('event') : undefined;
@@ -6206,69 +6852,399 @@ const module$2 = {
 };
 
 /**
- * Transforms events emitted by a given modules configurator into standardized telemetry items.
+ * 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.
  *
- * @param configurator - The modules configurator instance emitting events to be mapped.
- * @returns An observable stream of `TelemetryItem` objects, each representing a mapped event.
+ * 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.
  *
- * 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 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 resulting telemetry items include event name, type, level, message, properties, and a fixed scope of `['configuration']`.
+ * @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;
+ * }
+ * ```
  */
-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,
-            },
-            scope: ['configuration'],
-        };
-        // An event carrying an error is reported as a telemetry exception
-        if (event.error) {
-            return {
-                ...item,
-                type: TelemetryType.Exception,
-                exception: event.error,
+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();
+            },
+        });
+        // Synchronous replay can close capture before the subscription is assigned.
+        if (this.#status === 'closed') {
+            this.#subscription.unsubscribe();
         }
-        // An event carrying a metric value is reported as a telemetry metric
-        if (event.metric) {
-            return {
-                ...item,
-                type: TelemetryType.Metric,
-                value: event.metric,
-            };
+    }
+    /** 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;
         }
-        return item;
-    }));
-};
+        // 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 });
+        }
+        catch {
+            // Parent delivery failures fall through to local health reporting.
+            return false;
+        }
+    }
+    /**
+     * 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',
+            }),
+        };
+    }
+}
 
 /**
  * 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 - If true, attaches configurator events to the telemetry builder.
+ * @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.configure - An optional callback to further configure the telemetry builder. Can be synchronous or asynchronous.
  *
  * @remarks
- * 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.
+ * 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.
  *
  * @example
  * ```typescript
@@ -6288,18 +7264,19 @@ configurator) => {
 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,
-        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));
-            }
-        },
+        // 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,
     });
 };
 
@@ -8633,6 +9610,9 @@ 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. */
@@ -8659,32 +9639,40 @@ 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;
-            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;
+            record = await fn(this.#query.query());
         }
         catch (error) {
             this.#registerFailure(error, startedAt);
-            return this.#resolveFallback(error);
-        }
+            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;
     }
     /**
      * Records a failed request and schedules the next allowed request time.
@@ -8717,17 +9705,43 @@ 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) {
+    #resolveFallback(error, started, failedOrigin) {
         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);
@@ -8735,6 +9749,7 @@ 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;
@@ -8928,7 +9943,7 @@ class ServiceDiscoveryConfigurator extends BaseConfigBuilder {
 }
 
 // Generated by genversion.
-const version$1 = '10.2.0';
+const version$1 = '10.3.0-next.0';
 
 /**
  * Default implementation of {@link IServiceDiscoveryProvider}.
@@ -8951,6 +9966,62 @@ 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 resolution, plus
+     * `cache-hit`, `fallback`, `cooldown` and `unknown-service` notifications. 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;
+            report({ operation: 'resolve', outcome, duration });
+            // Network resolutions are fully described by the measurement and the HTTP attempt.
+            if (origin === 'cache') {
+                report({
+                    notification: true,
+                    operation: 'cache-hit',
+                    outcome,
+                    level: TelemetryLevel.Information,
+                });
+            }
+            else if (origin !== 'network') {
+                report({
+                    notification: true,
+                    operation: origin,
+                    outcome,
+                    level: TelemetryLevel.Warning,
+                });
+            }
+        });
     }
     /** {@inheritDoc IServiceDiscoveryProvider.client} */
     get client() {
@@ -8985,6 +10056,11 @@ 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.
@@ -9025,7 +10101,20 @@ const module$1 = {
         // service discovery requires http module to be initialized
         const httpModule = await requireInstance('http');
         // return service discovery provider
-        return new ServiceDiscoveryProvider(config, httpModule);
+        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);
     },
 };
 /**
@@ -9528,7 +10617,7 @@ async function registerServiceWorker(framework) {
 }
 
 // Generated by genversion.
-const version = '5.2.3';
+const version = '5.2.4-next.0';
 
 // Allow dynamic import without vite
 const importWithoutVite = (path) => import(/* @vite-ignore */ path);
@@ -9548,7 +10637,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-glg6-DFO.js');
+    const { enableMsalMock } = await import('../index-By7EVum8.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.
@@ -9571,12 +10660,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-GfRoCLxu.js');
+    const { enableDevServerTracing } = await import('../enable-dev-server-tracing-ac1hNKwa.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-CiqJ1Og1.js')).OtlpAdapter({
+    ? new (await import('../index-CYwi54x_.js')).OtlpAdapter({
         url: new URL(import.meta.env.FUSION_SPA_TELEMETRY_OTLP_ENDPOINT, window.location.origin).href,
         fallback: true,
         serviceName: 'fusion.dev-server',