@moostjs/vite 0.6.36 → 0.6.37

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
@@ -643,6 +694,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 +768,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 +966,7 @@ function moostVite(options) {
 			reloadRequired = false;
 			reloadPromise = null;
 			pendingCleanup = null;
-			bootingGeneration = bootGeneration;
+			beginBoot();
 			const runReload = () => {
 				reloadRequired = false;
 				console.log();
@@ -883,7 +974,7 @@ function moostVite(options) {
 				console.log();
 				return (async () => {
 					try {
-						bootingGeneration = bootGeneration;
+						beginBoot();
 						const cleanupInstances = pendingCleanup ?? void 0;
 						pendingCleanup = null;
 						await moostRestartCleanup(adapters, options.onEject, cleanupInstances);
@@ -891,8 +982,7 @@ function moostVite(options) {
 						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}`);
@@ -911,9 +1001,14 @@ function moostVite(options) {
 			for (const adapter of adapters) adapter.ssrLoadModule = ssrImport;
 			await moostRestartCleanup(adapters, 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 +1017,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 +1056,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
@@ -612,6 +663,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 +737,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 +935,7 @@ function moostVite(options) {
 			reloadRequired = false;
 			reloadPromise = null;
 			pendingCleanup = null;
-			bootingGeneration = bootGeneration;
+			beginBoot();
 			const runReload = () => {
 				reloadRequired = false;
 				console.log();
@@ -852,7 +943,7 @@ function moostVite(options) {
 				console.log();
 				return (async () => {
 					try {
-						bootingGeneration = bootGeneration;
+						beginBoot();
 						const cleanupInstances = pendingCleanup ?? void 0;
 						pendingCleanup = null;
 						await moostRestartCleanup(adapters, options.onEject, cleanupInstances);
@@ -860,8 +951,7 @@ function moostVite(options) {
 						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}`);
@@ -880,9 +970,14 @@ function moostVite(options) {
 			for (const adapter of adapters) adapter.ssrLoadModule = ssrImport;
 			await moostRestartCleanup(adapters, 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 +986,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 +1017,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.37",
   "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.37",
+    "moost": "^0.6.37"
   },
   "peerDependenciesMeta": {
     "sirv": {