fix(app): gate one-Tab message focus behind an experiment (#2762)

packages/schema/src/domains/admin/AdminSchemas.ts

@@ -27,6 +27,10 @@ import {
 	MessageHoverTrackingConfigResponse,
 	MessageHoverTrackingConfigUpdateRequest,
 } from '@fluxer/schema/src/domains/experiment/MessageHoverTrackingSchemas';
+import {
+	MessageKeyboardFocusConfigResponse,
+	MessageKeyboardFocusConfigUpdateRequest,
+} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
 import {GuildMemberResponse} from '@fluxer/schema/src/domains/guild/GuildMemberSchemas';
 import {
 	InstanceCaptchaProviderSchema,
@@ -635,6 +639,7 @@ export const InstanceConfigResponse = z.object({
 	voice_noise_suppression: VoiceNoiseSuppressionConfigResponse,
 	experiment_delivery: ExperimentDeliveryConfigResponse,
 	message_hover_tracking: MessageHoverTrackingConfigResponse,
+	message_keyboard_focus: MessageKeyboardFocusConfigResponse,
 	registration: InstanceRegistrationResponse,
 	self_hosted: z.boolean(),
 	app_public: AppPublicConfigResponse,
@@ -672,6 +677,7 @@ export const InstanceConfigUpdateRequest = z.object({
 	voice_noise_suppression: VoiceNoiseSuppressionConfigUpdateRequest.nullish(),
 	experiment_delivery: ExperimentDeliveryConfigUpdateRequest.nullish(),
 	message_hover_tracking: MessageHoverTrackingConfigUpdateRequest.nullish(),
+	message_keyboard_focus: MessageKeyboardFocusConfigUpdateRequest.nullish(),
 	registration: z
 		.object({
 			mode: InstanceRegistrationModeSchema.optional(),

packages/schema/src/domains/experiment/ExperimentSchemas.ts

@@ -8,6 +8,10 @@ import {
 	INERT_MESSAGE_HOVER_TRACKING_ASSIGNMENT,
 	MessageHoverTrackingAssignmentResponse,
 } from '@fluxer/schema/src/domains/experiment/MessageHoverTrackingSchemas';
+import {
+	INERT_MESSAGE_KEYBOARD_FOCUS_ASSIGNMENT,
+	MessageKeyboardFocusAssignmentResponse,
+} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
 import {z} from 'zod';
 
 export const EXPERIMENT_MIN_POLL_INTERVAL_SECONDS = 60;
@@ -47,6 +51,7 @@ export type ExperimentDeliveryConfigResponse = z.infer<typeof ExperimentDelivery
 const ExperimentAssignmentsSchema = z.object({
 	voice_noise_suppression: VoiceNoiseSuppressionAssignmentResponse.optional(),
 	message_hover_tracking: MessageHoverTrackingAssignmentResponse.optional(),
+	message_keyboard_focus: MessageKeyboardFocusAssignmentResponse.optional(),
 });
 
 export const ExperimentAssignmentsResponse = z.object({
@@ -74,3 +79,9 @@ export function readMessageHoverTrackingAssignment(
 ): MessageHoverTrackingAssignmentResponse {
 	return response.assignments.message_hover_tracking ?? INERT_MESSAGE_HOVER_TRACKING_ASSIGNMENT;
 }
+
+export function readMessageKeyboardFocusAssignment(
+	response: ExperimentAssignmentsResponse,
+): MessageKeyboardFocusAssignmentResponse {
+	return response.assignments.message_keyboard_focus ?? INERT_MESSAGE_KEYBOARD_FOCUS_ASSIGNMENT;
+}

packages/schema/src/domains/experiment/MessageKeyboardFocusSchemas.ts

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {createClientBehaviorExperiment} from '@fluxer/schema/src/domains/experiment/ClientBehaviorExperiment';
+import type {z} from 'zod';
+
+const messageKeyboardFocus = createClientBehaviorExperiment({
+	defaultRolloutSalt: 'message-keyboard-focus-v1',
+});
+
+export const MessageKeyboardFocusConfigSchema = messageKeyboardFocus.ConfigSchema;
+
+export type MessageKeyboardFocusConfig = z.infer<typeof MessageKeyboardFocusConfigSchema>;
+
+export const DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG: MessageKeyboardFocusConfig = messageKeyboardFocus.DEFAULT_CONFIG;
+
+export const MessageKeyboardFocusConfigUpdateRequest = messageKeyboardFocus.ConfigUpdateRequest;
+
+export type MessageKeyboardFocusConfigUpdateRequest = z.infer<typeof MessageKeyboardFocusConfigUpdateRequest>;
+
+export const MessageKeyboardFocusConfigResponse = messageKeyboardFocus.ConfigSchema;
+
+export type MessageKeyboardFocusConfigResponse = MessageKeyboardFocusConfig;
+
+export const MessageKeyboardFocusAssignmentResponse = messageKeyboardFocus.AssignmentResponse;
+
+export type MessageKeyboardFocusAssignmentResponse = z.infer<typeof MessageKeyboardFocusAssignmentResponse>;
+
+export const INERT_MESSAGE_KEYBOARD_FOCUS_ASSIGNMENT: MessageKeyboardFocusAssignmentResponse =
+	messageKeyboardFocus.INERT_ASSIGNMENT;
+
+export function resolveMessageKeyboardFocusAssignment(
+	config: MessageKeyboardFocusConfig,
+	userId: string,
+): MessageKeyboardFocusAssignmentResponse {
+	return messageKeyboardFocus.resolveAssignment(config, userId);
+}

packages/schema/src/domains/tests/MessageKeyboardFocusSchemas.test.ts

@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+
+import {EXPERIMENT_BUCKET_RESOLUTION, experimentBucket} from '@fluxer/schema/src/domains/experiment/ExperimentBucket';
+import {
+	DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG,
+	MessageKeyboardFocusConfigSchema,
+	resolveMessageKeyboardFocusAssignment,
+} from '@fluxer/schema/src/domains/experiment/MessageKeyboardFocusSchemas';
+import {describe, expect, it} from 'vitest';
+
+const USER_ID = '1485064866382176262';
+const OTHER_USER_ID = '1485064866382176263';
+
+function config(overrides: Partial<ReturnType<typeof MessageKeyboardFocusConfigSchema.parse>> = {}) {
+	return MessageKeyboardFocusConfigSchema.parse({...overrides});
+}
+
+describe('message keyboard focus configuration', () => {
+	it('defaults to a disabled rollout that targets nobody', () => {
+		expect(DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG).toEqual({
+			enabled: false,
+			config_version: 0,
+			rollout_basis_points: 0,
+			rollout_salt: 'message-keyboard-focus-v1',
+			included_user_ids: [],
+			excluded_user_ids: [],
+		});
+	});
+
+	it('refuses a rollout wider than the bucket resolution', () => {
+		expect(() => config({rollout_basis_points: EXPERIMENT_BUCKET_RESOLUTION + 1})).toThrow();
+	});
+
+	it('refuses a target that is not a snowflake', () => {
+		expect(() => config({included_user_ids: ['not-a-snowflake']})).toThrow();
+	});
+});
+
+describe('message keyboard focus resolution', () => {
+	it('reports the stored revision while the rollout is disabled', () => {
+		const assignment = resolveMessageKeyboardFocusAssignment(config({config_version: 3}), USER_ID);
+		expect(assignment).toEqual({enabled: false, config_version: 3, user_targeted: false, source: null});
+	});
+
+	it('targets an allowlisted account regardless of its bucket', () => {
+		const assignment = resolveMessageKeyboardFocusAssignment(
+			config({enabled: true, included_user_ids: [USER_ID]}),
+			USER_ID,
+		);
+		expect(assignment).toEqual({enabled: true, config_version: 0, user_targeted: true, source: 'user_rule'});
+	});
+
+	it('keeps a blocklisted account out of a full rollout', () => {
+		const assignment = resolveMessageKeyboardFocusAssignment(
+			config({
+				enabled: true,
+				rollout_basis_points: EXPERIMENT_BUCKET_RESOLUTION,
+				excluded_user_ids: [USER_ID],
+			}),
+			USER_ID,
+		);
+		expect(assignment).toEqual({enabled: true, config_version: 0, user_targeted: false, source: null});
+	});
+
+	it('prefers the blocklist over the allowlist', () => {
+		const assignment = resolveMessageKeyboardFocusAssignment(
+			config({enabled: true, included_user_ids: [USER_ID], excluded_user_ids: [USER_ID]}),
+			USER_ID,
+		);
+		expect(assignment.user_targeted).toBe(false);
+	});
+
+	it('targets an account whose bucket falls inside the rollout', () => {
+		const salt = DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG.rollout_salt;
+		const bucket = experimentBucket(USER_ID, salt);
+		const inside = resolveMessageKeyboardFocusAssignment(
+			config({enabled: true, rollout_basis_points: bucket + 1}),
+			USER_ID,
+		);
+		const outside = resolveMessageKeyboardFocusAssignment(
+			config({enabled: true, rollout_basis_points: bucket}),
+			USER_ID,
+		);
+		expect(inside).toEqual({enabled: true, config_version: 0, user_targeted: true, source: 'canary'});
+		expect(outside).toEqual({enabled: true, config_version: 0, user_targeted: false, source: null});
+	});
+
+	it('separates two accounts under the same salt', () => {
+		const salt = DEFAULT_MESSAGE_KEYBOARD_FOCUS_CONFIG.rollout_salt;
+		expect(experimentBucket(USER_ID, salt)).not.toBe(experimentBucket(OTHER_USER_ID, salt));
+	});
+
+	it('moves an account when the salt changes', () => {
+		expect(experimentBucket(USER_ID, 'message-keyboard-focus-v1')).not.toBe(
+			experimentBucket(USER_ID, 'message-keyboard-focus-v2'),
+		);
+	});
+});