feat: 投稿したコンテンツのAIによる学習を軽減するオプションを追加

Co-authored-by: GitHub <syuilo>

locales/en-US.yml

@@ -1083,6 +1083,9 @@ signupsDisabled: "Signups on this server are currently disabled, but you can alw
 findOtherInstance: "Find another server"
 apps: "Apps"
 sendModMail: "Send Moderation Notice"
+preventAiLearning: "Prevent AI bot scraping"
+preventAiLearningDescription: "Request third-party AI language models not to study content you upload, such as posts and images."
+
 
 _sensitiveMediaDetection:
   description: "Reduces the effort of server moderation through automatically recognizing\

locales/ja-JP.yml

@@ -973,6 +973,8 @@ customKaTeXMacroDescription: "数式入力を楽にするためのマクロを
   name}{content} または \\newcommand{\\add}[2]{#1 + #2} のように記述します。後者の例では \\add{3}{foo}\
   \ が 3 + foo に展開されます。また、マクロの名前を囲む波括弧を丸括弧 () および角括弧 [] に変更した場合、マクロの引数に使用する括弧が変更されます。マクロの定義は一行に一つのみで、途中で改行はできません。マクロの定義が無効な行は無視されます。文字列を単純に置換する機能のみに対応していて、条件分岐などの高度な構文は使用できません。"
 enableCustomKaTeXMacro: "カスタムKaTeXマクロを有効にする"
+preventAiLearning: "AIによる学習を防止"
+preventAiLearningDescription: "投稿したノート、添付した画像などのコンテンツを学習の対象にしないようAIに要求します。これはnoaiフラグをHTMLレスポンスに含めることによって実現されます。"
 
 _sensitiveMediaDetection:
   description: "機械学習を使って自動でセンシティブなメディアを検出し、モデレーションに役立てられます。サーバーの負荷が少し増えます。"

packages/backend/migration/1683682889948-prevent-ai-larning.js

@@ -0,0 +1,11 @@
+export class PreventAiLarning1683682889948 {
+    name = 'PreventAiLarning1683682889948'
+
+    async up(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "user_profile" ADD "preventAiLearning" boolean NOT NULL DEFAULT true`);
+    }
+
+    async down(queryRunner) {
+        await queryRunner.query(`ALTER TABLE "user_profile" DROP COLUMN "preventAiLearning"`);
+    }
+}

packages/backend/src/models/entities/user-profile.ts

@@ -154,6 +154,11 @@ export class UserProfile {
 	})
 	public noCrawle: boolean;
 
+	@Column('boolean', {
+		default: true,
+	})
+	public preventAiLearning: boolean;
+
 	@Column('boolean', {
 		default: false,
 	})

packages/backend/src/models/repositories/user.ts

@@ -535,6 +535,7 @@ export const UserRepository = db.getRepository(User).extend({
 						carefulBot: profile!.carefulBot,
 						autoAcceptFollowed: profile!.autoAcceptFollowed,
 						noCrawle: profile!.noCrawle,
+						preventAiLearning: profile!.preventAiLearning,
 						isExplorable: user.isExplorable,
 						isDeleted: user.isDeleted,
 						hideOnlineStatus: user.hideOnlineStatus,

packages/backend/src/models/schema/user.ts

@@ -394,6 +394,11 @@ export const packedMeDetailedOnlySchema = {
 			nullable: true,
 			optional: false,
 		},
+		preventAiLearning: {
+			type: "boolean",
+			nullable: true,
+			optional: false,
+		},
 		isExplorable: {
 			type: "boolean",
 			nullable: false,

packages/backend/src/server/api/endpoints/admin/show-user.ts

@@ -59,6 +59,7 @@ export default define(meta, paramDef, async (ps, me) => {
 		emailVerified: profile.emailVerified,
 		autoAcceptFollowed: profile.autoAcceptFollowed,
 		noCrawle: profile.noCrawle,
+		preventAiLearning: profile.preventAiLearning,
 		alwaysMarkNsfw: profile.alwaysMarkNsfw,
 		autoSensitive: profile.autoSensitive,
 		carefulBot: profile.carefulBot,

packages/backend/src/server/api/endpoints/i/update.ts

@@ -102,6 +102,7 @@ export const paramDef = {
 		carefulBot: { type: "boolean" },
 		autoAcceptFollowed: { type: "boolean" },
 		noCrawle: { type: "boolean" },
+		preventAiLearning: { type: "boolean" },
 		isBot: { type: "boolean" },
 		isCat: { type: "boolean" },
 		speakAsCat: { type: "boolean" },
@@ -191,6 +192,7 @@ export default define(meta, paramDef, async (ps, _user, token) => {
 	if (typeof ps.autoAcceptFollowed === "boolean")
 		profileUpdates.autoAcceptFollowed = ps.autoAcceptFollowed;
 	if (typeof ps.noCrawle === "boolean") profileUpdates.noCrawle = ps.noCrawle;
+	if (typeof ps.preventAiLearning === "boolean") profileUpdates.preventAiLearning = ps.preventAiLearning;
 	if (typeof ps.isCat === "boolean") updates.isCat = ps.isCat;
 	if (typeof ps.speakAsCat === "boolean") updates.speakAsCat = ps.speakAsCat;
 	if (typeof ps.injectFeaturedNote === "boolean")

packages/backend/src/server/web/views/clip.pug

@@ -24,6 +24,8 @@ block meta
 	unless privateMode
 		if profile.noCrawle
 			meta(name='robots' content='noindex')
+		if profile.preventAiLearning
+			meta(name='robots' content='noai')
 
 		meta(name='misskey:user-username' content=user.username)
 		meta(name='misskey:user-id' content=user.id)

packages/backend/src/server/web/views/gallery-post.pug

@@ -24,6 +24,8 @@ block meta
 	unless privateMode
 		if user.host || profile.noCrawle
 			meta(name='robots' content='noindex')
+		if profile.preventAiLearning
+			meta(name='robots' content='noai')
 
 		meta(name='misskey:user-username' content=user.username)
 		meta(name='misskey:user-id' content=user.id)

packages/backend/src/server/web/views/note.pug

@@ -36,6 +36,8 @@ block meta
 	unless privateMode
 		if user.host || isRenote || profile.noCrawle
 			meta(name='robots' content='noindex')
+		if profile.preventAiLearning
+			meta(name='robots' content='noai')
 
 		meta(name='misskey:user-username' content=user.username)
 		meta(name='misskey:user-id' content=user.id)

packages/backend/src/server/web/views/page.pug

@@ -24,6 +24,8 @@ block meta
 	unless privateMode
 		if profile.noCrawle
 			meta(name='robots' content='noindex')
+		if profile.preventAiLearning
+			meta(name='robots' content='noai')
 
 		meta(name='misskey:user-username' content=user.username)
 		meta(name='misskey:user-id' content=user.id)

packages/backend/src/server/web/views/user.pug

@@ -23,6 +23,8 @@ block meta
 	unless privateMode
 		if user.host || profile.noCrawle
 			meta(name='robots' content='noindex')
+		if profile.preventAiLearning
+			meta(name='robots' content='noai')
 
 		meta(name='misskey:user-username' content=user.username)
 		meta(name='misskey:user-id' content=user.id)

packages/backend/test/e2e/users.ts

@@ -0,0 +1,891 @@
+process.env.NODE_ENV = 'test';
+
+import * as assert from 'assert';
+import { inspect } from 'node:util';
+import { DEFAULT_POLICIES } from '@/core/RoleService.js';
+import type { Packed } from '@/misc/json-schema.js';
+import { 
+	signup, 
+	post, 
+	page,
+	role,
+	startServer, 
+	api,
+	successfulApiCall, 
+	failedApiCall,
+	uploadFile,
+} from '../utils.js';
+import type * as misskey from 'misskey-js';
+import type { INestApplicationContext } from '@nestjs/common';
+
+describe('ユーザー', () => {
+	// エンティティとしてのユーザーを主眼においたテストを記述する
+	// (Userを返すエンドポイントとUserエンティティを書き換えるエンドポイントをテストする)
+
+	const stripUndefined = <T extends { [key: string]: any }, >(orig: T): Partial<T> => {
+		return Object.entries({ ...orig })
+			.filter(([, value]) => value !== undefined)
+			.reduce((obj: Partial<T>, [key, value]) => {
+				obj[key as keyof T] = value;
+				return obj;
+			}, {});
+	};
+
+	// BUG misskey-jsとjson-schemaと実際に返ってくるデータが全部違う
+	type UserLite = misskey.entities.UserLite & {
+		badgeRoles: any[],
+	};
+
+	type UserDetailedNotMe = UserLite & 
+	misskey.entities.UserDetailed & {
+		roles: any[],
+	};
+
+	type MeDetailed = UserDetailedNotMe & 
+		misskey.entities.MeDetailed & {
+		showTimelineReplies: boolean,
+		achievements: object[],
+		loggedInDays: number,
+		policies: object,
+	};
+	
+	type User = MeDetailed & { token: string };	
+
+	const show = async (id: string, me = root): Promise<MeDetailed | UserDetailedNotMe> => {
+		return successfulApiCall({ endpoint: 'users/show', parameters: { userId: id }, user: me }) as any;
+	};
+
+	// UserLiteのキーが過不足なく入っている？
+	const userLite = (user: User): Partial<UserLite> => {
+		return stripUndefined({
+			id: user.id,
+			name: user.name,
+			username: user.username,
+			host: user.host,
+			avatarUrl: user.avatarUrl,
+			avatarBlurhash: user.avatarBlurhash,
+			isBot: user.isBot,
+			isCat: user.isCat,
+			instance: user.instance,
+			emojis: user.emojis,
+			onlineStatus: user.onlineStatus,
+			badgeRoles: user.badgeRoles,
+
+			// BUG isAdmin/isModeratorはUserLiteではなくMeDetailedOnlyに含まれる。
+			isAdmin: undefined,
+			isModerator: undefined,
+		});
+	};
+
+	// UserDetailedNotMeのキーが過不足なく入っている？
+	const userDetailedNotMe = (user: User): Partial<UserDetailedNotMe> => {
+		return stripUndefined({
+			...userLite(user),
+			url: user.url,
+			uri: user.uri,
+			movedTo: user.movedTo,
+			alsoKnownAs: user.alsoKnownAs,
+			createdAt: user.createdAt,
+			updatedAt: user.updatedAt,
+			lastFetchedAt: user.lastFetchedAt,
+			bannerUrl: user.bannerUrl,
+			bannerBlurhash: user.bannerBlurhash,
+			isLocked: user.isLocked,
+			isSilenced: user.isSilenced,
+			isSuspended: user.isSuspended,
+			description: user.description,
+			location: user.location,
+			birthday: user.birthday,
+			lang: user.lang,
+			fields: user.fields,
+			followersCount: user.followersCount,
+			followingCount: user.followingCount,
+			notesCount: user.notesCount,
+			pinnedNoteIds: user.pinnedNoteIds,
+			pinnedNotes: user.pinnedNotes,
+			pinnedPageId: user.pinnedPageId,
+			pinnedPage: user.pinnedPage,
+			publicReactions: user.publicReactions,
+			ffVisibility: user.ffVisibility,
+			twoFactorEnabled: user.twoFactorEnabled,
+			usePasswordLessLogin: user.usePasswordLessLogin,
+			securityKeys: user.securityKeys,
+			roles: user.roles,
+			memo: user.memo,
+		});
+	};
+
+	// Relations関連のキーが過不足なく入っている？
+	const userDetailedNotMeWithRelations = (user: User): Partial<UserDetailedNotMe> => {
+		return stripUndefined({
+			...userDetailedNotMe(user),
+			isFollowing: user.isFollowing ?? false,
+			isFollowed: user.isFollowed ?? false,
+			hasPendingFollowRequestFromYou: user.hasPendingFollowRequestFromYou ?? false,
+			hasPendingFollowRequestToYou: user.hasPendingFollowRequestToYou ?? false,
+			isBlocking: user.isBlocking ?? false,
+			isBlocked: user.isBlocked ?? false,
+			isMuted: user.isMuted ?? false,
+			isRenoteMuted: user.isRenoteMuted ?? false,
+		});
+	};
+
+	// MeDetailedのキーが過不足なく入っている？
+	const meDetailed = (user: User, security = false): Partial<MeDetailed> => {
+		return stripUndefined({
+			...userDetailedNotMe(user),
+			avatarId: user.avatarId,
+			bannerId: user.bannerId,
+			isModerator: user.isModerator,
+			isAdmin: user.isAdmin,
+			injectFeaturedNote: user.injectFeaturedNote,
+			receiveAnnouncementEmail: user.receiveAnnouncementEmail,
+			alwaysMarkNsfw: user.alwaysMarkNsfw,
+			autoSensitive: user.autoSensitive,
+			carefulBot: user.carefulBot,
+			autoAcceptFollowed: user.autoAcceptFollowed,
+			noCrawle: user.noCrawle,
+			preventAiLearning: user.preventAiLearning,
+			isExplorable: user.isExplorable,
+			isDeleted: user.isDeleted,
+			hideOnlineStatus: user.hideOnlineStatus,
+			hasUnreadSpecifiedNotes: user.hasUnreadSpecifiedNotes,
+			hasUnreadMentions: user.hasUnreadMentions,
+			hasUnreadAnnouncement: user.hasUnreadAnnouncement,
+			hasUnreadAntenna: user.hasUnreadAntenna,
+			hasUnreadChannel: user.hasUnreadChannel,
+			hasUnreadNotification: user.hasUnreadNotification,
+			hasPendingReceivedFollowRequest: user.hasPendingReceivedFollowRequest,
+			mutedWords: user.mutedWords,
+			mutedInstances: user.mutedInstances,
+			mutingNotificationTypes: user.mutingNotificationTypes,
+			emailNotificationTypes: user.emailNotificationTypes,
+			showTimelineReplies: user.showTimelineReplies,
+			achievements: user.achievements,
+			loggedInDays: user.loggedInDays,
+			policies: user.policies,
+			...(security ? {
+				email: user.email,
+				emailVerified: user.emailVerified,
+				securityKeysList: user.securityKeysList,
+			} : {}),
+		});
+	};
+
+	let app: INestApplicationContext;
+
+	let root: User;
+	let alice: User;
+	let aliceNote: misskey.entities.Note;
+	let alicePage: misskey.entities.Page;
+	let aliceList: misskey.entities.UserList;
+
+	let bob: User;
+	let bobNote: misskey.entities.Note;
+
+	let carol: User;
+	let dave: User;
+	let ellen: User;
+	let frank: User;
+
+	let usersReplying: User[];
+
+	let userNoNote: User;
+	let userNotExplorable: User;
+	let userLocking: User;
+	let userAdmin: User;
+	let roleAdmin: any;
+	let userModerator: User;
+	let roleModerator: any;
+	let userRolePublic: User;
+	let rolePublic: any;
+	let userRoleBadge: User;
+	let roleBadge: any;
+	let userSilenced: User;
+	let roleSilenced: any;
+	let userSuspended: User;
+	let userDeletedBySelf: User;
+	let userDeletedByAdmin: User;
+	let userFollowingAlice: User;
+	let userFollowedByAlice: User;
+	let userBlockingAlice: User;
+	let userBlockedByAlice: User;
+	let userMutingAlice: User;
+	let userMutedByAlice: User;
+	let userRnMutingAlice: User;
+	let userRnMutedByAlice: User;
+	let userFollowRequesting: User;
+	let userFollowRequested: User;
+
+	beforeAll(async () => {
+		app = await startServer();
+	}, 1000 * 60 * 2);
+
+	beforeAll(async () => {
+		root = await signup({ username: 'root' });
+		alice = await signup({ username: 'alice' });
+		aliceNote = await post(alice, { text: 'test' }) as any; 
+		alicePage = await page(alice);
+		aliceList = (await api('users/list/create', { name: 'aliceList' }, alice)).body;
+		bob = await signup({ username: 'bob' });
+		bobNote = await post(bob, { text: 'test' }) as any; 
+		carol = await signup({ username: 'carol' });
+		dave = await signup({ username: 'dave' });
+		ellen = await signup({ username: 'ellen' });
+		frank = await signup({ username: 'frank' });
+
+		// @alice -> @replyingへのリプライ。Promise.allで一気に作るとtimeoutしてしまうのでreduceで一つ一つawaitする
+		usersReplying = await [...Array(10)].map((_, i) => i).reduce(async (acc, i) => {
+			const u = await signup({ username: `replying${i}` });
+			for (let j = 0; j < 10 - i; j++) {
+				const p = await post(u, { text: `test${j}` }); 
+				await post(alice, { text: `@${u.username} test${j}`, replyId: p.id });
+			}
+			
+			return (await acc).concat(u);
+		}, Promise.resolve([] as User[]));
+
+		userNoNote = await signup({ username: 'userNoNote' });
+		userNotExplorable = await signup({ username: 'userNotExplorable' });
+		await post(userNotExplorable, { text: 'test' });
+		await api('i/update', { isExplorable: false }, userNotExplorable);
+		userLocking = await signup({ username: 'userLocking' });
+		await post(userLocking, { text: 'test' });
+		await api('i/update', { isLocked: true }, userLocking);
+		userAdmin = await signup({ username: 'userAdmin' });
+		roleAdmin = await role(root, { isAdministrator: true, name: 'Admin Role' });
+		await api('admin/roles/assign', { userId: userAdmin.id, roleId: roleAdmin.id }, root);
+		userModerator = await signup({ username: 'userModerator' });
+		roleModerator = await role(root, { isModerator: true, name: 'Moderator Role' });
+		await api('admin/roles/assign', { userId: userModerator.id, roleId: roleModerator.id }, root);
+		userRolePublic = await signup({ username: 'userRolePublic' });
+		rolePublic = await role(root, { isPublic: true, name: 'Public Role' });
+		await api('admin/roles/assign', { userId: userRolePublic.id, roleId: rolePublic.id }, root);
+		userRoleBadge = await signup({ username: 'userRoleBadge' });
+		roleBadge = await role(root, { asBadge: true, name: 'Badge Role' });
+		await api('admin/roles/assign', { userId: userRoleBadge.id, roleId: roleBadge.id }, root);
+		userSilenced = await signup({ username: 'userSilenced' });
+		await post(userSilenced, { text: 'test' });
+		roleSilenced = await role(root, {}, { canPublicNote: { priority: 0, useDefault: false, value: false } });
+		await api('admin/roles/assign', { userId: userSilenced.id, roleId: roleSilenced.id }, root);
+		userSuspended = await signup({ username: 'userSuspended' });
+		await post(userSuspended, { text: 'test' });
+		await successfulApiCall({ endpoint: 'i/update', parameters: { description: '#user_testuserSuspended' }, user: userSuspended });
+		await api('admin/suspend-user', { userId: userSuspended.id }, root);
+		userDeletedBySelf = await signup({ username: 'userDeletedBySelf', password: 'userDeletedBySelf' });
+		await post(userDeletedBySelf, { text: 'test' });
+		await api('i/delete-account', { password: 'userDeletedBySelf' }, userDeletedBySelf);
+		userDeletedByAdmin = await signup({ username: 'userDeletedByAdmin' });
+		await post(userDeletedByAdmin, { text: 'test' });
+		await api('admin/delete-account', { userId: userDeletedByAdmin.id }, root);
+		userFollowingAlice = await signup({ username: 'userFollowingAlice' });
+		await post(userFollowingAlice, { text: 'test' });
+		await api('following/create', { userId: alice.id }, userFollowingAlice);
+		userFollowedByAlice = await signup({ username: 'userFollowedByAlice' });
+		await post(userFollowedByAlice, { text: 'test' });
+		await api('following/create', { userId: userFollowedByAlice.id }, alice);
+		userBlockingAlice = await signup({ username: 'userBlockingAlice' });
+		await post(userBlockingAlice, { text: 'test' });
+		await api('blocking/create', { userId: alice.id }, userBlockingAlice);
+		userBlockedByAlice = await signup({ username: 'userBlockedByAlice' });
+		await post(userBlockedByAlice, { text: 'test' });
+		await api('blocking/create', { userId: userBlockedByAlice.id }, alice);
+		userMutingAlice = await signup({ username: 'userMutingAlice' });
+		await post(userMutingAlice, { text: 'test' });
+		await api('mute/create', { userId: alice.id }, userMutingAlice);
+		userMutedByAlice = await signup({ username: 'userMutedByAlice' });
+		await post(userMutedByAlice, { text: 'test' });
+		await api('mute/create', { userId: userMutedByAlice.id }, alice);
+		userRnMutingAlice = await signup({ username: 'userRnMutingAlice' });
+		await post(userRnMutingAlice, { text: 'test' });
+		await api('renote-mute/create', { userId: alice.id }, userRnMutingAlice);
+		userRnMutedByAlice = await signup({ username: 'userRnMutedByAlice' });
+		await post(userRnMutedByAlice, { text: 'test' });
+		await api('renote-mute/create', { userId: userRnMutedByAlice.id }, alice);
+		userFollowRequesting = await signup({ username: 'userFollowRequesting' });
+		await post(userFollowRequesting, { text: 'test' });
+		userFollowRequested = userLocking;
+		await api('following/create', { userId: userFollowRequested.id }, userFollowRequesting);
+	}, 1000 * 60 * 10);
+
+	afterAll(async () => {
+		await app.close();
+	});
+
+	beforeEach(async () => {
+		alice = {
+			...alice,
+			...await successfulApiCall({ endpoint: 'i', parameters: {}, user: alice }) as any,
+		};
+		aliceNote = await successfulApiCall({ endpoint: 'notes/show', parameters: { noteId: aliceNote.id }, user: alice });
+	});
+
+	//#region サインアップ(signup)
+
+	test('が作れる。（作りたての状態で自分のユーザー情報が取れる）', async () => {
+		// SignupApiService.ts
+		const response = await successfulApiCall({
+			endpoint: 'signup',
+			parameters: { username: 'zoe', password: 'password' },
+			user: undefined,
+		}) as unknown as User; // BUG MeDetailedに足りないキーがある
+
+		// signupの時はtokenが含まれる特別なMeDetailedが返ってくる
+		assert.match(response.token, /[a-zA-Z0-9]{16}/);
+
+		// UserLite
+		assert.match(response.id, /[0-9a-z]{10}/);
+		assert.strictEqual(response.name, null);
+		assert.strictEqual(response.username, 'zoe');
+		assert.strictEqual(response.host, null);
+		assert.match(response.avatarUrl, /^[-a-zA-Z0-9@:%._\+~#&?=\/]+$/);
+		assert.strictEqual(response.avatarBlurhash, null);
+		assert.strictEqual(response.isBot, false);
+		assert.strictEqual(response.isCat, false);
+		assert.strictEqual(response.instance, undefined);
+		assert.deepStrictEqual(response.emojis, {});
+		assert.strictEqual(response.onlineStatus, 'unknown');
+		assert.deepStrictEqual(response.badgeRoles, []);
+		// UserDetailedNotMeOnly
+		assert.strictEqual(response.url, null);
+		assert.strictEqual(response.uri, null);
+		assert.strictEqual(response.movedTo, null);
+		assert.strictEqual(response.alsoKnownAs, null);
+		assert.strictEqual(response.createdAt, new Date(response.createdAt).toISOString());
+		assert.strictEqual(response.updatedAt, null);
+		assert.strictEqual(response.lastFetchedAt, null);
+		assert.strictEqual(response.bannerUrl, null);
+		assert.strictEqual(response.bannerBlurhash, null);
+		assert.strictEqual(response.isLocked, false);
+		assert.strictEqual(response.isSilenced, false);
+		assert.strictEqual(response.isSuspended, false);
+		assert.strictEqual(response.description, null);
+		assert.strictEqual(response.location, null);
+		assert.strictEqual(response.birthday, null);
+		assert.strictEqual(response.lang, null);
+		assert.deepStrictEqual(response.fields, []);
+		assert.strictEqual(response.followersCount, 0);
+		assert.strictEqual(response.followingCount, 0);
+		assert.strictEqual(response.notesCount, 0);
+		assert.deepStrictEqual(response.pinnedNoteIds, []);
+		assert.deepStrictEqual(response.pinnedNotes, []);
+		assert.strictEqual(response.pinnedPageId, null);
+		assert.strictEqual(response.pinnedPage, null);
+		assert.strictEqual(response.publicReactions, false);
+		assert.strictEqual(response.ffVisibility, 'public');
+		assert.strictEqual(response.twoFactorEnabled, false);
+		assert.strictEqual(response.usePasswordLessLogin, false);
+		assert.strictEqual(response.securityKeys, false);
+		assert.deepStrictEqual(response.roles, []);
+		assert.strictEqual(response.memo, null);
+		
+		// MeDetailedOnly
+		assert.strictEqual(response.avatarId, null);
+		assert.strictEqual(response.bannerId, null);
+		assert.strictEqual(response.isModerator, false);
+		assert.strictEqual(response.isAdmin, false);
+		assert.strictEqual(response.injectFeaturedNote, true);
+		assert.strictEqual(response.receiveAnnouncementEmail, true);
+		assert.strictEqual(response.alwaysMarkNsfw, false);
+		assert.strictEqual(response.autoSensitive, false);
+		assert.strictEqual(response.carefulBot, false);
+		assert.strictEqual(response.autoAcceptFollowed, true);
+		assert.strictEqual(response.noCrawle, false);
+		assert.strictEqual(response.preventAiLearning, true);
+		assert.strictEqual(response.isExplorable, true);
+		assert.strictEqual(response.isDeleted, false);
+		assert.strictEqual(response.hideOnlineStatus, false);
+		assert.strictEqual(response.hasUnreadSpecifiedNotes, false);
+		assert.strictEqual(response.hasUnreadMentions, false);
+		assert.strictEqual(response.hasUnreadAnnouncement, false);
+		assert.strictEqual(response.hasUnreadAntenna, false);
+		assert.strictEqual(response.hasUnreadChannel, false);
+		assert.strictEqual(response.hasUnreadNotification, false);
+		assert.strictEqual(response.hasPendingReceivedFollowRequest, false);
+		assert.deepStrictEqual(response.mutedWords, []);
+		assert.deepStrictEqual(response.mutedInstances, []);
+		assert.deepStrictEqual(response.mutingNotificationTypes, []);
+		assert.deepStrictEqual(response.emailNotificationTypes, ['follow', 'receiveFollowRequest']);
+		assert.strictEqual(response.showTimelineReplies, false);
+		assert.deepStrictEqual(response.achievements, []);
+		assert.deepStrictEqual(response.loggedInDays, 0);
+		assert.deepStrictEqual(response.policies, DEFAULT_POLICIES); 
+		assert.notStrictEqual(response.email, undefined);
+		assert.strictEqual(response.emailVerified, false);
+		assert.deepStrictEqual(response.securityKeysList, []);
+	});
+
+	//#endregion
+	//#region 自分の情報(i)
+
+	test('を読み取ることができること（自分）、キーが過不足なく入っていること。', async () => {
+		const response = await successfulApiCall({
+			endpoint: 'i',
+			parameters: {},
+			user: userNoNote,
+		});
+		const expected = meDetailed(userNoNote, true);
+		expected.loggedInDays = 1; // iはloggedInDaysを更新する
+		assert.deepStrictEqual(response, expected);
+	});
+
+	//#endregion
+	//#region 自分の情報の更新(i/update)
+
+	test.each([
+		{ parameters: (): object => ({ name: null }) },
+		{ parameters: (): object => ({ name: 'x'.repeat(50) }) },
+		{ parameters: (): object => ({ name: 'x' }) },
+		{ parameters: (): object => ({ name: 'My name' }) },
+		{ parameters: (): object => ({ description: null }) },
+		{ parameters: (): object => ({ description: 'x'.repeat(1500) }) },
+		{ parameters: (): object => ({ description: 'x' }) },
+		{ parameters: (): object => ({ description: 'My description' }) },
+		{ parameters: (): object => ({ location: null }) },
+		{ parameters: (): object => ({ location: 'x'.repeat(50) }) },
+		{ parameters: (): object => ({ location: 'x' }) },
+		{ parameters: (): object => ({ location: 'My location' }) },
+		{ parameters: (): object => ({ birthday: '0000-00-00' }) },
+		{ parameters: (): object => ({ birthday: '9999-99-99' }) },
+		{ parameters: (): object => ({ lang: 'en-US' }) },
+		{ parameters: (): object => ({ fields: [] }) },
+		{ parameters: (): object => ({ fields: [{ name: 'x', value: 'x' }] }) },
+		{ parameters: (): object => ({ fields: [{ name: 'x'.repeat(3000), value: 'x'.repeat(3000) }] }) }, // BUG? fieldには制限がない
+		{ parameters: (): object => ({ fields: Array(16).fill({ name: 'x', value: 'y' }) }) },
+		{ parameters: (): object => ({ isLocked: true }) },
+		{ parameters: (): object => ({ isLocked: false }) },
+		{ parameters: (): object => ({ isExplorable: false }) },
+		{ parameters: (): object => ({ isExplorable: true }) },
+		{ parameters: (): object => ({ hideOnlineStatus: true }) },
+		{ parameters: (): object => ({ hideOnlineStatus: false }) },
+		{ parameters: (): object => ({ publicReactions: false }) },
+		{ parameters: (): object => ({ publicReactions: true }) },
+		{ parameters: (): object => ({ autoAcceptFollowed: true }) },
+		{ parameters: (): object => ({ autoAcceptFollowed: false }) },
+		{ parameters: (): object => ({ noCrawle: true }) },
+		{ parameters: (): object => ({ noCrawle: false }) },
+		{ parameters: (): object => ({ preventAiLearning: false }) },
+		{ parameters: (): object => ({ preventAiLearning: true }) },
+		{ parameters: (): object => ({ isBot: true }) },
+		{ parameters: (): object => ({ isBot: false }) },
+		{ parameters: (): object => ({ isCat: true }) },
+		{ parameters: (): object => ({ isCat: false }) },
+		{ parameters: (): object => ({ showTimelineReplies: true }) },
+		{ parameters: (): object => ({ showTimelineReplies: false }) },
+		{ parameters: (): object => ({ injectFeaturedNote: true }) },
+		{ parameters: (): object => ({ injectFeaturedNote: false }) },
+		{ parameters: (): object => ({ receiveAnnouncementEmail: true }) },
+		{ parameters: (): object => ({ receiveAnnouncementEmail: false }) },
+		{ parameters: (): object => ({ alwaysMarkNsfw: true }) },
+		{ parameters: (): object => ({ alwaysMarkNsfw: false }) },
+		{ parameters: (): object => ({ autoSensitive: true }) },
+		{ parameters: (): object => ({ autoSensitive: false }) },
+		{ parameters: (): object => ({ ffVisibility: 'private' }) },
+		{ parameters: (): object => ({ ffVisibility: 'followers' }) },
+		{ parameters: (): object => ({ ffVisibility: 'public' }) },
+		{ parameters: (): object => ({ mutedWords: Array(19).fill(['xxxxx']) }) },
+		{ parameters: (): object => ({ mutedWords: [['x'.repeat(194)]] }) },
+		{ parameters: (): object => ({ mutedWords: [] }) },
+		{ parameters: (): object => ({ mutedInstances: ['xxxx.xxxxx'] }) },
+		{ parameters: (): object => ({ mutedInstances: [] }) },
+		{ parameters: (): object => ({ mutingNotificationTypes: ['follow', 'mention', 'reply', 'renote', 'quote', 'reaction', 'pollEnded', 'receiveFollowRequest', 'followRequestAccepted', 'achievementEarned', 'app'] }) },
+		{ parameters: (): object => ({ mutingNotificationTypes: [] }) },
+		{ parameters: (): object => ({ emailNotificationTypes: ['mention', 'reply', 'quote', 'follow', 'receiveFollowRequest'] }) },
+		{ parameters: (): object => ({ emailNotificationTypes: [] }) },
+	] as const)('を書き換えることができる($#)', async ({ parameters }) => {
+		const response = await successfulApiCall({ endpoint: 'i/update', parameters: parameters(), user: alice });
+		const expected = { ...meDetailed(alice, true), ...parameters() };
+		assert.deepStrictEqual(response, expected, inspect(parameters()));
+	});
+
+	test('を書き換えることができる(Avatar)', async () => {
+		const aliceFile = (await uploadFile(alice)).body;
+		const parameters = { avatarId: aliceFile.id };
+		const response = await successfulApiCall({ endpoint: 'i/update', parameters: parameters, user: alice });
+		assert.match(response.avatarUrl ?? '.', /^[-a-zA-Z0-9@:%._\+~#&?=\/]+$/);
+		assert.match(response.avatarBlurhash ?? '.', /[ -~]{54}/);
+		const expected = { 
+			...meDetailed(alice, true), 
+			avatarId: aliceFile.id,
+			avatarBlurhash: response.avatarBlurhash,
+			avatarUrl: response.avatarUrl,
+		};
+		assert.deepStrictEqual(response, expected, inspect(parameters));
+
+		const parameters2 = { avatarId: null };
+		const response2 = await successfulApiCall({ endpoint: 'i/update', parameters: parameters2, user: alice });
+		const expected2 = { 
+			...meDetailed(alice, true), 
+			avatarId: null,
+			avatarBlurhash: null,
+			avatarUrl: alice.avatarUrl, // 解除した場合、identiconになる
+		};
+		assert.deepStrictEqual(response2, expected2, inspect(parameters));
+	});
+
+	test('を書き換えることができる(Banner)', async () => {
+		const aliceFile = (await uploadFile(alice)).body;
+		const parameters = { bannerId: aliceFile.id };
+		const response = await successfulApiCall({ endpoint: 'i/update', parameters: parameters, user: alice });
+		assert.match(response.bannerUrl ?? '.', /^[-a-zA-Z0-9@:%._\+~#&?=\/]+$/);
+		assert.match(response.bannerBlurhash ?? '.', /[ -~]{54}/);
+		const expected = { 
+			...meDetailed(alice, true), 
+			bannerId: aliceFile.id,
+			bannerBlurhash: response.bannerBlurhash,
+			bannerUrl: response.bannerUrl,
+		};
+		assert.deepStrictEqual(response, expected, inspect(parameters));
+
+		const parameters2 = { bannerId: null };
+		const response2 = await successfulApiCall({ endpoint: 'i/update', parameters: parameters2, user: alice });
+		const expected2 = { 
+			...meDetailed(alice, true), 
+			bannerId: null,
+			bannerBlurhash: null,
+			bannerUrl: null,
+		};
+		assert.deepStrictEqual(response2, expected2, inspect(parameters));
+	});
+
+	//#endregion
+	//#region 自分の情報の更新(i/pin, i/unpin)
+
+	test('を書き換えることができる(ピン止めノート)', async () => {
+		const parameters = { noteId: aliceNote.id };
+		const response = await successfulApiCall({ endpoint: 'i/pin', parameters, user: alice });
+		const expected = { ...meDetailed(alice, false), pinnedNoteIds: [aliceNote.id], pinnedNotes: [aliceNote] };
+		assert.deepStrictEqual(response, expected);
+		
+		const response2 = await successfulApiCall({ endpoint: 'i/unpin', parameters, user: alice });
+		const expected2 = meDetailed(alice, false);
+		assert.deepStrictEqual(response2, expected2);
+	});
+
+	//#endregion
+	//#region メモの更新(users/update-memo)
+
+	test.each([
+		{ label: '最大長', memo: 'x'.repeat(2048) },
+		{ label: '空文字', memo: '', expects: null },
+		{ label: 'null', memo: null },
+	])('を書き換えることができる(メモを$labelに)', async ({ memo, expects }) => {
+		const expected = { ...await show(bob.id, alice), memo: expects === undefined ? memo : expects };
+		const parameters = { userId: bob.id, memo };
+		await successfulApiCall({ endpoint: 'users/update-memo', parameters, user: alice });
+		const response = await show(bob.id, alice);
+		assert.deepStrictEqual(response, expected);
+	});
+
+	//#endregion
+	//#region ユーザー(users)
+
+	test.each([
+		{ label: 'ID昇順', parameters: { limit: 5 }, selector: (u: UserLite): string => u.id },
+		{ label: 'フォロワー昇順', parameters: { sort: '+follower' }, selector: (u: UserDetailedNotMe): string => String(u.followersCount) },
+		{ label: 'フォロワー降順', parameters: { sort: '-follower' }, selector: (u: UserDetailedNotMe): string => String(u.followersCount) },
+		{ label: '登録日時昇順', parameters: { sort: '+createdAt' }, selector: (u: UserDetailedNotMe): string => u.createdAt },
+		{ label: '登録日時降順', parameters: { sort: '-createdAt' }, selector: (u: UserDetailedNotMe): string => u.createdAt },
+		{ label: '投稿日時昇順', parameters: { sort: '+updatedAt' }, selector: (u: UserDetailedNotMe): string => String(u.updatedAt) },
+		{ label: '投稿日時降順', parameters: { sort: '-updatedAt' }, selector: (u: UserDetailedNotMe): string => String(u.updatedAt) },
+	] as const)('をリスト形式で取得することができる（$label）', async ({ parameters, selector }) => {
+		const response = await successfulApiCall({ endpoint: 'users', parameters, user: alice });
+
+		// 結果の並びを事前にアサートするのは困難なので返ってきたidに対応するユーザーが返っており、ソート順が正しいことだけを検証する
+		const users = await Promise.all(response.map(u => show(u.id, alice)));
+		const expected = users.sort((x, y) => {
+			const index = (selector(x) < selector(y)) ? -1 : (selector(x) > selector(y)) ? 1 : 0;
+			return index * (parameters.sort?.startsWith('+') ? -1 : 1);
+		});
+		assert.deepStrictEqual(response, expected);
+	});
+	test.each([
+		{ label: '「見つけやすくする」がOFFのユーザーが含まれない', user: (): User => userNotExplorable, excluded: true },
+		{ label: 'ミュートユーザーが含まれない', user: (): User => userMutedByAlice, excluded: true },
+		{ label: 'ブロックされているユーザーが含まれない', user: (): User => userBlockedByAlice, excluded: true },
+		{ label: 'ブロックしてきているユーザーが含まれる', user: (): User => userBlockingAlice, excluded: true },
+		{ label: '承認制ユーザーが含まれる', user: (): User => userLocking },
+		{ label: 'サイレンスユーザーが含まれる', user: (): User => userSilenced },
+		{ label: 'サスペンドユーザーが含まれない', user: (): User => userSuspended, excluded: true },
+		{ label: '削除済ユーザーが含まれる', user: (): User => userDeletedBySelf },
+		{ label: '削除済(byAdmin)ユーザーが含まれる', user: (): User => userDeletedByAdmin },
+	] as const)('をリスト形式で取得することができ、結果に$label', async ({ user, excluded }) => {
+		const parameters = { limit: 100 };
+		const response = await successfulApiCall({ endpoint: 'users', parameters, user: alice });
+		const expected = (excluded ?? false) ? [] : [await show(user().id, alice)];
+		assert.deepStrictEqual(response.filter((u) => u.id === user().id), expected);
+	});
+	test.todo('をリスト形式で取得することができる（リモート, hostname指定）');
+	test.todo('をリスト形式で取得することができる（pagenation）');
+	
+	//#endregion
+	//#region ユーザー情報(users/show)
+
+	test.each([
+		{ label: 'ID指定で自分自身を', parameters: (): object => ({ userId: alice.id }), user: (): User => alice, type: meDetailed },
+		{ label: 'ID指定で他人を', parameters: (): object => ({ userId: alice.id }), user: (): User => bob, type: userDetailedNotMeWithRelations },
+		{ label: 'ID指定かつ未認証', parameters: (): object => ({ userId: alice.id }), user: undefined, type: userDetailedNotMe },
+		{ label: '@指定で自分自身を', parameters: (): object => ({ username: alice.username }), user: (): User => alice, type: meDetailed },
+		{ label: '@指定で他人を', parameters: (): object => ({ username: alice.username }), user: (): User => bob, type: userDetailedNotMeWithRelations },
+		{ label: '@指定かつ未認証', parameters: (): object => ({ username: alice.username }), user: undefined, type: userDetailedNotMe },
+	] as const)('を取得することができる（$label）', async ({ parameters, user, type }) => {
+		const response = await successfulApiCall({ endpoint: 'users/show', parameters: parameters(), user: user?.() });
+		const expected = type(alice);
+		assert.deepStrictEqual(response, expected);
+	});
+	test.each([
+		{ label: 'Administratorになっている', user: (): User => userAdmin, me: (): User => userAdmin, selector: (user: User): unknown => user.isAdmin },
+		{ label: '自分以外から見たときはAdministratorか判定できない', user: (): User => userAdmin, selector: (user: User): unknown => user.isAdmin, expected: (): undefined => undefined },
+		{ label: 'Moderatorになっている', user: (): User => userModerator, me: (): User => userModerator, selector: (user: User): unknown => user.isModerator },
+		{ label: '自分以外から見たときはModeratorか判定できない', user: (): User => userModerator, selector: (user: User): unknown => user.isModerator, expected: (): undefined => undefined },
+		{ label: 'サイレンスになっている', user: (): User => userSilenced, selector: (user: User): unknown => user.isSilenced },
+		//{ label: 'サスペンドになっている', user: (): User => userSuspended, selector: (user: User): unknown => user.isSuspended },
+		{ label: '削除済みになっている', user: (): User => userDeletedBySelf, me: (): User => userDeletedBySelf, selector: (user: User): unknown => user.isDeleted },
+		{ label: '自分以外から見たときは削除済みか判定できない', user: (): User => userDeletedBySelf, selector: (user: User): unknown => user.isDeleted, expected: (): undefined => undefined },
+		{ label: '削除済み(byAdmin)になっている', user: (): User => userDeletedByAdmin, me: (): User => userDeletedByAdmin, selector: (user: User): unknown => user.isDeleted },
+		{ label: '自分以外から見たときは削除済み(byAdmin)か判定できない', user: (): User => userDeletedByAdmin, selector: (user: User): unknown => user.isDeleted, expected: (): undefined => undefined },
+		{ label: 'フォロー中になっている', user: (): User => userFollowedByAlice, selector: (user: User): unknown => user.isFollowing },
+		{ label: 'フォローされている', user: (): User => userFollowingAlice, selector: (user: User): unknown => user.isFollowed },
+		{ label: 'ブロック中になっている', user: (): User => userBlockedByAlice, selector: (user: User): unknown => user.isBlocking },
+		{ label: 'ブロックされている', user: (): User => userBlockingAlice, selector: (user: User): unknown => user.isBlocked },
+		{ label: 'ミュート中になっている', user: (): User => userMutedByAlice, selector: (user: User): unknown => user.isMuted },
+		{ label: 'リノートミュート中になっている', user: (): User => userRnMutedByAlice, selector: (user: User): unknown => user.isRenoteMuted },
+		{ label: 'フォローリクエスト中になっている', user: (): User => userFollowRequested, me: (): User => userFollowRequesting, selector: (user: User): unknown => user.hasPendingFollowRequestFromYou },
+		{ label: 'フォローリクエストされている', user: (): User => userFollowRequesting, me: (): User => userFollowRequested, selector: (user: User): unknown => user.hasPendingFollowRequestToYou },
+	] as const)('を取得することができ、$labelこと', async ({ user, me, selector, expected }) => {
+		const response = await successfulApiCall({ endpoint: 'users/show', parameters: { userId: user().id }, user: me?.() ?? alice });
+		assert.strictEqual(selector(response), (expected ?? ((): true => true))());
+	});
+	test('を取得することができ、Publicなロールがセットされていること', async () => {
+		const response = await successfulApiCall({ endpoint: 'users/show', parameters: { userId: userRolePublic.id }, user: alice });
+		assert.deepStrictEqual(response.badgeRoles, []);
+		assert.deepStrictEqual(response.roles, [{
+			id: rolePublic.id,
+			name: rolePublic.name,
+			color: rolePublic.color,
+			iconUrl: rolePublic.iconUrl,
+			description: rolePublic.description,
+			isModerator: rolePublic.isModerator,
+			isAdministrator: rolePublic.isAdministrator,
+			displayOrder: rolePublic.displayOrder,
+		}]);
+	});
+	test('を取得することができ、バッヂロールがセットされていること', async () => {
+		const response = await successfulApiCall({ endpoint: 'users/show', parameters: { userId: userRoleBadge.id }, user: alice });
+		assert.deepStrictEqual(response.badgeRoles, [{
+			name: roleBadge.name,
+			iconUrl: roleBadge.iconUrl,
+			displayOrder: roleBadge.displayOrder,
+		}]);
+		assert.deepStrictEqual(response.roles, []); // バッヂだからといってrolesが取れるとは限らない
+	});
+	test('をID指定のリスト形式で取得することができる（空）', async () => {
+		const parameters = { userIds: [] };
+		const response = await successfulApiCall({ endpoint: 'users/show', parameters, user: alice });
+		const expected: [] = [];
+		assert.deepStrictEqual(response, expected);
+	});
+	test('をID指定のリスト形式で取得することができる', async() => {
+		const parameters = { userIds: [bob.id, alice.id, carol.id] };
+		const response = await successfulApiCall({ endpoint: 'users/show', parameters, user: alice });
+		const expected = [
+			await successfulApiCall({ endpoint: 'users/show', parameters: { userId: bob.id }, user: alice }), 
+			await successfulApiCall({ endpoint: 'users/show', parameters: { userId: alice.id }, user: alice }), 
+			await successfulApiCall({ endpoint: 'users/show', parameters: { userId: carol.id }, user: alice }), 
+		];
+		assert.deepStrictEqual(response, expected);
+	});
+	test.each([
+		{ label: '「見つけやすくする」がOFFのユーザーが含まれる', user: (): User => userNotExplorable },
+		{ label: 'ミュートユーザーが含まれる', user: (): User => userMutedByAlice },
+		{ label: 'ブロックされているユーザーが含まれる', user: (): User => userBlockedByAlice },
+		{ label: 'ブロックしてきているユーザーが含まれる', user: (): User => userBlockingAlice },
+		{ label: '承認制ユーザーが含まれる', user: (): User => userLocking },
+		{ label: 'サイレンスユーザーが含まれる', user: (): User => userSilenced },
+		{ label: 'サスペンドユーザーが（モデレーターが見るときは）含まれる', user: (): User => userSuspended, me: (): User => root },
+		// BUG サスペンドユーザーを一般ユーザーから見るとrootユーザーが返ってくる
+		//{ label: 'サスペンドユーザーが（一般ユーザーが見るときは）含まれない', user: (): User => userSuspended, me: (): User => bob, excluded: true },
+		{ label: '削除済ユーザーが含まれる', user: (): User => userDeletedBySelf },
+		{ label: '削除済(byAdmin)ユーザーが含まれる', user: (): User => userDeletedByAdmin },	
+	] as const)('をID指定のリスト形式で取得することができ、結果に$label', async ({ user, me, excluded }) => {
+		const parameters = { userIds: [user().id] };
+		const response = await successfulApiCall({ endpoint: 'users/show', parameters, user: me?.() ?? alice });
+		const expected = (excluded ?? false) ? [] : [await show(user().id, me?.() ?? alice)];
+		assert.deepStrictEqual(response, expected);
+	});
+	test.todo('をID指定のリスト形式で取得することができる(リモート)');
+
+	//#endregion
+	//#region 検索(users/search)
+
+	test('を検索することができる', async () => {
+		const parameters = { query: 'carol', limit: 10 };
+		const response = await successfulApiCall({ endpoint: 'users/search', parameters, user: alice });
+		const expected = [await show(carol.id, alice)];
+		assert.deepStrictEqual(response, expected);
+	});
+	test('を検索することができる(UserLite)', async () => {
+		const parameters = { query: 'carol', detail: false, limit: 10 };
+		const response = await successfulApiCall({ endpoint: 'users/search', parameters, user: alice });
+		const expected = [userLite(await show(carol.id, alice))];
+		assert.deepStrictEqual(response, expected);
+	});
+	test.each([
+		{ label: '「見つけやすくする」がOFFのユーザーが含まれる', user: (): User => userNotExplorable },
+		{ label: 'ミュートユーザーが含まれる', user: (): User => userMutedByAlice },
+		{ label: 'ブロックされているユーザーが含まれる', user: (): User => userBlockedByAlice },
+		{ label: 'ブロックしてきているユーザーが含まれる', user: (): User => userBlockingAlice },
+		{ label: '承認制ユーザーが含まれる', user: (): User => userLocking },
+		{ label: 'サイレンスユーザーが含まれる', user: (): User => userSilenced },
+		{ label: 'サスペンドユーザーが含まれない', user: (): User => userSuspended, excluded: true },
+		{ label: '削除済ユーザーが含まれる', user: (): User => userDeletedBySelf },
+		{ label: '削除済(byAdmin)ユーザーが含まれる', user: (): User => userDeletedByAdmin },	
+	] as const)('を検索することができ、結果に$labelが含まれる', async ({ user, excluded }) => {
+		const parameters = { query: user().username, limit: 1 };
+		const response = await successfulApiCall({ endpoint: 'users/search', parameters, user: alice });
+		const expected = (excluded ?? false) ? [] : [await show(user().id, alice)];
+		assert.deepStrictEqual(response, expected);
+	});
+	test.todo('を検索することができる(リモート)');
+	test.todo('を検索することができる(pagenation)');
+
+	//#endregion
+	//#region ID指定検索(users/search-by-username-and-host)
+
+	test.each([ 
+		{ label: '自分', parameters: { username: 'alice' }, user: (): User[] => [alice] },
+		{ label: '自分かつusernameが大文字', parameters: { username: 'ALICE' }, user: (): User[] => [alice] },
+		{ label: 'ローカルのフォロイーでノートなし', parameters: { username: 'userFollowedByAlice' }, user: (): User[] => [userFollowedByAlice] },
+		{ label: 'ローカルでノートなしは検索に載らない', parameters: { username: 'userNoNote' }, user: (): User[] => [] },
+		{ label: 'ローカルの他人1', parameters: { username: 'bob' }, user: (): User[] => [bob] },
+		{ label: 'ローカルの他人2', parameters: { username: 'bob', host: null }, user: (): User[] => [bob] },
+		{ label: 'ローカルの他人3', parameters: { username: 'bob', host: '.' }, user: (): User[] => [bob] },
+		{ label: 'ローカル', parameters: { host: null, limit: 1 }, user: (): User[] => [userFollowedByAlice] },
+		{ label: 'ローカル', parameters: { host: '.', limit: 1 }, user: (): User[] => [userFollowedByAlice] },
+	])('をID&ホスト指定で検索できる($label)', async ({ parameters, user }) => {
+		const response = await successfulApiCall({ endpoint: 'users/search-by-username-and-host', parameters, user: alice });
+		const expected = await Promise.all(user().map(u => show(u.id, alice)));
+		assert.deepStrictEqual(response, expected);
+	});
+	test.each([
+		{ label: '「見つけやすくする」がOFFのユーザーが含まれる', user: (): User => userNotExplorable },
+		{ label: 'ミュートユーザーが含まれる', user: (): User => userMutedByAlice },
+		{ label: 'ブロックされているユーザーが含まれる', user: (): User => userBlockedByAlice },
+		{ label: 'ブロックしてきているユーザーが含まれる', user: (): User => userBlockingAlice },
+		{ label: '承認制ユーザーが含まれる', user: (): User => userLocking },
+		{ label: 'サイレンスユーザーが含まれる', user: (): User => userSilenced },
+		{ label: 'サスペンドユーザーが含まれない', user: (): User => userSuspended, excluded: true },
+		{ label: '削除済ユーザーが含まれる', user: (): User => userDeletedBySelf },
+		{ label: '削除済(byAdmin)ユーザーが含まれる', user: (): User => userDeletedByAdmin },
+	] as const)('をID&ホスト指定で検索でき、結果に$label', async ({ user, excluded }) => {
+		const parameters = { username: user().username };
+		const response = await successfulApiCall({ endpoint: 'users/search-by-username-and-host', parameters, user: alice });
+		const expected = (excluded ?? false) ? [] : [await show(user().id, alice)];
+		assert.deepStrictEqual(response, expected);
+	});
+	test.todo('をID&ホスト指定で検索できる(リモート)');
+
+	//#endregion
+	//#region ID指定検索(users/get-frequently-replied-users)
+
+	test('がよくリプライをするユーザーのリストを取得できる', async () => {
+		const parameters = { userId: alice.id, limit: 5 };
+		const response = await successfulApiCall({ endpoint: 'users/get-frequently-replied-users', parameters, user: alice });
+		const expected = await Promise.all(usersReplying.slice(0, parameters.limit).map(async (s, i) => ({ 
+			user: await show(s.id, alice),
+			weight: (usersReplying.length - i) / usersReplying.length,
+		})));
+		assert.deepStrictEqual(response, expected);
+	});
+	test.each([
+		{ label: '「見つけやすくする」がOFFのユーザーが含まれる', user: (): User => userNotExplorable },
+		{ label: 'ミュートユーザーが含まれる', user: (): User => userMutedByAlice },
+		{ label: 'ブロックされているユーザーが含まれる', user: (): User => userBlockedByAlice },
+		{ label: 'ブロックしてきているユーザーが含まれない', user: (): User => userBlockingAlice, excluded: true },
+		{ label: '承認制ユーザーが含まれる', user: (): User => userLocking },
+		{ label: 'サイレンスユーザーが含まれる', user: (): User => userSilenced },
+		//{ label: 'サスペンドユーザーが含まれない', user: (): User => userSuspended, excluded: true },
+		{ label: '削除済ユーザーが含まれる', user: (): User => userDeletedBySelf },
+		{ label: '削除済(byAdmin)ユーザーが含まれる', user: (): User => userDeletedByAdmin },
+	] as const)('がよくリプライをするユーザーのリストを取得でき、結果に$label', async ({ user, excluded }) => {
+		const replyTo = (await successfulApiCall({ endpoint: 'users/notes', parameters: { userId: user().id }, user: undefined }))[0];
+		await post(alice, { text: `@${user().username} test`, replyId: replyTo.id });
+		const parameters = { userId: alice.id, limit: 100 };
+		const response = await successfulApiCall({ endpoint: 'users/get-frequently-replied-users', parameters, user: alice });
+		const expected = (excluded ?? false) ? [] : [await show(user().id, alice)];
+		assert.deepStrictEqual(response.map(s => s.user).filter((u) => u.id === user().id), expected);
+	});
+
+	//#endregion
+	//#region ハッシュタグ(hashtags/users)
+
+	test.each([
+		{ label: 'フォロワー昇順', sort: { sort: '+follower' }, selector: (u: UserDetailedNotMe): string => String(u.followersCount) },
+		{ label: 'フォロワー降順', sort: { sort: '-follower' }, selector: (u: UserDetailedNotMe): string => String(u.followersCount) },
+		{ label: '登録日時昇順', sort: { sort: '+createdAt' }, selector: (u: UserDetailedNotMe): string => u.createdAt },
+		{ label: '登録日時降順', sort: { sort: '-createdAt' }, selector: (u: UserDetailedNotMe): string => u.createdAt },
+		{ label: '投稿日時昇順', sort: { sort: '+updatedAt' }, selector: (u: UserDetailedNotMe): string => String(u.updatedAt) },
+		{ label: '投稿日時降順', sort: { sort: '-updatedAt' }, selector: (u: UserDetailedNotMe): string => String(u.updatedAt) },
+	] as const)('をハッシュタグ指定で取得することができる($label)', async ({ sort, selector }) => {
+		const hashtag = 'test_hashtag';
+		await successfulApiCall({ endpoint: 'i/update', parameters: { description: `#${hashtag}` }, user: alice });
+		const parameters = { tag: hashtag, limit: 5, ...sort };
+		const response = await successfulApiCall({ endpoint: 'hashtags/users', parameters, user: alice });
+		const users = await Promise.all(response.map(u => show(u.id, alice)));
+		const expected = users.sort((x, y) => {
+			const index = (selector(x) < selector(y)) ? -1 : (selector(x) > selector(y)) ? 1 : 0;
+			return index * (parameters.sort.startsWith('+') ? -1 : 1);
+		});
+		assert.deepStrictEqual(response, expected);
+	});
+	test.each([
+		{ label: '「見つけやすくする」がOFFのユーザーが含まれる', user: (): User => userNotExplorable },
+		{ label: 'ミュートユーザーが含まれる', user: (): User => userMutedByAlice },
+		{ label: 'ブロックされているユーザーが含まれる', user: (): User => userBlockedByAlice },
+		{ label: 'ブロックしてきているユーザーが含まれる', user: (): User => userBlockingAlice },
+		{ label: '承認制ユーザーが含まれる', user: (): User => userLocking },
+		{ label: 'サイレンスユーザーが含まれる', user: (): User => userSilenced },
+		{ label: 'サスペンドユーザーが含まれない', user: (): User => userSuspended, excluded: true },
+		{ label: '削除済ユーザーが含まれる', user: (): User => userDeletedBySelf },
+		{ label: '削除済(byAdmin)ユーザーが含まれる', user: (): User => userDeletedByAdmin },
+	] as const)('をハッシュタグ指定で取得することができ、結果に$label', async ({ user, excluded }) => {
+		const hashtag = `user_test${user().username}`;
+		if (user() !== userSuspended) {
+			// サスペンドユーザーはupdateできない。
+			await successfulApiCall({ endpoint: 'i/update', parameters: { description: `#${hashtag}` }, user: user() });
+		}
+		const parameters = { tag: hashtag, limit: 100, sort: '-follower' } as const;
+		const response = await successfulApiCall({ endpoint: 'hashtags/users', parameters, user: alice });
+		const expected = (excluded ?? false) ? [] : [await show(user().id, alice)];
+		assert.deepStrictEqual(response, expected);
+	});
+	test.todo('をハッシュタグ指定で取得することができる(リモート)');
+
+	//#endregion
+	//#region オススメユーザー(users/recommendation)
+
+	// BUG users/recommendationは壊れている？ > QueryFailedError: missing FROM-clause entry for table "note"
+	test.skip('のオススメを取得することができる', async () => {
+		const parameters = {};
+		const response = await successfulApiCall({ endpoint: 'users/recommendation', parameters, user: alice });
+		const expected = await Promise.all(response.map(u => show(u.id)));
+		assert.deepStrictEqual(response, expected);
+	});
+
+	//#endregion
+	//#region ピン止めユーザー(pinned-users)
+
+	test('のピン止めユーザーを取得することができる', async () => {
+		await successfulApiCall({ endpoint: 'admin/update-meta', parameters: { pinnedUsers: [bob.username, `@${carol.username}`] }, user: root });
+		const parameters = {} as const;
+		const response = await successfulApiCall({ endpoint: 'pinned-users', parameters, user: alice });
+		const expected = await Promise.all([bob, carol].map(u => show(u.id, alice)));
+		assert.deepStrictEqual(response, expected);
+	});
+
+	//#endregion
+
+	test.todo('を管理人として確認することができる(admin/show-user)');
+	test.todo('を管理人として確認することができる(admin/show-users)');
+	test.todo('をサーバー向けに取得することができる(federation/users)');
+});

