@squide/firefly 15.0.5 → 16.0.0

package/src/honeycomb/registerHoneycombInstrumentation.ts

@@ -20,43 +20,27 @@ import {
     type LocalModulesRegistrationStartedEventPayload,
     type ModuleRegistrationError
 } from "@squide/core";
-import {
-    DeferredRegistrationsUpdateCompletedEvent,
-    DeferredRegistrationsUpdateStartedEvent,
-    RemoteModuleDeferredRegistrationFailedEvent,
-    RemoteModuleDeferredRegistrationUpdateFailedEvent,
-    type RemoteModuleRegistrationError,
-    RemoteModuleRegistrationFailedEvent,
-    RemoteModulesDeferredRegistrationCompletedEvent,
-    type RemoteModulesDeferredRegistrationCompletedEventPayload,
-    RemoteModulesDeferredRegistrationStartedEvent,
-    type RemoteModulesDeferredRegistrationStartedEventPayload,
-    RemoteModulesDeferredRegistrationsUpdateCompletedEvent,
-    type RemoteModulesDeferredRegistrationsUpdateCompletedEventPayload,
-    RemoteModulesDeferredRegistrationsUpdateStartedEvent,
-    type RemoteModulesDeferredRegistrationsUpdateStartedEventPayload,
-    RemoteModulesRegistrationCompletedEvent,
-    type RemoteModulesRegistrationCompletedEventPayload,
-    RemoteModulesRegistrationStartedEvent,
-    type RemoteModulesRegistrationStartedEventPayload
-} from "@squide/module-federation";
 import { ApplicationBoostrappedEvent, type AppRouterWaitState, ModulesReadyEvent, ModulesRegisteredEvent, MswReadyEvent, ProtectedDataReadyEvent, PublicDataReadyEvent } from "../AppRouterReducer.ts";
+import { FireflyPlugin } from "../FireflyPlugin.ts";
 import type { FireflyRuntime } from "../FireflyRuntime.tsx";
 import { ApplicationBootstrappingStartedEvent } from "../initializeFirefly.ts";
 import { ProtectedDataFetchFailedEvent, ProtectedDataFetchStartedEvent } from "../useProtectedDataQueries.ts";
 import { PublicDataFetchFailedEvent, PublicDataFetchStartedEvent } from "../usePublicDataQueries.ts";
+import { DeferredRegistrationsUpdateCompletedEvent, DeferredRegistrationsUpdateStartedEvent } from "../useUpdateDeferredRegistrations.ts";
 import { type ActiveSpan, createOverrideFetchRequestSpanWithActiveSpanContext, registerActiveSpanStack } from "./activeSpan.ts";
 import { getTracer } from "./tracer.ts";
 import { endActiveSpan, startActiveChildSpan, startChildSpan, startSpan, traceError } from "./utils.ts";
 
 // TIPS:
-// To query those traces in Honeycomb, use the following query filter: "root.name = squide-bootstrapping".
+// To query those traces in Honeycomb, use the following query filter:
+// "root.name = squide-bootstrapping" and
+// "root.name = squide-deferred-registrations-update".
 
