feat(variants): default a registered account to Erudit + Russian Scrabble

New Game opened on a single variant for everyone, which reads poorly on VK
where Russian Scrabble is the familiar game. A registered account now starts
with both Russian-alphabet games, so the picker offers a real choice with no
pre-selection.

A guest stays on Erudit alone and is invited to register for the rest: the
device-local guest has no profile at all, so the client-side fallback has to
keep matching the server. Registering promotes the set, but only while the
guest still carries the untouched guest default. Existing accounts are not
backfilled — the set they carry may be a deliberate choice.

The Telegram promo start-param becomes additive rather than a replacement,
with English Scrabble withheld from a Russian-speaking arrival; otherwise the
English campaign link would have taken Russian Scrabble away from every
account it onboarded.

backend/internal/account/account.go

@@ -18,6 +18,7 @@ import (
 	"github.com/go-jet/jet/v2/qrm"
 	"github.com/google/uuid"
 	"github.com/jackc/pgx/v5/pgconn"
+	"github.com/lib/pq"
 
 	"scrabble/backend/internal/postgres/jet/backend/model"
 	"scrabble/backend/internal/postgres/jet/backend/table"
@@ -57,8 +58,9 @@ type Account struct {
 	// VariantPreferences is the set of game variants (engine.Variant stable labels:
 	// "scrabble_en", "scrabble_ru", "erudit_ru") the player is willing to be matched
 	// into. It gates the New Game picker, the matchmaker and the friend-invite the
-	// player creates; an invited friend may still accept any variant. A new account
-	// defaults to Erudit only. Never empty — enforced on update and by a DB check.
+	// player creates; an invited friend may still accept any variant. A newly registered
+	// account defaults to DefaultVariantPreferences and a guest to
+	// GuestVariantPreferences. Never empty — enforced on update and by a DB check.
 	VariantPreferences []string
 	// IsGuest marks an ephemeral guest account: a durable row with no identity,
 	// excluded from statistics, friends and history.
@@ -562,9 +564,14 @@ func (s *Store) ProvisionGuest(ctx context.Context, browserTZ, language string)
 	if lang == "" {
 		lang = "en"
 	}
+	// A guest is narrower than a registered player: Эрудит alone, where the column default
+	// gives a registered account both Russian-alphabet games (DefaultVariantPreferences).
+	// The set is written explicitly for exactly that reason, and ClearGuest widens it to the
+	// default when the guest later registers.
 	stmt := table.Accounts.
-		INSERT(table.Accounts.AccountID, table.Accounts.DisplayName, table.Accounts.IsGuest, table.Accounts.TimeZone, table.Accounts.PreferredLanguage).
-		VALUES(accountID, guestDisplayName(), true, tz, lang).
+		INSERT(table.Accounts.AccountID, table.Accounts.DisplayName, table.Accounts.IsGuest, table.Accounts.TimeZone, table.Accounts.PreferredLanguage, table.Accounts.VariantPreferences).
+		VALUES(accountID, guestDisplayName(), true, tz, lang,
+			postgres.Raw("#guest_variants::text[]", map[string]interface{}{"#guest_variants": pq.StringArray(GuestVariantPreferences)})).
 		RETURNING(table.Accounts.AllColumns)
 
 	var row model.Accounts

backend/internal/account/link.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/go-jet/jet/v2/postgres"
 	"github.com/google/uuid"
+	"github.com/lib/pq"
 
 	"scrabble/backend/internal/postgres/jet/backend/table"
 )
@@ -282,9 +283,22 @@ func (s *Store) AttachIdentity(ctx context.Context, accountID uuid.UUID, kind, e
 // ClearGuest removes the is_guest flag from accountID, promoting an ephemeral guest
 // to a durable account once it gains its first identity. It is a no-op
 // for an already-durable account.
+//
+// The promotion also widens the guest's narrow variant set (GuestVariantPreferences,
+// Эрудит alone) to the registered default, so a player who registers from the New Game
+// hint really does gain Russian Scrabble. A guest who changed the set themselves is left
+// alone: only the untouched guest default is replaced.
 func (s *Store) ClearGuest(ctx context.Context, accountID uuid.UUID) error {
-	upd := table.Accounts.UPDATE(table.Accounts.IsGuest, table.Accounts.UpdatedAt).
-		SET(postgres.Bool(false), postgres.TimestampzT(time.Now().UTC())).
+	upd := table.Accounts.UPDATE(table.Accounts.IsGuest, table.Accounts.VariantPreferences, table.Accounts.UpdatedAt).
+		SET(postgres.Bool(false),
+			postgres.Raw(
+				"CASE WHEN variant_preferences = #guest_variants::text[] THEN #default_variants::text[] ELSE variant_preferences END",
+				map[string]interface{}{
+					"#guest_variants":   pq.StringArray(GuestVariantPreferences),
+					"#default_variants": pq.StringArray(DefaultVariantPreferences),
+				},
+			),
+			postgres.TimestampzT(time.Now().UTC())).
 		WHERE(
 			table.Accounts.AccountID.EQ(postgres.UUID(accountID)).
 				AND(table.Accounts.IsGuest.EQ(postgres.Bool(true))),

backend/internal/account/profile.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"math/rand/v2"
 	"regexp"
+	"slices"
 	"strings"
 	"time"
 	"unicode"
@@ -76,6 +77,18 @@ var knownVariants = map[string]bool{"erudit_ru": true, "scrabble_ru": true, "scr
 // in (Erudit, Russian Scrabble, English), independent of the client's order.
 var canonicalVariantOrder = []string{"erudit_ru", "scrabble_ru", "scrabble_en"}
 
+// DefaultVariantPreferences is the variant set a newly registered account starts with:
+// both Russian-alphabet games. It mirrors the accounts.variant_preferences column
+// default, which is what actually seeds a created row — the constant is here so the
+// promotion of a guest (ClearGuest) and the tests name the same set as the schema.
+var DefaultVariantPreferences = []string{"erudit_ru", "scrabble_ru"}
+
+// GuestVariantPreferences is the variant set an ephemeral guest starts with: Эрудит
+// alone. A guest is deliberately narrower than a registered player — the New Game
+// screen offers the single variant and invites the guest to register for the rest —
+// so ProvisionGuest writes it explicitly instead of taking the column default.
+var GuestVariantPreferences = []string{"erudit_ru"}
+
 // validateVariantPreferences cleans a profile's variant-preference set: it drops
 // duplicates, rejects an unknown label or an empty set (ErrInvalidProfile) and
 // returns the preferences in canonicalVariantOrder so the stored value is
@@ -129,6 +142,33 @@ func SeedVariantsFromStartParam(startParam string) []string {
 	return prefs
 }
 
+// MergeVariantSeed resolves the variant-preference set to store for an account that
+// arrived on a promo deep link. The seed decoded from the link is *added* to current
+// (the set the account already carries, normally the column default) rather than
+// replacing it, so a campaign can only ever widen a player's choice. English Scrabble
+// is the one variant the language gates: it is dropped from seed when languageCode is
+// Russian, because a Russian-speaking arrival is served by the two Russian-alphabet
+// games and the English one would only clutter New Game. It returns nil when there is
+// nothing to write — an empty or invalid seed, or a merge that leaves current as it is
+// — so the caller can skip the update.
+func MergeVariantSeed(current, seed []string, languageCode string) []string {
+	if len(seed) == 0 {
+		return nil
+	}
+	extra := seed
+	if supportedLanguage(languageCode) == "ru" {
+		extra = slices.DeleteFunc(slices.Clone(seed), func(v string) bool { return v == "scrabble_en" })
+	}
+	merged, err := validateVariantPreferences(append(slices.Clone(current), extra...))
+	if err != nil {
+		return nil
+	}
+	if base, err := validateVariantPreferences(current); err == nil && slices.Equal(base, merged) {
+		return nil
+	}
+	return merged
+}
+
 // SetVariantPreferences overwrites only the variant-preference set of the account,
 // cleaning it to a deduplicated, canonically ordered subset of the known variants
 // (rejecting an empty or unknown set with ErrInvalidProfile) and bumping updated_at; it

backend/internal/account/variant_seed_test.go

@@ -35,3 +35,37 @@ func TestSeedVariantsFromStartParam(t *testing.T) {
 		})
 	}
 }
+
+// TestMergeVariantSeed covers resolving what a promo-onboarded account should end up with:
+// the seed only ever widens the current set, English Scrabble is withheld from a
+// Russian-speaking arrival, and a merge that changes nothing reports nil so the caller
+// skips the write.
+func TestMergeVariantSeed(t *testing.T) {
+	promo := []string{"erudit_ru", "scrabble_en"} // the campaign link "verudit_ru-scrabble_en"
+	tests := []struct {
+		name     string
+		current  []string
+		seed     []string
+		language string
+		want     []string
+	}{
+		{"russian speaker keeps the default", DefaultVariantPreferences, promo, "ru", nil},
+		{"russian locale variant is still russian", DefaultVariantPreferences, promo, "ru-RU", nil},
+		{"english speaker gains english", DefaultVariantPreferences, promo, "en", []string{"erudit_ru", "scrabble_ru", "scrabble_en"}},
+		{"unsupported language is not russian", DefaultVariantPreferences, promo, "de", []string{"erudit_ru", "scrabble_ru", "scrabble_en"}},
+		{"absent language is not russian", DefaultVariantPreferences, promo, "", []string{"erudit_ru", "scrabble_ru", "scrabble_en"}},
+		{"no seed writes nothing", DefaultVariantPreferences, nil, "en", nil},
+		{"seed already covered writes nothing", DefaultVariantPreferences, []string{"scrabble_ru"}, "ru", nil},
+		{"the russian filter spares the account's own english", []string{"erudit_ru", "scrabble_en"}, promo, "ru", nil},
+		{"invalid seed writes nothing", DefaultVariantPreferences, []string{"chess"}, "en", nil},
+		{"a guest set is widened by the seed", GuestVariantPreferences, []string{"scrabble_ru"}, "ru", DefaultVariantPreferences},
+	}
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			got := MergeVariantSeed(tc.current, tc.seed, tc.language)
+			if !slices.Equal(got, tc.want) {
+				t.Errorf("MergeVariantSeed(%v, %v, %q) = %v, want %v", tc.current, tc.seed, tc.language, got, tc.want)
+			}
+		})
+	}
+}

