@znight/core 0.6.3 → 0.6.4

package/README.md

@@ -156,7 +156,8 @@ begins. If a step fails, what was started is stopped, everything is disposed and
 **`app.stop()`** is idempotent and waits for an in-progress start, at most `hookTimeoutMs` (a start
 hook that never settles cannot block the shutdown: past that budget, a `Waiting for start() timed out`
 failure is recorded, the remaining start hooks are skipped and what completed its `onStart` is
-stopped). It runs three phases:
+stopped; a plugin whose `onStart` is still in flight is stopped and disposed when that hook settles,
+not before). It runs three phases:
 
 1. plugins' `onStop`, in reverse order (stop ingress, drain in-flight work);
 2. for each provider in reverse resolution order: `onStop` (if it was started), then disposal;

package/dist/index.mjs

@@ -1956,6 +1956,13 @@ var Application = class Application {
 	#startAborted = false;
 	/** Releases a `stop()` waiting for the start, when a start hook asks to stop in turn. */
 	#releaseStopWait;
+	/** Owner of the `onStart` hook in progress. */
+	#starting;
+	/**
+	* Owner of the `onStart` hook still in flight when the wait of `stop()` timed out: the shutdown
+	* skips its `onDispose`, and it is stopped and disposed when that hook settles.
+	*/
+	#lateStart;
 	constructor(options) {
 		const plugins = [...options.plugins ?? []];
 		const byName = /* @__PURE__ */ new Map();
@@ -2089,11 +2096,11 @@ var Application = class Application {
 	async #runStartHooks() {
 		const providers = this.container.instances();
 		for (const provider of providers) {
-			if (!await this.#startHook(() => this.#callProvider(provider, "onStart"))) return false;
+			if (!await this.#startHook(() => this.#callProvider(provider, "onStart"), { provider })) return false;
 			this.#startedProviders.add(provider.token);
 		}
 		for (const plugin of this.#plugins) {
-			if (!await this.#startHook(() => this.#callPlugin(plugin, "onStart"))) return false;
+			if (!await this.#startHook(() => this.#callPlugin(plugin, "onStart"), { plugin })) return false;
 			this.#startedPlugins.push(plugin);
 		}
 		for (const provider of providers) if (!await this.#startHook(() => this.#callProvider(provider, "onReady"))) return false;
@@ -2103,17 +2110,41 @@ var Application = class Application {
 	/**
 	* Runs one start hook in an async context carrying a fresh marker, so that a `stop()` called from
 	* it (or from work it awaits) is recognised. Returns `false` when the hook stopped the application.
+	* `owner` is given for `onStart` hooks: one that settles after `stop()` stopped waiting for it is
+	* stopped and disposed then (see `#stopLateStart`).
 	*/
-	async #startHook(hook) {
+	async #startHook(hook, owner) {
 		const marker = {};
 		this.#startHookMarker = marker;
+		this.#starting = owner;
+		let started = false;
 		try {
 			await startHookContext.run(marker, hook);
+			started = true;
 		} finally {
 			this.#startHookMarker = void 0;
+			this.#starting = void 0;
+			if (owner !== void 0 && this.#lateStart === owner) await this.#stopLateStart(owner, started);
 		}
 		return !this.#startAborted;
 	}
+	/**
+	* Stops what an `onStart` hook settling after the shutdown started (best effort, failures logged):
+	* a plugin gets `onStop` (when its `onStart` succeeded) then the `onDispose` the shutdown skipped;
+	* a provider, already disposed by the shutdown, gets `onStop` when its `onStart` succeeded.
+	*/
+	async #stopLateStart(owner, started) {
+		const { plugin, provider } = owner;
+		const label = plugin === void 0 ? `${provider?.displayName}.onStart()` : `Plugin "${plugin.name}" onStart()`;
+		this.#logger.warn(`${label} settled after the shutdown stopped waiting for it: stopping it now`);
+		const errors = [];
+		const step = this.#stepRunner(errors);
+		if (plugin !== void 0) {
+			if (started && typeof plugin.onStop === "function") await step(`Plugin "${plugin.name}" onStop()`, () => plugin.onStop?.(this.#context));
+			if (typeof plugin.onDispose === "function") await step(`Plugin "${plugin.name}" onDispose()`, () => plugin.onDispose?.(this.#context));
+		} else if (provider !== void 0 && started && hasLifecycleHook(provider.instance, "onStop")) await step(`${provider.displayName}.onStop()`, () => callLifecycleHook(provider.instance, "onStop"));
+		for (const error of errors) this.#logger.error("Failed to stop a late start", { err: error });
+	}
 	/** Whether the caller runs in the async context of the start hook in progress. */
 	#calledFromStartHook() {
 		const marker = this.#startHookMarker;
@@ -2153,6 +2184,7 @@ var Application = class Application {
 			if (this.#state === "starting") {
 				this.#startAborted = true;
 				this.#releaseStopWait = void 0;
+				this.#lateStart = this.#starting;
 			}
 		}
 		if (this.#state === "failed" || this.#state === "stopped") {
@@ -2195,7 +2227,7 @@ var Application = class Application {
 		} catch (error) {
 			errors.push(...flatten(error));
 		}
-		for (const plugin of [...this.#registered].reverse()) if (typeof plugin.onDispose === "function") await step(`Plugin "${plugin.name}" onDispose()`, () => plugin.onDispose?.(this.#context));
+		for (const plugin of [...this.#registered].reverse()) if (typeof plugin.onDispose === "function" && plugin !== this.#lateStart?.plugin) await step(`Plugin "${plugin.name}" onDispose()`, () => plugin.onDispose?.(this.#context));
 		this.#startedPlugins.length = 0;
 		this.#startedProviders.clear();
 		return errors;