@superblocksteam/vite-plugin-file-sync 2.0.23 → 2.0.24-next.1

package/dist/file-sync-vite-plugin.js

@@ -76,60 +76,66 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
             if (aiService) {
                 aiService.setSourceTracker(fileSyncManager.getSourceTracker());
             }
-            server.middlewares.use(indexHtmlMiddleware(server));
+            server.middlewares.use((req, res, next) => {
+                void indexHtmlMiddleware(server)(req, res, next);
+            });
             server.middlewares.use("/sb-init", bodyParser.json({ strict: true }));
-            server.middlewares.use("/sb-init", async (req, res, next) => {
-                if (!isInitialized) {
-                    return next();
-                }
-                if (req.method !== "GET" && req.method !== "OPTIONS") {
-                    res.statusCode = 405;
-                    res.end("Method not allowed");
-                    return res.end();
-                }
-                res.setHeader("Access-Control-Allow-Origin", "*");
-                res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
-                res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-                if (req.method === "OPTIONS") {
-                    res.statusCode = 204;
-                    res.end();
-                    return;
-                }
-                const fullUrl = new URL(req.url ?? "/", "http://localhost:5173");
-                if (!fullUrl.searchParams.get("route")) {
-                    res.statusCode = 400;
-                    res.end("Missing route, use ?route=/route");
-                    return res.end();
-                }
-                const actualUrl = new URL(fullUrl.searchParams.get("route") ?? "/", fullUrl);
-                const files = await getAllApiDefinitions({
-                    rootDir: config.root,
-                    currentUrl: actualUrl.toString(),
-                });
-                res.setHeader("Content-Type", "application/json");
-                return res.end(JSON.stringify(files));
+            server.middlewares.use("/sb-init", (req, res, next) => {
+                void (async () => {
+                    if (!isInitialized) {
+                        return next();
+                    }
+                    if (req.method !== "GET" && req.method !== "OPTIONS") {
+                        res.statusCode = 405;
+                        res.end("Method not allowed");
+                        return res.end();
+                    }
+                    res.setHeader("Access-Control-Allow-Origin", "*");
+                    res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+                    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+                    if (req.method === "OPTIONS") {
+                        res.statusCode = 204;
+                        res.end();
+                        return;
+                    }
+                    const fullUrl = new URL(req.url ?? "/", "http://localhost:5173");
+                    if (!fullUrl.searchParams.get("route")) {
+                        res.statusCode = 400;
+                        res.end("Missing route, use ?route=/route");
+                        return res.end();
+                    }
+                    const actualUrl = new URL(fullUrl.searchParams.get("route") ?? "/", fullUrl);
+                    const files = await getAllApiDefinitions({
+                        rootDir: config.root,
+                        currentUrl: actualUrl.toString(),
+                    });
+                    res.setHeader("Content-Type", "application/json");
+                    return res.end(JSON.stringify(files));
+                })();
             });
             server.middlewares.use("/sb-scopes", bodyParser.json({ strict: true }));
-            server.middlewares.use("/sb-scopes", async (req, res, next) => {
-                if (!isInitialized) {
-                    return next();
-                }
-                if (req.method !== "GET" && req.method !== "OPTIONS") {
-                    res.statusCode = 405;
-                    res.end("Method not allowed");
-                    return res.end();
-                }
-                res.setHeader("Access-Control-Allow-Origin", "*");
-                res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
-                res.setHeader("Access-Control-Allow-Headers", "Content-Type");
-                if (req.method === "OPTIONS") {
-                    res.statusCode = 204;
-                    res.end();
-                    return;
-                }
-                const appScope = await getAppScope(fileSyncManager);
-                res.setHeader("Content-Type", "application/json");
-                return res.end(JSON.stringify(appScope));
+            server.middlewares.use("/sb-scopes", (req, res, next) => {
+                void (async () => {
+                    if (!isInitialized) {
+                        return next();
+                    }
+                    if (req.method !== "GET" && req.method !== "OPTIONS") {
+                        res.statusCode = 405;
+                        res.end("Method not allowed");
+                        return res.end();
+                    }
+                    res.setHeader("Access-Control-Allow-Origin", "*");
+                    res.setHeader("Access-Control-Allow-Methods", "GET, OPTIONS");
+                    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+                    if (req.method === "OPTIONS") {
+                        res.statusCode = 204;
+                        res.end();
+                        return;
+                    }
+                    const appScope = await getAppScope(fileSyncManager);
+                    res.setHeader("Content-Type", "application/json");
+                    return res.end(JSON.stringify(appScope));
+                })();
             });
             const socketManager = createSocketManager(pluginParams.tracer);
             socketManager.startSocketServer({
@@ -143,7 +149,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
             });
             socketManager.removeAllListeners();
             const sendError = (errorEvent) => {
-                socketManager.callEditorClients((socket) => socket.call.error(errorEvent));
+                void socketManager.callEditorClients((socket) => socket.call.error(errorEvent));
             };
             // Add some process error handling to ensure to notify the user of
             // any uncaught exceptions or rejections
@@ -164,16 +170,18 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
             lockService?.removeListener?.("error", sendError);
             lockService?.on?.("error", sendError);
             syncService?.on?.("degradedModeChange", (degradedMode) => {
-                socketManager.callEditorClients((socket) => {
-                    return socket.call.setDegradedMode({ degradedMode });
-                });
+                void (async () => {
+                    void socketManager.callEditorClients((socket) => {
+                        return socket.call.setDegradedMode({ degradedMode });
+                    });
+                })();
             });
             const extractApiParamsAndDependencies = (socket) => {
                 const allApis = fileSyncManager.getApiFiles();
                 // If we do not have any APIs, we can mark the apis as loaded immediately
                 // to trigger side effects like page load events
                 if (Object.keys(allApis).length === 0) {
-                    socket.call.setApisLoaded();
+                    void socket.call.setApisLoaded();
                     return;
                 }
                 const allApiNames = Object.values(allApis).map(({ api }) => api.apiPb.metadata.name);
@@ -196,22 +204,24 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                         });
                     }),
                 ]).then(() => {
-                    socketManager.callEditorClients((editorClientSocket) => {
+                    void socketManager.callEditorClients((editorClientSocket) => {
                         return editorClientSocket.call.setApiDependencies({
                             apiDependencies: apiDependencyMap,
                         });
                     });
                 });
             };
-            socketManager.on("connect:library", async (socket) => {
-                const allApis = fileSyncManager.getApiFiles();
-                socket.call
-                    .setApiDefinitions(allApis)
-                    .then(() => extractApiParamsAndDependencies(socket));
-                const tsFilePaths = fileSyncManager.getTsFilePaths();
-                return socket.call.updateLocalBindingEntities({
-                    entities: Array.from(new Set(tsFilePaths.flatMap((file) => fileSyncManager.getLocalBindingEntities(file)))),
-                });
+            socketManager.on("connect:library", (socket) => {
+                void (async () => {
+                    const allApis = fileSyncManager.getApiFiles();
+                    void socket.call
+                        .setApiDefinitions(allApis)
+                        .then(() => extractApiParamsAndDependencies(socket));
+                    const tsFilePaths = fileSyncManager.getTsFilePaths();
+                    void socket.call.updateLocalBindingEntities({
+                        entities: Array.from(new Set(tsFilePaths.flatMap((file) => fileSyncManager.getLocalBindingEntities(file)))),
+                    });
+                })();
             });
             const sendRootUpdate = async (path, sync = false) => {
                 const roots = fileSyncManager.getPageRoots(path);
@@ -221,7 +231,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                     return;
                 }
                 const { scopeId } = scope;
-                socketManager.callEditorClients((socket) => {
+                void socketManager.callEditorClients((socket) => {
                     return socket.call.updateScope({
                         scopeId,
                         updates: { roots },
@@ -236,7 +246,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                     update.type !== "editor:setProperties");
                 if (shouldSendRootUpdate) {
                     paths.forEach((path) => {
-                        sendRootUpdate(path);
+                        void sendRootUpdate(path);
                     });
                 }
                 if (syncService) {
@@ -245,7 +255,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
             };
             const sendRootReset = async (sync = false) => {
                 const appScope = await getAppScope(fileSyncManager);
-                socketManager.callEditorClients((socket) => {
+                void socketManager.callEditorClients((socket) => {
                     return socket.call.resetScope({
                         appScope,
                     });
@@ -260,7 +270,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                 const entities = scope?.entities ?? {};
                 const scopeId = scope?.scopeId ?? "";
                 const roots = fileSyncManager.getPageRoots(path);
-                socketManager.callEditorClients((socket) => socket.call.updateScope({
+                void socketManager.callEditorClients((socket) => socket.call.updateScope({
                     scopeId,
                     updates: { entities, roots: roots ?? undefined },
                 }));
@@ -272,7 +282,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                     return;
                 }
                 await sendRootUpdate(path);
-                socketManager.callLibraryClients((socket) => {
+                void socketManager.callLibraryClients((socket) => {
                     return socket.call.deleteEntities(sourceIds.map((sourceId) => ({
                         scopeId: scope.scopeId,
                         sourceId,
@@ -287,7 +297,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                 }
                 const { scopeId } = scope;
                 sendEntityUpdate(path, undefined, true);
-                socketManager.callLibraryClients((socket) => {
+                void socketManager.callLibraryClients((socket) => {
                     return socket.call.deleteEntities([
                         {
                             scopeId,
@@ -337,97 +347,131 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
             // configured twice otherwise, always remove all listeners
             fileSyncManager.removeAllListeners();
             fileSyncManager.on("error", sendError);
-            fileSyncManager.on("reparent", sendRootUpdate);
-            fileSyncManager.on("batchUpdate", sendMultiRootUpdate);
-            fileSyncManager.on("createComponent", sendRootUpdate);
-            fileSyncManager.on("deleteComponents", sendDeleteComponentsUpdate);
-            fileSyncManager.on("addEntity", sendEntityUpdate);
-            fileSyncManager.on("updateEntity", sendEntityUpdate);
-            fileSyncManager.on("deleteEntity", sendDeleteEntityUpdate);
-            fileSyncManager.on("renameComponent", sendFileUpdate);
-            fileSyncManager.on("renameEntity", sendFileUpdate);
-            fileSyncManager.on("addPage", () => sendRootReset(true));
-            fileSyncManager.on("deletePage", () => sendRootReset(true));
-            fileSyncManager.on("renamePage", () => sendRootReset(true));
+            fileSyncManager.on("reparent", (path) => {
+                void sendRootUpdate(path);
+            });
+            fileSyncManager.on("batchUpdate", (paths, payload) => {
+                void sendMultiRootUpdate(paths, payload);
+            });
+            fileSyncManager.on("createComponent", (path) => {
+                void sendRootUpdate(path);
+            });
+            fileSyncManager.on("deleteComponents", (path, sourceIds) => {
+                void sendDeleteComponentsUpdate(path, sourceIds);
+            });
+            fileSyncManager.on("addEntity", (path, request) => {
+                void sendEntityUpdate(path, request);
+            });
+            fileSyncManager.on("updateEntity", (path, request) => {
+                void sendEntityUpdate(path, request);
+            });
+            fileSyncManager.on("deleteEntity", (path, entityName) => {
+                void sendDeleteEntityUpdate(path, entityName);
+            });
+            fileSyncManager.on("renameComponent", (path) => {
+                void sendFileUpdate(path);
+            });
+            fileSyncManager.on("renameEntity", (path) => {
+                void sendFileUpdate(path);
+            });
+            fileSyncManager.on("addPage", () => {
+                void sendRootReset(true);
+            });
+            fileSyncManager.on("deletePage", () => {
+                void sendRootReset(true);
+            });
+            fileSyncManager.on("renamePage", () => {
+                void sendRootReset(true);
+            });
             if (aiService) {
-                fileSyncManager.on("fileChanged", debounce(async () => {
-                    const appScope = await getAppScope(fileSyncManager);
-                    aiService.appContext.handleAppScopeReset(appScope);
+                fileSyncManager.on("fileChanged", debounce(() => {
+                    void (async () => {
+                        const appScope = await getAppScope(fileSyncManager);
+                        void aiService.appContext.handleAppScopeReset(appScope);
+                    })();
                 }, 1000));
             }
-            fileSyncManager.on("fileChanged", async (path, _content, isNonVisualEdit) => {
-                socketManager.callLibraryClients((socket) => {
-                    return socket.call.updateLocalBindingEntities({
-                        entities: fileSyncManager.getLocalBindingEntities(path),
-                    });
-                });
-                if (isNonVisualEdit) {
-                    sendFileUpdate(path);
-                    socketManager.callLibraryClients((socket) => {
-                        return socket.call.nonVisualEdit();
+            fileSyncManager.on("fileChanged", (path, _content, isNonVisualEdit) => {
+                void (async () => {
+                    void socketManager.callLibraryClients((socket) => {
+                        return socket.call.updateLocalBindingEntities({
+                            entities: fileSyncManager.getLocalBindingEntities(path),
+                        });
                     });
-                }
-                if (syncService) {
-                    await syncService.uploadDirectory();
-                }
+                    if (isNonVisualEdit) {
+                        void sendFileUpdate(path);
+                        void socketManager.callLibraryClients((socket) => {
+                            return socket.call.nonVisualEdit();
+                        });
+                    }
+                    if (syncService) {
+                        await syncService.uploadDirectory();
+                    }
+                })();
             });
-            fileSyncManager.on("apiUpdate", async (payload) => {
-                socketManager.callLibraryClients(async (socket) => {
-                    Promise.all([
-                        socket.call.updateApi(payload),
-                        extractApiParamsAndDependencies(socket),
-                    ]);
-                });
-                if (payload.api.pageName) {
-                    const pagePath = getPageFilePath(config.root, payload.api.pageName);
-                    sendEntityUpdate(pagePath);
-                }
-                if (syncService) {
-                    await syncService.uploadDirectory();
-                }
-                if (aiService) {
-                    aiService.appContext.handleApiUpdate(toApiV3Dto(payload.api));
-                }
+            fileSyncManager.on("apiUpdate", (payload) => {
+                void (async () => {
+                    void socketManager.callLibraryClients(async (socket) => {
+                        void Promise.all([
+                            socket.call.updateApi(payload),
+                            extractApiParamsAndDependencies(socket),
+                        ]);
+                    });
+                    if (payload.api.pageName) {
+                        const pagePath = getPageFilePath(config.root, payload.api.pageName);
+                        void sendEntityUpdate(pagePath);
+                    }
+                    if (syncService) {
+                        await syncService.uploadDirectory();
+                    }
+                    if (aiService) {
+                        void aiService.appContext.handleApiUpdate(toApiV3Dto(payload.api));
+                    }
+                })();
             });
-            fileSyncManager.on("apiManualUpdate", async (payload, sendScopeUpdates = false) => {
-                socketManager.callLibraryClients(async (socket) => {
-                    Promise.all([
-                        socket.call.updateApi(payload),
-                        extractApiParamsAndDependencies(socket),
-                    ]);
-                });
-                if (sendScopeUpdates) {
-                    sendFileUpdate(getPageFilePath(config.root, payload.api.pageName));
-                }
-                if (syncService) {
-                    await syncService.uploadDirectory();
-                }
-                socketManager.callEditorClients((socket) => {
-                    return socket.call.manualUpdateApi({
-                        api: payload.api,
+            fileSyncManager.on("apiManualUpdate", (payload, sendScopeUpdates = false) => {
+                void (async () => {
+                    void socketManager.callLibraryClients(async (socket) => {
+                        void Promise.all([
+                            socket.call.updateApi(payload),
+                            extractApiParamsAndDependencies(socket),
+                        ]);
                     });
-                });
-                if (aiService) {
-                    aiService.appContext.handleApiUpdate(toApiV3Dto(payload.api));
-                }
+                    if (sendScopeUpdates) {
+                        void sendFileUpdate(getPageFilePath(config.root, payload.api.pageName));
+                    }
+                    if (syncService) {
+                        await syncService.uploadDirectory();
+                    }
+                    void socketManager.callEditorClients((socket) => {
+                        return socket.call.manualUpdateApi({
+                            api: payload.api,
+                        });
+                    });
+                    if (aiService) {
+                        void aiService.appContext.handleApiUpdate(toApiV3Dto(payload.api));
+                    }
+                })();
             });
             if (syncService) {
-                syncService.on("synchronizationStatusChange", async (status, generationNumber) => {
-                    socketManager.callEditorClients(async (socket) => {
-                        try {
-                            await socket.call.syncStatus({ status, generationNumber });
-                        }
-                        catch (err) {
-                            logger.error("Failed to send syncStatus", getErrorMeta(err));
-                        }
-                    });
+                syncService.on("synchronizationStatusChange", (status, generationNumber) => {
+                    void (async () => {
+                        void socketManager.callEditorClients(async (socket) => {
+                            try {
+                                await socket.call.syncStatus({ status, generationNumber });
+                            }
+                            catch (err) {
+                                logger.error("Failed to send syncStatus", getErrorMeta(err));
+                            }
+                        });
+                    })();
                 });
             }
             if (lockService) {
                 lockService.on("statusChange", (status) => {
                     if (status === LockServiceStatus.RELEASING ||
                         status === LockServiceStatus.LOCK_INVALID) {
-                        socketManager.callEditorClients(async (socket) => {
+                        void socketManager.callEditorClients(async (socket) => {
                             try {
                                 await socket.call.releasingLock();
                             }
@@ -438,7 +482,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                     }
                 });
                 lockService.on("closedByServer", (data) => {
-                    socketManager.callEditorClients(async (socket) => {
+                    void socketManager.callEditorClients(async (socket) => {
                         try {
                             await socket.call.closedByServer(data);
                         }
@@ -448,96 +492,110 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                     });
                 });
             }
-            fileSyncManager.on("routesChanged", async () => {
-                const rootId = normalizePath(path.join(config.root, "root.tsx"));
-                const module = server.moduleGraph.getModuleById(rootId);
-                // for root.tsx
-                if (module) {
-                    // trigger transform() hook
-                    server.moduleGraph.invalidateModule(module);
-                    // trigger hot module reload
-                    await server.reloadModule(module);
-                }
+            fileSyncManager.on("routesChanged", () => {
+                void (async () => {
+                    const rootId = normalizePath(path.join(config.root, "root.tsx"));
+                    const module = server.moduleGraph.getModuleById(rootId);
+                    // for root.tsx
+                    if (module) {
+                        // trigger transform() hook
+                        server.moduleGraph.invalidateModule(module);
+                        // trigger hot module reload
+                        await server.reloadModule(module);
+                    }
+                })();
             });
-            fileSyncManager.on("apiDelete", async (payload) => {
-                socketManager.callLibraryClients(async (socket) => {
-                    Promise.all([
-                        socket.call.deleteApis(payload.apis.map((api) => ({
-                            apiName: api.apiName,
-                            scopeId: api.scopeId,
-                        }))),
-                        extractApiParamsAndDependencies(socket),
-                    ]);
-                    // All APIs should belong to the same page but to be consistant we iterate over all APIs
-                    const pageNames = new Set(payload.apis.map((api) => api.pageName));
-                    if (pageNames.size > 0) {
-                        pageNames.forEach((pageName) => {
-                            const pagePath = getPageFilePath(config.root, pageName);
-                            sendFileUpdate(pagePath);
-                        });
+            fileSyncManager.on("apiDelete", (payload) => {
+                void (async () => {
+                    void socketManager.callLibraryClients(async (socket) => {
+                        void Promise.all([
+                            socket.call.deleteApis(payload.apis.map((api) => ({
+                                apiName: api.apiName,
+                                scopeId: api.scopeId,
+                            }))),
+                            extractApiParamsAndDependencies(socket),
+                        ]);
+                        // All APIs should belong to the same page but to be consistant we iterate over all APIs
+                        const pageNames = new Set(payload.apis.map((api) => api.pageName));
+                        if (pageNames.size > 0) {
+                            pageNames.forEach((pageName) => {
+                                const pagePath = getPageFilePath(config.root, pageName);
+                                void sendFileUpdate(pagePath);
+                            });
+                        }
+                        if (syncService) {
+                            await syncService.uploadDirectory();
+                        }
+                    });
+                    if (aiService) {
+                        for (const api of payload.apis) {
+                            void aiService.appContext.handleApiDelete(api.apiName);
+                        }
                     }
+                })();
+            });
+            fileSyncManager.on("apiManualDelete", (payload) => {
+                void (async () => {
+                    void socketManager.callLibraryClients(async (socket) => {
+                        void Promise.all([
+                            socket.call.deleteApis([
+                                {
+                                    apiName: payload.api.apiName,
+                                    scopeId: payload.api.scopeId,
+                                },
+                            ]),
+                            extractApiParamsAndDependencies(socket),
+                        ]);
+                        const pagePath = getPageFilePath(config.root, payload.api.pageName);
+                        void sendFileUpdate(pagePath);
+                    });
+                    void socketManager.callEditorClients((socket) => {
+                        return socket.call.manualDeleteApi({
+                            id: payload.api.id,
+                        });
+                    });
                     if (syncService) {
                         await syncService.uploadDirectory();
                     }
-                });
-                if (aiService) {
-                    for (const api of payload.apis) {
-                        aiService.appContext.handleApiDelete(api.apiName);
+                    if (aiService) {
+                        void aiService.appContext.handleApiDelete(payload.api.apiName);
                     }
-                }
-            });
-            fileSyncManager.on("apiManualDelete", async (payload) => {
-                socketManager.callLibraryClients(async (socket) => {
-                    Promise.all([
-                        socket.call.deleteApis([
-                            {
-                                apiName: payload.api.apiName,
-                                scopeId: payload.api.scopeId,
-                            },
-                        ]),
-                        extractApiParamsAndDependencies(socket),
-                    ]);
-                    const pagePath = getPageFilePath(config.root, payload.api.pageName);
-                    sendFileUpdate(pagePath);
-                });
-                socketManager.callEditorClients((socket) => {
-                    return socket.call.manualDeleteApi({
-                        id: payload.api.id,
-                    });
-                });
-                if (syncService) {
-                    await syncService.uploadDirectory();
-                }
-                if (aiService) {
-                    aiService.appContext.handleApiDelete(payload.api.apiName);
-                }
+                })();
             });
             if (syncService && aiService) {
-                socketManager.on("connect:editor", async (socket) => {
-                    const hasDraft = await syncService.hasLocalDraftChanges();
-                    return socket.call.aiSetDraftState({ hasDraft });
+                socketManager.on("connect:editor", (socket) => {
+                    void (async () => {
+                        const hasDraft = await syncService.hasLocalDraftChanges();
+                        return socket.call.aiSetDraftState({ hasDraft });
+                    })();
                 });
                 syncService.on("draftStateChanged", (hasDraft) => {
-                    socketManager.callEditorClients((socket) => {
-                        return socket.call.aiSetDraftState({ hasDraft });
-                    });
+                    void (async () => {
+                        void socketManager.callEditorClients((socket) => {
+                            return socket.call.aiSetDraftState({ hasDraft });
+                        });
+                    })();
                 });
                 aiService.on("generationStarted", () => {
                     fileSyncManager.enableOperationsQueue();
                 });
-                aiService.on("generationCompleted", async (hasDraft, useFullReload) => {
-                    fileSyncManager.disableOperationsQueue();
-                    await fileSyncManager.flushOperations();
-                    if (hasDraft && useFullReload) {
-                        // we have been deferring hot updates; trigger a reload to render the ai draft
-                        logger.info("Requesting full reload to render AI draft");
-                        server.ws.send({
-                            type: "full-reload",
-                        });
-                    }
+                aiService.on("generationCompleted", (hasDraft, useFullReload) => {
+                    void (async () => {
+                        fileSyncManager.disableOperationsQueue();
+                        await fileSyncManager.flushOperations();
+                        if (hasDraft && useFullReload) {
+                            // we have been deferring hot updates; trigger a reload to render the ai draft
+                            logger.info("Requesting full reload to render AI draft");
+                            server.ws.send({
+                                type: "full-reload",
+                            });
+                        }
+                    })();
                 });
                 const appScope = await getAppScope(fileSyncManager);
-                aiService.appContext.handleAppScopeReset(appScope);
+                void (async () => {
+                    void aiService.appContext.handleAppScopeReset(appScope);
+                })();
                 // capture vite error logging
                 const originalErrorLogger = config.logger.error;
                 config.logger.error = (...args) => {
@@ -554,7 +612,7 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
                         else {
                             error = new Error(message);
                         }
-                        aiService.handleBuildSystemError(error);
+                        void aiService.handleBuildSystemError(error);
                     }
                     return originalErrorLogger.apply(config.logger, args);
                 };
@@ -562,29 +620,31 @@ export const fileSyncVitePlugin = (pluginParams, options) => {
             const triggerRegisteredComponentUpdate = () => {
                 const module = server.moduleGraph.getModuleById(resolvedVirtualRegisteredComponentsId);
                 if (module) {
-                    server.reloadModule(module);
+                    void server.reloadModule(module);
                 }
             };
             componentsManager.on("error", sendError);
             componentsManager.on("registeredComponentAdded", triggerRegisteredComponentUpdate);
             componentsManager.on("registeredComponentRemoved", (name) => {
                 triggerRegisteredComponentUpdate();
-                socketManager.callLibraryClients((socket) => {
+                void socketManager.callLibraryClients((socket) => {
                     return socket.call.removeRegisteredComponent({
                         name,
                     });
                 });
             });
-            componentsManager.on("registeredComponentChanged", async (name, oldName) => {
-                triggerRegisteredComponentUpdate();
-                if (oldName) {
-                    socketManager.callLibraryClients(async (socket) => {
-                        await socket.call.renameRegisteredComponent({
-                            name,
-                            oldName,
+            componentsManager.on("registeredComponentChanged", (name, oldName) => {
+                void (async () => {
+                    triggerRegisteredComponentUpdate();
+                    if (oldName) {
+                        void socketManager.callLibraryClients(async (socket) => {
+                            await socket.call.renameRegisteredComponent({
+                                name,
+                                oldName,
+                            });
                         });
-                    });
-                }
+                    }
+                })();
             });
         },
         async transform(code, id) {