@moostjs/vite 0.6.36 → 0.6.38

package/dist/index.cjs

@@ -249,19 +249,63 @@ function _define_property(obj, key, value) {
 * A reference to a shared LogsStorage instance that persists
 * across init cycles in dev mode.
 */ let logsStorage;
+/** Whether {@link patchMoostHandlerLogging} already installed its wrappers in this process. */ let installed = false;
 /**
-* Patches Moost’s .init() and .logMappedHandler() methods so that, during dev:
+* The slot {@link captureMoostInit} fills: receives every `init()` promise the
+* wrapper below produces. Unset in prod/test, where nothing consumes a capture.
+*/ let onInitCaptured;
+/**
+* Hands every `Moost.prototype.init()` promise to `onCapture`, letting a boot
+* await the app's **initialization** instead of only its module evaluation.
+*
+* The documented entry shape is `app.adapter(http).listen(port)` followed by an
+* **un-awaited** `app.init()`: the HTTP middleware is therefore captured *before*
+* init finishes, and nothing else observes a rejecting init — a bind error, a DI
+* audit error or a throwing `@MoostInit` hook would leave the dev server serving
+* a half-booted app (the routes bound before the failure answer 200, the rest
+* fall through to the SPA fallback) instead of the plugin's 502. That is also
+* why the plugin's `bootError` gate runs BEFORE the captured middleware, and why
+* the SSR fallback checks it too: `listen()` ran first and left both a middleware
+* and the local-fetch hook behind.
+*
+* Patches the plugin's **own** `moost` import, exactly like the handler logging
+* does: in dev the runtime is externalized, so the plugin and the app share one
+* native `moost` instance (the premise the DI eject in `restart-cleanup` rests on
+* too, and what `ssrExternalCheck` warns about when it stops holding). Unlike the
+* adapters there is nothing to re-establish per reload — a static import is never
+* re-evaluated — and unlike them it must NOT be pulled through the SSR module
+* runner: importing `moost` there registers it as the runner's first module and
+* makes subsequent hot updates re-evaluate the entry only, serving every one of
+* its dependencies (controllers included) from the stale cache.
+*
+* There is exactly ONE `init` wrapper per process (installed by
+* {@link patchMoostHandlerLogging}) and this only fills its slot, so the newest
+* plugin instance wins: Vite re-imports the config on every config-file
+* `server.restart()`, re-running the plugin factory, and a per-instance wrapper
+* would stack on the previous one and keep the dead instance's scope alive.
+*
+* @param onCapture receives each captured init promise (already marked handled).
+*/ function captureMoostInit(onCapture) {
+	onInitCaptured = onCapture;
+}
+/**
+* Patches Moost’s .init() and .logMappedHandler() methods — once per process —
+* so that, during dev:
 * - Only newly added handlers are logged normally.
 * - Removed handlers are logged/stroked out to indicate removal.
 * - Prevents repeated logs from flooding the console across multiple hot reloads.
+* - Every init() promise reaches the {@link captureMoostInit} slot, if filled.
 */ function patchMoostHandlerLogging() {
+	if (installed) return;
+	installed = true;
 	const origInit = moost.Moost.prototype.init;
+	const origLogMappedHandler = moost.Moost.prototype.logMappedHandler;
 	/**
-	* Monkey-patch Moost.init:
+	* The logging body of the patched Moost.init:
 	* 1. Start a new recording cycle in LogsStorage.
 	* 2. Call the real .init().
 	* 3. End the recording, logging any removed handlers.
-	*/ moost.Moost.prototype.init = async function init() {
+	*/ const initWithLogging = async function() {
 		if (!logsStorage) logsStorage = new LogsStorage();
 		logsStorage.startRecording();
 		await origInit.call(this);
@@ -269,7 +313,14 @@ function _define_property(obj, key, value) {
 			origLogMappedHandler.call(this, item.eventName, item.classConstructor, item.method, true, "❌ ");
 		});
 	};
-	const origLogMappedHandler = moost.Moost.prototype.logMappedHandler;
+	moost.Moost.prototype.init = function init() {
+		const promise = initWithLogging.call(this);
+		if (onInitCaptured) {
+			promise.catch(() => {});
+			onInitCaptured(promise);
+		}
+		return promise;
+	};
 	/**
 	* Monkey-patch Moost.logMappedHandler:
 	* If we haven’t seen this particular route+class+method combination
@@ -289,7 +340,7 @@ function _define_property(obj, key, value) {
 /**
 * Clean up Moost’s global containers and optionally remove specific instances from the registry.
 *
-* Every instance actually removed from a registry is **disposed** before the
+* Every instance actually removed from the registry is **disposed** before the
 * caches are dropped: its `@MoostDispose` hooks (or `Symbol.asyncDispose` /
 * `Symbol.dispose`) are awaited, so a singleton owning a connection, consumer,
 * timer or file handle releases it instead of leaking one copy per reload. An
@@ -298,46 +349,25 @@ function _define_property(obj, key, value) {
 *
 * @param {Set<string>} [cleanupInstances] A set of module IDs to remove from the registry.
 * @returns the instances that were ejected (and therefore disposed)
-*/ async function moostRestartCleanup(adapters, onEject, cleanupInstances) {
+*/ async function moostRestartCleanup(onEject, cleanupInstances) {
 	const logger = getLogger();
 	const infact = (0, moost.getMoostInfact)();
-	const { registry, scopes } = infact;
-	const registries = [registry, ...Object.values(scopes)];
+	const { registry } = infact;
 	infact._cleanup();
 	const mate = (0, moost.getMoostMate)();
-	/** Instances removed from a registry by this run — disposed below, before the caches drop. */ const ejected = [];
+	/** Instances removed from the registry by this run — disposed below, before the caches drop. */ const ejected = [];
 	if (cleanupInstances) {
-		for (const reg of registries) {
-			for (const key of Object.getOwnPropertySymbols(reg)) {
-				const instance = reg[key];
-				const viteId = mate.read(instance)?.__vite_id;
-				if (viteId && cleanupInstances.has(viteId)) {
-					logger.debug(`🔃 Replacing "${constructorName(instance)}"`);
-					delete reg[key];
-					ejected.push(instance);
-				}
-			}
-			for (const key of Object.getOwnPropertySymbols(reg)) {
-				const instance = reg[key];
-				scanParams(instance, (type) => {
-					if ((type === moost.Moost || type instanceof moost.Moost || type.prototype instanceof moost.Moost) && (!onEject || onEject(instance, type))) {
-						delete reg[key];
-						ejected.push(instance);
-						logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on re-instantiated "Moost")`);
-						return true;
-					}
-					for (const adapter of adapters) if (adapter.compare(type) && (!onEject || onEject(instance, type))) {
-						delete reg[key];
-						ejected.push(instance);
-						logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on re-instantiated "${adapter.constructor.name}")`);
-						return true;
-					}
-				});
+		for (const key of Object.getOwnPropertySymbols(registry)) {
+			const instance = registry[key];
+			const viteId = mate.read(instance)?.__vite_id;
+			if (viteId && cleanupInstances.has(viteId)) {
+				logger.debug(`🔃 Replacing "${constructorName(instance)}"`);
+				delete registry[key];
+				ejected.push(instance);
 			}
-			clearDependantRegistry(reg, onEject, ejected);
 		}
+		clearDependantRegistry(registry, onEject, ejected);
 		infact.registry = registry;
-		infact.scopes = scopes;
 	}
 	await disposeEjected(ejected);
 	(0, moost.getMoostMate)()._cleanup();
@@ -354,19 +384,21 @@ function _define_property(obj, key, value) {
 	for (const instance of disposed) logger.debug(`♻️  Disposed "${constructorName(instance)}"`);
 	for (const e of errors) logger.warn(`⚠️  Dispose hook "${constructorName(e.instance)}.${String(e.method)}" failed — the reload continues`);
 }
-function clearDependantRegistry(registry, onEject, ejected) {
+/**
+* Ejects, to a fixed point, every instance whose constructor dependency is not
+* in the registry: an instance ejected in one pass ejects its consumers in the
+* next (Moost → Database → Repository → Worker loses the whole chain). An
+* `onEject` veto keeps the instance present, and with it its consumers.
+*/ function clearDependantRegistry(registry, onEject, ejected) {
 	const logger = getLogger();
-	const objSet = /* @__PURE__ */ new Set();
 	let somethingIsDeleted = true;
 	while (somethingIsDeleted) {
 		somethingIsDeleted = false;
-		for (const key of Object.getOwnPropertySymbols(registry)) {
+		const keys = Object.getOwnPropertySymbols(registry);
+		const present = new Set(keys.map((key) => registry[key].constructor));
+		for (const key of keys) {
 			const instance = registry[key];
-			objSet.add(Object.getPrototypeOf(instance).constructor);
-		}
-		for (const key of Object.getOwnPropertySymbols(registry)) {
-			const instance = registry[key];
-			if (checkAndEject(instance, objSet, onEject, registry, key, logger)) {
+			if (checkAndEject(instance, present, onEject, registry, key, logger)) {
 				ejected.push(instance);
 				somethingIsDeleted = true;
 			}
@@ -378,7 +410,7 @@ function checkAndEject(instance, objSet, onEject, registry, key, logger) {
 	scanParams(instance, (type) => {
 		if (!objSet.has(type) && (!onEject || onEject(instance, type))) {
 			delete registry[key];
-			logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on "${type.name}" which is not in registry)`);
+			logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on "${type.name}", rebuilt by this reload)`);
 			ejected = true;
 			return true;
 		}
@@ -643,6 +675,11 @@ function moostVite(options) {
 	*/ let bootGeneration = 0;
 	let bootingGeneration = 0;
 	/** Whether the HTTP listen() patch has ever captured a middleware (i.e. this is an HTTP app). */ let httpCaptured = false;
+	/**
+	* The `app.init()` promises the current boot handed us (see `captureMoostInit`) —
+	* several when one entry boots several apps, none for a boot that never calls
+	* `init()`. Reset by `beginBoot()`, consumed by `settleBootInit()`.
+	*/ let bootInitPromises = [];
 	/** Module IDs awaiting DI cleanup — consumed in runReload; see ejectApp. */ let pendingCleanup = null;
 	/** In middleware mode: maps req → next() for the onNoMatch callback */ const pendingNextMap = /* @__PURE__ */ new WeakMap();
 	const adapters = isTest ? [] : [
@@ -712,6 +749,41 @@ function moostVite(options) {
 		reloadRequired = true;
 	};
 	patchMoostHandlerLogging();
+	if (!isTest && !isProd) captureMoostInit((promise) => {
+		if (bootingGeneration !== bootGeneration) {
+			logger.error(`⚠️  A stale Moost boot called init() (boot generation ${bootingGeneration}, latest ${bootGeneration}) — an HMR reload race; a follow-up reload will replace it.`);
+			return;
+		}
+		bootInitPromises.push(promise);
+	});
+	/** Marks the boot about to run as authoritative for the current generation. */ const beginBoot = () => {
+		bootingGeneration = bootGeneration;
+		bootInitPromises = [];
+	};
+	/**
+	* Finishes a boot: awaits the `init()` promise(s) the entry that just executed
+	* handed us, so the boot is only "done" once the app is fully initialized —
+	* every controller bound, every `@MoostInit` hook run (see `captureMoostInit`).
+	* Owns `bootError`: cleared on success, set and logged when an init rejected;
+	* returns whether the boot succeeded.
+	*/ const settleBootInit = async () => {
+		const initPromises = bootInitPromises;
+		bootInitPromises = [];
+		try {
+			await Promise.all(initPromises);
+			bootError = null;
+			return true;
+		} catch (error) {
+			bootError = error;
+			logger.error(`✖️  Moost app init failed: ${error.message}`);
+			return false;
+		}
+	};
+	/** Answers a request while `bootError` is set (see the gate in configureServer). */ const answerBootError = (res) => {
+		res.statusCode = 502;
+		res.setHeader("Content-Type", "text/plain");
+		res.end(`Moost app failed to load: ${bootError.message}`);
+	};
 	/** Set by the middleware-mode `config` hook: the consumer externalized the runtime themselves. */ let runtimeExternalized = false;
 	let resolvedConfig;
 	const pluginConfig = {
@@ -875,7 +947,7 @@ function moostVite(options) {
 			reloadRequired = false;
 			reloadPromise = null;
 			pendingCleanup = null;
-			bootingGeneration = bootGeneration;
+			beginBoot();
 			const runReload = () => {
 				reloadRequired = false;
 				console.log();
@@ -883,16 +955,15 @@ function moostVite(options) {
 				console.log();
 				return (async () => {
 					try {
-						bootingGeneration = bootGeneration;
+						beginBoot();
 						const cleanupInstances = pendingCleanup ?? void 0;
 						pendingCleanup = null;
-						await moostRestartCleanup(adapters, options.onEject, cleanupInstances);
+						await moostRestartCleanup(options.onEject, cleanupInstances);
 						for (const adapter of adapters) if (adapter.detected) await adapter.init();
 						const entryModule = await getEntryModule(server.environments.ssr.moduleGraph);
 						if (entryModule?.transformResult) server.environments.ssr.moduleGraph.invalidateModule(entryModule);
 						await ssrImport(options.entry);
-						bootError = null;
-						if (httpCaptured && !moostMiddleware) logger.error(`⚠️  Moost app reloaded but no HTTP middleware was captured — the entry did not re-run listen().`);
+						if (await settleBootInit() && httpCaptured && !moostMiddleware) logger.error(`⚠️  Moost app reloaded but no HTTP middleware was captured — the entry did not re-run listen().`);
 					} catch (error) {
 						bootError = error;
 						logger.error(`✖️  Failed to reload Moost App: ${error.message}`);
@@ -909,11 +980,16 @@ function moostVite(options) {
 				}
 			};
 			for (const adapter of adapters) adapter.ssrLoadModule = ssrImport;
-			await moostRestartCleanup(adapters, options.onEject);
+			await moostRestartCleanup(options.onEject);
 			await ssrImport(options.entry);
+			await settleBootInit();
 			server.middlewares.use(async (req, res, next) => {
 				await drainReload();
 				if (options.middleware && prefixes && !matchesPrefix(req.url || "", prefixes)) return next();
+				if (bootError) {
+					answerBootError(res);
+					return;
+				}
 				if (moostMiddleware) {
 					if (options.middleware) {
 						pendingNextMap.set(req, next);
@@ -922,12 +998,6 @@ function moostVite(options) {
 					}
 					return moostMiddleware(req, res);
 				}
-				if (bootError) {
-					res.statusCode = 502;
-					res.setHeader("Content-Type", "text/plain");
-					res.end(`Moost app failed to load: ${bootError.message}`);
-					return;
-				}
 				next();
 			});
 		},
@@ -967,6 +1037,10 @@ function moostVite(options) {
 					const url = req.originalUrl || req.url || "/";
 					try {
 						await drainReload();
+						if (bootError) {
+							answerBootError(res);
+							return;
+						}
 						let template = await fs.readFile((0, node_path.resolve)(server.config.root, "index.html"), "utf8");
 						template = await server.transformIndexHtml(url, template);
 						const { render } = await server.ssrLoadModule(options.ssrEntry);

package/dist/index.mjs

@@ -220,19 +220,63 @@ function _define_property(obj, key, value) {
 * A reference to a shared LogsStorage instance that persists
 * across init cycles in dev mode.
 */ let logsStorage;
+/** Whether {@link patchMoostHandlerLogging} already installed its wrappers in this process. */ let installed = false;
 /**
-* Patches Moost’s .init() and .logMappedHandler() methods so that, during dev:
+* The slot {@link captureMoostInit} fills: receives every `init()` promise the
+* wrapper below produces. Unset in prod/test, where nothing consumes a capture.
+*/ let onInitCaptured;
+/**
+* Hands every `Moost.prototype.init()` promise to `onCapture`, letting a boot
+* await the app's **initialization** instead of only its module evaluation.
+*
+* The documented entry shape is `app.adapter(http).listen(port)` followed by an
+* **un-awaited** `app.init()`: the HTTP middleware is therefore captured *before*
+* init finishes, and nothing else observes a rejecting init — a bind error, a DI
+* audit error or a throwing `@MoostInit` hook would leave the dev server serving
+* a half-booted app (the routes bound before the failure answer 200, the rest
+* fall through to the SPA fallback) instead of the plugin's 502. That is also
+* why the plugin's `bootError` gate runs BEFORE the captured middleware, and why
+* the SSR fallback checks it too: `listen()` ran first and left both a middleware
+* and the local-fetch hook behind.
+*
+* Patches the plugin's **own** `moost` import, exactly like the handler logging
+* does: in dev the runtime is externalized, so the plugin and the app share one
+* native `moost` instance (the premise the DI eject in `restart-cleanup` rests on
+* too, and what `ssrExternalCheck` warns about when it stops holding). Unlike the
+* adapters there is nothing to re-establish per reload — a static import is never
+* re-evaluated — and unlike them it must NOT be pulled through the SSR module
+* runner: importing `moost` there registers it as the runner's first module and
+* makes subsequent hot updates re-evaluate the entry only, serving every one of
+* its dependencies (controllers included) from the stale cache.
+*
+* There is exactly ONE `init` wrapper per process (installed by
+* {@link patchMoostHandlerLogging}) and this only fills its slot, so the newest
+* plugin instance wins: Vite re-imports the config on every config-file
+* `server.restart()`, re-running the plugin factory, and a per-instance wrapper
+* would stack on the previous one and keep the dead instance's scope alive.
+*
+* @param onCapture receives each captured init promise (already marked handled).
+*/ function captureMoostInit(onCapture) {
+	onInitCaptured = onCapture;
+}
+/**
+* Patches Moost’s .init() and .logMappedHandler() methods — once per process —
+* so that, during dev:
 * - Only newly added handlers are logged normally.
 * - Removed handlers are logged/stroked out to indicate removal.
 * - Prevents repeated logs from flooding the console across multiple hot reloads.
+* - Every init() promise reaches the {@link captureMoostInit} slot, if filled.
 */ function patchMoostHandlerLogging() {
+	if (installed) return;
+	installed = true;
 	const origInit = Moost.prototype.init;
+	const origLogMappedHandler = Moost.prototype.logMappedHandler;
 	/**
-	* Monkey-patch Moost.init:
+	* The logging body of the patched Moost.init:
 	* 1. Start a new recording cycle in LogsStorage.
 	* 2. Call the real .init().
 	* 3. End the recording, logging any removed handlers.
-	*/ Moost.prototype.init = async function init() {
+	*/ const initWithLogging = async function() {
 		if (!logsStorage) logsStorage = new LogsStorage();
 		logsStorage.startRecording();
 		await origInit.call(this);
@@ -240,7 +284,14 @@ function _define_property(obj, key, value) {
 			origLogMappedHandler.call(this, item.eventName, item.classConstructor, item.method, true, "❌ ");
 		});
 	};
-	const origLogMappedHandler = Moost.prototype.logMappedHandler;
+	Moost.prototype.init = function init() {
+		const promise = initWithLogging.call(this);
+		if (onInitCaptured) {
+			promise.catch(() => {});
+			onInitCaptured(promise);
+		}
+		return promise;
+	};
 	/**
 	* Monkey-patch Moost.logMappedHandler:
 	* If we haven’t seen this particular route+class+method combination
@@ -260,7 +311,7 @@ function _define_property(obj, key, value) {
 /**
 * Clean up Moost’s global containers and optionally remove specific instances from the registry.
 *
-* Every instance actually removed from a registry is **disposed** before the
+* Every instance actually removed from the registry is **disposed** before the
 * caches are dropped: its `@MoostDispose` hooks (or `Symbol.asyncDispose` /
 * `Symbol.dispose`) are awaited, so a singleton owning a connection, consumer,
 * timer or file handle releases it instead of leaking one copy per reload. An
@@ -269,46 +320,25 @@ function _define_property(obj, key, value) {
 *
 * @param {Set<string>} [cleanupInstances] A set of module IDs to remove from the registry.
 * @returns the instances that were ejected (and therefore disposed)
-*/ async function moostRestartCleanup(adapters, onEject, cleanupInstances) {
+*/ async function moostRestartCleanup(onEject, cleanupInstances) {
 	const logger = getLogger();
 	const infact = getMoostInfact();
-	const { registry, scopes } = infact;
-	const registries = [registry, ...Object.values(scopes)];
+	const { registry } = infact;
 	infact._cleanup();
 	const mate = getMoostMate();
-	/** Instances removed from a registry by this run — disposed below, before the caches drop. */ const ejected = [];
+	/** Instances removed from the registry by this run — disposed below, before the caches drop. */ const ejected = [];
 	if (cleanupInstances) {
-		for (const reg of registries) {
-			for (const key of Object.getOwnPropertySymbols(reg)) {
-				const instance = reg[key];
-				const viteId = mate.read(instance)?.__vite_id;
-				if (viteId && cleanupInstances.has(viteId)) {
-					logger.debug(`🔃 Replacing "${constructorName(instance)}"`);
-					delete reg[key];
-					ejected.push(instance);
-				}
-			}
-			for (const key of Object.getOwnPropertySymbols(reg)) {
-				const instance = reg[key];
-				scanParams(instance, (type) => {
-					if ((type === Moost || type instanceof Moost || type.prototype instanceof Moost) && (!onEject || onEject(instance, type))) {
-						delete reg[key];
-						ejected.push(instance);
-						logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on re-instantiated "Moost")`);
-						return true;
-					}
-					for (const adapter of adapters) if (adapter.compare(type) && (!onEject || onEject(instance, type))) {
-						delete reg[key];
-						ejected.push(instance);
-						logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on re-instantiated "${adapter.constructor.name}")`);
-						return true;
-					}
-				});
+		for (const key of Object.getOwnPropertySymbols(registry)) {
+			const instance = registry[key];
+			const viteId = mate.read(instance)?.__vite_id;
+			if (viteId && cleanupInstances.has(viteId)) {
+				logger.debug(`🔃 Replacing "${constructorName(instance)}"`);
+				delete registry[key];
+				ejected.push(instance);
 			}
-			clearDependantRegistry(reg, onEject, ejected);
 		}
+		clearDependantRegistry(registry, onEject, ejected);
 		infact.registry = registry;
-		infact.scopes = scopes;
 	}
 	await disposeEjected(ejected);
 	getMoostMate()._cleanup();
@@ -325,19 +355,21 @@ function _define_property(obj, key, value) {
 	for (const instance of disposed) logger.debug(`♻️  Disposed "${constructorName(instance)}"`);
 	for (const e of errors) logger.warn(`⚠️  Dispose hook "${constructorName(e.instance)}.${String(e.method)}" failed — the reload continues`);
 }
-function clearDependantRegistry(registry, onEject, ejected) {
+/**
+* Ejects, to a fixed point, every instance whose constructor dependency is not
+* in the registry: an instance ejected in one pass ejects its consumers in the
+* next (Moost → Database → Repository → Worker loses the whole chain). An
+* `onEject` veto keeps the instance present, and with it its consumers.
+*/ function clearDependantRegistry(registry, onEject, ejected) {
 	const logger = getLogger();
-	const objSet = /* @__PURE__ */ new Set();
 	let somethingIsDeleted = true;
 	while (somethingIsDeleted) {
 		somethingIsDeleted = false;
-		for (const key of Object.getOwnPropertySymbols(registry)) {
+		const keys = Object.getOwnPropertySymbols(registry);
+		const present = new Set(keys.map((key) => registry[key].constructor));
+		for (const key of keys) {
 			const instance = registry[key];
-			objSet.add(Object.getPrototypeOf(instance).constructor);
-		}
-		for (const key of Object.getOwnPropertySymbols(registry)) {
-			const instance = registry[key];
-			if (checkAndEject(instance, objSet, onEject, registry, key, logger)) {
+			if (checkAndEject(instance, present, onEject, registry, key, logger)) {
 				ejected.push(instance);
 				somethingIsDeleted = true;
 			}
@@ -349,7 +381,7 @@ function checkAndEject(instance, objSet, onEject, registry, key, logger) {
 	scanParams(instance, (type) => {
 		if (!objSet.has(type) && (!onEject || onEject(instance, type))) {
 			delete registry[key];
-			logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on "${type.name}" which is not in registry)`);
+			logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on "${type.name}", rebuilt by this reload)`);
 			ejected = true;
 			return true;
 		}
@@ -612,6 +644,11 @@ function moostVite(options) {
 	*/ let bootGeneration = 0;
 	let bootingGeneration = 0;
 	/** Whether the HTTP listen() patch has ever captured a middleware (i.e. this is an HTTP app). */ let httpCaptured = false;
+	/**
+	* The `app.init()` promises the current boot handed us (see `captureMoostInit`) —
+	* several when one entry boots several apps, none for a boot that never calls
+	* `init()`. Reset by `beginBoot()`, consumed by `settleBootInit()`.
+	*/ let bootInitPromises = [];
 	/** Module IDs awaiting DI cleanup — consumed in runReload; see ejectApp. */ let pendingCleanup = null;
 	/** In middleware mode: maps req → next() for the onNoMatch callback */ const pendingNextMap = /* @__PURE__ */ new WeakMap();
 	const adapters = [
@@ -681,6 +718,41 @@ function moostVite(options) {
 		reloadRequired = true;
 	};
 	patchMoostHandlerLogging();
+	captureMoostInit((promise) => {
+		if (bootingGeneration !== bootGeneration) {
+			logger.error(`⚠️  A stale Moost boot called init() (boot generation ${bootingGeneration}, latest ${bootGeneration}) — an HMR reload race; a follow-up reload will replace it.`);
+			return;
+		}
+		bootInitPromises.push(promise);
+	});
+	/** Marks the boot about to run as authoritative for the current generation. */ const beginBoot = () => {
+		bootingGeneration = bootGeneration;
+		bootInitPromises = [];
+	};
+	/**
+	* Finishes a boot: awaits the `init()` promise(s) the entry that just executed
+	* handed us, so the boot is only "done" once the app is fully initialized —
+	* every controller bound, every `@MoostInit` hook run (see `captureMoostInit`).
+	* Owns `bootError`: cleared on success, set and logged when an init rejected;
+	* returns whether the boot succeeded.
+	*/ const settleBootInit = async () => {
+		const initPromises = bootInitPromises;
+		bootInitPromises = [];
+		try {
+			await Promise.all(initPromises);
+			bootError = null;
+			return true;
+		} catch (error) {
+			bootError = error;
+			logger.error(`✖️  Moost app init failed: ${error.message}`);
+			return false;
+		}
+	};
+	/** Answers a request while `bootError` is set (see the gate in configureServer). */ const answerBootError = (res) => {
+		res.statusCode = 502;
+		res.setHeader("Content-Type", "text/plain");
+		res.end(`Moost app failed to load: ${bootError.message}`);
+	};
 	/** Set by the middleware-mode `config` hook: the consumer externalized the runtime themselves. */ let runtimeExternalized = false;
 	let resolvedConfig;
 	return [{
@@ -844,7 +916,7 @@ function moostVite(options) {
 			reloadRequired = false;
 			reloadPromise = null;
 			pendingCleanup = null;
-			bootingGeneration = bootGeneration;
+			beginBoot();
 			const runReload = () => {
 				reloadRequired = false;
 				console.log();
@@ -852,16 +924,15 @@ function moostVite(options) {
 				console.log();
 				return (async () => {
 					try {
-						bootingGeneration = bootGeneration;
+						beginBoot();
 						const cleanupInstances = pendingCleanup ?? void 0;
 						pendingCleanup = null;
-						await moostRestartCleanup(adapters, options.onEject, cleanupInstances);
+						await moostRestartCleanup(options.onEject, cleanupInstances);
 						for (const adapter of adapters) if (adapter.detected) await adapter.init();
 						const entryModule = await getEntryModule(server.environments.ssr.moduleGraph);
 						if (entryModule?.transformResult) server.environments.ssr.moduleGraph.invalidateModule(entryModule);
 						await ssrImport(options.entry);
-						bootError = null;
-						if (httpCaptured && !moostMiddleware) logger.error(`⚠️  Moost app reloaded but no HTTP middleware was captured — the entry did not re-run listen().`);
+						if (await settleBootInit() && httpCaptured && !moostMiddleware) logger.error(`⚠️  Moost app reloaded but no HTTP middleware was captured — the entry did not re-run listen().`);
 					} catch (error) {
 						bootError = error;
 						logger.error(`✖️  Failed to reload Moost App: ${error.message}`);
@@ -878,11 +949,16 @@ function moostVite(options) {
 				}
 			};
 			for (const adapter of adapters) adapter.ssrLoadModule = ssrImport;
-			await moostRestartCleanup(adapters, options.onEject);
+			await moostRestartCleanup(options.onEject);
 			await ssrImport(options.entry);
+			await settleBootInit();
 			server.middlewares.use(async (req, res, next) => {
 				await drainReload();
 				if (options.middleware && prefixes && !matchesPrefix(req.url || "", prefixes)) return next();
+				if (bootError) {
+					answerBootError(res);
+					return;
+				}
 				if (moostMiddleware) {
 					if (options.middleware) {
 						pendingNextMap.set(req, next);
@@ -891,12 +967,6 @@ function moostVite(options) {
 					}
 					return moostMiddleware(req, res);
 				}
-				if (bootError) {
-					res.statusCode = 502;
-					res.setHeader("Content-Type", "text/plain");
-					res.end(`Moost app failed to load: ${bootError.message}`);
-					return;
-				}
 				next();
 			});
 		},
@@ -928,6 +998,10 @@ function moostVite(options) {
 					const url = req.originalUrl || req.url || "/";
 					try {
 						await drainReload();
+						if (bootError) {
+							answerBootError(res);
+							return;
+						}
 						let template = await fs.readFile(resolve(server.config.root, "index.html"), "utf8");
 						template = await server.transformIndexHtml(url, template);
 						const { render } = await server.ssrLoadModule(options.ssrEntry);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moostjs/vite",
-  "version": "0.6.36",
+  "version": "0.6.38",
   "description": "Vite Dev plugin for moostjs",
   "keywords": [
     "composables",
@@ -58,8 +58,8 @@
   "peerDependencies": {
     "sirv": "^3.0.0",
     "vite": "^8.0.0",
-    "@moostjs/event-http": "^0.6.36",
-    "moost": "^0.6.36"
+    "@moostjs/event-http": "^0.6.38",
+    "moost": "^0.6.38"
   },
   "peerDependenciesMeta": {
     "sirv": {