backend/internal/inttest/account_test.go

@@ -6,6 +6,7 @@ import (
 	"context"
 	"errors"
 	"regexp"
+	"slices"
 	"testing"
 	"time"
 
@@ -266,6 +267,81 @@ func TestProvisionSeedsTimeZone(t *testing.T) {
 	}
 }
 
+// TestVariantPreferenceDefaults covers the variant set an account is born with and how
+// registration widens it: a registered account starts on both Russian-alphabet games
+// (the column default), a guest on Эрудит alone, and promoting the guest lifts it to the
+// registered default — but only while the guest still carries that untouched set, and
+// never for an account that is already durable.
+func TestVariantPreferenceDefaults(t *testing.T) {
+	ctx := context.Background()
+	store := account.NewStore(testDB)
+
+	equal := func(t *testing.T, what string, got, want []string) {
+		t.Helper()
+		if !slices.Equal(got, want) {
+			t.Errorf("%s = %v, want %v", what, got, want)
+		}
+	}
+
+	// A registered account (any identity kind) takes the column default.
+	durable, _, err := store.ProvisionTelegram(ctx, "tg-"+uuid.NewString(), "ru", "", "Player", "")
+	if err != nil {
+		t.Fatalf("provision telegram: %v", err)
+	}
+	equal(t, "registered account variants", durable.VariantPreferences, account.DefaultVariantPreferences)
+
+	// A guest is deliberately narrower.
+	guest, err := store.ProvisionGuest(ctx, "", "ru")
+	if err != nil {
+		t.Fatalf("provision guest: %v", err)
+	}
+	equal(t, "guest variants", guest.VariantPreferences, account.GuestVariantPreferences)
+
+	// Registering the guest promotes it to a durable account on the registered default.
+	if err := store.ClearGuest(ctx, guest.ID); err != nil {
+		t.Fatalf("clear guest: %v", err)
+	}
+	promoted, err := store.GetByID(ctx, guest.ID)
+	if err != nil {
+		t.Fatalf("reload promoted guest: %v", err)
+	}
+	if promoted.IsGuest {
+		t.Error("promoted guest is still flagged is_guest")
+	}
+	equal(t, "promoted guest variants", promoted.VariantPreferences, account.DefaultVariantPreferences)
+
+	// A guest who picked their own set keeps it through the promotion.
+	picky, err := store.ProvisionGuest(ctx, "", "en")
+	if err != nil {
+		t.Fatalf("provision picky guest: %v", err)
+	}
+	if _, err := store.SetVariantPreferences(ctx, picky.ID, []string{"scrabble_en"}); err != nil {
+		t.Fatalf("set picky guest variants: %v", err)
+	}
+	if err := store.ClearGuest(ctx, picky.ID); err != nil {
+		t.Fatalf("clear picky guest: %v", err)
+	}
+	reloaded, err := store.GetByID(ctx, picky.ID)
+	if err != nil {
+		t.Fatalf("reload picky guest: %v", err)
+	}
+	equal(t, "picky guest variants", reloaded.VariantPreferences, []string{"scrabble_en"})
+
+	// An account that is already durable is never rewritten — an established player who
+	// settled on Эрудит alone stays there.
+	if _, err := store.SetVariantPreferences(ctx, durable.ID, []string{"erudit_ru"}); err != nil {
+		t.Fatalf("narrow durable variants: %v", err)
+	}
+	if err := store.ClearGuest(ctx, durable.ID); err != nil {
+		t.Fatalf("clear guest on a durable account: %v", err)
+	}
+	established, err := store.GetByID(ctx, durable.ID)
+	if err != nil {
+		t.Fatalf("reload durable account: %v", err)
+	}
+	equal(t, "established account variants", established.VariantPreferences, []string{"erudit_ru"})
+}
+
 // TestProvisionTelegramUnknownLanguageDefaults checks an unsupported Telegram
 // client language falls back to the account default rather than failing the
 // language CHECK.