packages/calckey-js/src/api.types.ts

@@ -687,6 +687,7 @@ export type Endpoints = {
 			carefulBot?: boolean;
 			autoAcceptFollowed?: boolean;
 			noCrawle?: boolean;
+			preventAiLearning?: boolean;
 			isBot?: boolean;
 			isCat?: boolean;
 			injectFeaturedNote?: boolean;

packages/calckey-js/src/entities.ts

@@ -104,6 +104,7 @@ export type MeDetailed = UserDetailed & {
 	mutedWords: string[][];
 	mutingNotificationTypes: string[];
 	noCrawle: boolean;
+	preventAiLearning: boolean;
 	receiveAnnouncementEmail: boolean;
 	usePasswordLessLogin: boolean;
 	[other: string]: any;

packages/client/src/pages/settings/privacy.vue

@@ -60,6 +60,10 @@
 			{{ i18n.ts.noCrawle }}
 			<template #caption>{{ i18n.ts.noCrawleDescription }}</template>
 		</FormSwitch>
+		<FormSwitch v-model="preventAiLearning" @update:model-value="save()">
+			{{ i18n.ts.preventAiLearning }}<span class="_beta">{{ i18n.ts.beta }}</span>
+			<template #caption>{{ i18n.ts.preventAiLearningDescription }}</template>
+		</FormSwitch>
 		<FormSwitch
 			v-model="isExplorable"
 			class="_formBlock"
@@ -145,6 +149,7 @@ let isExplorable = $ref($i.isExplorable);
 let hideOnlineStatus = $ref($i.hideOnlineStatus);
 let publicReactions = $ref($i.publicReactions);
 let ffVisibility = $ref($i.ffVisibility);
+let preventAiLearning = $ref($i.preventAiLearning);
 
 let defaultNoteVisibility = $computed(
 	defaultStore.makeGetterSetter("defaultNoteVisibility")
@@ -165,6 +170,7 @@ function save() {
 		isExplorable: !!isExplorable,
 		hideOnlineStatus: !!hideOnlineStatus,
 		publicReactions: !!publicReactions,
+		preventAiLearning: !!preventAiLearning,
 		ffVisibility: ffVisibility,
 	});
 }