-interface AddProtectedListenerOptions extends AddListenerOptions {
+export interface AddProtectedListenerOptions extends AddListenerOptions {
     onError?: (error: unknown) => void;
 }
 
-function addProtectedListener(runtime: FireflyRuntime, eventName: EventName, callback: EventCallbackFunction, options?: AddProtectedListenerOptions) {
+export function addProtectedListener(runtime: FireflyRuntime, eventName: EventName, callback: EventCallbackFunction, options?: AddProtectedListenerOptions) {
     const protectedCallback = (...args: unknown[]) => {
         try {
             callback(...args);
@@ -71,6 +55,9 @@ function addProtectedListener(runtime: FireflyRuntime, eventName: EventName, cal
     runtime.eventBus.addListener(eventName, protectedCallback, options);
 }
 
+export type GetSpanFunction = () => Span;
+export type HoneycombTrackingUnmanagedErrorHandler = (error: unknown) => void;
+
 type DataFetchState = "none" | "fetching-data" | "public-data-ready" | "protected-data-ready" | "data-ready" | "data-fetch-failed";
 
 export function reduceDataFetchEvents(
@@ -172,12 +159,11 @@ function registerTrackingListeners(runtime: FireflyRuntime) {
     let bootstrappingSpanHasEnded: boolean = false;
     let localModuleRegistrationSpan: Span;
     let localModuleDeferredRegistrationSpan: Span;
-    let remoteModuleRegistrationSpan: Span;
-    let remoteModuleDeferredRegistrationSpan: Span;
     let dataFetchSpan: ActiveSpan;
     let deferredRegistrationsUpdateSpan: Span;
     let localModuleDeferredRegistrationsUpdateSpan: ActiveSpan;
-    let remoteModuleDeferredRegistrationsUpdateSpan: ActiveSpan;
+
+    const pluginsUnmanagedErrorHandlers: HoneycombTrackingUnmanagedErrorHandler[] = [];
 
     const handleUnmanagedError = (error: unknown) => {
         if (bootstrappingSpan && !bootstrappingSpanHasEnded) {
@@ -195,14 +181,6 @@ function registerTrackingListeners(runtime: FireflyRuntime) {
             localModuleDeferredRegistrationSpan.end();
         }
 
-        if (remoteModuleRegistrationSpan) {
-            remoteModuleRegistrationSpan.end();
-        }
-
-        if (remoteModuleDeferredRegistrationSpan) {
-            remoteModuleDeferredRegistrationSpan.end();
-        }
-
         if (dataFetchSpan) {
             dataFetchSpan.instance.end();
         }
@@ -215,9 +193,9 @@ function registerTrackingListeners(runtime: FireflyRuntime) {
             localModuleDeferredRegistrationsUpdateSpan.instance.end();
         }
 
-        if (remoteModuleDeferredRegistrationsUpdateSpan) {
-            remoteModuleDeferredRegistrationsUpdateSpan.instance.end();
-        }
+        pluginsUnmanagedErrorHandlers.forEach(x => {
+            x(error);
+        });
     };
 
     addProtectedListener(runtime, ApplicationBootstrappingStartedEvent, () => {
@@ -332,92 +310,6 @@ function registerTrackingListeners(runtime: FireflyRuntime) {
         onError: handleUnmanagedError
     });
 
-    addProtectedListener(runtime, RemoteModulesRegistrationStartedEvent, (payload: unknown) => {
-        const attributes = {
-            "app.squide.remote_count": (payload as RemoteModulesRegistrationStartedEventPayload).remoteCount
-        };
-
-        if (bootstrappingSpan) {
-            bootstrappingSpan.addEvent("remote-module-registration-started", attributes);
-        }
-
-        remoteModuleRegistrationSpan = startChildSpan(bootstrappingSpan, (options, context) => {
-            return getTracer().startSpan("remote-module-registration", { ...options, attributes }, context);
-        });
-    }, {
-        once: true,
-        onError: handleUnmanagedError
-    });
-
-    addProtectedListener(runtime, RemoteModulesRegistrationCompletedEvent, (payload: unknown) => {
-        if (bootstrappingSpan) {
-            bootstrappingSpan.addEvent("remote-module-registration-completed", {
-                "app.squide.remote_count": (payload as RemoteModulesRegistrationCompletedEventPayload).remoteCount
-            });
-        }
-
-        if (remoteModuleRegistrationSpan) {
-            remoteModuleRegistrationSpan.end();
-        }
-    }, {
-        once: true,
-        onError: handleUnmanagedError
-    });
-
-    // Can occur multiple times.
-    addProtectedListener(runtime, RemoteModuleRegistrationFailedEvent, (payload: unknown) => {
-        const registrationError = payload as RemoteModuleRegistrationError;
-
-        if (remoteModuleRegistrationSpan) {
-            traceError(remoteModuleRegistrationSpan, registrationError);
-        }
-    }, {
-        onError: handleUnmanagedError
-    });
-
-    addProtectedListener(runtime, RemoteModulesDeferredRegistrationStartedEvent, (payload: unknown) => {
-        const attributes = {
-            "app.squide.registration_count": (payload as RemoteModulesDeferredRegistrationStartedEventPayload).registrationCount
-        };
-
-        if (bootstrappingSpan) {
-            bootstrappingSpan.addEvent("remote-module-deferred-registration-started", attributes);
-        }
-
-        remoteModuleDeferredRegistrationSpan = startChildSpan(bootstrappingSpan, (options, context) => {
-            return getTracer().startSpan("remote-module-deferred-registration", { ...options, attributes }, context);
-        });
-    }, {
-        once: true,
-        onError: handleUnmanagedError
-    });
-
-    addProtectedListener(runtime, RemoteModulesDeferredRegistrationCompletedEvent, (payload: unknown) => {
-        if (bootstrappingSpan) {
-            bootstrappingSpan.addEvent("remote-module-deferred-registration-completed", {
-                "app.squide.registration_count": (payload as RemoteModulesDeferredRegistrationCompletedEventPayload).registrationCount
-            });
-        }
-
-        if (remoteModuleDeferredRegistrationSpan) {
-            remoteModuleDeferredRegistrationSpan.end();
-        }
-    }, {
-        once: true,
-        onError: handleUnmanagedError
-    });
-
-    // Can occur multiple times.
-    addProtectedListener(runtime, RemoteModuleDeferredRegistrationFailedEvent, (payload: unknown) => {
-        const registrationError = payload as RemoteModuleRegistrationError;
-
-        if (remoteModuleDeferredRegistrationSpan) {
-            traceError(remoteModuleDeferredRegistrationSpan, registrationError);
-        }
-    }, {
-        onError: handleUnmanagedError
-    });
-
     const handleFetchDataStarted = () => {
         dataFetchSpan = startActiveChildSpan(bootstrappingSpan, (options, context) => {
             const name = "data-fetch";
@@ -576,57 +468,26 @@ function registerTrackingListeners(runtime: FireflyRuntime) {
         onError: handleUnmanagedError
     });
 
-    // Can occur multiple times.
-    addProtectedListener(runtime, RemoteModulesDeferredRegistrationsUpdateStartedEvent, (payload: unknown) => {
-        const attributes = {
-            "app.squide.registration_count": (payload as RemoteModulesDeferredRegistrationsUpdateStartedEventPayload).registrationCount
-        };
-
-        if (deferredRegistrationsUpdateSpan) {
-            deferredRegistrationsUpdateSpan.addEvent("remote-module-deferred-registrations-update-started", attributes);
-        }
-
-        remoteModuleDeferredRegistrationsUpdateSpan = startActiveChildSpan(deferredRegistrationsUpdateSpan, (options, context) => {
-            const name = "remote-module-deferred-registrations-update";
-
-            const span = getTracer().startSpan(name, {
-                attributes,
-                ...options
-            }, context);
-
-            return {
-                name,
-                span
-            };
-        });
-    }, {
-        onError: handleUnmanagedError
-    });
+    const getBootstrappingSpan: GetSpanFunction = () => bootstrappingSpan;
+    const getDeferredRegistrationsUpdateSpan: GetSpanFunction = () => deferredRegistrationsUpdateSpan;
 
-    // Can occur multiple times.
-    addProtectedListener(runtime, RemoteModulesDeferredRegistrationsUpdateCompletedEvent, (payload: unknown) => {
-        if (deferredRegistrationsUpdateSpan) {
-            deferredRegistrationsUpdateSpan.addEvent("remote-module-deferred-registrations-update-completed", {
-                "app.squide.registration_count": (payload as RemoteModulesDeferredRegistrationsUpdateCompletedEventPayload).registrationCount
-            });
-        }
+    const handlePluginUnmanagedError: HoneycombTrackingUnmanagedErrorHandler = (error: unknown) => {
+        handleUnmanagedError(error);
+    };
 
-        if (remoteModuleDeferredRegistrationsUpdateSpan) {
-            endActiveSpan(remoteModuleDeferredRegistrationsUpdateSpan);
-        }
-    }, {
-        onError: handleUnmanagedError
-    });
+    // Register plugins specific handlers for Honeycomb telemetry.
+    runtime.plugins.forEach(x => {
+        const plugin = x as FireflyPlugin;
 
-    // Can occur multiple times.
-    addProtectedListener(runtime, RemoteModuleDeferredRegistrationUpdateFailedEvent, (payload: unknown) => {
-        const registrationError = payload as RemoteModuleRegistrationError;
+        if (plugin.registerHoneycombTrackingListeners) {
+            const unmanagedErrorHandler = plugin.registerHoneycombTrackingListeners(
+                getBootstrappingSpan,
+                getDeferredRegistrationsUpdateSpan,
+                handlePluginUnmanagedError
+            );
 
-        if (remoteModuleDeferredRegistrationsUpdateSpan) {
-            traceError(remoteModuleDeferredRegistrationsUpdateSpan.instance, registrationError);
+            pluginsUnmanagedErrorHandlers.push(unmanagedErrorHandler);
         }
-    }, {
-        onError: handleUnmanagedError
     });
 }
 

package/src/index.ts

@@ -1,14 +1,25 @@
 export * from "@squide/core";
-export * from "@squide/module-federation";
 export * from "@squide/msw";
 export * from "@squide/react-router";
 
+export type { FireflyPlugin } from "./FireflyPlugin.ts";
 export * from "./FireflyProvider.tsx";
 export * from "./FireflyRuntime.tsx";
 
 export * from "./AppRouter.tsx";
-export * from "./AppRouterContext.ts";
-export * from "./AppRouterReducer.ts";
+export {
+    ActiveRouteIsProtectedEvent,
+    ActiveRouteIsPublicEvent,
+    ApplicationBoostrappedEvent,
+    DeferredRegistrationsUpdatedEvent,
+    ModulesReadyEvent,
+    ModulesRegisteredEvent,
+    MswReadyEvent,
+    ProtectedDataReadyEvent,
+    ProtectedDataUpdatedEvent,
+    PublicDataReadyEvent,
+    PublicDataUpdatedEvent
+} from "./AppRouterReducer.ts";
 
 export * from "./AppRouterStore.ts";
 export * from "./GlobalDataQueriesError.ts";

package/src/initializeFirefly.ts

@@ -1,6 +1,5 @@
-import { isFunction, registerLocalModules, type ModuleRegisterFunction, type RegisterModulesOptions } from "@squide/core";
-import { registerRemoteModules, type RemoteDefinition } from "@squide/module-federation";
-import { setMswAsReady } from "@squide/msw";
+import { isFunction, ModuleDefinition, toLocalModuleDefinitions, type ModuleRegisterFunction, type RegisterModulesOptions } from "@squide/core";
+import { MswPlugin } from "@squide/msw";
 import type { HoneycombInstrumentationPartialClient } from "@workleap-telemetry/core";
 import { FireflyRuntime, type FireflyRuntimeOptions } from "./FireflyRuntime.tsx";
 import { initializeHoneycomb } from "./honeycomb/initializeHoneycomb.ts";
@@ -13,26 +12,19 @@ export type StartMswFunction<TRuntime = FireflyRuntime> = (runtime: TRuntime) =>
 
 export interface InitializeFireflyOptions<TRuntime extends FireflyRuntime, TContext = unknown, TData = unknown> extends RegisterModulesOptions<TContext>, FireflyRuntimeOptions {
     localModules?: ModuleRegisterFunction<TRuntime, TContext, TData>[];
-    remotes?: RemoteDefinition[];
+    moduleDefinitions?: ModuleDefinition<TRuntime, TContext, TData>[];
+    useMsw?: boolean;
     honeycombInstrumentationClient?: HoneycombInstrumentationPartialClient;
     startMsw?: StartMswFunction<FireflyRuntime>;
     onError?: OnInitializationErrorFunction;
 }
 
-function propagateRegistrationErrors(results: PromiseSettledResult<unknown[]>, onError: OnInitializationErrorFunction) {
-    if (results) {
-        if (results.status === "fulfilled") {
-            results.value.forEach(x => {
-                onError(x);
-            });
-        }
-    }
-}
-
-export function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(runtime: TRuntime, options: InitializeFireflyOptions<TRuntime, TContext, TData> = {}) {
+export function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TContext = unknown, TData = unknown>(
+    runtime: TRuntime,
+    modulesDefinitions: ModuleDefinition<TRuntime, TContext, TData>[],
+    options: Omit<InitializeFireflyOptions<TRuntime, TContext, TData>, "localModules" | "moduleDefinitions"> = {}
+) {
     const {
-        localModules = [],
-        remotes = [],
         startMsw,
         onError,
         context
@@ -40,43 +32,51 @@ export function bootstrap<TRuntime extends FireflyRuntime = FireflyRuntime, TCon
 
     runtime.eventBus.dispatch(ApplicationBootstrappingStartedEvent);
 
-    Promise.allSettled([
-        registerLocalModules<TRuntime, TContext, TData>(localModules, runtime, { context }),
-        registerRemoteModules(remotes, runtime, { context })
-    ]).then(results => {
-        if (runtime.isMswEnabled) {
-            if (!isFunction(startMsw)) {
-                throw new Error("[squide] When MSW is enabled, the \"startMsw\" function must be provided.");
+    runtime.moduleManager.registerModules(modulesDefinitions, { context })
+        .then(results => {
+            if (runtime.isMswEnabled) {
+                if (!isFunction(startMsw)) {
+                    throw new Error("[squide] When MSW is enabled, the \"startMsw\" function must be provided.");
+                }
+
+                startMsw(runtime)
+                    .then(() => {
+                        if (runtime.isMswEnabled) {
+                            runtime.getMswState().setAsReady();
+                        }
+                    })
+                    .catch((error: unknown) => {
+                        runtime.logger
+                            .withText("[squide] An error occured while starting MSW.")
+                            .withError(error as Error)
+                            .error();
+                    });
             }
 
-            startMsw(runtime)
-                .then(() => {
-                    setMswAsReady();
-                })
-                .catch((error: unknown) => {
-                    runtime.logger
-                        .withText("[squide] An error occured while starting MSW.")
-                        .withError(error as Error)
-                        .error();
+            if (onError) {
+                results.forEach(error => {
+                    onError(error);
                 });
-        }
-
-        if (onError) {
-            propagateRegistrationErrors(results[0], onError);
-            propagateRegistrationErrors(results[1], onError);
-        }
-    });
+            }
+        });
 }
 
 let hasExecuted = false;
 
+// Should only be used by tests.
+export function __resetHasExecutedGuard() {
+    hasExecuted = false;
+}
+
 export function initializeFirefly<TContext = unknown, TData = unknown>(options: InitializeFireflyOptions<FireflyRuntime, TContext, TData> = {}) {
     const {
         mode,
+        localModules = [],
+        moduleDefinitions = [],
         useMsw,
-        loggers,
-        plugins,
+        plugins = [],
         honeycombInstrumentationClient,
+        loggers,
         onError
     } = options;
 
@@ -86,9 +86,12 @@ export function initializeFirefly<TContext = unknown, TData = unknown>(options:
 
     hasExecuted = true;
 
+    if (useMsw) {
+        plugins.push(x => new MswPlugin(x));
+    }
+
     const runtime = new FireflyRuntime({
         mode,
-        useMsw,
         honeycombInstrumentationClient,
         loggers,
         plugins
@@ -101,12 +104,12 @@ export function initializeFirefly<TContext = unknown, TData = unknown>(options:
             }
         })
         .finally(() => {
-            bootstrap(runtime, options);
+            bootstrap(
+                runtime,
+                [...moduleDefinitions, ...toLocalModuleDefinitions(localModules)],
+                options
+            );
         });
 
     return runtime;
 }
-
-export function __resetHasExecuteGuard() {
-    hasExecuted = false;
-}

package/src/internal.ts

@@ -0,0 +1,22 @@
+export { AppRouterDispatcherContext, AppRouterStateContext } from "./AppRouterContext.ts";
+export { __clearAppReducerDispatchProxy, __setAppReducerDispatchProxyFactory, useAppRouterReducer, type AppRouterDispatch, type AppRouterState } from "./AppRouterReducer.ts";
+
+export type { ActiveSpan, ActiveSpanId } from "./honeycomb/activeSpan.ts";
+export { addProtectedListener, type AddProtectedListenerOptions, type GetSpanFunction, type HoneycombTrackingUnmanagedErrorHandler } from "./honeycomb/registerHoneycombInstrumentation.ts";
+export { getTracer } from "./honeycomb/tracer.ts";
+export {
+    endActiveSpan,
+    startActiveChildSpan,
+    startActiveSpan,
+    startChildSpan,
+    startSpan,
+    traceError,
+    type StartActiveChildSpanFactory,
+    type StartActiveChildSpanFactoryReturn,
+    type StartActiveSpanFactory,
+    type StartActiveSpanFactoryReturn,
+    type StartChildSpanFactory,
+    type StartSpanFactory,
+    type TraceErrorOptions
+} from "./honeycomb/utils.ts";
+

package/src/useDeferredRegistrations.ts

@@ -5,21 +5,12 @@ import { useCanUpdateDeferredRegistrations } from "./useCanUpdateDeferredRegistr
 import { useRegisterDeferredRegistrations } from "./useRegisterDeferredRegistrations.ts";
 import { useUpdateDeferredRegistrations } from "./useUpdateDeferredRegistrations.ts";
 
-export interface DeferredRegistrationsErrorsObject {
-    localModuleErrors: ModuleRegistrationError[];
-    remoteModuleErrors: ModuleRegistrationError[];
-}
-
-export type DeferredRegistrationsErrorCallback = (errorsObject: DeferredRegistrationsErrorsObject) => void;
+export type DeferredRegistrationsErrorCallback = (errors: ModuleRegistrationError[]) => void;
 
 export interface UseDeferredRegistrationsOptions {
     onError?: DeferredRegistrationsErrorCallback;
 }
 
-function hasError({ localModuleErrors, remoteModuleErrors }: DeferredRegistrationsErrorsObject) {
-    return localModuleErrors.length > 0 || remoteModuleErrors.length > 0;
-}
-
 export function useDeferredRegistrations(data: unknown, { onError }: UseDeferredRegistrationsOptions = {}) {
     const runtime = useRuntime();
 
@@ -34,7 +25,7 @@ export function useDeferredRegistrations(data: unknown, { onError }: UseDeferred
             const register = async () => {
                 const errors = await registerDeferredRegistrations(data, runtime);
 
-                if (hasError(errors) && onError) {
+                if (errors.length > 0 && onError) {
                     onError(errors);
                 }
             };
@@ -48,7 +39,7 @@ export function useDeferredRegistrations(data: unknown, { onError }: UseDeferred
             const update = async () => {
                 const errors = await updateDeferredRegistrations(data, runtime);
 
-                if (hasError(errors) && onError) {
+                if (errors.length > 0 && onError) {
                     onError(errors);
                 }
             };

package/src/useRegisterDeferredRegistrations.ts

@@ -1,9 +1,8 @@
 import type { Runtime } from "@squide/core";
-import { registerDeferredRegistrations } from "@squide/module-federation";
 import { useCallback } from "react";
 
 export function useRegisterDeferredRegistrations() {
     return useCallback(<TData = unknown, TRuntime extends Runtime = Runtime>(data: TData, runtime: TRuntime) => {
-        return registerDeferredRegistrations(data, runtime);
+        return runtime.moduleManager.registerDeferredRegistrations(data);
     }, []);
 }

package/src/useStrictRegistrationMode.ts

@@ -1,28 +1,23 @@
-import { addLocalModuleRegistrationStatusChangedListener, getLocalModuleRegistrationStatus, removeLocalModuleRegistrationStatusChangedListener, useRuntime } from "@squide/core";
-import { addRemoteModuleRegistrationStatusChangedListener, areModulesReady, getRemoteModuleRegistrationStatus, removeRemoteModuleRegistrationStatusChangedListener } from "@squide/module-federation";
+import { Runtime, useRuntime } from "@squide/core";
 import { useEffect, useSyncExternalStore } from "react";
 
-function subscribeToLocalModuleRegistrationStatusChanged(callback: () => void) {
-    addLocalModuleRegistrationStatusChangedListener(callback);
+function subscribeToModulesReady(runtime: Runtime) {
+    return (callback: () => void) => {
+        runtime.moduleManager.registerModulesReadyListener(callback);
 
-    return () => removeLocalModuleRegistrationStatusChangedListener(callback);
-}
-
-function subscribeToRemoteModuleRegistrationStatusChanged(callback: () => void) {
-    addRemoteModuleRegistrationStatusChangedListener(callback);
-
-    return () => removeRemoteModuleRegistrationStatusChangedListener(callback);
+        return () => runtime.moduleManager.removeModulesReadyListener(callback);
+    };
 }
 
 export function useStrictRegistrationMode() {
     const runtime = useRuntime();
 
-    const localModuleStatus = useSyncExternalStore(subscribeToLocalModuleRegistrationStatusChanged, getLocalModuleRegistrationStatus);
-    const remoteModuleStatus = useSyncExternalStore(subscribeToRemoteModuleRegistrationStatusChanged, getRemoteModuleRegistrationStatus);
+    // This listener is only executed if the modules are ready.
+    const areModulesReady = useSyncExternalStore(subscribeToModulesReady(runtime), () => runtime.moduleManager.getAreModulesReady());
 
     useEffect(() => {
-        if (areModulesReady(localModuleStatus, remoteModuleStatus)) {
+        if (areModulesReady) {
             runtime._validateRegistrations();
         }
-    }, [runtime, localModuleStatus, remoteModuleStatus]);
+    }, [runtime, areModulesReady]);
 }

package/src/useUpdateDeferredRegistrations.ts

@@ -1,16 +1,22 @@
 import type { Runtime } from "@squide/core";
-import { updateDeferredRegistrations } from "@squide/module-federation";
 import { useCallback } from "react";
 import { useAppRouterDispatcher } from "./AppRouterContext.ts";
 
+export const DeferredRegistrationsUpdateStartedEvent = "squide-deferred-registrations-update-started";
+export const DeferredRegistrationsUpdateCompletedEvent = "squide-deferred-registrations-update-completed-started";
+
 export function useUpdateDeferredRegistrations() {
     const dispatch = useAppRouterDispatcher();
 
     return useCallback(async <TData = unknown, TRuntime extends Runtime = Runtime>(data: TData, runtime: TRuntime) => {
-        const errors = await updateDeferredRegistrations(data, runtime);
+        runtime.eventBus.dispatch(DeferredRegistrationsUpdateStartedEvent);
+
+        const errors = await runtime.moduleManager.updateDeferredRegistrations(data);
 
         dispatch({ type: "deferred-registrations-updated" });
 
+        runtime.eventBus.dispatch(DeferredRegistrationsUpdateCompletedEvent);
+
         return errors;
     }, [dispatch]);
 }