feat(voice): ship noise suppression treatment to everyone (#3029)

fluxer_api/src/api/admin/controllers/InstanceConfigAdminController.ts

@@ -40,7 +40,6 @@ import {DomainMigrationConfigSchema} from '@fluxer/schema/src/domains/admin/Doma
 import {GatewayRolloutConfigSchema} from '@fluxer/schema/src/domains/admin/GatewayRolloutSchemas';
 import {ProfileTimezoneConfigSchema} from '@fluxer/schema/src/domains/admin/ProfileTimezoneSchemas';
 import type {PushRelayConfig, PushRelayConfigUpdateRequest} from '@fluxer/schema/src/domains/admin/PushRelaySchemas';
-import {VoiceNoiseSuppressionConfigSchema} from '@fluxer/schema/src/domains/admin/VoiceNoiseSuppressionSchemas';
 import {UserIdParam} from '@fluxer/schema/src/domains/common/CommonParamSchemas';
 import {ExperimentDeliveryConfigSchema} from '@fluxer/schema/src/domains/experiment/ExperimentSchemas';
 import type {InstanceBranding} from '@fluxer/schema/src/domains/instance/InstanceSchemas';
@@ -67,7 +66,6 @@ async function buildInstanceConfigResponse(): Promise<InstanceConfigResponse> {
 	const [
 		ssoConfig,
 		gatewayRollout,
-		voiceNoiseSuppression,
 		pushRelay,
 		domainMigration,
 		altchaCaptcha,
@@ -79,7 +77,6 @@ async function buildInstanceConfigResponse(): Promise<InstanceConfigResponse> {
 	] = await Promise.all([
 		instanceConfigRepository.getSsoConfig(),
 		instanceConfigRepository.getGatewayRolloutConfig(),
-		instanceConfigRepository.getVoiceNoiseSuppressionConfig(),
 		instanceConfigRepository.getPushRelayConfig(),
 		instanceConfigRepository.getDomainMigrationConfig(),
 		instanceConfigRepository.getAltchaCaptchaConfig(),
@@ -115,7 +112,6 @@ async function buildInstanceConfigResponse(): Promise<InstanceConfigResponse> {
 			redirect_uri: deriveSsoRedirectUri(Config.endpoints.webApp),
 		},
 		gateway_rollout: gatewayRollout,
-		voice_noise_suppression: voiceNoiseSuppression,
 		push_relay: pushRelay,
 		domain_migration: domainMigration,
 		altcha_captcha: altchaCaptcha,
@@ -377,18 +373,6 @@ export function InstanceConfigAdminController(app: HonoApp) {
 				);
 				await getGatewayRolloutConfigPublisher().publish(landed);
 			}
-			if (data.voice_noise_suppression) {
-				const patch = omitUndefinedFields(data.voice_noise_suppression);
-				if (Object.keys(patch).length > 0) {
-					await instanceConfigRepository.updateVoiceNoiseSuppressionConfig((current) =>
-						VoiceNoiseSuppressionConfigSchema.parse({
-							...current,
-							...patch,
-							config_version: current.config_version + 1,
-						}),
-					);
-				}
-			}
 			if (data.push_relay) {
 				const patch = omitUndefinedFields(data.push_relay);
 				if (Object.keys(patch).length > 0) {

fluxer_api/src/api/experiment/ExperimentController.ts

@@ -12,7 +12,6 @@ import {Headers as HttpHeaders} from '@fluxer/constants/src/Headers';
 import {resolveAltchaCaptchaAssignment} from '@fluxer/schema/src/domains/admin/AltchaCaptchaSchemas';
 import {resolveDomainMigrationAssignment} from '@fluxer/schema/src/domains/admin/DomainMigrationSchemas';
 import {resolveProfileTimezoneAssignment} from '@fluxer/schema/src/domains/admin/ProfileTimezoneSchemas';
-import {resolveVoiceNoiseSuppressionAssignment} from '@fluxer/schema/src/domains/admin/VoiceNoiseSuppressionSchemas';
 import {ExperimentAssignmentsResponse} from '@fluxer/schema/src/domains/experiment/ExperimentSchemas';
 
 export function ExperimentController(app: HonoApp) {
@@ -32,18 +31,15 @@ export function ExperimentController(app: HonoApp) {
 		}),
 		async (ctx) => {
 			const instanceConfigRepository = ctx.get('instanceConfigRepository');
-			const [delivery, voiceConfig, domainMigrationConfig, altchaCaptchaConfig, profileTimezoneConfig] =
-				await Promise.all([
-					instanceConfigRepository.getExperimentDeliveryConfig(),
-					instanceConfigRepository.getVoiceNoiseSuppressionConfig(),
-					instanceConfigRepository.getDomainMigrationConfig(),
-					instanceConfigRepository.getAltchaCaptchaConfig(),
-					instanceConfigRepository.getProfileTimezoneConfig(),
-				]);
+			const [delivery, domainMigrationConfig, altchaCaptchaConfig, profileTimezoneConfig] = await Promise.all([
+				instanceConfigRepository.getExperimentDeliveryConfig(),
+				instanceConfigRepository.getDomainMigrationConfig(),
+				instanceConfigRepository.getAltchaCaptchaConfig(),
+				instanceConfigRepository.getProfileTimezoneConfig(),
+			]);
 			const user = ctx.get('user');
 			const userId = user.id.toString();
 			const targeting = await resolveExperimentTargeting(user, [
-				voiceConfig,
 				domainMigrationConfig,
 				altchaCaptchaConfig,
 				profileTimezoneConfig,
@@ -52,7 +48,6 @@ export function ExperimentController(app: HonoApp) {
 				poll_interval_seconds: delivery.poll_interval_seconds,
 				poll_jitter_percent: delivery.poll_jitter_percent,
 				assignments: {
-					voice_noise_suppression: resolveVoiceNoiseSuppressionAssignment(voiceConfig, userId, targeting),
 					domain_migration: resolveDomainMigrationAssignment(domainMigrationConfig, userId, targeting),
 					altcha_captcha: resolveAltchaCaptchaAssignment(altchaCaptchaConfig, userId, targeting),
 					profile_timezone: resolveProfileTimezoneAssignment(profileTimezoneConfig, userId, targeting),

fluxer_api/src/api/experiment/tests/ExperimentController.test.ts

@@ -21,17 +21,12 @@ import {
 	DEFAULT_PROFILE_TIMEZONE_CONFIG,
 	INERT_PROFILE_TIMEZONE_ASSIGNMENT,
 } from '@fluxer/schema/src/domains/admin/ProfileTimezoneSchemas';
-import {
-	DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
-	INERT_VOICE_NOISE_SUPPRESSION_ASSIGNMENT,
-} from '@fluxer/schema/src/domains/admin/VoiceNoiseSuppressionSchemas';
 import {
 	DEFAULT_EXPERIMENT_POLL_INTERVAL_SECONDS,
 	DEFAULT_EXPERIMENT_POLL_JITTER_PERCENT,
 	type ExperimentAssignmentsResponse,
 	type ExperimentDeliveryConfigResponse,
 	readDomainMigrationAssignment,
-	readVoiceNoiseSuppressionAssignment,
 } from '@fluxer/schema/src/domains/experiment/ExperimentSchemas';
 import {afterAll, beforeAll, beforeEach, describe, expect, it} from 'vitest';
 
@@ -66,7 +61,6 @@ describe('GET /experiments', () => {
 			poll_interval_seconds: DEFAULT_EXPERIMENT_POLL_INTERVAL_SECONDS,
 			poll_jitter_percent: DEFAULT_EXPERIMENT_POLL_JITTER_PERCENT,
 			assignments: {
-				voice_noise_suppression: INERT_VOICE_NOISE_SUPPRESSION_ASSIGNMENT,
 				domain_migration: INERT_DOMAIN_MIGRATION_ASSIGNMENT,
 				altcha_captcha: INERT_ALTCHA_CAPTCHA_ASSIGNMENT,
 				profile_timezone: INERT_PROFILE_TIMEZONE_ASSIGNMENT,
@@ -74,33 +68,6 @@ describe('GET /experiments', () => {
 		});
 	});
 
-	it('returns the inert assignment while the stored config is disabled but populated', async () => {
-		const account = await createTestAccount(harness);
-		await getInstanceConfigRepository().setVoiceNoiseSuppressionConfig({
-			...DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
-			enabled: false,
-			config_version: 9,
-			rollout_basis_points: 10000,
-			included_user_ids: [account.userId],
-		});
-
-		const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
-
-		expect(body.assignments.voice_noise_suppression).toEqual({
-			...INERT_VOICE_NOISE_SUPPRESSION_ASSIGNMENT,
-			config_version: 9,
-		});
-	});
-
-	it('populates the voice assignment key even when the rollout is disabled', async () => {
-		const account = await createTestAccount(harness);
-
-		const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
-
-		expect(Object.hasOwn(body.assignments, 'voice_noise_suppression')).toBe(true);
-		expect(readVoiceNoiseSuppressionAssignment(body).enabled).toBe(false);
-	});
-
 	it('populates the domain migration assignment key even when the rollout is disabled', async () => {
 		const account = await createTestAccount(harness);
 
@@ -262,11 +229,6 @@ describe('GET /experiments', () => {
 		const invite = await createChannelInvite(harness, owner.token, systemChannel.id);
 		await acceptInvite(harness, member.token, invite.code);
 		const repository = getInstanceConfigRepository();
-		await repository.setVoiceNoiseSuppressionConfig({
-			...DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
-			enabled: true,
-			included_guild_ids: [guild.id],
-		});
 		await repository.setDomainMigrationConfig({
 			...DEFAULT_DOMAIN_MIGRATION_CONFIG,
 			enabled: true,
@@ -286,7 +248,6 @@ describe('GET /experiments', () => {
 		const memberBody = await createBuilder<ExperimentAssignmentsResponse>(harness, member.token)
 			.get(ENDPOINT)
 			.execute();
-		expect(memberBody.assignments.voice_noise_suppression).toMatchObject({user_targeted: true, source: 'user_rule'});
 		expect(memberBody.assignments.domain_migration).toEqual({enabled: true});
 		expect(memberBody.assignments.altcha_captcha).toEqual({enabled: true});
 		expect(memberBody.assignments.profile_timezone).toEqual({enabled: true});
@@ -294,7 +255,6 @@ describe('GET /experiments', () => {
 		const outsiderBody = await createBuilder<ExperimentAssignmentsResponse>(harness, outsider.token)
 			.get(ENDPOINT)
 			.execute();
-		expect(outsiderBody.assignments.voice_noise_suppression).toMatchObject({user_targeted: false, source: null});
 		expect(outsiderBody.assignments.domain_migration).toEqual({enabled: false});
 		expect(outsiderBody.assignments.altcha_captcha).toEqual({enabled: false});
 		expect(outsiderBody.assignments.profile_timezone).toEqual({enabled: false});
@@ -330,89 +290,25 @@ describe('GET /experiments', () => {
 		const guildIds = ['1500000000000000001', '1500000000000000002'];
 		const body = await createBuilder<
 			Record<
-				'voice_noise_suppression' | 'domain_migration' | 'altcha_captcha' | 'profile_timezone',
+				'domain_migration' | 'altcha_captcha' | 'profile_timezone',
 				{included_guild_ids: Array<string>; include_premium_users: boolean}
 			>
 		>(harness, admin.token)
 			.patch('/admin/instance/config')
 			.body({
-				voice_noise_suppression: {included_guild_ids: guildIds, include_premium_users: true},
 				domain_migration: {included_guild_ids: guildIds, include_premium_users: true},
 				altcha_captcha: {included_guild_ids: guildIds, include_premium_users: true},
 				profile_timezone: {included_guild_ids: guildIds, include_premium_users: true},
 			})
 			.execute();
-		expect(body.voice_noise_suppression.included_guild_ids).toEqual(guildIds);
 		expect(body.domain_migration.included_guild_ids).toEqual(guildIds);
 		expect(body.altcha_captcha.included_guild_ids).toEqual(guildIds);
 		expect(body.profile_timezone.included_guild_ids).toEqual(guildIds);
-		for (const section of [
-			body.voice_noise_suppression,
-			body.domain_migration,
-			body.altcha_captcha,
-			body.profile_timezone,
-		]) {
+		for (const section of [body.domain_migration, body.altcha_captcha, body.profile_timezone]) {
 			expect(section.include_premium_users).toBe(true);
 		}
 	});
 
-	it('serves the delivery cadence from the delivery config and not from the voice config', async () => {
-		const account = await createTestAccount(harness);
-		await getInstanceConfigRepository().setExperimentDeliveryConfig({
-			poll_interval_seconds: 7200,
-			poll_jitter_percent: 45,
-		});
-		await getInstanceConfigRepository().setVoiceNoiseSuppressionConfig({
-			...DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
-			enabled: true,
-			config_version: 3,
-			rollout_basis_points: 10000,
-		});
-
-		const body = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token).get(ENDPOINT).execute();
-
-		expect(body.poll_interval_seconds).toBe(7200);
-		expect(body.poll_jitter_percent).toBe(45);
-		expect(body.assignments.voice_noise_suppression).toMatchObject({enabled: true, config_version: 3});
-		expect(body.assignments.voice_noise_suppression).not.toHaveProperty('poll_interval_seconds');
-		expect(body.assignments.voice_noise_suppression).not.toHaveProperty('poll_jitter_percent');
-	});
-
-	it('echoes the config version and resolves the caller through the allowlist', async () => {
-		const targeted = await createTestAccount(harness);
-		const untargeted = await createTestAccount(harness);
-		await getInstanceConfigRepository().setVoiceNoiseSuppressionConfig({
-			...DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
-			enabled: true,
-			config_version: 14,
-			default_backend: 'rnnoise',
-			rollout_basis_points: 0,
-			included_user_ids: [targeted.userId],
-		});
-
-		const targetedBody = await createBuilder<ExperimentAssignmentsResponse>(harness, targeted.token)
-			.get(ENDPOINT)
-			.execute();
-		expect(targetedBody.assignments.voice_noise_suppression).toMatchObject({
-			enabled: true,
-			config_version: 14,
-			user_targeted: true,
-			backend: 'rnnoise',
-			source: 'user_rule',
-		});
-
-		const untargetedBody = await createBuilder<ExperimentAssignmentsResponse>(harness, untargeted.token)
-			.get(ENDPOINT)
-			.execute();
-		expect(untargetedBody.assignments.voice_noise_suppression).toMatchObject({
-			enabled: true,
-			config_version: 14,
-			user_targeted: false,
-			backend: null,
-			source: null,
-		});
-	});
-
 	it('revalidates with a strong etag and answers 304 when nothing changed', async () => {
 		const account = await createTestAccount(harness);
 
@@ -442,34 +338,6 @@ describe('GET /experiments', () => {
 		expect(preflight.headers.get('access-control-expose-headers')).toContain('ETag');
 	});
 
-	it('serves a fresh body once the voice config changes', async () => {
-		const account = await createTestAccount(harness);
-
-		const first = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token)
-			.get(ENDPOINT)
-			.executeWithResponse();
-		const staleEtag = first.response.headers.get('etag') as string;
-
-		await getInstanceConfigRepository().setVoiceNoiseSuppressionConfig({
-			...DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
-			enabled: true,
-			config_version: 1,
-			rollout_basis_points: 10000,
-		});
-
-		const refreshed = await createBuilder<ExperimentAssignmentsResponse>(harness, account.token)
-			.get(ENDPOINT)
-			.header('If-None-Match', staleEtag)
-			.executeWithResponse();
-		expect(refreshed.response.status).toBe(HTTP_STATUS.OK);
-		expect(refreshed.response.headers.get('etag')).not.toBe(staleEtag);
-		expect(refreshed.json?.assignments.voice_noise_suppression).toMatchObject({
-			enabled: true,
-			config_version: 1,
-			user_targeted: true,
-		});
-	});
-
 	it('serves a fresh body once the domain migration config changes', async () => {
 		const account = await createTestAccount(harness);
 
@@ -517,39 +385,6 @@ describe('GET /experiments', () => {
 		expect(refreshed.json?.poll_jitter_percent).toBe(5);
 	});
 
-	it('bumps the config version on every admin update without the client sending one', async () => {
-		const admin = await setUserACLs(harness, await createTestAccount(harness), [
-			AdminACLs.AUTHENTICATE,
-			AdminACLs.INSTANCE_CONFIG_VIEW,
-			AdminACLs.INSTANCE_CONFIG_UPDATE,
-		]);
-
-		const afterFirst = await createBuilder<{voice_noise_suppression: {config_version: number; enabled: boolean}}>(
-			harness,
-			admin.token,
-		)
-			.patch('/admin/instance/config')
-			.body({voice_noise_suppression: {enabled: true, rollout_basis_points: 10000}})
-			.execute();
-		expect(afterFirst.voice_noise_suppression).toMatchObject({config_version: 1, enabled: true});
-
-		const afterSecond = await createBuilder<{voice_noise_suppression: {config_version: number; enabled: boolean}}>(
-			harness,
-			admin.token,
-		)
-			.patch('/admin/instance/config')
-			.body({voice_noise_suppression: {suppression_strength: 42}})
-			.execute();
-		expect(afterSecond.voice_noise_suppression).toMatchObject({config_version: 2, enabled: true});
-
-		const body = await createBuilder<ExperimentAssignmentsResponse>(harness, admin.token).get(ENDPOINT).execute();
-		expect(body.assignments.voice_noise_suppression).toMatchObject({
-			enabled: true,
-			config_version: 2,
-			suppression_strength: 42,
-		});
-	});
-
 	it('bumps the domain migration config version on every admin update without the client sending one', async () => {
 		const admin = await setUserACLs(harness, await createTestAccount(harness), [
 			AdminACLs.AUTHENTICATE,
@@ -591,39 +426,39 @@ describe('GET /experiments', () => {
 		expect(body.assignments.domain_migration).toEqual({enabled: true});
 	});
 
-	it('leaves the config version alone for an admin update that sets no field', async () => {
+	it('leaves the domain migration config version alone for an admin update that sets no field', async () => {
 		const admin = await setUserACLs(harness, await createTestAccount(harness), [
 			AdminACLs.AUTHENTICATE,
 			AdminACLs.INSTANCE_CONFIG_VIEW,
 			AdminACLs.INSTANCE_CONFIG_UPDATE,
 		]);
 
-		const afterFirst = await createBuilder<{voice_noise_suppression: {config_version: number; enabled: boolean}}>(
+		const afterFirst = await createBuilder<{domain_migration: {config_version: number; enabled: boolean}}>(
 			harness,
 			admin.token,
 		)
 			.patch('/admin/instance/config')
-			.body({voice_noise_suppression: {enabled: true}})
+			.body({domain_migration: {enabled: true}})
 			.execute();
-		expect(afterFirst.voice_noise_suppression).toMatchObject({config_version: 1, enabled: true});
+		expect(afterFirst.domain_migration).toMatchObject({config_version: 1, enabled: true});
 
-		const afterEmpty = await createBuilder<{voice_noise_suppression: {config_version: number; enabled: boolean}}>(
+		const afterEmpty = await createBuilder<{domain_migration: {config_version: number; enabled: boolean}}>(
 			harness,
 			admin.token,
 		)
 			.patch('/admin/instance/config')
-			.body({voice_noise_suppression: {}})
+			.body({domain_migration: {}})
 			.execute();
-		expect(afterEmpty.voice_noise_suppression).toMatchObject({config_version: 1, enabled: true});
+		expect(afterEmpty.domain_migration).toMatchObject({config_version: 1, enabled: true});
 
-		const afterUndefined = await createBuilder<{voice_noise_suppression: {config_version: number; enabled: boolean}}>(
+		const afterUndefined = await createBuilder<{domain_migration: {config_version: number; enabled: boolean}}>(
 			harness,
 			admin.token,
 		)
 			.patch('/admin/instance/config')
-			.body({voice_noise_suppression: {enabled: undefined}})
+			.body({domain_migration: {enabled: undefined}})
 			.execute();
-		expect(afterUndefined.voice_noise_suppression).toMatchObject({config_version: 1, enabled: true});
+		expect(afterUndefined.domain_migration).toMatchObject({config_version: 1, enabled: true});
 	});
 
 	it('serves the delivery cadence an admin set through the instance config', async () => {

fluxer_api/src/api/instance/InstanceConfigRepository.test.ts

@@ -22,10 +22,6 @@ import {
 	DEFAULT_DOMAIN_MIGRATION_CONFIG,
 	type DomainMigrationConfig,
 } from '@fluxer/schema/src/domains/admin/DomainMigrationSchemas';
-import {
-	DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
-	type VoiceNoiseSuppressionConfig,
-} from '@fluxer/schema/src/domains/admin/VoiceNoiseSuppressionSchemas';
 import {
 	DEFAULT_EXPERIMENT_DELIVERY_CONFIG,
 	type ExperimentDeliveryConfig,
@@ -38,7 +34,6 @@ import {
 } from '@pkgs/postgres/src/Client';
 import {afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, vi} from 'vitest';
 
-const VOICE_NOISE_SUPPRESSION_CONFIG_KEY = 'voice_noise_suppression_config';
 const DOMAIN_MIGRATION_CONFIG_KEY = 'domain_migration_config';
 const EXPERIMENT_DELIVERY_CONFIG_KEY = 'experiment_delivery_config';
 const APP_PUBLIC_CONFIG_KEY = 'app_public_config';
@@ -287,75 +282,6 @@ describe('InstanceConfigRepository', () => {
 		expect(domains).not.toContain('example.com');
 	});
 
-	it('returns the default voice noise suppression config when the key is absent', async () => {
-		const executor = new CountingInMemoryCassandraQueryExecutor();
-		setCassandraQueryExecutorForTesting(executor);
-		const kvProvider = new MockKVProvider();
-		const repository = createRepository(kvProvider);
-
-		await expect(repository.getVoiceNoiseSuppressionConfig()).resolves.toEqual(DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG);
-	});
-
-	it.each([
-		{name: 'unparseable text', stored: 'not-json'},
-		{name: 'a json array', stored: '[]'},
-		{name: 'out-of-range values', stored: '{"rollout_basis_points":99999}'},
-		{name: 'an unknown backend', stored: '{"default_backend":"magic"}'},
-	])('falls back to the default voice noise suppression config for $name', async ({stored}) => {
-		const executor = new CountingInMemoryCassandraQueryExecutor();
-		setCassandraQueryExecutorForTesting(executor);
-		const kvProvider = new MockKVProvider();
-		const repository = createRepository(kvProvider);
-
-		await repository.setConfig(VOICE_NOISE_SUPPRESSION_CONFIG_KEY, stored);
-
-		await expect(repository.getVoiceNoiseSuppressionConfig()).resolves.toEqual(DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG);
-	});
-
-	it('round-trips a stored voice noise suppression config', async () => {
-		const executor = new CountingInMemoryCassandraQueryExecutor();
-		setCassandraQueryExecutorForTesting(executor);
-		const kvProvider = new MockKVProvider();
-		const repository = createRepository(kvProvider);
-
-		const config: VoiceNoiseSuppressionConfig = {
-			...DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
-			enabled: true,
-			config_version: 3,
-			default_backend: 'rnnoise',
-			enabled_backends: ['none', 'standard', 'rnnoise'],
-			allow_user_override: false,
-			rollout_basis_points: 2500,
-			rollout_salt: 'voice-ns-v2',
-			included_user_ids: ['1400000000000000001'],
-			excluded_user_ids: ['1400000000000000002'],
-			guild_overrides: [{guild_id: '2400000000000000001', backend: 'rnnoise'}],
-			suppression_strength: 55,
-		};
-		await repository.setVoiceNoiseSuppressionConfig(config);
-
-		await expect(repository.getVoiceNoiseSuppressionConfig()).resolves.toEqual(config);
-	});
-
-	it('fills newly added voice noise suppression fields from the schema defaults', async () => {
-		const executor = new CountingInMemoryCassandraQueryExecutor();
-		setCassandraQueryExecutorForTesting(executor);
-		const kvProvider = new MockKVProvider();
-		const repository = createRepository(kvProvider);
-
-		await repository.setConfig(
-			VOICE_NOISE_SUPPRESSION_CONFIG_KEY,
-			JSON.stringify({enabled: true, config_version: 2, rollout_basis_points: 1000}),
-		);
-
-		await expect(repository.getVoiceNoiseSuppressionConfig()).resolves.toEqual({
-			...DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
-			enabled: true,
-			config_version: 2,
-			rollout_basis_points: 1000,
-		});
-	});
-
 	it('returns the default domain migration config when the key is absent', async () => {
 		const executor = new CountingInMemoryCassandraQueryExecutor();
 		setCassandraQueryExecutorForTesting(executor);
@@ -494,26 +420,6 @@ describe('InstanceConfigRepository', () => {
 		});
 	});
 
-	it('publishes a refresh so another repository observes the voice noise suppression config', async () => {
-		const executor = new CountingInMemoryCassandraQueryExecutor();
-		setCassandraQueryExecutorForTesting(executor);
-		const kvProvider = new MockKVProvider();
-		const reader = createRepository(kvProvider);
-		const writer = createRepository(kvProvider);
-
-		await expect(reader.getVoiceNoiseSuppressionConfig()).resolves.toEqual(DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG);
-
-		await writer.setVoiceNoiseSuppressionConfig({
-			...DEFAULT_VOICE_NOISE_SUPPRESSION_CONFIG,
-			enabled: true,
-			config_version: 1,
-		});
-
-		await vi.waitFor(async () => {
-			expect(await reader.getVoiceNoiseSuppressionConfig()).toMatchObject({enabled: true, config_version: 1});
-		});
-	});
-
 	it('uses the registration URL id as the admin-visible registration code', async () => {
 		const executor = new CountingInMemoryCassandraQueryExecutor();
 		setCassandraQueryExecutorForTesting(executor);

fluxer_api/src/api/instance/InstanceConfigRepository.ts

@@ -61,10 +61,6 @@ import {
 	PushRelayConfigSchema,
 	toLegacyPushServiceDeliveryWire,
 } from '@fluxer/schema/src/domains/admin/PushRelaySchemas';
-import {
-	type VoiceNoiseSuppressionConfig,
-	VoiceNoiseSuppressionConfigSchema,
-} from '@fluxer/schema/src/domains/admin/VoiceNoiseSuppressionSchemas';
 import {
 	type ExperimentDeliveryConfig,
 	ExperimentDeliveryConfigSchema,
@@ -86,7 +82,6 @@ import type {IKVProvider} from '@pkgs/kv_client/src/IKVProvider';
 import {z} from 'zod';
 
 const GATEWAY_ROLLOUT_CONFIG_KEY = 'gateway_rollout_config';
-const VOICE_NOISE_SUPPRESSION_CONFIG_KEY = 'voice_noise_suppression_config';
 const PUSH_RELAY_CONFIG_KEY = 'push_service_delivery_config';
 const DOMAIN_MIGRATION_CONFIG_KEY = 'domain_migration_config';
 const ALTCHA_CAPTCHA_CONFIG_KEY = 'altcha_captcha_config';
@@ -447,7 +442,6 @@ function getDefaultAppPublicConfig(): InstanceAppPublicConfig {
 type StoredConfigSection =
 	| 'app public'
 	| 'gateway rollout'
-	| 'voice noise suppression'
 	| 'push relay'
 	| 'domain migration'
 	| 'altcha captcha'
@@ -587,10 +581,6 @@ function parseStoredGatewayRolloutConfig(raw: string | null): GatewayRolloutConf
 	return decodeGatewayRolloutConfig(parseStoredConfigValue(raw, 'gateway rollout'));
 }
 
-function parseStoredVoiceNoiseSuppressionConfig(raw: string | null): VoiceNoiseSuppressionConfig {
-	return parseStoredConfigOrDefault(VoiceNoiseSuppressionConfigSchema, raw, 'voice noise suppression');
-}
-
 const StoredPushRelayConfigSchema = PushRelayConfigSchema.extend({
 	config_version: z.number().int().min(0).default(0),
 });
@@ -1296,7 +1286,6 @@ export class InstanceConfigRepository {
 		checkStoredConfig('gateway rollout', () =>
 			parseStoredGatewayRolloutConfig(snapshot.get(GATEWAY_ROLLOUT_CONFIG_KEY) ?? null),
 		);
-		parseStoredVoiceNoiseSuppressionConfig(snapshot.get(VOICE_NOISE_SUPPRESSION_CONFIG_KEY) ?? null);
 		parseStoredPushRelayConfig(snapshot.get(PUSH_RELAY_CONFIG_KEY) ?? null);
 		parseStoredDomainMigrationConfig(snapshot.get(DOMAIN_MIGRATION_CONFIG_KEY) ?? null);
 		parseStoredAltchaCaptchaConfig(snapshot.get(ALTCHA_CAPTCHA_CONFIG_KEY) ?? null);
@@ -1377,27 +1366,6 @@ export class InstanceConfigRepository {
 		);
 	}
 
-	async getVoiceNoiseSuppressionConfig(): Promise<VoiceNoiseSuppressionConfig> {
-		const raw = await this.getConfig(VOICE_NOISE_SUPPRESSION_CONFIG_KEY);
-		return parseStoredVoiceNoiseSuppressionConfig(raw);
-	}
-
-	async setVoiceNoiseSuppressionConfig(config: VoiceNoiseSuppressionConfig): Promise<void> {
-		await this.updateVoiceNoiseSuppressionConfig(() => config);
-	}
-
-	updateVoiceNoiseSuppressionConfig(
-		update: (current: VoiceNoiseSuppressionConfig) => VoiceNoiseSuppressionConfig,
-	): Promise<VoiceNoiseSuppressionConfig> {
-		return this.updateStoredConfig(VOICE_NOISE_SUPPRESSION_CONFIG_KEY, (raw) =>
-			validateStoredConfig(
-				VoiceNoiseSuppressionConfigSchema,
-				update(parseStoredVoiceNoiseSuppressionConfig(raw)),
-				'voice noise suppression',
-			),
-		);
-	}
-
 	async getLegacyPushServiceDeliveryWire(): Promise<LegacyPushServiceDeliveryWire> {
 		const raw = await this.getConfig(PUSH_RELAY_CONFIG_KEY);
 		return parseStoredPushRelayConfig(raw);

fluxer_api/src/api/openapi/openapi.json

@@ -27950,7 +27950,6 @@
 					"assignments": {
 						"type": "object",
 						"properties": {
-							"voice_noise_suppression": {"$ref": "#/components/schemas/VoiceNoiseSuppressionAssignmentResponse"},
 							"domain_migration": {"$ref": "#/components/schemas/DomainMigrationAssignmentResponse"},
 							"altcha_captcha": {"$ref": "#/components/schemas/AltchaCaptchaAssignmentResponse"},
 							"profile_timezone": {"$ref": "#/components/schemas/ProfileTimezoneAssignmentResponse"}
@@ -31670,50 +31669,6 @@
 				"required": ["enabled"],
 				"additionalProperties": false
 			},
-			"VoiceNoiseSuppressionAssignmentResponse": {
-				"type": "object",
-				"properties": {
-					"enabled": {"type": "boolean"},
-					"config_version": {"type": "integer", "minimum": -9007199254740991, "maximum": 9007199254740991},
-					"user_targeted": {"type": "boolean"},
-					"backend": {"anyOf": [{"$ref": "#/components/schemas/VoiceNoiseSuppressionBackendSchema"}, {"type": "null"}]},
-					"source": {"anyOf": [{"type": "string", "enum": ["user_rule", "canary"]}, {"type": "null"}]},
-					"guild_overrides": {
-						"type": "array",
-						"items": {
-							"type": "object",
-							"properties": {
-								"guild_id": {"type": "string", "pattern": "^\\d{1,20}$"},
-								"backend": {"$ref": "#/components/schemas/VoiceNoiseSuppressionBackendSchema"}
-							},
-							"required": ["guild_id", "backend"],
-							"additionalProperties": false
-						}
-					},
-					"enabled_backends": {
-						"type": "array",
-						"items": {"$ref": "#/components/schemas/VoiceNoiseSuppressionBackendSchema"}
-					},
-					"allow_user_override": {"type": "boolean"},
-					"suppression_strength": {"type": "integer", "minimum": 0, "maximum": 100}
-				},
-				"required": [
-					"enabled",
-					"config_version",
-					"user_targeted",
-					"backend",
-					"source",
-					"guild_overrides",
-					"enabled_backends",
-					"allow_user_override",
-					"suppression_strength"
-				],
-				"additionalProperties": false
-			},
-			"VoiceNoiseSuppressionBackendSchema": {
-				"type": "string",
-				"enum": ["none", "standard", "gate", "speex", "rnnoise", "gtcrn", "deep_filter"]
-			},
 			"GiftCodeDurationTypeSchema": {
 				"description": "Gift code duration unit",
 				"x-enumNames": ["days", "weeks", "months", "years"],