moost 0.6.36 → 0.6.37

package/dist/index.cjs

@@ -48,7 +48,7 @@ let stamped = false;
 	if (stamped) return;
 	stamped = true;
 	stampModuleIdentity({
-		version: "0.6.36",
+		version: "0.6.37",
 		path: typeof __filename === "string" ? __filename : require("url").pathToFileURL(__filename).href
 	});
 }
@@ -670,7 +670,7 @@ const disposeSymbol = typeof Symbol.dispose === "symbol" ? Symbol.dispose : void
 /** Class name of an instance, read through the prototype (never touches own props). */ function classNameOf(instance) {
 	return Object.getPrototypeOf(instance)?.constructor?.name || "Object";
 }
-function errorMessage(error) {
+/** @internal Message of a thrown value, whatever it is. */ function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 /** `Class.method (message)` pairs for every failed hook. */ function formatDisposeErrors(errors) {
@@ -1952,6 +1952,67 @@ function lostCtorParamsMessage(input, ancestor, count) {
 	return [auditRouteDrop(input), auditLostCtorParams(input)].filter((f) => f !== void 0);
 }
 
+//#endregion
+//#region packages/moost/src/dispose-signals.ts
+/**
+* Global key for the record above. Global (rather than module-scoped) for the
+* same reason the module-identity stamp is: two copies of moost, or the entry
+* re-executing under the `@moostjs/vite` dev server, must share one set of
+* process listeners instead of stacking one per app.
+*/ const DISPOSE_SIGNALS_KEY = Symbol.for("moost:dispose-on-signals");
+/**
+* Removes every registered listener and forgets the record. A no-op for a record
+* that is no longer the live one (a stale unregister fn, or a signal that already
+* dropped it).
+*/ function dropSignalsRecord(record) {
+	const holder = globalThis;
+	if (holder[DISPOSE_SIGNALS_KEY] !== record) return;
+	for (const [signal, listener] of record.listeners) process.off(signal, listener);
+	record.listeners.clear();
+	delete holder[DISPOSE_SIGNALS_KEY];
+}
+/**
+* The one listener body per signal (NestJS `enableShutdownHooks` semantics):
+* unhook every listener first, dispose the newest app, then re-raise `signal`
+* so the process exits with Node's default status for it. Because the listeners
+* are already gone, a second signal while disposal runs gets Node's default
+* handling (exit `128 + n`) — an impatient Ctrl-C is never stuck.
+*/ async function onSignal(signal) {
+	const record = globalThis[DISPOSE_SIGNALS_KEY];
+	if (!record) return;
+	const { app } = record;
+	dropSignalsRecord(record);
+	try {
+		await app.dispose();
+	} catch (error) {
+		app.getLogger().warn(`[moost] dispose on ${signal} failed: ${errorMessage(error)}`);
+	}
+	process.kill(process.pid, signal);
+}
+/**
+* @internal Backs `Moost.disposeOnSignals()` — see that method's JSDoc for the
+* full contract. Registers at most one process listener per signal, ever, and
+* re-targets the existing ones at `app`.
+*/ function registerDisposeOnSignals(app, signals) {
+	var _holder, _DISPOSE_SIGNALS_KEY;
+	const record = (_holder = globalThis)[_DISPOSE_SIGNALS_KEY = DISPOSE_SIGNALS_KEY] ?? (_holder[_DISPOSE_SIGNALS_KEY] = {
+		app,
+		listeners: /* @__PURE__ */ new Map()
+	});
+	record.app = app;
+	for (const signal of signals) {
+		if (record.listeners.has(signal)) continue;
+		const listener = () => {
+			onSignal(signal);
+		};
+		record.listeners.set(signal, listener);
+		process.on(signal, listener);
+	}
+	return () => {
+		dropSignalsRecord(record);
+	};
+}
+
 //#endregion
 //#region packages/moost/src/moost.ts
 function _define_property(obj, key, value) {
@@ -2136,14 +2197,38 @@ function _define_property(obj, key, value) {
 	* cleanup helpers when a clean container is what you need.
 	*
 	* ```ts
-	* for (const signal of ['SIGTERM', 'SIGINT'] as const) {
-	*   process.once(signal, () => { void app.dispose().finally(() => process.exit(0)) })
-	* }
+	* app.disposeOnSignals() // SIGTERM + SIGINT → dispose() → re-raise
 	* ```
 	*/ dispose() {
 		if (!this.disposePromise) this.disposePromise = this.runDispose();
 		return this.disposePromise;
 	}
+	/**
+	* ### disposeOnSignals
+	* Disposes this app when the process receives one of `signals` (default
+	* `['SIGTERM', 'SIGINT']`), then re-raises the signal with no listener left,
+	* so the process exits with Node's default status for it.
+	*
+	* Registers each process listener **once per process**: calling it again —
+	* e.g. the entry re-executing under the `@moostjs/vite` dev server — re-targets
+	* the existing listeners at the newest app instead of stacking one handler per
+	* old app (which is what a plain `process.once(...)` in the entry does, until
+	* Node warns about a listener leak). Signals are unioned across calls; an
+	* already-registered one is never replaced or removed.
+	*
+	* A second signal while disposal runs gets Node's default handling, since the
+	* listeners are already removed. A failing `dispose()` is logged as a warning
+	* and the signal is re-raised all the same.
+	*
+	* Returns a function that unregisters the listeners (tests, embedded runners).
+	*
+	* ```ts
+	* await app.init()
+	* app.disposeOnSignals()
+	* ```
+	*/ disposeOnSignals(signals = ["SIGTERM", "SIGINT"]) {
+		return registerDisposeOnSignals(this, signals);
+	}
 	/** Adapters' `onDispose` in registration order; errors are collected, not fatal. */ async disposeAdapters() {
 		const errors = [];
 		for (const a of this.adapters) try {
@@ -2154,7 +2239,7 @@ function _define_property(obj, key, value) {
 				method: "onDispose",
 				error
 			});
-			this.logger.warn(`[moost] adapter "${a.name}" onDispose failed: ${error instanceof Error ? error.message : String(error)}`);
+			this.logger.warn(`[moost] adapter "${a.name}" onDispose failed: ${errorMessage(error)}`);
 		}
 		return errors;
 	}

package/dist/index.d.ts

@@ -762,12 +762,35 @@ declare class Moost extends Hookable {
      * cleanup helpers when a clean container is what you need.
      *
      * ```ts
-     * for (const signal of ['SIGTERM', 'SIGINT'] as const) {
-     *   process.once(signal, () => { void app.dispose().finally(() => process.exit(0)) })
-     * }
+     * app.disposeOnSignals() // SIGTERM + SIGINT → dispose() → re-raise
      * ```
      */
     dispose(): Promise<void>;
+    /**
+     * ### disposeOnSignals
+     * Disposes this app when the process receives one of `signals` (default
+     * `['SIGTERM', 'SIGINT']`), then re-raises the signal with no listener left,
+     * so the process exits with Node's default status for it.
+     *
+     * Registers each process listener **once per process**: calling it again —
+     * e.g. the entry re-executing under the `@moostjs/vite` dev server — re-targets
+     * the existing listeners at the newest app instead of stacking one handler per
+     * old app (which is what a plain `process.once(...)` in the entry does, until
+     * Node warns about a listener leak). Signals are unioned across calls; an
+     * already-registered one is never replaced or removed.
+     *
+     * A second signal while disposal runs gets Node's default handling, since the
+     * listeners are already removed. A failing `dispose()` is logged as a warning
+     * and the signal is re-raised all the same.
+     *
+     * Returns a function that unregisters the listeners (tests, embedded runners).
+     *
+     * ```ts
+     * await app.init()
+     * app.disposeOnSignals()
+     * ```
+     */
+    disposeOnSignals(signals?: NodeJS.Signals[]): () => void;
     /** Adapters' `onDispose` in registration order; errors are collected, not fatal. */
     protected disposeAdapters(): Promise<TDisposeError[]>;
     /** The one-shot body behind {@link Moost.dispose} (see its docs for the contract). */

package/dist/index.mjs

@@ -47,7 +47,7 @@ let stamped = false;
 	if (stamped) return;
 	stamped = true;
 	stampModuleIdentity({
-		version: "0.6.36",
+		version: "0.6.37",
 		path: typeof __filename === "string" ? __filename : import.meta.url
 	});
 }
@@ -669,7 +669,7 @@ const disposeSymbol = typeof Symbol.dispose === "symbol" ? Symbol.dispose : void
 /** Class name of an instance, read through the prototype (never touches own props). */ function classNameOf(instance) {
 	return Object.getPrototypeOf(instance)?.constructor?.name || "Object";
 }
-function errorMessage(error) {
+/** @internal Message of a thrown value, whatever it is. */ function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 /** `Class.method (message)` pairs for every failed hook. */ function formatDisposeErrors(errors) {
@@ -1951,6 +1951,67 @@ function lostCtorParamsMessage(input, ancestor, count) {
 	return [auditRouteDrop(input), auditLostCtorParams(input)].filter((f) => f !== void 0);
 }
 
+//#endregion
+//#region packages/moost/src/dispose-signals.ts
+/**
+* Global key for the record above. Global (rather than module-scoped) for the
+* same reason the module-identity stamp is: two copies of moost, or the entry
+* re-executing under the `@moostjs/vite` dev server, must share one set of
+* process listeners instead of stacking one per app.
+*/ const DISPOSE_SIGNALS_KEY = Symbol.for("moost:dispose-on-signals");
+/**
+* Removes every registered listener and forgets the record. A no-op for a record
+* that is no longer the live one (a stale unregister fn, or a signal that already
+* dropped it).
+*/ function dropSignalsRecord(record) {
+	const holder = globalThis;
+	if (holder[DISPOSE_SIGNALS_KEY] !== record) return;
+	for (const [signal, listener] of record.listeners) process.off(signal, listener);
+	record.listeners.clear();
+	delete holder[DISPOSE_SIGNALS_KEY];
+}
+/**
+* The one listener body per signal (NestJS `enableShutdownHooks` semantics):
+* unhook every listener first, dispose the newest app, then re-raise `signal`
+* so the process exits with Node's default status for it. Because the listeners
+* are already gone, a second signal while disposal runs gets Node's default
+* handling (exit `128 + n`) — an impatient Ctrl-C is never stuck.
+*/ async function onSignal(signal) {
+	const record = globalThis[DISPOSE_SIGNALS_KEY];
+	if (!record) return;
+	const { app } = record;
+	dropSignalsRecord(record);
+	try {
+		await app.dispose();
+	} catch (error) {
+		app.getLogger().warn(`[moost] dispose on ${signal} failed: ${errorMessage(error)}`);
+	}
+	process.kill(process.pid, signal);
+}
+/**
+* @internal Backs `Moost.disposeOnSignals()` — see that method's JSDoc for the
+* full contract. Registers at most one process listener per signal, ever, and
+* re-targets the existing ones at `app`.
+*/ function registerDisposeOnSignals(app, signals) {
+	var _holder, _DISPOSE_SIGNALS_KEY;
+	const record = (_holder = globalThis)[_DISPOSE_SIGNALS_KEY = DISPOSE_SIGNALS_KEY] ?? (_holder[_DISPOSE_SIGNALS_KEY] = {
+		app,
+		listeners: /* @__PURE__ */ new Map()
+	});
+	record.app = app;
+	for (const signal of signals) {
+		if (record.listeners.has(signal)) continue;
+		const listener = () => {
+			onSignal(signal);
+		};
+		record.listeners.set(signal, listener);
+		process.on(signal, listener);
+	}
+	return () => {
+		dropSignalsRecord(record);
+	};
+}
+
 //#endregion
 //#region packages/moost/src/moost.ts
 function _define_property(obj, key, value) {
@@ -2135,14 +2196,38 @@ function _define_property(obj, key, value) {
 	* cleanup helpers when a clean container is what you need.
 	*
 	* ```ts
-	* for (const signal of ['SIGTERM', 'SIGINT'] as const) {
-	*   process.once(signal, () => { void app.dispose().finally(() => process.exit(0)) })
-	* }
+	* app.disposeOnSignals() // SIGTERM + SIGINT → dispose() → re-raise
 	* ```
 	*/ dispose() {
 		if (!this.disposePromise) this.disposePromise = this.runDispose();
 		return this.disposePromise;
 	}
+	/**
+	* ### disposeOnSignals
+	* Disposes this app when the process receives one of `signals` (default
+	* `['SIGTERM', 'SIGINT']`), then re-raises the signal with no listener left,
+	* so the process exits with Node's default status for it.
+	*
+	* Registers each process listener **once per process**: calling it again —
+	* e.g. the entry re-executing under the `@moostjs/vite` dev server — re-targets
+	* the existing listeners at the newest app instead of stacking one handler per
+	* old app (which is what a plain `process.once(...)` in the entry does, until
+	* Node warns about a listener leak). Signals are unioned across calls; an
+	* already-registered one is never replaced or removed.
+	*
+	* A second signal while disposal runs gets Node's default handling, since the
+	* listeners are already removed. A failing `dispose()` is logged as a warning
+	* and the signal is re-raised all the same.
+	*
+	* Returns a function that unregisters the listeners (tests, embedded runners).
+	*
+	* ```ts
+	* await app.init()
+	* app.disposeOnSignals()
+	* ```
+	*/ disposeOnSignals(signals = ["SIGTERM", "SIGINT"]) {
+		return registerDisposeOnSignals(this, signals);
+	}
 	/** Adapters' `onDispose` in registration order; errors are collected, not fatal. */ async disposeAdapters() {
 		const errors = [];
 		for (const a of this.adapters) try {
@@ -2153,7 +2238,7 @@ function _define_property(obj, key, value) {
 				method: "onDispose",
 				error
 			});
-			this.logger.warn(`[moost] adapter "${a.name}" onDispose failed: ${error instanceof Error ? error.message : String(error)}`);
+			this.logger.warn(`[moost] adapter "${a.name}" onDispose failed: ${errorMessage(error)}`);
 		}
 		return errors;
 	}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moost",
-  "version": "0.6.36",
+  "version": "0.6.37",
   "description": "moost",
   "keywords": [
     "composables",
@@ -49,7 +49,7 @@
     "@wooksjs/event-http": "^0.7.23",
     "@wooksjs/http-body": "^0.7.23",
     "vitest": "3.2.7",
-    "@moostjs/event-http": "^0.6.36"
+    "@moostjs/event-http": "^0.6.37"
   },
   "scripts": {
     "pub": "pnpm publish --access public",