backend/internal/inttest/email_test.go

@@ -135,10 +135,11 @@ func TestUpdateProfilePersists(t *testing.T) {
 	store := account.NewStore(testDB)
 	acc := provisionAccount(t)
 
-	// A fresh account defaults to Erudit only (the DB-level column default).
+	// A fresh registered account defaults to both Russian-alphabet games (the DB-level
+	// column default); the lifecycle around it is covered by TestVariantPreferenceDefaults.
 	if def, err := store.GetByID(ctx, acc); err != nil {
 		t.Fatalf("get default: %v", err)
-	} else if want := []string{"erudit_ru"}; !slices.Equal(def.VariantPreferences, want) {
+	} else if want := account.DefaultVariantPreferences; !slices.Equal(def.VariantPreferences, want) {
 		t.Errorf("default variant preferences = %v, want %v", def.VariantPreferences, want)
 	}
 

backend/internal/inttest/promo_variant_test.go

@@ -19,10 +19,11 @@ import (
 )
 
 // TestTelegramAuthSeedsPromoVariantForNewUserOnly drives the sessions/telegram endpoint
-// to confirm a promo deep-link start-param seeds a brand-new account's variant
-// preferences (English Scrabble alongside the default Erudit), that a new account with no
-// such payload keeps the Erudit-only default, and that an existing account is never
-// re-seeded on a later login (the new-user-only contract).
+// to confirm a promo deep-link start-param widens a brand-new account's variant
+// preferences — English Scrabble on top of the default pair, but only for a
+// non-Russian-speaking arrival — that a new account with no such payload keeps the
+// default, and that an existing account is never re-seeded on a later login (the
+// new-user-only contract).
 func TestTelegramAuthSeedsPromoVariantForNewUserOnly(t *testing.T) {
 	srv := server.New(":0", server.Deps{
 		Logger:   zaptest.NewLogger(t),
@@ -33,8 +34,8 @@ func TestTelegramAuthSeedsPromoVariantForNewUserOnly(t *testing.T) {
 	})
 	h := srv.Handler()
 
-	post := func(ext, startParam string) {
-		body := `{"external_id":"` + ext + `","language_code":"en","first_name":"Promo"`
+	post := func(ext, language, startParam string) {
+		body := `{"external_id":"` + ext + `","language_code":"` + language + `","first_name":"Promo"`
 		if startParam != "" {
 			body += `,"start_param":"` + startParam + `"`
 		}
@@ -56,25 +57,33 @@ func TestTelegramAuthSeedsPromoVariantForNewUserOnly(t *testing.T) {
 		return acc.VariantPreferences
 	}
 
-	// A brand-new account reached through a promo deep-link is seeded with English
-	// Scrabble alongside the default Erudit.
+	// An English-speaking arrival on a promo deep-link gains English Scrabble on top of
+	// the default pair, so a native English player is not lost at the door.
 	promoExt := "tg-" + uuid.NewString()
-	post(promoExt, "verudit_ru-scrabble_en")
-	if got, want := reload(promoExt), []string{"erudit_ru", "scrabble_en"}; !slices.Equal(got, want) {
-		t.Errorf("promo new account variants = %v, want %v", got, want)
+	post(promoExt, "en", "verudit_ru-scrabble_en")
+	if got, want := reload(promoExt), []string{"erudit_ru", "scrabble_ru", "scrabble_en"}; !slices.Equal(got, want) {
+		t.Errorf("english promo account variants = %v, want %v", got, want)
 	}
 
-	// A brand-new account with no promo payload keeps the Erudit-only default.
+	// A Russian-speaking arrival on the same link stays on the default pair: the two
+	// Russian-alphabet games serve them, and English would only clutter New Game.
+	ruExt := "tg-" + uuid.NewString()
+	post(ruExt, "ru", "verudit_ru-scrabble_en")
+	if got, want := reload(ruExt), []string{"erudit_ru", "scrabble_ru"}; !slices.Equal(got, want) {
+		t.Errorf("russian promo account variants = %v, want %v", got, want)
+	}
+
+	// A brand-new account with no promo payload keeps the default.
 	plainExt := "tg-" + uuid.NewString()
-	post(plainExt, "")
-	if got, want := reload(plainExt), []string{"erudit_ru"}; !slices.Equal(got, want) {
+	post(plainExt, "en", "")
+	if got, want := reload(plainExt), []string{"erudit_ru", "scrabble_ru"}; !slices.Equal(got, want) {
 		t.Errorf("plain new account variants = %v, want %v", got, want)
 	}
 
 	// A later login of the promo account, even via a different payload, must not re-seed:
 	// the seed is first-contact only.
-	post(promoExt, "vscrabble_ru")
-	if got, want := reload(promoExt), []string{"erudit_ru", "scrabble_en"}; !slices.Equal(got, want) {
+	post(promoExt, "en", "vscrabble_ru")
+	if got, want := reload(promoExt), []string{"erudit_ru", "scrabble_ru", "scrabble_en"}; !slices.Equal(got, want) {
 		t.Errorf("existing account re-seeded = %v, want unchanged %v", got, want)
 	}
 }

backend/internal/inttest/variant_preference_test.go

@@ -16,10 +16,10 @@ import (
 
 // TestVariantPreferenceGate covers the New Game gate: a player may start a quick game
 // or create a friend invitation only in a variant they have enabled in their profile
-// (a fresh account defaults to Erudit only), and any other variant is refused with 400.
-// The complementary case — an invited friend accepting an invitation in a variant they
-// have NOT enabled — is exercised by TestGameLimitGate, where a default-Erudit human
-// accepts an English invitation over HTTP.
+// (a fresh account defaults to the two Russian-alphabet games), and any other variant is
+// refused with 400. The complementary case — an invited friend accepting an invitation in
+// a variant they have NOT enabled — is exercised by TestGameLimitGate, where a
+// default-preference human accepts an English invitation over HTTP.
 func TestVariantPreferenceGate(t *testing.T) {
 	clearOpenGames(t)
 	srv := server.New(":0", server.Deps{

backend/internal/postgres/migrations/00018_default_variant_preferences.sql

@@ -0,0 +1,16 @@
+-- Registered players start with both Russian-alphabet games enabled: Эрудит and Russian Scrabble.
+-- Only the column default moves — existing accounts keep the set they already carry, so a player
+-- who deliberately settled on one variant is not overruled. Guests are the exception and stay on
+-- Эрудит alone; account.ProvisionGuest therefore writes the column explicitly rather than relying
+-- on this default, and account.ClearGuest widens a promoted guest to the default set. A default
+-- change rewrites no rows (no contour wipe); an image rollback ignores it — the previous code
+-- reads a two-element set unchanged.
+-- +goose Up
+
+ALTER TABLE backend.accounts
+    ALTER COLUMN variant_preferences SET DEFAULT ARRAY['erudit_ru', 'scrabble_ru']::text[];
+
+-- +goose Down
+
+ALTER TABLE backend.accounts
+    ALTER COLUMN variant_preferences SET DEFAULT ARRAY['erudit_ru']::text[];

backend/internal/server/handlers_auth.go

@@ -23,10 +23,11 @@ import (
 // validated initData payload. Username, FirstName and LanguageCode seed a
 // brand-new account's display name and language; BrowserTZ (the client's detected
 // "±HH:MM" UTC offset) seeds its time zone; StartParam is the validated launch
-// deep-link payload, which may seed the new account's variant preferences (first
-// contact only). Subtype is the client-reported device family (ios/android/web);
-// Telegram's initData does not sign it, so it is recorded best-effort and the
-// payments gate never relies on it.
+// deep-link payload, which may widen the new account's variant preferences (first
+// contact only) — LanguageCode decides whether English Scrabble is part of that.
+// Subtype is the client-reported device family (ios/android/web); Telegram's initData
+// does not sign it, so it is recorded best-effort and the payments gate never relies
+// on it.
 type telegramAuthRequest struct {
 	ExternalID   string `json:"external_id"`
 	Username     string `json:"username"`
@@ -56,12 +57,14 @@ func (s *Server) handleTelegramAuth(c *gin.Context) {
 		// joined the chat before registering is granted on the spot (no chat_member
 		// event fires on registration).
 		s.publishChatAccessChange(acc.ID)
-		// A promo deep-link may seed this brand-new account's variant preferences (e.g.
-		// English Scrabble alongside the default Erudit). Best-effort: an absent or
-		// malformed payload leaves the account on its defaults, and a write failure must
-		// not block the session mint.
-		if seed := account.SeedVariantsFromStartParam(req.StartParam); len(seed) > 0 {
-			if _, err := s.accounts.SetVariantPreferences(c.Request.Context(), acc.ID, seed); err != nil {
+		// A promo deep-link may widen this brand-new account's variant preferences beyond
+		// the default (English Scrabble for a non-Russian-speaking arrival — see
+		// account.MergeVariantSeed, which gates that variant on req.LanguageCode).
+		// Best-effort: an absent or malformed payload leaves the account on its defaults,
+		// and a write failure must not block the session mint.
+		seed := account.SeedVariantsFromStartParam(req.StartParam)
+		if merged := account.MergeVariantSeed(acc.VariantPreferences, seed, req.LanguageCode); len(merged) > 0 {
+			if _, err := s.accounts.SetVariantPreferences(c.Request.Context(), acc.ID, merged); err != nil {
 				s.log.Warn("telegram: seed variant preferences failed",
 					zap.String("account", acc.ID.String()), zap.Error(err))
 			}