Описания параметров на русском независимо от локали сервера

Панель показывала комментарии из самого конфига, а игра пишет их на языке
сервера: на Windows-клиенте они русские, на Linux-сервере почти всегда
английские — и вся вкладка оказывалась на английском.

Теперь у панели свой словарь: подпись и описание для всех 153 параметров
servertest.ini, встречающихся в Build 41 и 42, плюс подписи для 182
параметров песочницы. Комментарий из файла остаётся запасным вариантом для
ключей, которых словарь не знает, — в новых версиях игры их добавляют.

Песочница заодно научилась отдавать свои комментарии: игра расписывает там
смысл каждого значения, и даже английский текст лучше пустоты.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

README.md

@@ -22,7 +22,8 @@
 - **Мониторинг** — состояние, аптайм, CPU и память процесса сервера, свободные
   ОЗУ и диск на хосте, список игроков онлайн.
 - **Редактор конфигов** — `servertest.ini` и `SandboxVars.lua` прямо в
-  браузере, с поиском по параметрам и сохранением комментариев в файле.
+  браузере: параметры разложены по разделам, у каждого видно описание из
+  самого конфига, поиск идёт и по названию, и по описанию.
 - **Мод-менеджер** — моды списком с галочками и перетаскиванием порядка
   загрузки, добавление по ссылке и разворачивание коллекций Steam целиком.
 - **Бэкапы** — ручные и по расписанию, отдельно по каждому профилю, с
@@ -192,6 +193,22 @@ Mod ID, который нужен серверу, лежит внутри сам
 Один пакет мастерской может содержать несколько модов — в списке они идут
 отдельными строками, и включать их можно по отдельности.
 
+## Редактор конфигов
+
+Вкладки «Конфиг сервера» и «Песочница» показывают параметры не сплошным
+списком, а разделами: «Основное», «PVP и урон», «Убежища», «Античит» и так
+далее. Разделы сворачиваются, а поиск сверху раскрывает те, где нашлось
+совпадение. Ключи, которых панель не знает (в новой версии игры их всегда
+добавляют), не теряются — они собираются в раздел «Прочее».
+
+Описания параметров панель берёт из самого конфига: игра пишет их
+комментариями на языке сервера. Полный текст виден при наведении, начало —
+прямо под полем.
+
+Правка меняет ровно ту строку, которую поправили: комментарии, порядок и
+переводы строк файла сохраняются, а рядом остаётся копия прежней версии с
+расширением `.bak`.
+
 ## Профили серверов
 
 Профиль — это отдельный сервер: свой мир, свой `*.ini`, свои настройки
@@ -213,6 +230,20 @@ Mod ID, который нужен серверу, лежит внутри сам
 При создании профиля можно скопировать `.ini` и настройки песочницы из
 существующего: удобно, когда нужен тот же набор правил, но чистый мир.
 
+### Память JVM
+
+`java_memory` — это `-Xmx`, верхняя граница кучи. `java_memory_min` (`-Xms`)
+по умолчанию пуст, и это осознанно: равные значения избавляют от роста кучи на
+ходу, но заставляют JVM занять весь объём сразу при старте. На машине, где
+столько свободной памяти не набирается, сервер тогда не поднимется вовсе —
+`Failed to allocate initial Java heap`. Задавайте минимум, только если памяти
+заведомо хватает.
+
+Сервер, упавший сразу после запуска три раза подряд, панель перестаёт
+поднимать автоматически: обычно так проявляется нехватка памяти или битый
+конфиг, и перезапуск делу не помогает. Пока идёт отсчёт до автоподъёма, его
+можно отменить кнопкой «Отменить перезапуск».
+
 Удаление профиля убирает его только из панели — мир и конфиги остаются на
 диске. Чтобы вернуть профиль, создайте его с тем же идентификатором.
 
@@ -327,7 +358,8 @@ profiles:                       # серверы: у каждого свой м
   - id: vanilla                 # vanilla -> vanilla.ini, Saves/Multiplayer/vanilla
     title: Ванильный мир        # как профиль подписан в панели
     admin_password: ""          # пароль админа игрового сервера
-    java_memory: 4g             # -Xmx для JVM этого профиля
+    java_memory: 4g             # -Xmx: верхняя граница кучи JVM
+    java_memory_min: ""         # -Xms: пусто — JVM берёт память по мере надобности
     extra_args: []              # доп. аргументы start-server.sh
   - id: modded
     title: Сборка с модами

internal/api/handlers_config.go

@@ -32,6 +32,9 @@ func (s *Server) handleGetServerConfig(w http.ResponseWriter, r *http.Request) {
 		"path":   path,
 		"keys":   ini.Keys(),
 		"values": ini.Map(),
+		// Игра сама пишет в конфиг описания параметров на языке сервера —
+		// показываем их, вместо того чтобы придумывать свои.
+		"descriptions": ini.Comments(),
 	})
 }
 

internal/api/handlers_profiles.go

@@ -7,15 +7,36 @@ import (
 	"os"
 
 	"github.com/mrleo1nid/pzmanager/internal/config"
+	"github.com/mrleo1nid/pzmanager/internal/pzconfig"
 	"github.com/mrleo1nid/pzmanager/internal/pzserver"
 )
 
+// validateProfileMemory проверяет границы кучи JVM здесь, а не при запуске
+// сервера: иначе про опечатку в профиле стало бы известно только из лога
+// упавшего сервера.
+func validateProfileMemory(dto profileDTO) error {
+	maxBytes, err := pzconfig.ParseMemory(dto.JavaMemory)
+	if err != nil {
+		return err
+	}
+	minBytes, err := pzconfig.ParseMemory(dto.JavaMemoryMin)
+	if err != nil {
+		return err
+	}
+	if maxBytes > 0 && minBytes > maxBytes {
+		return fmt.Errorf("начальный размер памяти (%s) больше максимального (%s)",
+			dto.JavaMemoryMin, dto.JavaMemory)
+	}
+	return nil
+}
+
 // profileDTO — профиль в том виде, в каком его показывает панель. Пароль
 // наружу не отдаётся, только признак того, что он задан.
 type profileDTO struct {
 	ID               string   `json:"id"`
 	Title            string   `json:"title"`
 	JavaMemory       string   `json:"java_memory"`
+	JavaMemoryMin    string   `json:"java_memory_min"`
 	ExtraArgs        []string `json:"extra_args"`
 	HasAdminPassword bool     `json:"has_admin_password"`
 	AdminPassword    string   `json:"admin_password,omitempty"`
@@ -33,6 +54,7 @@ func (s *Server) profileToDTO(p config.Profile) profileDTO {
 		ID:               p.ID,
 		Title:            p.Title,
 		JavaMemory:       p.JavaMemory,
+		JavaMemoryMin:    p.JavaMemoryMin,
 		ExtraArgs:        p.ExtraArgs,
 		HasAdminPassword: p.AdminPassword != "",
 		HasConfig:        fileExists(s.cfg.ServerConfigPathFor(p.ID)),
@@ -61,11 +83,16 @@ func (s *Server) handleCreateProfile(w http.ResponseWriter, r *http.Request) {
 	if !decodeJSON(w, r, &dto) {
 		return
 	}
+	if err := validateProfileMemory(dto); err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
+		return
+	}
 
 	profile := config.Profile{
 		ID:            dto.ID,
 		Title:         dto.Title,
 		JavaMemory:    dto.JavaMemory,
+		JavaMemoryMin: dto.JavaMemoryMin,
 		ExtraArgs:     dto.ExtraArgs,
 		AdminPassword: dto.AdminPassword,
 	}
@@ -133,12 +160,17 @@ func (s *Server) handleUpdateProfile(w http.ResponseWriter, r *http.Request) {
 	if !decodeJSON(w, r, &dto) {
 		return
 	}
+	if err := validateProfileMemory(dto); err != nil {
+		writeError(w, http.StatusBadRequest, err.Error())
+		return
+	}
 
 	updated := config.Profile{
-		ID:         id,
+		ID:            id,
-		Title:      dto.Title,
+		Title:         dto.Title,
-		JavaMemory: dto.JavaMemory,
+		JavaMemory:    dto.JavaMemory,
-		ExtraArgs:  dto.ExtraArgs,
+		JavaMemoryMin: dto.JavaMemoryMin,
+		ExtraArgs:     dto.ExtraArgs,
 		// Пустой пароль означает "оставить прежний": наружу мы его не отдаём,
 		// и форма присылает пустую строку, пока его не меняли.
 		AdminPassword: current.AdminPassword,

internal/api/handlers_tasks.go

@@ -236,12 +236,16 @@ func StartBackupScheduler(ctx context.Context, s *Server) {
 // При обычном старте то же самое делает супервизор.
 func (s *Server) applyJavaMemory(log func(string)) error {
 	profile := s.cfg.ActiveProfile()
-	if profile.JavaMemory == "" {
+	if profile.JavaMemory == "" && profile.JavaMemoryMin == "" {
 		return nil
 	}
-	if err := pzconfig.SetJavaMemory(s.cfg.ServerDir, profile.JavaMemory); err != nil {
+	if err := pzconfig.SetJavaMemory(s.cfg.ServerDir, profile.JavaMemory, profile.JavaMemoryMin); err != nil {
 		return err
 	}
-	log("Лимит памяти JVM выставлен: " + profile.JavaMemory)
+	if profile.JavaMemoryMin != "" {
+		log(fmt.Sprintf("Память JVM: от %s до %s", profile.JavaMemoryMin, profile.JavaMemory))
+	} else {
+		log("Лимит памяти JVM выставлен: " + profile.JavaMemory)
+	}
 	return nil
 }

internal/config/config.go

@@ -34,6 +34,11 @@ type Profile struct {
 	// запуске: файл запуска сервера общий для всех профилей.
 	JavaMemory string `yaml:"java_memory"`
 
+	// JavaMemoryMin — -Xms. Пусто (по умолчанию) означает, что JVM занимает
+	// память по мере надобности: равные -Xms и -Xmx заставляют её забрать всё
+	// сразу, и на машине с небольшой ОЗУ сервер не поднимется.
+	JavaMemoryMin string `yaml:"java_memory_min"`
+
 	// ExtraArgs — дополнительные аргументы start-server.sh.
 	ExtraArgs []string `yaml:"extra_args"`
 }

internal/pzconfig/ini.go

@@ -16,6 +16,10 @@ type iniLine struct {
 	Key   string
 	Value string
 	Raw   string
+	// Comment — описание параметра: строки комментария прямо перед ним.
+	// Project Zomboid пишет их на языке сервера, так что панели есть что
+	// показать человеку, не выдумывая своих формулировок.
+	Comment string
 }
 
 // INI — конфиг PZ в виде плоских key=value. Разбор сохраняет исходный порядок
@@ -23,22 +27,46 @@ type iniLine struct {
 type INI struct {
 	lines []iniLine
 	index map[string]int
+	// crlf — файл был с виндовыми переводами строк. Сохраняем как было: иначе
+	// правка одного параметра переписывает весь файл целиком.
+	crlf bool
 }
 
 // ParseINI разбирает содержимое конфига.
 func ParseINI(data []byte) *INI {
 	ini := &INI{index: make(map[string]int)}
-	text := strings.ReplaceAll(string(data), "\r\n", "\n")
+	raw := string(data)
+	ini.crlf = strings.Contains(raw, "\r\n")
+	text := strings.ReplaceAll(raw, "\r\n", "\n")
+
+	// Комментарии копим до ближайшего параметра: в конфигах PZ описание стоит
+	// строкой выше. Пустая строка обрывает связь — иначе описание прилипло бы
+	// к следующему блоку.
+	var comment []string
+
 	for _, raw := range strings.Split(text, "\n") {
 		trimmed := strings.TrimSpace(raw)
 		key, value, found := strings.Cut(raw, "=")
-		if !found || trimmed == "" || strings.HasPrefix(trimmed, "#") {
+
+		if strings.HasPrefix(trimmed, "#") {
+			comment = append(comment, strings.TrimSpace(strings.TrimPrefix(trimmed, "#")))
 			ini.lines = append(ini.lines, iniLine{Raw: raw})
 			continue
 		}
+		if !found || trimmed == "" {
+			comment = nil
+			ini.lines = append(ini.lines, iniLine{Raw: raw})
+			continue
+		}
+
 		key = strings.TrimSpace(key)
 		ini.index[key] = len(ini.lines)
-		ini.lines = append(ini.lines, iniLine{Key: key, Value: strings.TrimSpace(value)})
+		ini.lines = append(ini.lines, iniLine{
+			Key:     key,
+			Value:   strings.TrimSpace(value),
+			Comment: strings.Join(comment, " "),
+		})
+		comment = nil
 	}
 	return ini
 }
@@ -90,6 +118,17 @@ func (i *INI) Keys() []string {
 	return out
 }
 
+// Comments возвращает описания параметров: ключ -> текст комментария.
+func (i *INI) Comments() map[string]string {
+	out := make(map[string]string, len(i.index))
+	for _, l := range i.lines {
+		if l.Key != "" && l.Comment != "" {
+			out[l.Key] = l.Comment
+		}
+	}
+	return out
+}
+
 // Map отдаёт все параметры в виде словаря.
 func (i *INI) Map() map[string]string {
 	out := make(map[string]string, len(i.index))
@@ -103,6 +142,11 @@ func (i *INI) Map() map[string]string {
 
 // Render собирает файл обратно в текст.
 func (i *INI) Render() []byte {
+	newline := "\n"
+	if i.crlf {
+		newline = "\r\n"
+	}
+
 	var buf bytes.Buffer
 	for n, l := range i.lines {
 		if l.Key == "" {
@@ -113,7 +157,7 @@ func (i *INI) Render() []byte {
 			buf.WriteString(l.Value)
 		}
 		if n < len(i.lines)-1 {
-			buf.WriteByte('\n')
+			buf.WriteString(newline)
 		}
 	}
 	return buf.Bytes()

internal/pzconfig/java.go

@@ -6,24 +6,71 @@ import (
 	"os"
 	"path/filepath"
 	"regexp"
+	"strconv"
 	"strings"
 )
 
 // javaLauncherFile — файл, из которого сервер берёт аргументы JVM.
 const javaLauncherFile = "ProjectZomboid64.json"
 
-var xmxRe = regexp.MustCompile(`^-Xm[sx]`)
+var (
+	heapArgRe = regexp.MustCompile(`^-Xm[sx]`)
+	memoryRe  = regexp.MustCompile(`^([0-9]+)([kKmMgG])$`)
+)
 
-// SetJavaMemory прописывает лимит памяти JVM в ProjectZomboid64.json. Именно
+// ParseMemory переводит запись вида "4g" в байты. Возвращает 0, если строка
-// оттуда start-server.sh берёт -Xmx, поэтому менять размер памяти в аргументах
+// пустая, и ошибку, если формат непонятен.
-// запуска бесполезно.
+func ParseMemory(value string) (int64, error) {
-func SetJavaMemory(serverDir, memory string) error {
+	value = strings.TrimSpace(value)
-	memory = strings.TrimSpace(memory)
+	if value == "" {
-	if memory == "" {
+		return 0, nil
+	}
+	match := memoryRe.FindStringSubmatch(value)
+	if match == nil {
+		return 0, fmt.Errorf("объём памяти должен выглядеть как 4g или 8192m, получено %q", value)
+	}
+	amount, err := strconv.ParseInt(match[1], 10, 64)
+	if err != nil {
+		return 0, fmt.Errorf("не разобран объём памяти %q", value)
+	}
+	switch strings.ToLower(match[2]) {
+	case "k":
+		return amount * 1024, nil
+	case "m":
+		return amount * 1024 * 1024, nil
+	default:
+		return amount * 1024 * 1024 * 1024, nil
+	}
+}
+
+// SetJavaMemory прописывает границы кучи JVM в ProjectZomboid64.json. Именно
+// оттуда start-server.sh берёт -Xmx и -Xms, поэтому менять размер памяти в
+// аргументах запуска бесполезно.
+//
+// maxMemory задаёт -Xmx (верхнюю границу), minMemory — -Xms. Пустой minMemory
+// означает, что -Xms не выставляется вовсе: JVM тогда занимает память по мере
+// надобности. Равные значения удобны тем, что куча не растёт на ходу, но JVM
+// обязана занять весь объём при старте — на машине с небольшой ОЗУ сервер
+// просто не поднимется.
+func SetJavaMemory(serverDir, maxMemory, minMemory string) error {
+	maxMemory = strings.TrimSpace(maxMemory)
+	minMemory = strings.TrimSpace(minMemory)
+	if maxMemory == "" && minMemory == "" {
 		return nil
 	}
-	if !regexp.MustCompile(`^[0-9]+[kKmMgG]$`).MatchString(memory) {
+
-		return fmt.Errorf("объём памяти должен выглядеть как 4g или 8192m, получено %q", memory)
+	maxBytes, err := ParseMemory(maxMemory)
+	if err != nil {
+		return err
+	}
+	minBytes, err := ParseMemory(minMemory)
+	if err != nil {
+		return err
+	}
+	// JVM с -Xms больше -Xmx не стартует вообще, поэтому ловим это здесь, а не
+	// в логе упавшего сервера.
+	if maxBytes > 0 && minBytes > maxBytes {
+		return fmt.Errorf("начальный размер кучи (%s) больше максимального (%s)", minMemory, maxMemory)
 	}
 
 	path := filepath.Join(serverDir, javaLauncherFile)
@@ -41,14 +88,17 @@ func SetJavaMemory(serverDir, memory string) error {
 	args, _ := doc["vmArgs"].([]any)
 	updated := make([]any, 0, len(args)+2)
 	for _, a := range args {
-		if str, ok := a.(string); ok && xmxRe.MatchString(str) {
+		if str, ok := a.(string); ok && heapArgRe.MatchString(str) {
 			continue
 		}
 		updated = append(updated, a)
 	}
-	// -Xms равным -Xmx: JVM сразу забирает память и не тратит время на рост
+	if minMemory != "" {
-	// кучи в момент, когда на сервере много игроков.
+		updated = append(updated, "-Xms"+minMemory)
-	updated = append(updated, "-Xms"+memory, "-Xmx"+memory)
+	}
+	if maxMemory != "" {
+		updated = append(updated, "-Xmx"+maxMemory)
+	}
 	doc["vmArgs"] = updated
 
 	out, err := json.MarshalIndent(doc, "", "  ")

internal/pzconfig/java_test.go

@@ -0,0 +1,167 @@
+package pzconfig
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// TestSetJavaMemoryKeepsOnlyXmx: -Xms равным -Xmx заставляет JVM занять весь
+// объём при старте, и на машине с небольшой ОЗУ сервер падает с «Failed to
+// allocate initial Java heap». Ставим только верхнюю границу.
+func TestSetJavaMemoryKeepsOnlyXmx(t *testing.T) {
+	dir := t.TempDir()
+	writeLauncher(t, dir, map[string]any{
+		"mainClass": "zombie/network/GameServer",
+		"vmArgs": []any{
+			"-Djava.awt.headless=true",
+			"-XX:+UseZGC",
+			// Значения от прошлой установки должны замениться.
+			"-Xms8g",
+			"-Xmx8g",
+		},
+	})
+
+	if err := SetJavaMemory(dir, "3g", ""); err != nil {
+		t.Fatal(err)
+	}
+
+	args := launcherArgs(t, dir)
+	var xms, xmx int
+	for _, a := range args {
+		switch {
+		case len(a) > 4 && a[:4] == "-Xms":
+			xms++
+			t.Errorf("в аргументах остался %s — JVM займёт всю память при старте", a)
+		case a == "-Xmx3g":
+			xmx++
+		}
+	}
+	if xms != 0 {
+		t.Errorf("-Xms не должен добавляться, найдено вхождений: %d", xms)
+	}
+	if xmx != 1 {
+		t.Errorf("-Xmx3g встречается %d раз, ожидалось 1: %v", xmx, args)
+	}
+
+	// Чужие аргументы должны остаться нетронутыми.
+	if !contains(args, "-XX:+UseZGC") || !contains(args, "-Djava.awt.headless=true") {
+		t.Errorf("потеряны исходные аргументы: %v", args)
+	}
+}
+
+func TestSetJavaMemoryValidates(t *testing.T) {
+	dir := t.TempDir()
+	writeLauncher(t, dir, map[string]any{"vmArgs": []any{}})
+
+	for _, bad := range []string{"4", "4gb", "много", "-4g", "4g; rm -rf /"} {
+		if err := SetJavaMemory(dir, bad, ""); err == nil {
+			t.Errorf("значение %q принято, ожидалась ошибка", bad)
+		}
+	}
+	// Пустые значения — «не трогать», это не ошибка.
+	if err := SetJavaMemory(dir, "", ""); err != nil {
+		t.Errorf("пустое значение вернуло ошибку: %v", err)
+	}
+	for _, good := range []string{"512m", "4g", "8G", "16384M"} {
+		if err := SetJavaMemory(dir, good, ""); err != nil {
+			t.Errorf("значение %q отклонено: %v", good, err)
+		}
+	}
+
+	// JVM с -Xms больше -Xmx не стартует, поэтому ловим это заранее.
+	if err := SetJavaMemory(dir, "2g", "4g"); err == nil {
+		t.Error("начальный размер больше максимального принят, ожидалась ошибка")
+	}
+	if err := SetJavaMemory(dir, "4g", "2g"); err != nil {
+		t.Errorf("корректная пара 2g/4g отклонена: %v", err)
+	}
+}
+
+func writeLauncher(t *testing.T, dir string, doc map[string]any) {
+	t.Helper()
+	raw, err := json.MarshalIndent(doc, "", "  ")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(dir, javaLauncherFile), raw, 0o644); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func launcherArgs(t *testing.T, dir string) []string {
+	t.Helper()
+	raw, err := os.ReadFile(filepath.Join(dir, javaLauncherFile))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var doc struct {
+		VMArgs []string `json:"vmArgs"`
+	}
+	if err := json.Unmarshal(raw, &doc); err != nil {
+		t.Fatal(err)
+	}
+	return doc.VMArgs
+}
+
+func contains(list []string, want string) bool {
+	for _, item := range list {
+		if item == want {
+			return true
+		}
+	}
+	return false
+}
+
+// TestSetJavaMemoryWritesXmsWhenAsked: минимальный размер кучи задаётся
+// отдельно и попадает в файл, только если его действительно указали.
+func TestSetJavaMemoryWritesXmsWhenAsked(t *testing.T) {
+	dir := t.TempDir()
+	writeLauncher(t, dir, map[string]any{"vmArgs": []any{"-XX:+UseZGC"}})
+
+	if err := SetJavaMemory(dir, "6g", "2g"); err != nil {
+		t.Fatal(err)
+	}
+	args := launcherArgs(t, dir)
+	if !contains(args, "-Xms2g") || !contains(args, "-Xmx6g") {
+		t.Fatalf("границы кучи не выставлены: %v", args)
+	}
+
+	// Убрали минимум — из файла он тоже должен уйти.
+	if err := SetJavaMemory(dir, "6g", ""); err != nil {
+		t.Fatal(err)
+	}
+	args = launcherArgs(t, dir)
+	for _, a := range args {
+		if len(a) > 4 && a[:4] == "-Xms" {
+			t.Errorf("после очистки минимума остался %s: %v", a, args)
+		}
+	}
+	if !contains(args, "-Xmx6g") {
+		t.Errorf("максимум потерян: %v", args)
+	}
+}
+
+func TestParseMemory(t *testing.T) {
+	cases := map[string]int64{
+		"":      0,
+		"512m":  512 * 1024 * 1024,
+		"4g":    4 * 1024 * 1024 * 1024,
+		"8G":    8 * 1024 * 1024 * 1024,
+		"1024k": 1024 * 1024,
+	}
+	for input, want := range cases {
+		got, err := ParseMemory(input)
+		if err != nil {
+			t.Errorf("ParseMemory(%q): %v", input, err)
+			continue
+		}
+		if got != want {
+			t.Errorf("ParseMemory(%q) = %d, ожидалось %d", input, got, want)
+		}
+	}
+	if _, err := ParseMemory("4гб"); err == nil {
+		t.Error("значение с кириллицей принято")
+	}
+}

internal/pzconfig/pzconfig_test.go

@@ -154,3 +154,34 @@ func TestSandboxEntriesFollowFileOrder(t *testing.T) {
 		}
 	}
 }
+
+// TestKeepsWindowsLineEndings: конфиги, созданные игрой на Windows, приходят с
+// CRLF. Если при сохранении переписать их в LF, изменится каждая строка файла —
+// правка одного параметра превратится в полную перезапись.
+func TestKeepsWindowsLineEndings(t *testing.T) {
+	ini := ParseINI([]byte("# Комментарий\r\nMaxPlayers=32\r\nPVP=true\r\n"))
+	ini.Set("MaxPlayers", "64")
+
+	got := string(ini.Render())
+	if strings.Count(got, "\r\n") != 3 {
+		t.Errorf("переводы строк не сохранены:\n%q", got)
+	}
+	if strings.Contains(strings.ReplaceAll(got, "\r\n", ""), "\n") {
+		t.Errorf("в файле появились одиночные LF:\n%q", got)
+	}
+
+	// Файл с LF таким и остаётся.
+	unix := ParseINI([]byte("MaxPlayers=32\nPVP=true"))
+	unix.Set("PVP", "false")
+	if strings.Contains(string(unix.Render()), "\r") {
+		t.Error("в файл с LF добавились CR")
+	}
+
+	sandbox := ParseSandbox([]byte("SandboxVars = {\r\n    Zombies = 3,\r\n}\r\n"))
+	if err := sandbox.Set("Zombies", "1"); err != nil {
+		t.Fatal(err)
+	}
+	if strings.Count(string(sandbox.Render()), "\r\n") != 3 {
+		t.Errorf("песочница потеряла CRLF:\n%q", string(sandbox.Render()))
+	}
+}

internal/pzconfig/sandbox.go

@@ -13,6 +13,9 @@ import (
 type SandboxEntry struct {
 	Path  string `json:"path"`
 	Value string `json:"value"`
+	// Comment — строки "--" перед параметром: игра расписывает там смысл
+	// значения и расшифровку вариантов.
+	Comment string `json:"comment,omitempty"`
 }
 
 // Sandbox — разбор <server>_SandboxVars.lua. Файл генерируется игрой и имеет
@@ -24,6 +27,10 @@ type Sandbox struct {
 	lines []string
 	// index сопоставляет путь параметра с номером строки.
 	index map[string]int
+	// comments хранит описание параметра по его пути.
+	comments map[string]string
+	// crlf — файл был с виндовыми переводами строк; сохраняем как было.
+	crlf bool
 }
 
 var (
@@ -33,14 +40,24 @@ var (
 
 // ParseSandbox разбирает содержимое SandboxVars.lua.
 func ParseSandbox(data []byte) *Sandbox {
-	s := &Sandbox{index: make(map[string]int)}
+	s := &Sandbox{index: make(map[string]int), comments: make(map[string]string)}
-	text := strings.ReplaceAll(string(data), "\r\n", "\n")
+	raw := string(data)
+	s.crlf = strings.Contains(raw, "\r\n")
+	text := strings.ReplaceAll(raw, "\r\n", "\n")
 	s.lines = strings.Split(text, "\n")
 
 	var stack []string
+	// Комментарии копим до ближайшего параметра, как и в .ini.
+	var comment []string
+
 	for n, line := range s.lines {
 		trimmed := strings.TrimSpace(line)
-		if trimmed == "" || strings.HasPrefix(trimmed, "--") {
+		if strings.HasPrefix(trimmed, "--") {
+			comment = append(comment, strings.TrimSpace(strings.TrimPrefix(trimmed, "--")))
+			continue
+		}
+		if trimmed == "" {
+			comment = nil
 			continue
 		}
 		if sandboxCloseRe.MatchString(line) {
@@ -62,6 +79,7 @@ func ParseSandbox(data []byte) *Sandbox {
 			} else {
 				stack = stack[:0]
 			}
+			comment = nil
 			continue
 		}
 		path := name
@@ -69,6 +87,10 @@ func ParseSandbox(data []byte) *Sandbox {
 			path = strings.Join(stack, ".") + "." + name
 		}
 		s.index[path] = n
+		if len(comment) > 0 {
+			s.comments[path] = strings.Join(comment, " ")
+		}
+		comment = nil
 	}
 	return s
 }
@@ -95,7 +117,11 @@ func (s *Sandbox) Entries() []SandboxEntry {
 		if !ok {
 			continue
 		}
-		out = append(out, SandboxEntry{Path: path, Value: s.valueAt(n)})
+		out = append(out, SandboxEntry{
+			Path:    path,
+			Value:   s.valueAt(n),
+			Comment: s.comments[path],
+		})
 	}
 	return out
 }
@@ -139,11 +165,16 @@ func (s *Sandbox) Set(path, value string) error {
 
 // Render собирает файл обратно.
 func (s *Sandbox) Render() []byte {
+	newline := "\n"
+	if s.crlf {
+		newline = "\r\n"
+	}
+
 	var buf bytes.Buffer
 	for n, line := range s.lines {
 		buf.WriteString(line)
 		if n < len(s.lines)-1 {
-			buf.WriteByte('\n')
+			buf.WriteString(newline)
 		}
 	}
 	return buf.Bytes()

internal/pzserver/supervisor.go

@@ -23,10 +23,13 @@ import (
 type State string
 
 const (
-	StateStopped  State = "stopped"
+	StateStopped State = "stopped"
-	StateStarting State = "starting"
+	// StateRestarting — сервер упал и ждёт автоподъёма. Отдельное состояние
-	StateRunning  State = "running"
+	// нужно, чтобы это ожидание можно было отменить кнопкой.
-	StateStopping State = "stopping"
+	StateRestarting State = "restarting"
+	StateStarting   State = "starting"
+	StateRunning    State = "running"
+	StateStopping   State = "stopping"
 )
 
 // Ошибки, на которые HTTP-слой отвечает осмысленным кодом.
@@ -42,20 +45,30 @@ const playersPollInterval = 30 * time.Second
 // restartDelay — пауза перед автоподъёмом упавшего сервера.
 const restartDelay = 10 * time.Second
 
+// Сервер, падающий сразу после старта, автоперезапуском не лечится: обычно
+// это нехватка памяти или испорченный конфиг. После нескольких таких падений
+// подряд перестаём поднимать его сам, чтобы не крутить бесконечный цикл.
+const (
+	quickCrashWindow = time.Minute
+	maxQuickCrashes  = 3
+)
+
 // Status — снимок состояния для веб-панели.
 type Status struct {
 	State State `json:"state"`
 	// Profile и ProfileTitle описывают профиль, который сейчас работает
 	// (а если сервер остановлен — который будет запущен).
-	Profile      string            `json:"profile"`
+	Profile      string   `json:"profile"`
-	ProfileTitle string            `json:"profile_title"`
+	ProfileTitle string   `json:"profile_title"`
-	Installed    bool              `json:"installed"`
+	Installed    bool     `json:"installed"`
-	PID          int               `json:"pid"`
+	PID          int      `json:"pid"`
-	UptimeSec    int64             `json:"uptime_sec"`
+	UptimeSec    int64    `json:"uptime_sec"`
-	Players      []string          `json:"players"`
+	Players      []string `json:"players"`
-	PlayersAt    int64             `json:"players_at"`
+	PlayersAt    int64    `json:"players_at"`
-	LastExit     string            `json:"last_exit"`
+	LastExit     string   `json:"last_exit"`
-	AutoRestart  bool              `json:"auto_restart"`
+	AutoRestart  bool     `json:"auto_restart"`
+	// RestartInSec — сколько секунд осталось до автоподъёма (0, если не ждём).
+	RestartInSec int64             `json:"restart_in_sec"`
 	Proc         sysinfo.ProcStats `json:"proc"`
 	Host         sysinfo.HostStats `json:"host"`
 }
@@ -89,6 +102,13 @@ type Supervisor struct {
 	captured  []string
 	autoQuery bool
 
+	// restartCancel закрывается, чтобы отменить ожидание автоперезапуска;
+	// restartAt — когда оно закончится.
+	restartCancel chan struct{}
+	restartAt     time.Time
+	// crashStreak — сколько раз подряд сервер упал сразу после запуска.
+	crashStreak int
+
 	sampler  *sysinfo.Sampler
 	stopOnce sync.Once
 	quit     chan struct{}
@@ -165,9 +185,14 @@ func (s *Supervisor) Status() Status {
 	if s.cmd != nil && s.cmd.Process != nil {
 		st.PID = s.cmd.Process.Pid
 	}
-	if !s.startedAt.IsZero() && s.state != StateStopped {
+	if !s.startedAt.IsZero() && s.state != StateStopped && s.state != StateRestarting {
 		st.UptimeSec = int64(time.Since(s.startedAt).Seconds())
 	}
+	if s.state == StateRestarting && !s.restartAt.IsZero() {
+		if left := time.Until(s.restartAt).Seconds(); left > 0 {
+			st.RestartInSec = int64(left + 0.5)
+		}
+	}
 	s.mu.Unlock()
 
 	st.Installed = s.Installed()
@@ -185,9 +210,28 @@ func (s *Supervisor) Status() Status {
 func (s *Supervisor) Start() error {
 	s.mu.Lock()
 	defer s.mu.Unlock()
+
+	// Запуск руками — знак, что причину падений устранили.
+	s.crashStreak = 0
+	// Если ждали автоподъёма, поднимаем немедленно.
+	s.cancelRestartLocked()
 	return s.startLocked()
 }
 
+// cancelRestartLocked снимает запланированный автоперезапуск. Вызывается под
+// удержанным s.mu.
+func (s *Supervisor) cancelRestartLocked() {
+	if s.restartCancel == nil {
+		return
+	}
+	close(s.restartCancel)
+	s.restartCancel = nil
+	s.restartAt = time.Time{}
+	if s.state == StateRestarting {
+		s.state = StateStopped
+	}
+}
+
 func (s *Supervisor) startLocked() error {
 	if s.state != StateStopped {
 		return ErrAlreadyRunning
@@ -204,8 +248,8 @@ func (s *Supervisor) startLocked() error {
 	profile := s.cfg.ActiveProfile()
 	// Лимит памяти живёт в файле запуска, общем для всех профилей, поэтому
 	// выставляем его на каждом старте — иначе профиль унаследует чужой -Xmx.
-	if err := pzconfig.SetJavaMemory(s.cfg.ServerDir, profile.JavaMemory); err != nil {
+	if err := pzconfig.SetJavaMemory(s.cfg.ServerDir, profile.JavaMemory, profile.JavaMemoryMin); err != nil {
-		s.AppendLog("manager", "Не удалось выставить лимит памяти JVM: "+err.Error())
+		s.AppendLog("manager", "Не удалось выставить границы памяти JVM: "+err.Error())
 	}
 
 	args := []string{"-servername", profile.ID}
@@ -322,6 +366,8 @@ func (s *Supervisor) wait(cmd *exec.Cmd, exited chan struct{}) {
 	err := cmd.Wait()
 	close(exited)
 
+	lifetime := time.Since(s.startedAt)
+
 	s.mu.Lock()
 	wasIntentional := s.intentionalStop
 	s.state = StateStopped
@@ -336,6 +382,15 @@ func (s *Supervisor) wait(cmd *exec.Cmd, exited chan struct{}) {
 		s.lastExit = "штатное завершение"
 	}
 	reason := s.lastExit
+
+	// Падение сразу после запуска — признак того, что перезапуск не поможет:
+	// не хватило памяти, испорчен конфиг, нет файлов сервера.
+	if !wasIntentional && lifetime < quickCrashWindow {
+		s.crashStreak++
+	} else {
+		s.crashStreak = 0
+	}
+	streak := s.crashStreak
 	autoRestart := s.cfg.AutoRestart && !wasIntentional
 	s.mu.Unlock()
 
@@ -343,14 +398,38 @@ func (s *Supervisor) wait(cmd *exec.Cmd, exited chan struct{}) {
 	if !autoRestart {
 		return
 	}
+	if streak >= maxQuickCrashes {
+		s.AppendLog("manager", fmt.Sprintf(
+			"Сервер падает сразу после запуска %d раза подряд — автоперезапуск остановлен. "+
+				"Посмотрите ошибку выше и запустите сервер вручную.", streak))
+		return
+	}
+
+	s.mu.Lock()
+	cancel := make(chan struct{})
+	s.restartCancel = cancel
+	s.restartAt = time.Now().Add(restartDelay)
+	s.state = StateRestarting
+	s.mu.Unlock()
+
+	s.AppendLog("manager", fmt.Sprintf("Автоперезапуск через %s (можно отменить кнопкой «Остановить»)", restartDelay))
 
-	s.AppendLog("manager", fmt.Sprintf("Автоперезапуск через %s", restartDelay))
 	select {
 	case <-time.After(restartDelay):
+	case <-cancel:
+		// Состояние уже переставил тот, кто отменил ожидание.
+		s.AppendLog("manager", "Автоперезапуск отменён")
+		return
 	case <-s.quit:
 		return
 	}
+
 	s.mu.Lock()
+	s.restartCancel = nil
+	s.restartAt = time.Time{}
+	if s.state == StateRestarting {
+		s.state = StateStopped
+	}
 	err = s.startLocked()
 	s.mu.Unlock()
 	if err != nil && !errors.Is(err, ErrAlreadyRunning) {
@@ -394,6 +473,12 @@ func (s *Supervisor) sendQuiet(command string) error {
 // мир), затем SIGTERM группе процессов и в крайнем случае SIGKILL.
 func (s *Supervisor) Stop() error {
 	s.mu.Lock()
+	// Ждём автоподъёма — «остановить» здесь значит «не поднимать».
+	if s.state == StateRestarting {
+		s.cancelRestartLocked()
+		s.mu.Unlock()
+		return nil
+	}
 	if s.state == StateStopped || s.cmd == nil {
 		s.mu.Unlock()
 		return ErrNotRunning

internal/updater/updater.go

@@ -16,6 +16,7 @@ import (
 	"fmt"
 	"net/http"
 	"os/exec"
+	"sort"
 	"strconv"
 	"strings"
 	"time"
@@ -27,6 +28,14 @@ const adminCommand = "pzmanager-admin"
 // ErrNoAdmin возвращается, когда обновление из панели недоступно.
 var ErrNoAdmin = errors.New("обновление из панели недоступно: нет pzmanager-admin или правила sudo")
 
+// ReleaseNote — одна версия в списке изменений.
+type ReleaseNote struct {
+	Version   string `json:"version"`
+	Notes     string `json:"notes"`
+	Published int64  `json:"published"`
+	URL       string `json:"url"`
+}
+
 // Info — то, что панель показывает в разделе обновления.
 type Info struct {
 	Current   string `json:"current"`
@@ -40,6 +49,10 @@ type Info struct {
 	CanApply bool `json:"can_apply"`
 	// ManualCommand — что выполнить в терминале, если сама не может.
 	ManualCommand string `json:"manual_command"`
+	// Changelog — все версии между установленной и последней, свежие первыми.
+	// Одного описания последнего релиза мало: пропустив пару версий, человек
+	// не увидит, что менялось в промежутке.
+	Changelog []ReleaseNote `json:"changelog"`
 	// Error — почему не удалось узнать последнюю версию.
 	Error string `json:"error,omitempty"`
 }
@@ -75,12 +88,14 @@ func (u *Updater) apiBase() (string, error) {
 	return fmt.Sprintf("%s://%s/api/v1/repos/%s", scheme, host, path), nil
 }
 
-// Check спрашивает у Gitea последний релиз и сравнивает его с текущей версией.
+// Check спрашивает у Gitea список релизов и оставляет те, что новее
+// установленной версии.
 func (u *Updater) Check(ctx context.Context) Info {
 	info := Info{
 		Current:       u.Version,
 		CanApply:      u.CanApply(ctx),
 		ManualCommand: u.manualCommand(),
+		Changelog:     []ReleaseNote{},
 	}
 
 	api, err := u.apiBase()
@@ -89,7 +104,10 @@ func (u *Updater) Check(ctx context.Context) Info {
 		return info
 	}
 
-	req, err := http.NewRequestWithContext(ctx, http.MethodGet, api+"/releases/latest", nil)
+	// limit с запасом: показываем изменения за все пропущенные версии, но не
+	// тянем историю репозитория целиком.
+	req, err := http.NewRequestWithContext(ctx, http.MethodGet,
+		api+"/releases?limit=30&draft=false", nil)
 	if err != nil {
 		info.Error = err.Error()
 		return info
@@ -101,36 +119,73 @@ func (u *Updater) Check(ctx context.Context) Info {
 	}
 	defer resp.Body.Close()
 
-	if resp.StatusCode == http.StatusNotFound {
-		info.Error = "в репозитории ещё нет релизов"
-		return info
-	}
 	if resp.StatusCode != http.StatusOK {
 		info.Error = "репозиторий ответил " + resp.Status
 		return info
 	}
 
-	var release struct {
+	var releases []struct {
 		TagName     string    `json:"tag_name"`
 		Body        string    `json:"body"`
 		HTMLURL     string    `json:"html_url"`
 		PublishedAt time.Time `json:"published_at"`
+		Draft       bool      `json:"draft"`
+		Prerelease  bool      `json:"prerelease"`
 	}
-	if err := json.NewDecoder(resp.Body).Decode(&release); err != nil {
+	if err := json.NewDecoder(resp.Body).Decode(&releases); err != nil {
 		info.Error = "ответ репозитория не разобран: " + err.Error()
 		return info
 	}
 
-	info.Latest = release.TagName
+	notes := make([]ReleaseNote, 0, len(releases))
-	info.Notes = release.Body
+	for _, r := range releases {
-	info.URL = release.HTMLURL
+		if r.Draft || r.Prerelease || r.TagName == "" {
-	if !release.PublishedAt.IsZero() {
+			continue
-		info.Published = release.PublishedAt.Unix()
+		}
+		note := ReleaseNote{Version: r.TagName, Notes: r.Body, URL: r.HTMLURL}
+		if !r.PublishedAt.IsZero() {
+			note.Published = r.PublishedAt.Unix()
+		}
+		notes = append(notes, note)
 	}
-	info.Available = IsNewer(u.Version, release.TagName)
+	if len(notes) == 0 {
+		info.Error = "в репозитории ещё нет релизов"
+		return info
+	}
+
+	// Gitea отдаёт релизы свежими вперёд, но полагаться на это не станем.
+	sort.Slice(notes, func(i, j int) bool {
+		if IsNewer(notes[j].Version, notes[i].Version) {
+			return true
+		}
+		if IsNewer(notes[i].Version, notes[j].Version) {
+			return false
+		}
+		return notes[i].Published > notes[j].Published
+	})
+
+	latest := notes[0]
+	info.Latest = latest.Version
+	info.Notes = latest.Notes
+	info.URL = latest.URL
+	info.Published = latest.Published
+	info.Available = IsNewer(u.Version, latest.Version)
+	info.Changelog = NewerThan(notes, u.Version)
 	return info
 }
 
+// NewerThan оставляет из списка релизы новее указанной версии, сохраняя
+// порядок «свежие первыми».
+func NewerThan(notes []ReleaseNote, current string) []ReleaseNote {
+	out := make([]ReleaseNote, 0, len(notes))
+	for _, note := range notes {
+		if IsNewer(current, note.Version) {
+			out = append(out, note)
+		}
+	}
+	return out
+}
+
 // CanApply проверяет, что привилегированный скрипт на месте и sudo пускает к
 // нему без пароля. Проверяем вызовом: наличие файла ещё не значит, что
 // правило sudoers действует.

internal/updater/updater_test.go

@@ -57,3 +57,33 @@ func TestAPIBase(t *testing.T) {
 		}
 	}
 }
+
+func TestNewerThan(t *testing.T) {
+	notes := []ReleaseNote{
+		{Version: "v0.3.0"},
+		{Version: "v0.2.2"},
+		{Version: "v0.2.1"},
+		{Version: "v0.2.0"},
+		{Version: "v0.1.3"},
+	}
+
+	got := NewerThan(notes, "v0.2.0")
+	want := []string{"v0.3.0", "v0.2.2", "v0.2.1"}
+	if len(got) != len(want) {
+		t.Fatalf("отобрано %d версий, ожидалось %d: %v", len(got), len(want), got)
+	}
+	for i, version := range want {
+		if got[i].Version != version {
+			t.Errorf("changelog[%d] = %s, ожидалось %s", i, got[i].Version, version)
+		}
+	}
+
+	// На последней версии показывать нечего.
+	if got := NewerThan(notes, "v0.3.0"); len(got) != 0 {
+		t.Errorf("на последней версии отобрано %d записей: %v", len(got), got)
+	}
+	// Сборка из рабочей копии не знает своей версии — показываем всё.
+	if got := NewerThan(notes, "dev"); len(got) != len(notes) {
+		t.Errorf("для dev отобрано %d из %d записей", len(got), len(notes))
+	}
+}

web/static/app.js

@@ -94,6 +94,7 @@ function escapeHTML(value) {
 
 const STATE_LABELS = {
   stopped: "Остановлен",
+  restarting: "Ждёт перезапуска",
   starting: "Запускается",
   running: "Работает",
   stopping: "Останавливается",
@@ -230,8 +231,18 @@ async function refreshStatus() {
   renderTask(data.task);
 }
 
+// hostStats нужен карточкам профилей: там подсказываем, сколько памяти можно
+// отдать JVM, чтобы не выбирать объём вслепую.
+let hostStats = {};
+
 function renderStatus(status) {
-  const label = STATE_LABELS[status.state] || status.state;
+  hostStats = status.host || {};
+  let label = STATE_LABELS[status.state] || status.state;
+  // Пока идёт обратный отсчёт, показываем, сколько осталось: иначе непонятно,
+  // происходит ли вообще что-нибудь.
+  if (status.state === "restarting" && status.restart_in_sec > 0) {
+    label = `Перезапуск через ${status.restart_in_sec} с`;
+  }
   $("#status-text").textContent = label;
   $("#status-dot").className = `dot ${status.state}`;
 
@@ -274,8 +285,13 @@ function renderStatus(status) {
     : "Займёт несколько минут и около 3 ГБ на диске — прогресс виден во вкладке «Консоль».";
 
   const running = status.state !== "stopped";
-  $("#btn-start").disabled = running || !status.installed;
+  const waitingRestart = status.state === "restarting";
+
+  // В ожидании автоподъёма обе кнопки осмысленны: «Запустить» поднимает
+  // сервер сразу, «Остановить» отменяет перезапуск.
+  $("#btn-start").disabled = (running && !waitingRestart) || !status.installed;
   $("#btn-stop").disabled = !running;
+  $("#btn-stop").textContent = waitingRestart ? "Отменить перезапуск" : "Остановить";
   $("#btn-restart").disabled = !status.installed;
   $("#btn-install").disabled = running;
 
@@ -283,16 +299,19 @@ function renderStatus(status) {
   // и команда всё равно вернулась бы ошибкой.
   const consoleInput = $("#console-command");
   const consoleButton = $("#console-form").querySelector("button[type=submit]");
-  consoleInput.disabled = !running;
+  // Процесс есть только в этих двух состояниях; в ожидании перезапуска писать
-  consoleButton.disabled = !running;
+  // некуда, хотя формально сервер и не «остановлен».
-  consoleInput.placeholder = running
+  const consoleReady = status.state === "running" || status.state === "starting";
+  consoleInput.disabled = !consoleReady;
+  consoleButton.disabled = !consoleReady;
+  consoleInput.placeholder = consoleReady
     ? "Команда сервера, например: players, save, quit"
     : "Сервер остановлен — консоль принимает команды только на работающем";
 
   // Профили делят игровые порты и файл запуска, поэтому переключать их можно
   // только на остановленном сервере.
   const picker = $("#profile-select");
-  picker.disabled = running;
+  picker.disabled = running && !waitingRestart;
   picker.title = running
     ? "Остановите сервер, чтобы переключить профиль"
     : "Профиль сервера: свой мир, конфиг и моды";
@@ -331,8 +350,11 @@ async function serverAction(path, confirmText) {
 }
 
 $("#btn-start").addEventListener("click", () => serverAction("/api/server/start"));
-$("#btn-stop").addEventListener("click", () =>
+$("#btn-stop").addEventListener("click", () => {
-  serverAction("/api/server/stop", "Остановить игровой сервер? Игроки будут отключены."));
+  // Отмена перезапуска ничего не рушит, спрашивать незачем.
+  const waiting = $("#btn-stop").textContent === "Отменить перезапуск";
+  serverAction("/api/server/stop", waiting ? "" : "Остановить игровой сервер? Игроки будут отключены.");
+});
 $("#btn-restart").addEventListener("click", () =>
   serverAction("/api/server/restart", "Перезапустить сервер? Игроки будут отключены."));
 
@@ -454,35 +476,548 @@ $("#console-command").addEventListener("keydown", (event) => {
 // Конфиг сервера
 // ---------------------------------------------------------------------------
 
-// Подсказки к самым востребованным параметрам: остальные показываются как есть.
+// Подписи и описания параметров servertest.ini. Игра пишет свои комментарии
+// на языке сервера, и на Linux они почти всегда английские, поэтому панель
+// держит собственные: ключ -> [подпись, описание]. Чего здесь нет, панель
+// покажет с описанием из самого конфига.
 const CONFIG_HINTS = {
-  PublicName: "Название сервера в списке серверов",
+  PublicName: ["Название сервера", "Показывается в списке серверов игры и Steam."],
-  PublicDescription: "Описание сервера",
+  PublicDescription: ["Описание сервера", "Текст под названием в списке серверов. Перенос строки — <LINE>."],
-  Public: "Показывать сервер в публичном списке (true/false)",
+  Public: ["Показывать в списке серверов", "Сервер со Steam-авторизацией виден в браузере Steam в любом случае."],
-  Password: "Пароль для входа на сервер (пусто — без пароля)",
+  Open: ["Пускать без белого списка", "Если выключено, учётные записи создаёт администратор вручную."],
-  MaxPlayers: "Максимум игроков",
+  MaxPlayers: ["Максимум игроков", "Администраторы не считаются. Выше 32 игроков возможны просадки."],
-  DefaultPort: "Игровой порт (UDP), по умолчанию 16261",
+  ServerWelcomeMessage: ["Приветственное сообщение", "Показывается в чате сразу после входа. Поддерживает <LINE> и цвета <RGB:r,g,b>."],
-  UDPPort: "Второй игровой порт, по умолчанию 16262",
+  ResetID: ["Идентификатор сброса", "Меняется при мягком сбросе мира: клиенты с другим значением создают нового персонажа."],
-  PVP: "Разрешить бой между игроками",
+  ServerPlayerID: ["Идентификатор персонажей", "По нему игра отличает персонажей этого сервера от чужих."],
-  PauseEmpty: "Ставить мир на паузу, когда никого нет онлайн",
+  Seed: ["Зерно генерации мира", "Чтобы сменить, впишите новое значение и удалите map_worldgen.bin в папке мира."],
-  GlobalChat: "Общий чат для всего сервера",
+  server_browser_announced_ip: ["Объявляемый IP", "Нужен, когда у машины несколько адресов и в список серверов должен попасть определённый."],
-  Open: "Пускать игроков без записи в белом списке",
+  Password: ["Пароль сервера", "Пусто — вход без пароля."],
-  ServerWelcomeMessage: "Приветственное сообщение",
+  MaxAccountsPerUser: ["Учёток на игрока", "Сколько персонажей может завести один Steam-аккаунт. 0 — без ограничения."],
-  SaveWorldEveryMinutes: "Как часто сохранять мир, минут",
+  DenyLoginOnOverloadedServer: ["Не пускать при перегрузке", "Отказывать во входе, когда сервер не справляется с нагрузкой."],
-  BackupsOnStart: "Делать бэкап силами самой игры при старте",
+  DropOffWhiteListAfterDeath: ["Убирать из белого списка после смерти", "Погибший игрок теряет доступ и должен получить его заново."],
-  RCONPort: "Порт RCON",
+  LoginQueueEnabled: ["Очередь на вход", "Лишние игроки ждут освободившегося места вместо отказа."],
-  RCONPassword: "Пароль RCON",
+  LoginQueueConnectTimeout: ["Таймаут очереди, сек", "Сколько ждать подключения игрока, дошедшего до начала очереди."],
-  AdminSafehouse: "Разрешить админам входить в чужие убежища",
+  AllowCoop: ["Разрешить разделённый экран", "Несколько игроков с одного клиента."],
-  SafetySystem: "Система защиты от PVP-урона",
+  AllowNonAsciiUsername: ["Ники не только латиницей", "Разрешить кириллицу и другие не-ASCII символы в никах."],
-  DisplayUserName: "Показывать ники над персонажами",
+  SteamScoreboard: ["Показывать Steam-имена", "Отображать имена и аватары Steam в списке игроков."],
-  SpawnPoint: "Точка появления новых игроков (x,y,z)",
+  SteamVAC: ["Защита Steam VAC", "Включает античит-защиту Valve."],
-  Mods: "Список модов — редактируется во вкладке «Моды»",
+  DoLuaChecksum: ["Сверять контрольные суммы Lua", "Отключать игроков с изменёнными Lua-файлами."],
-  WorkshopItems: "Моды мастерской — редактируется во вкладке «Моды»",
+  DefaultPort: ["Игровой порт (UDP)", "По умолчанию 16261. Должен быть открыт на firewall."],
-  Map: "Карты — редактируется во вкладке «Моды»",
+  UDPPort: ["Второй игровой порт", "По умолчанию 16262. Тоже должен быть открыт."],
+  RCONPort: ["Порт RCON", "Порт для внешнего управления консолью сервера."],
+  RCONPassword: ["Пароль RCON", "Пусто — RCON выключен. Панели он не нужен: она пишет прямо в консоль."],
+  PingLimit: ["Предел пинга, мс", "Игроков с задержкой выше выкидывает. Ниже 100 ставить не стоит."],
+  UPnP: ["Пробрасывать порты через UPnP", "Автоматически открыть порты на роутере, если тот поддерживает UPnP."],
+  MaxPacketsPerSecond: ["Пакетов в секунду", "Ограничение сетевого потока на игрока."],
+  ClientCommandFilter: ["Фильтр команд клиента", "Список команд, которые не пишутся в журнал."],
+  MultiplayerStatisticsPeriod: ["Период сбора статистики", "Как часто писать сетевую статистику. 0 — не собирать."],
+  PVP: ["Разрешить бой между игроками", "Игроки могут ранить и убивать друг друга."],
+  PVPLogToolChat: ["Писать PVP в чат админов", "Сообщать администраторам о PVP-стычках в чате."],
+  PVPLogToolFile: ["Писать PVP в файл", "Вести журнал PVP-стычек на диске."],
+  SafetySystem: ["Система безопасности", "Урон игроку проходит, только когда оба сняли защиту."],
+  ShowSafety: ["Показывать значок защиты", "Иконка над головой показывает, снята ли защита."],
+  SafetyToggleTimer: ["Задержка переключения, сек", "Сколько секунд занимает снятие или включение защиты."],
+  SafetyCooldownTimer: ["Откат переключения, сек", "Через сколько секунд защиту можно переключить снова."],
+  SafetyDisconnectDelay: ["Задержка выхода в PVP, сек", "Сколько игрок остаётся в мире после отключения во время боя."],
+  PVPMeleeDamageModifier: ["Урон в ближнем бою, %", "Множитель урона игрок-игрок для оружия ближнего боя."],
+  PVPFirearmDamageModifier: ["Урон от огнестрела, %", "Множитель урона игрок-игрок для огнестрельного оружия."],
+  PVPMeleeWhileHitReaction: ["Удары во время реакции на попадание", "Разрешить бить игрока, пока тот отшатывается от предыдущего удара."],
+  KnockedDownAllowed: ["Разрешить сбивать с ног", "Игроки могут сбивать друг друга с ног."],
+  SneakModeHideFromOtherPlayers: ["Скрытность прячет от игроков", "В режиме скрытности игрока не видят другие игроки."],
+  PlayerBumpPlayer: ["Толкать других игроков", "Столкновения игроков между собой."],
+  UsePhysicsHitReaction: ["Физическая реакция на удар", "Включает физику отдачи при попадании."],
+  CarEngineAttractionModifier: ["Шум двигателя для зомби", "Насколько сильно двигатель привлекает зомби."],
+  Map: ["Карты", "Список карт через точку с запятой. Первой идёт карта мода, последней — базовая."],
+  SpawnPoint: ["Точка появления", "Координаты x,y,z. Нули — стандартные точки появления карты."],
+  SpawnItems: ["Стартовые предметы", "Список предметов, которые получает новый персонаж."],
+  SaveWorldEveryMinutes: ["Сохранять мир каждые, мин", "0 — сохранять только при выходе игроков и остановке сервера."],
+  PauseEmpty: ["Пауза без игроков", "Игровое время останавливается, когда на сервере никого нет."],
+  NoFire: ["Запретить огонь", "Полностью отключает распространение огня."],
+  AllowDestructionBySledgehammer: ["Разрешить кувалду", "Игроки могут ломать стены и объекты кувалдой."],
+  SledgehammerOnlyInSafehouse: ["Кувалда только в убежище", "Ломать можно лишь внутри своего убежища."],
+  PlayerRespawnWithSelf: ["Возрождение у своего трупа", "Разрешить появляться на месте гибели прошлого персонажа."],
+  PlayerRespawnWithOther: ["Возрождение у товарища", "Разрешить появляться рядом с другим игроком."],
+  FastForwardMultiplier: ["Ускорение времени", "Во сколько раз ускоряется время при перемотке."],
+  RemovePlayerCorpsesOnCorpseRemoval: ["Убирать и трупы игроков", "Автоочистка трупов затрагивает и погибших игроков."],
+  TrashDeleteAll: ["Кнопка «удалить всё»", "Разрешить очищать контейнер целиком одним действием."],
+  BloodSplatLifespanDays: ["Кровь исчезает через, дней", "0 — пятна крови остаются навсегда."],
+  ItemNumbersLimitPerContainer: ["Предметов в контейнере", "Ограничение на количество предметов. 0 — без ограничения."],
+  SafehousePreventsLootRespawn: ["Убежище блокирует респавн лута", "В зданиях-убежищах лут заново не появляется."],
+  SwitchZombiesOwnershipEachUpdate: ["Передавать зомби каждый такт", "Меняет схему распределения зомби между клиентами."],
+  UltraSpeedDoesnotAffectToAnimals: ["Перемотка не ускоряет животных", "На максимальной скорости времени животные живут в обычном темпе."],
+  SleepAllowed: ["Разрешить сон", "Игроки могут спать; на сервере с несколькими игроками время не перематывается."],
+  SleepNeeded: ["Требовать сон", "Усталость накапливается и требует сна."],
+  SpeedLimit: ["Ограничение скорости", "Предел скорости транспорта, км/ч."],
+  BackupsCount: ["Сколько копий хранить", "Резервные копии, которые делает сама игра."],
+  BackupsOnStart: ["Копия при запуске", "Игра делает бэкап мира при каждом старте сервера."],
+  BackupsOnVersionChange: ["Копия при смене версии", "Бэкап перед первым запуском на новой версии игры."],
+  BackupsPeriod: ["Период копий, мин", "0 — периодические бэкапы игры выключены. У панели есть свои."],
+  Mods: ["Включённые моды", "Список Mod ID в порядке загрузки. Правится на вкладке «Моды»."],
+  WorkshopItems: ["Загружаемые из мастерской", "Список Workshop ID. Правится на вкладке «Моды»."],
+  GlobalChat: ["Общий чат", "Сообщения видят все игроки на сервере."],
+  ChatStreams: ["Доступные каналы чата", "Список каналов: s — сказать, r — рация, a — админ, w — крик и так далее."],
+  VoiceEnable: ["Голосовой чат", "Разрешить голосовое общение."],
+  VoiceMinDistance: ["Слышимость вблизи", "Расстояние, на котором голос слышен без затухания."],
+  VoiceMaxDistance: ["Предел слышимости", "Расстояние, дальше которого голос не слышен."],
+  Voice3D: ["Объёмный звук голоса", "Голос слышен с направления, откуда говорит игрок."],
+  ChatMessageCharacterLimit: ["Длина сообщения", "Максимум символов в одном сообщении чата."],
+  ChatMessageSlowModeTime: ["Пауза между сообщениями, сек", "Защита от флуда: минимальный интервал между сообщениями."],
+  AnnounceDeath: ["Объявлять о смертях", "Сообщать в чат о гибели игроков."],
+  AnnounceAnimalDeath: ["Объявлять о гибели животных", "Сообщать в чат, когда погибает домашнее животное."],
+  BanKickGlobalSound: ["Звук при бане и кике", "Проигрывать звук всем при исключении игрока."],
+  BadWordListFile: ["Файл со списком брани", "Путь к списку запрещённых слов."],
+  GoodWordListFile: ["Файл с исключениями", "Слова, которые фильтр пропускает."],
+  BadWordPolicy: ["Что делать с бранью", "Заменять слово или блокировать сообщение целиком."],
+  BadWordReplacement: ["Чем заменять", "Текст, на который меняется запрещённое слово."],
+  DisplayUserName: ["Ники над головами", "Показывать имена игроков в мире."],
+  ShowFirstAndLastName: ["Имя и фамилия", "Показывать полное имя персонажа вместо ника."],
+  UsernameDisguises: ["Маскировка ника", "Ник скрывается, когда лицо игрока закрыто маской или шлемом."],
+  HideDisguisedUserName: ["Прятать ник замаскированных", "У замаскированного игрока имя не показывается вовсе."],
+  MouseOverToSeeDisplayName: ["Имя по наведению", "Ник виден, только если навести на игрока курсор."],
+  HidePlayersBehindYou: ["Скрывать игроков за спиной", "Не показывать тех, кто вне поля зрения персонажа."],
+  MapRemotePlayerVisibility: ["Игроки на карте", "Показывать ли других игроков на внутриигровой карте."],
+  ShowCoordinates: ["Показывать координаты", "Координаты видны игрокам в интерфейсе."],
+  DisableScoreboard: ["Отключить таблицу игроков", "Скрыть список игроков сервера."],
+  HideAdminsInPlayerList: ["Прятать администраторов", "Администраторы не видны в списке игроков."],
+  PlayerSafehouse: ["Игроки могут ставить убежища", "Разрешить обычным игрокам объявлять здание своим."],
+  AdminSafehouse: ["Убежища только у админов", "Объявлять убежища могут лишь администраторы."],
+  SafehouseAllowTrepass: ["Пускать посторонних", "Разрешить входить в чужое убежище."],
+  SafehouseAllowFire: ["Огонь в убежище", "Разрешить возгорания на территории убежища."],
+  SafehouseAllowLoot: ["Брать вещи в убежище", "Разрешить посторонним забирать предметы из убежища."],
+  SafehouseAllowRespawn: ["Возрождение в убежище", "Члены убежища появляются в нём после гибели."],
+  SafehouseDaySurvivedToClaim: ["Дней до права на убежище", "Сколько дней надо прожить, прежде чем объявлять здание своим."],
+  SafeHouseRemovalTime: ["Освобождение убежища, ч", "Через сколько часов отсутствия владельца убежище снимается."],
+  SafehouseAllowNonResidential: ["Нежилые здания под убежище", "Разрешить занимать магазины, склады и прочие нежилые постройки."],
+  SafehouseDisableDisguises: ["Без маскировки в убежище", "Маскировка не действует на территории убежища."],
+  MaxSafezoneSize: ["Размер безопасной зоны", "Максимальная площадь убежища в клетках."],
+  DisableSafehouseWhenOwnerConnected: ["Снимать защиту при владельце", "Пока владелец в игре, защита убежища не действует."],
+  DisableSafehouseWhenPlayerConnected: ["Снимать защиту при игроках", "Защита не действует, пока внутри есть игроки."],
+  Faction: ["Разрешить фракции", "Игроки могут создавать группировки."],
+  FactionDaySurvivedToCreate: ["Дней до создания фракции", "Сколько дней нужно прожить, чтобы основать фракцию."],
+  FactionPlayersRequiredForTag: ["Игроков для метки фракции", "Сколько участников нужно, чтобы у фракции появился тег."],
+  War: ["Разрешить войны фракций", "Фракции могут объявлять друг другу войну."],
+  WarStartDelay: ["Задержка начала войны", "Через сколько времени после объявления начинается война."],
+  WarDuration: ["Длительность войны", "Сколько длится объявленная война."],
+  WarSafehouseHitPoints: ["Прочность убежищ в войне", "Сколько урона выдерживают постройки во время войны."],
+  DisableRadioStaff: ["Скрыть рацию персонала", "Отключить служебный радиоканал."],
+  DisableRadioAdmin: ["Скрыть рацию админов", "Отключить радиоканал администраторов."],
+  DisableRadioGM: ["Скрыть рацию гейм-мастеров", "Отключить радиоканал GM."],
+  DisableRadioOverseer: ["Скрыть рацию наблюдателей", "Отключить радиоканал наблюдателей."],
+  DisableRadioModerator: ["Скрыть рацию модераторов", "Отключить радиоканал модераторов."],
+  DisableRadioInvisible: ["Скрыть рацию невидимых", "Отключить радиоканал скрытых персонажей."],
+  DiscordEnable: ["Связь с Discord", "Пересылать чат сервера в Discord и обратно."],
+  DiscordToken: ["Токен бота", "Токен Discord-бота, через которого идёт связь."],
+  DiscordChannel: ["Канал чата", "Название канала для игрового чата."],
+  DiscordChannelID: ["Идентификатор канала", "Числовой ID канала Discord."],
+  DiscordChatChannel: ["Канал чата", "Канал, куда пересылается игровой чат."],
+  DiscordLogChannel: ["Канал журнала", "Канал для служебных сообщений сервера."],
+  DiscordCommandChannel: ["Канал команд", "Канал, из которого принимаются команды."],
+  WebhookAddress: ["Адрес вебхука", "Куда отправлять события сервера по HTTP."],
+  AntiCheatSafety: ["Античит: система защиты", "Проверка попыток обойти защиту от урона."],
+  AntiCheatSpeed: ["Античит: скорость", "Проверка неестественно быстрого перемещения."],
+  AntiCheatNoClip: ["Античит: проход сквозь стены", "Проверка перемещения через препятствия."],
+  AntiCheatHit: ["Античит: попадания", "Проверка ударов с недостижимого расстояния."],
+  AntiCheatPacketException: ["Античит: битые пакеты", "Реакция на некорректные сетевые пакеты."],
+  AntiCheatPermission: ["Античит: права", "Проверка попыток выполнить действия без прав."],
+  AntiCheatXP: ["Античит: опыт", "Проверка неестественного роста навыков."],
+  AntiCheatSafeHouse: ["Античит: убежища", "Проверка обхода защиты убежищ."],
+  AntiCheatPlayer: ["Античит: персонаж", "Проверка изменённых характеристик персонажа."],
+  AntiCheatChecksum: ["Античит: контрольные суммы", "Сверка файлов игры у клиента."],
+  ClientActionLogs: ["Журнал действий клиента", "Какие действия игроков записывать в журнал."],
+  PerkLogs: ["Журнал навыков", "Записывать изменения уровней навыков."],
+  DisableVehicleTowing: ["Запретить буксировку", "Машины нельзя цеплять друг к другу."],
+  DisableTrailerTowing: ["Запретить прицепы", "Прицепы нельзя цеплять к машинам."],
+  DisableBurntTowing: ["Не буксировать сгоревшие", "Сгоревший транспорт нельзя буксировать."],
+
+  AutoCreateUserInWhiteList: ["Заводить учётки автоматически", "Игрок при первом входе сам создаёт логин и пароль."],
+  ConstructionPreventsLootRespawn: ["Постройки блокируют респавн лута", "В зданиях, где игроки что-то построили, лут заново не появляется."],
+  HoursForLootRespawn: ["Респавн лута через, часов", "0 — лут не появляется заново."],
+  MaxItemsForLootRespawn: ["Предметов при респавне", "Сколько предметов возвращается в контейнер при обновлении лута."],
+  KickFastPlayers: ["Выкидывать за скорость", "Отключать игроков, движущихся неестественно быстро. Может срабатывать ложно."],
+  MinutesPerPage: ["Минут на страницу", "Сколько игрового времени уходит на чтение одной страницы книги."],
 };
 
 const BOOLEAN_VALUES = new Set(["true", "false"]);
 
+// Категории параметров servertest.ini. Порядок важен: в нём и рисуются
+// разделы, а всё, чего здесь нет, попадает в «Прочее» — конфиг PZ меняется от
+// версии к версии, и новые ключи не должны пропадать со страницы.
+const CONFIG_GROUPS = [
+  {
+    title: "Основное",
+    keys: ["PublicName", "PublicDescription", "Public", "Open", "MaxPlayers",
+      "ServerWelcomeMessage", "ResetID", "ServerPlayerID", "Seed",
+      "server_browser_announced_ip", "PublicServerIP", "ServerBrowserAnnouncedIP"],
+  },
+  {
+    title: "Доступ и учётные записи",
+    keys: ["Password", "MaxAccountsPerUser", "DenyLoginOnOverloadedServer",
+      "AutoCreateUserInWhiteList", "DropOffWhiteListAfterDeath", "LoginQueueEnabled",
+      "LoginQueueConnectTimeout", "AllowCoop", "AllowNonAsciiUsername",
+      "SteamScoreboard", "SteamVAC", "DoLuaChecksum"],
+  },
+  {
+    title: "Сеть и порты",
+    keys: ["DefaultPort", "UDPPort", "RCONPort", "RCONPassword", "PingLimit", "UPnP",
+      "MaxPacketsPerSecond", "ClientCommandFilter", "MultiplayerStatisticsPeriod"],
+  },
+  {
+    title: "PVP и урон",
+    keys: ["PVP", "PVPLogToolChat", "PVPLogToolFile", "SafetySystem", "ShowSafety",
+      "SafetyToggleTimer", "SafetyCooldownTimer", "SafetyDisconnectDelay",
+      "PVPMeleeDamageModifier", "PVPFirearmDamageModifier", "PVPMeleeWhileHitReaction",
+      "KnockedDownAllowed", "SneakModeHideFromOtherPlayers", "PlayerBumpPlayer",
+      "UsePhysicsHitReaction", "CarEngineAttractionModifier"],
+  },
+  {
+    title: "Мир и правила",
+    keys: ["Map", "SpawnPoint", "SpawnItems", "SaveWorldEveryMinutes", "PauseEmpty",
+      "NoFire", "AllowDestructionBySledgehammer", "SledgehammerOnlyInSafehouse",
+      "PlayerRespawnWithSelf", "PlayerRespawnWithOther", "FastForwardMultiplier",
+      "RemovePlayerCorpsesOnCorpseRemoval", "TrashDeleteAll", "BloodSplatLifespanDays",
+      "ItemNumbersLimitPerContainer", "SafehousePreventsLootRespawn",
+      "ConstructionPreventsLootRespawn", "HoursForLootRespawn", "MaxItemsForLootRespawn",
+      "SwitchZombiesOwnershipEachUpdate", "UltraSpeedDoesnotAffectToAnimals",
+      "SleepAllowed", "SleepNeeded", "SpeedLimit"],
+  },
+  {
+    title: "Бэкапы самой игры",
+    keys: ["BackupsCount", "BackupsOnStart", "BackupsOnVersionChange", "BackupsPeriod"],
+  },
+  {
+    title: "Моды",
+    keys: ["Mods", "WorkshopItems"],
+  },
+  {
+    title: "Чат и голос",
+    keys: ["GlobalChat", "ChatStreams", "VoiceEnable", "VoiceMinDistance", "VoiceMaxDistance",
+      "Voice3D", "ChatMessageCharacterLimit", "ChatMessageSlowModeTime", "AnnounceDeath",
+      "AnnounceAnimalDeath", "MinutesPerPage", "BanKickGlobalSound"],
+  },
+  {
+    title: "Фильтр брани",
+    keys: ["BadWordListFile", "GoodWordListFile", "BadWordPolicy", "BadWordReplacement"],
+  },
+  {
+    title: "Видимость игроков",
+    keys: ["DisplayUserName", "ShowFirstAndLastName", "UsernameDisguises",
+      "HideDisguisedUserName", "MouseOverToSeeDisplayName", "HidePlayersBehindYou",
+      "MapRemotePlayerVisibility", "ShowCoordinates", "DisableScoreboard",
+      "HideAdminsInPlayerList"],
+  },
+  {
+    title: "Убежища",
+    keys: ["PlayerSafehouse", "AdminSafehouse", "SafehouseAllowTrepass", "SafehouseAllowFire",
+      "SafehouseAllowLoot", "SafehouseAllowRespawn", "SafehouseDaySurvivedToClaim",
+      "SafeHouseRemovalTime", "SafehouseAllowNonResidential", "SafehouseDisableDisguises",
+      "MaxSafezoneSize", "DisableSafehouseWhenOwnerConnected",
+      "DisableSafehouseWhenPlayerConnected"],
+  },
+  {
+    title: "Фракции и войны",
+    keys: ["Faction", "FactionDaySurvivedToCreate", "FactionPlayersRequiredForTag",
+      "War", "WarStartDelay", "WarDuration", "WarSafehouseHitPoints"],
+  },
+  {
+    title: "Рации",
+    keys: ["DisableRadioStaff", "DisableRadioAdmin", "DisableRadioGM", "DisableRadioOverseer",
+      "DisableRadioModerator", "DisableRadioInvisible"],
+  },
+  {
+    title: "Discord",
+    keys: ["DiscordEnable", "DiscordToken", "DiscordChannel", "DiscordChannelID",
+      "DiscordChatChannel", "DiscordLogChannel", "DiscordCommandChannel", "WebhookAddress"],
+  },
+  {
+    title: "Античит и журналы",
+    keys: ["AntiCheatSafety", "AntiCheatSpeed", "AntiCheatNoClip", "AntiCheatHit",
+      "AntiCheatPacketException", "AntiCheatPermission", "AntiCheatXP", "AntiCheatSafeHouse",
+      "AntiCheatPlayer", "AntiCheatChecksum", "KickFastPlayers", "ClientActionLogs", "PerkLogs"],
+    // Нумерованных проверок два десятка, перечислять их поимённо бессмысленно.
+    prefixes: ["AntiCheatProtectionType"],
+  },
+  {
+    title: "Транспорт",
+    keys: ["DisableVehicleTowing", "DisableTrailerTowing", "DisableBurntTowing"],
+  },
+];
+
+// Подписи параметров песочницы. Подробное описание игра пишет сама (в Build 42
+// с расшифровкой каждого значения), но на языке сервера — обычно английском,
+// поэтому подпись даём свою, а описание берём из файла.
+const SANDBOX_HINTS = {
+  Zombies: ["Количество зомби"],
+  Distribution: ["Распределение зомби"],
+  ZombiesRespawn: ["Восстановление популяции"],
+  ZombieRespawn: ["Восстановление популяции"],
+  ZombieMigrate: ["Миграция зомби"],
+  ZombieVoronoiNoise: ["Неравномерность расселения"],
+  ZombieAttractionMultiplier: ["Притяжение на шум"],
+  ZombieHealthImpact: ["Здоровье зомби"],
+  ZombiePopLootEffect: ["Влияние популяции на лут"],
+  MultiHitZombies: ["Удар по нескольким зомби"],
+  RearVulnerability: ["Уязвимость со спины"],
+  SirenEffectsZombies: ["Сирены привлекают зомби"],
+  RallyGroupSize: ["Размер скопления"],
+  RallyTravelDistance: ["Дальность схода в группу"],
+  RallyGroupSeparation: ["Расстояние между группами"],
+  RallyGroupRadius: ["Плотность группы"],
+  HoursForCorpseRemoval: ["Трупы исчезают через, часов"],
+  DecayingCorpseHealthImpact: ["Вред от разлагающихся трупов"],
+  BloodLevel: ["Количество крови"],
+  BloodSplatLifespanDays: ["Кровь исчезает через, дней"],
+  DayLength: ["Длина игрового дня"],
+  StartYear: ["Год начала"],
+  StartMonth: ["Месяц начала"],
+  StartDay: ["День начала"],
+  StartTime: ["Время начала"],
+  DayNightCycle: ["Смена дня и ночи"],
+  NightLength: ["Длина ночи"],
+  NightDarkness: ["Темнота ночью"],
+  TimeSinceApo: ["Времени с начала эпидемии"],
+  WaterShut: ["Отключение воды"],
+  ElecShut: ["Отключение электричества"],
+  WaterShutModifier: ["Дней до отключения воды"],
+  ElecShutModifier: ["Дней до отключения света"],
+  Alarm: ["Частота сигнализаций"],
+  AlarmDecay: ["Затухание сигнализаций"],
+  AlarmDecayModifier: ["Скорость затухания сигнализаций"],
+  LockedHouses: ["Запертые дома"],
+  ErosionSpeed: ["Скорость зарастания"],
+  ErosionDays: ["Дней до полного зарастания"],
+  EndRegen: ["Восстановление выносливости"],
+  Helicopter: ["Вертолёт"],
+  MetaEvent: ["Случайные события"],
+  SleepingEvent: ["Ночные события"],
+  AnnotatedMapChance: ["Шанс найти карту с пометками"],
+  VehicleStoryChance: ["Частота историй с транспортом"],
+  ZoneStoryChance: ["Частота историй на местности"],
+  SurvivorHouseChance: ["Частота домов выживших"],
+  MaximumLootedBuildingRooms: ["Комнат в разграбленном здании"],
+  ClimateCycle: ["Смена времён года"],
+  FogCycle: ["Частота туманов"],
+  Temperature: ["Температура"],
+  TemperatureModifier: ["Поправка температуры"],
+  Rain: ["Дожди"],
+  RainModifier: ["Поправка дождей"],
+  MaxFogIntensity: ["Плотность тумана"],
+  MaxRainFxIntensity: ["Сила дождя"],
+  EnableSnowOnGround: ["Снег на земле"],
+  LootRespawn: ["Обновление лута"],
+  SeenHoursPreventLootRespawn: ["Часов после осмотра до респавна"],
+  HoursForLootRespawn: ["Респавн лута через, часов"],
+  MaxItemsForLootRespawn: ["Предметов при респавне"],
+  ConstructionPreventsLootRespawn: ["Постройки блокируют респавн"],
+  RollsMultiplier: ["Множитель бросков лута"],
+  FoodLoot: ["Еда"],
+  CannedFoodLoot: ["Консервы"],
+  LiteratureLoot: ["Книги и журналы"],
+  SurvivalGearsLoot: ["Снаряжение"],
+  MedicalLoot: ["Медикаменты"],
+  WeaponLoot: ["Оружие"],
+  RangedWeaponLoot: ["Огнестрельное оружие"],
+  AmmoLoot: ["Патроны"],
+  MechanicsLoot: ["Автозапчасти"],
+  OtherLoot: ["Прочее"],
+  SkillBookLoot: ["Учебники навыков"],
+  RecipeResourceLoot: ["Материалы для рецептов"],
+  RemoveStoryLoot: ["Убирать сюжетный лут"],
+  RemoveZombieLoot: ["Убирать лут с зомби"],
+  MaximumLooted: ["Предел разграбленности"],
+  DaysUntilMaximumLooted: ["Дней до предела разграбленности"],
+  RuralLooted: ["Разграбленность сельской местности"],
+  MaximumDiminishedLoot: ["Предел оскудения лута"],
+  DaysUntilMaximumDiminishedLoot: ["Дней до оскудения лута"],
+  XpMultiplier: ["Множитель опыта"],
+  XpMultiplierAffectsPassive: ["Опыт и пассивные навыки"],
+  StatsDecrease: ["Скорость падения характеристик"],
+  Endurance: ["Выносливость"],
+  Nutrition: ["Учитывать питание"],
+  StarterKit: ["Стартовый набор"],
+  InjurySeverity: ["Тяжесть травм"],
+  BoneFracture: ["Переломы"],
+  CharacterFreePoints: ["Свободных очков персонажа"],
+  ConstructionBonusPoints: ["Бонус к строительству"],
+  NightVisionEnabled: ["Ночное зрение"],
+  InjuredHealingModifier: ["Скорость заживления"],
+  MuscleStrainFactor: ["Растяжение мышц"],
+  DiscomfortFactor: ["Дискомфорт"],
+  WoundInfectionFactor: ["Заражение ран"],
+  NegativeTraitsPenalty: ["Штраф отрицательных черт"],
+  EnablePoisoning: ["Отравления"],
+  ClothingDegradation: ["Износ одежды"],
+  AllClothesUnlocked: ["Вся одежда доступна"],
+  NoBlackClothes: ["Без чёрной одежды"],
+  EasyClimbing: ["Лёгкое перелезание"],
+  AttackBlockMovements: ["Атака блокирует движение"],
+  MetaKnowledge: ["Знание рецептов заранее"],
+  SeeNotLearntRecipe: ["Видеть неизученные рецепты"],
+  LiteratureCooldown: ["Перерыв между чтением"],
+  MinutesPerPage: ["Минут на страницу"],
+  LevelForMediaXPCutoff: ["Предел опыта с кассет"],
+  LevelForDismantleXPCutoff: ["Предел опыта с разборки"],
+  FoodRotSpeed: ["Скорость порчи еды"],
+  FridgeFactor: ["Эффективность холодильников"],
+  MaggotSpawn: ["Появление личинок"],
+  EnableTaintedWaterText: ["Помечать грязную воду"],
+  FishAbundance: ["Обилие рыбы"],
+  NatureAbundance: ["Обилие даров природы"],
+  PlantResilience: ["Живучесть растений"],
+  PlantAbundance: ["Урожайность"],
+  Farming: ["Скорость роста"],
+  FarmingSpeedNew: ["Скорость земледелия"],
+  FarmingAmountNew: ["Урожай с грядки"],
+  CompostTime: ["Время компостирования"],
+  KillInsideCrops: ["Губить посевы в помещении"],
+  PlantGrowingSeasons: ["Сезонность посевов"],
+  PlaceDirtAboveground: ["Грядки на любом уровне"],
+  ClayLakeChance: ["Глина у озёр"],
+  ClayRiverChance: ["Глина у рек"],
+  DaysForRottenFoodRemoval: ["Дней до удаления гнили"],
+  AidPackage: ["Сброс гуманитарной помощи"],
+  AnimalStatsModifier: ["Характеристики животных"],
+  AnimalMetaStatsModifier: ["Дикие животные"],
+  AnimalPregnancyTime: ["Срок беременности"],
+  AnimalAgeModifier: ["Скорость взросления"],
+  AnimalMilkIncModifier: ["Надой молока"],
+  AnimalWoolIncModifier: ["Настриг шерсти"],
+  AnimalRanchChance: ["Частота ферм"],
+  AnimalGrassRegrowTime: ["Отрастание травы"],
+  AnimalMetaPredator: ["Хищники"],
+  AnimalMatingSeason: ["Сезон спаривания"],
+  AnimalEggHatch: ["Вылупление яиц"],
+  AnimalSoundAttractZombies: ["Животные привлекают зомби"],
+  AnimalTrackChance: ["Частота следов"],
+  AnimalPathChance: ["Частота троп"],
+  MaximumRatIndex: ["Предел числа крыс"],
+  DaysUntilMaximumRatIndex: ["Дней до предела крыс"],
+  CarSpawnRate: ["Частота машин"],
+  ChanceHasGas: ["Шанс бензина в баке"],
+  InitialGas: ["Бензина в баке"],
+  CarGasConsumption: ["Расход топлива"],
+  LockedCar: ["Запертые машины"],
+  CarGeneralCondition: ["Состояние машин"],
+  CarDamageOnImpact: ["Урон машине при ударе"],
+  DamageToPlayerFromHitByACar: ["Урон игроку от наезда"],
+  TrafficJam: ["Пробки на дорогах"],
+  CarAlarm: ["Автосигнализации"],
+  PlayerDamageFromCrash: ["Урон при аварии"],
+  SirenShutoffHours: ["Сирена смолкает через, часов"],
+  RecentlySurvivorVehicles: ["Машины выживших"],
+  EnableVehicles: ["Транспорт в игре"],
+  VehicleEasyUse: ["Упрощённое управление"],
+  MassInvasion: ["Массовое нашествие"],
+  FuelStationGas: ["Топливо на заправках"],
+  FuelStationGasInfinite: ["Бесконечное топливо"],
+  FuelStationGasMin: ["Минимум топлива на заправке"],
+  FuelStationGasMax: ["Максимум топлива на заправке"],
+  FuelStationGasEmptyChance: ["Шанс пустой заправки"],
+  FirearmUseDamageChance: ["Износ при стрельбе"],
+  FirearmNoiseMultiplier: ["Громкость выстрелов"],
+  FirearmJamMultiplier: ["Частота осечек"],
+  FirearmMoodleMultiplier: ["Влияние состояния на меткость"],
+  FirearmWeatherMultiplier: ["Влияние погоды на меткость"],
+  FirearmHeadGearEffect: ["Влияние головного убора"],
+  Generator: ["Расход топлива генератора"],
+  GeneratorSpawning: ["Частота генераторов"],
+  GeneratorFuelConsumption: ["Расход генератора"],
+  GeneratorTileRange: ["Радиус питания генератора"],
+  GeneratorVerticalPowerRange: ["Этажей питания генератора"],
+  AllowExteriorGenerator: ["Генератор на улице"],
+  FireSpread: ["Распространение огня"],
+  MaximumFireFuelHours: ["Часов горения топлива"],
+  LightBulbLifespan: ["Срок службы лампочек"],
+  VERSION: ["Версия набора настроек"],
+};
+
+// Категории верхнеуровневых параметров песочницы. Вложенные (ZombieLore.Speed
+// и подобные) группируются сами — по имени таблицы, в которой лежат.
+const SANDBOX_GROUPS = [
+  {
+    title: "Зомби",
+    keys: ["Zombies", "Distribution", "ZombiesRespawn", "ZombieRespawn", "ZombieMigrate",
+      "ZombieVoronoiNoise", "ZombieAttractionMultiplier", "ZombieHealthImpact",
+      "ZombiePopLootEffect", "MultiHitZombies", "RearVulnerability", "SirenEffectsZombies",
+      "RallyGroupSize", "RallyTravelDistance", "RallyGroupSeparation", "RallyGroupRadius",
+      "HoursForCorpseRemoval", "DecayingCorpseHealthImpact", "BloodLevel",
+      "BloodSplatLifespanDays"],
+  },
+  {
+    title: "Мир и время",
+    keys: ["DayLength", "StartYear", "StartMonth", "StartDay", "StartTime", "DayNightCycle",
+      "NightLength", "NightDarkness", "TimeSinceApo", "WaterShut", "ElecShut",
+      "WaterShutModifier", "ElecShutModifier", "Alarm", "AlarmDecay", "AlarmDecayModifier",
+      "LockedHouses", "ErosionSpeed", "ErosionDays", "EndRegen", "Helicopter", "MetaEvent",
+      "SleepingEvent", "AnnotatedMapChance", "VehicleStoryChance", "ZoneStoryChance",
+      "SurvivorHouseChance", "MaximumLootedBuildingRooms"],
+  },
+  {
+    title: "Погода",
+    keys: ["ClimateCycle", "FogCycle", "Temperature", "TemperatureModifier", "Rain",
+      "RainModifier", "MaxFogIntensity", "MaxRainFxIntensity", "EnableSnowOnGround"],
+  },
+  {
+    title: "Лут и предметы",
+    keys: ["LootRespawn", "SeenHoursPreventLootRespawn", "HoursForLootRespawn",
+      "MaxItemsForLootRespawn", "ConstructionPreventsLootRespawn", "RollsMultiplier",
+      "LootItemRemovalList", "RemoveStoryLoot", "RemoveZombieLoot", "WorldItemRemovalList",
+      "HoursForWorldItemRemoval", "ItemRemovalListBlacklistToggle", "MaximumLooted",
+      "DaysUntilMaximumLooted", "RuralLooted", "MaximumDiminishedLoot",
+      "DaysUntilMaximumDiminishedLoot", "SkillBookLoot", "RecipeResourceLoot"],
+    // *Loot, *LootNew и *LootFactor — десятки однотипных ключей.
+    prefixes: ["Food", "Canned", "Literature", "Medical", "SurvivalGears", "Weapon",
+      "RangedWeapon", "Ammo", "Mechanics", "Other", "Clothing", "Container", "Key", "Media",
+      "Memento", "Cookware", "Material", "Farming", "Tool"],
+    suffixes: ["Loot", "LootNew", "LootFactor"],
+  },
+  {
+    title: "Персонаж и навыки",
+    keys: ["XpMultiplier", "XpMultiplierAffectsPassive", "StatsDecrease", "Endurance",
+      "Nutrition", "StarterKit", "InjurySeverity", "BoneFracture", "CharacterFreePoints",
+      "ConstructionBonusPoints", "NightVisionEnabled", "InjuredHealingModifier",
+      "MuscleStrainFactor", "DiscomfortFactor", "WoundInfectionFactor", "NegativeTraitsPenalty",
+      "EnablePoisoning", "ClothingDegradation", "AllClothesUnlocked", "NoBlackClothes",
+      "EasyClimbing", "AttackBlockMovements", "MetaKnowledge", "SeeNotLearntRecipe",
+      "LiteratureCooldown", "MinutesPerPage", "LevelForMediaXPCutoff",
+      "LevelForDismantleXPCutoff"],
+  },
+  {
+    title: "Еда, вода и хозяйство",
+    keys: ["FoodRotSpeed", "FridgeFactor", "MaggotSpawn", "EnableTaintedWaterText",
+      "FishAbundance", "NatureAbundance", "PlantResilience", "PlantAbundance", "Farming",
+      "FarmingSpeedNew", "FarmingAmountNew", "CompostTime", "KillInsideCrops",
+      "PlantGrowingSeasons", "PlaceDirtAboveground", "ClayLakeChance", "ClayRiverChance",
+      "DaysForRottenFoodRemoval", "AidPackage"],
+  },
+  {
+    title: "Животные",
+    keys: ["MaximumRatIndex", "DaysUntilMaximumRatIndex"],
+    prefixes: ["Animal"],
+  },
+  {
+    title: "Транспорт",
+    keys: ["CarSpawnRate", "ChanceHasGas", "InitialGas", "CarGasConsumption", "LockedCar",
+      "CarGeneralCondition", "CarDamageOnImpact", "DamageToPlayerFromHitByACar", "TrafficJam",
+      "CarAlarm", "PlayerDamageFromCrash", "SirenShutoffHours", "RecentlySurvivorVehicles",
+      "EnableVehicles", "VehicleEasyUse", "MassInvasion"],
+    prefixes: ["FuelStation"],
+  },
+  {
+    title: "Огнестрельное оружие",
+    keys: [],
+    prefixes: ["Firearm"],
+  },
+  {
+    title: "Электричество и огонь",
+    keys: ["AllowExteriorGenerator", "FireSpread", "MaximumFireFuelHours", "LightBulbLifespan"],
+    prefixes: ["Generator"],
+  },
+  {
+    title: "Служебное",
+    keys: ["VERSION"],
+  },
+];
+
 let serverConfigValues = {};
 
 async function loadServerConfig() {
@@ -497,24 +1032,154 @@ async function loadServerConfig() {
     return;
   }
   serverConfigValues = data.values;
-  const container = $("#config-fields");
+  const descriptions = data.descriptions || {};
-  data.keys.forEach((key) => {
+  const entries = data.keys.map((key) => ({
-    container.appendChild(buildConfigField(key, data.values[key], CONFIG_HINTS[key]));
+    key,
-  });
+    value: data.values[key],
+    description: descriptions[key],
+  }));
+  renderGroupedFields("#config-fields", entries, CONFIG_GROUPS, CONFIG_HINTS);
   applyFieldFilter("#config-filter", "#config-fields");
   refreshFieldSaveState(SAVE_TARGETS[0]);
 }
 
+// groupEntries раскладывает параметры по разделам. Неизвестные ключи не
+// теряются: они собираются в «Прочее» — конфиг PZ меняется от версии к версии.
+function groupEntries(entries, groups) {
+  const byKey = new Map();
+  entries.forEach((entry) => byKey.set(entry.key, entry));
+
+  const result = [];
+  const used = new Set();
+
+  groups.forEach((group) => {
+    const items = [];
+    group.keys.forEach((key) => {
+      const entry = byKey.get(key);
+      if (entry && !used.has(key)) {
+        used.add(key);
+        items.push(entry);
+      }
+    });
+    (group.prefixes || []).forEach((prefix) => {
+      entries.forEach((entry) => {
+        if (used.has(entry.key)) return;
+        // Для лута prefixes перечисляет вид припасов, suffixes — вид ключа
+        // (FoodLoot, FoodLootNew, RareLootFactor): совпасть должны оба.
+        const suffixes = group.suffixes;
+        const matches = suffixes
+          ? suffixes.some((suffix) => entry.key === prefix + suffix)
+          : entry.key.startsWith(prefix);
+        if (matches) {
+          used.add(entry.key);
+          items.push(entry);
+        }
+      });
+    });
+    // Суффиксы без своей пары в prefixes — например RareLootFactor.
+    (group.suffixes || []).forEach((suffix) => {
+      entries.forEach((entry) => {
+        if (!used.has(entry.key) && entry.key.endsWith(suffix)) {
+          used.add(entry.key);
+          items.push(entry);
+        }
+      });
+    });
+    if (items.length) result.push({ title: group.title, items });
+  });
+
+  // Вложенные параметры песочницы сами собой образуют разделы: у них путь вида
+  // ZombieLore.Speed.
+  const nested = new Map();
+  const rest = [];
+  entries.forEach((entry) => {
+    if (used.has(entry.key)) return;
+    const dot = entry.key.indexOf(".");
+    if (dot > 0) {
+      const table = entry.key.slice(0, dot);
+      if (!nested.has(table)) nested.set(table, []);
+      nested.get(table).push(entry);
+      return;
+    }
+    rest.push(entry);
+  });
+
+  Array.from(nested.entries())
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .forEach(([table, items]) => result.push({ title: table, items }));
+
+  if (rest.length) result.push({ title: "Прочее", items: rest });
+  return result;
+}
+
+// Какие разделы человек раскрыл: вкладка перерисовывается при каждом переходе,
+// и без этого раскрытый раздел схлопывался бы обратно.
+const openedGroups = new Map();
+
+function rememberOpenGroups(containerSelector) {
+  const opened = new Set();
+  $$(`${containerSelector} .cfg-group`).forEach((group) => {
+    if (group.open) opened.add(group.dataset.group);
+  });
+  openedGroups.set(containerSelector, opened);
+}
+
+// renderGroupedFields рисует разделы: свёрнутые по умолчанию, кроме первого —
+// иначе сотня параметров снова превращается в простыню.
+function renderGroupedFields(containerSelector, entries, groups, hints) {
+  const container = $(containerSelector);
+  container.replaceChildren();
+
+  const opened = openedGroups.get(containerSelector);
+  groupEntries(entries, groups).forEach((group, index) => {
+    const section = document.createElement("details");
+    section.className = "cfg-group";
+    section.dataset.group = group.title;
+    section.open = opened ? opened.has(group.title) : index === 0;
+
+    const summary = document.createElement("summary");
+    summary.innerHTML =
+      `${escapeHTML(group.title)} <span class="cfg-count">${group.items.length}</span>`;
+    section.appendChild(summary);
+
+    const fields = document.createElement("div");
+    fields.className = "fields";
+    group.items.forEach((entry) => {
+      // Свой словарь важнее комментария из файла: игра пишет его на языке
+      // сервера, а он почти всегда английский.
+      let hint = hints ? hints[entry.key] : null;
+      // Нумерованные проверки античита описывать поимённо нечем: игра не
+      // раскрывает, что стоит за каждым номером.
+      if (!hint && entry.key.startsWith("AntiCheatProtectionType")) {
+        hint = ["Античит: проверка " + entry.key.replace("AntiCheatProtectionType", "№"),
+          "Одна из встроенных проверок. Отключайте только при ложных срабатываниях."];
+      }
+      const label = Array.isArray(hint) ? hint[0] : hint;
+      const description = (Array.isArray(hint) && hint[1]) || entry.description;
+      fields.appendChild(buildConfigField(entry.key, entry.value, label, description));
+    });
+    section.appendChild(fields);
+    container.appendChild(section);
+  });
+}
+
 // buildConfigField выбирает тип поля по текущему значению: булевы значения
 // удобнее переключать списком, числа — числовым полем.
-function buildConfigField(key, value, hint) {
+function buildConfigField(key, value, hint, description) {
   const wrapper = document.createElement("div");
   wrapper.className = "cfg-field";
   wrapper.dataset.key = key.toLowerCase();
-  wrapper.dataset.hint = (hint || "").toLowerCase();
+  // Поиск идёт и по описанию: по-русски параметр искать привычнее, чем по
+  // английскому имени ключа.
+  wrapper.dataset.hint = `${hint || ""} ${description || ""}`.toLowerCase();
 
   const label = document.createElement("label");
   label.textContent = hint || key;
+  if (description) {
+    // Полный текст — во всплывающей подсказке: описания бывают в несколько
+    // строк, и разворачивать их для каждого параметра значит утопить форму.
+    wrapper.title = description;
+  }
   wrapper.appendChild(label);
 
   let input;
@@ -547,6 +1212,13 @@ function buildConfigField(key, value, hint) {
   keyLabel.className = "key";
   keyLabel.textContent = key;
   wrapper.appendChild(keyLabel);
+
+  if (description) {
+    const hintLine = document.createElement("div");
+    hintLine.className = "hint";
+    hintLine.textContent = description;
+    wrapper.appendChild(hintLine);
+  }
   return wrapper;
 }
 
@@ -611,11 +1283,30 @@ $("#btn-config-save").addEventListener("click", async () => {
 
 function applyFieldFilter(inputSelector, containerSelector) {
   const filter = $(inputSelector).value.trim().toLowerCase();
+
   $$(`${containerSelector} .cfg-field`).forEach((field) => {
     field.hidden = filter && !field.dataset.key.includes(filter) && !field.dataset.hint.includes(filter);
   });
+
+  // Раздел без совпадений прячем целиком, а с совпадениями — раскрываем:
+  // искать параметр по свёрнутым разделам бессмысленно.
+  $$(`${containerSelector} .cfg-group`).forEach((group) => {
+    const visible = Array.from(group.querySelectorAll(".cfg-field")).filter((f) => !f.hidden);
+    group.hidden = visible.length === 0;
+    if (filter) {
+      group.open = visible.length > 0;
+    }
+    const count = group.querySelector(".cfg-count");
+    if (count) {
+      count.textContent = filter ? `${visible.length}` : `${group.querySelectorAll(".cfg-field").length}`;
+    }
+  });
 }
 
+// toggle не всплывает, поэтому слушаем на фазе перехвата.
+["#config-fields", "#sandbox-fields"].forEach((selector) =>
+  $(selector).addEventListener("toggle", () => rememberOpenGroups(selector), true));
+
 $("#config-filter").addEventListener("input", () => applyFieldFilter("#config-filter", "#config-fields"));
 $("#sandbox-filter").addEventListener("input", () => applyFieldFilter("#sandbox-filter", "#sandbox-fields"));
 
@@ -634,10 +1325,12 @@ async function loadSandbox() {
     refreshFieldSaveState(SAVE_TARGETS[1]);
     return;
   }
-  const container = $("#sandbox-fields");
+  const entries = data.entries.map((entry) => ({
-  data.entries.forEach((entry) => {
+    key: entry.path,
-    container.appendChild(buildConfigField(entry.path, entry.value, null));
+    value: entry.value,
-  });
+    description: entry.comment,
+  }));
+  renderGroupedFields("#sandbox-fields", entries, SANDBOX_GROUPS, SANDBOX_HINTS);
   applyFieldFilter("#sandbox-filter", "#sandbox-fields");
   refreshFieldSaveState(SAVE_TARGETS[1]);
 }
@@ -1048,8 +1741,16 @@ function renderProfileCards() {
           <input type="text" data-field="title" value="${escapeHTML(p.title || "")}">
         </label>
         <label class="field">
-          <span>Память JVM</span>
+          <span>Память JVM, максимум</span>
           <input type="text" data-field="java_memory" value="${escapeHTML(p.java_memory || "")}">
+          <small>${escapeHTML(memoryHint())}</small>
+        </label>
+        <label class="field">
+          <span>Память JVM, начальная</span>
+          <input type="text" data-field="java_memory_min" value="${escapeHTML(p.java_memory_min || "")}"
+                 placeholder="не задана">
+          <small>Пусто — JVM берёт память по мере надобности. Если задать, она
+            займёт этот объём сразу при старте и не сможет подняться, когда его нет.</small>
         </label>
         <label class="field">
           <span>Пароль админа игры</span>
@@ -1069,6 +1770,15 @@ function renderProfileCards() {
 
 // renderCopySource предлагает копировать настройки только с тех профилей, у
 // которых конфиг уже создан игрой.
+// memoryHint подсказывает разумный потолок: JVM должна поместиться в свободную
+// память, иначе сервер не поднимется вовсе.
+function memoryHint() {
+  if (!hostStats.mem_total_bytes) return "Например 4g";
+  const total = formatBytes(hostStats.mem_total_bytes);
+  const free = formatBytes(hostStats.mem_available_bytes);
+  return `На машине ${total} ОЗУ, свободно ${free}. Оставьте запас системе.`;
+}
+
 function renderCopySource() {
   $("#new-profile-copy").innerHTML =
     `<option value="">не копировать</option>` +
@@ -1110,6 +1820,7 @@ $("#profile-cards").addEventListener("click", async (event) => {
         await put(`/api/profiles/${encodeURIComponent(id)}`, {
           title: field("title"),
           java_memory: field("java_memory"),
+          java_memory_min: field("java_memory_min"),
           admin_password: field("admin_password"),
         });
         ok("Профиль сохранён");
@@ -1262,8 +1973,13 @@ async function loadUpdateInfo() {
   }
 
   const notes = $("#update-notes");
-  notes.hidden = !(info.available && info.notes);
+  const changelog = info.changelog || [];
-  if (!notes.hidden) renderReleaseNotes(info.notes, info.url);
+  notes.hidden = !(info.available && changelog.length);
+  if (!notes.hidden) {
+    notes.querySelector("summary").textContent =
+      changelog.length > 1 ? `Что нового (версий: ${changelog.length})` : "Что нового";
+    renderChangelog(changelog);
+  }
 
   $("#btn-manager-restart").disabled = !info.can_apply;
   $("#btn-manager-restart").title = info.can_apply
@@ -1274,40 +1990,56 @@ async function loadUpdateInfo() {
 // Описание релиза приходит из Gitea разметкой Markdown, и показывать её как
 // есть неудобно: первым идёт раздел про установку, который в уже работающей
 // панели ни к чему. Берём только список изменений.
-function renderReleaseNotes(text, url) {
+function releaseItems(text) {
-  const body = $("#update-notes-body");
+  const changes = text.split(/^##\s+Изменения\s*$/m)[1];
-  body.replaceChildren();
+  return (changes ?? text)
-
-  const changesSection = text.split(/^##\s+Изменения\s*$/m)[1];
-  const items = (changesSection ?? text)
     .split("\n")
     .map((line) => line.trim())
     .filter((line) => line.startsWith("- "))
     .map((line) => line.slice(2).trim())
     .filter(Boolean);
+}
+
+// renderChangelog показывает изменения всех версий между установленной и
+// последней: пропустив несколько релизов, иначе не узнать, что было в них.
+function renderChangelog(releases) {
+  const body = $("#update-notes-body");
+  body.replaceChildren();
+
+  releases.forEach((release) => {
+    const heading = document.createElement("h4");
+    heading.className = "release-version";
+    heading.textContent = release.published
+      ? `${release.version} — ${formatDate(release.published)}`
+      : release.version;
+    body.appendChild(heading);
+
+    const items = releaseItems(release.notes || "");
+    if (items.length) {
+      const list = document.createElement("ul");
+      items.forEach((item) => {
+        const li = document.createElement("li");
+        li.textContent = item;
+        list.appendChild(li);
+      });
+      body.appendChild(list);
+      return;
+    }
 
-  if (items.length) {
-    const list = document.createElement("ul");
-    items.forEach((item) => {
-      const li = document.createElement("li");
-      li.textContent = item;
-      list.appendChild(li);
-    });
-    body.appendChild(list);
-  } else {
     // Непривычный формат описания — показываем как есть, лишь бы не потерять.
     const raw = document.createElement("pre");
-    raw.textContent = text.trim();
+    raw.textContent = (release.notes || "").trim() || "Описание не заполнено";
     body.appendChild(raw);
-  }
+  });
 
-  if (url) {
+  const newest = releases[0];
+  if (newest && newest.url) {
     const link = document.createElement("a");
-    link.href = url;
+    link.href = newest.url;
     link.target = "_blank";
     link.rel = "noopener noreferrer";
     link.className = "release-link";
-    link.textContent = "Полное описание релиза";
+    link.textContent = "Полное описание релизов";
     body.appendChild(link);
   }
 }

web/static/index.html

@@ -149,7 +149,7 @@
         </div>
       </div>
       <p class="muted" id="config-empty" hidden></p>
-      <div id="config-fields" class="fields"></div>
+      <div id="config-fields"></div>
     </section>
 
     <!-- Песочница -->
@@ -165,7 +165,7 @@
         </div>
       </div>
       <p class="muted" id="sandbox-empty" hidden></p>
-      <div id="sandbox-fields" class="fields"></div>
+      <div id="sandbox-fields"></div>
     </section>
 
     <!-- Моды -->

web/static/style.css

@@ -108,7 +108,7 @@ code {
   background: var(--muted);
 }
 .dot.running { background: var(--accent); box-shadow: 0 0 8px var(--accent); }
-.dot.starting, .dot.stopping { background: var(--warn); animation: pulse 1.2s infinite; }
+.dot.starting, .dot.stopping, .dot.restarting { background: var(--warn); animation: pulse 1.2s infinite; }
 .dot.stopped { background: #5b636f; }
 
 @keyframes pulse { 50% { opacity: .35; } }
@@ -267,6 +267,40 @@ input.input-sm, .input-sm { width: auto; padding: 6px 10px; font-size: 13px; }
   gap: 12px;
 }
 
+.cfg-group {
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  background: var(--bg-soft);
+  margin-bottom: 10px;
+}
+
+.cfg-group > summary {
+  padding: 11px 14px;
+  cursor: pointer;
+  font-weight: 600;
+  font-size: 14px;
+  user-select: none;
+  list-style: none;
+}
+.cfg-group > summary::-webkit-details-marker { display: none; }
+.cfg-group > summary::before {
+  content: "▸";
+  display: inline-block;
+  width: 14px;
+  color: var(--muted);
+}
+.cfg-group[open] > summary::before { content: "▾"; }
+.cfg-group > summary:hover { background: var(--bg-card); border-radius: var(--radius); }
+
+.cfg-count {
+  color: var(--muted);
+  font-weight: 400;
+  font-size: 12px;
+  margin-left: 4px;
+}
+
+.cfg-group > .fields { padding: 0 14px 14px; }
+
 .cfg-field {
   background: var(--bg-card);
   border: 1px solid var(--border);
@@ -275,7 +309,17 @@ input.input-sm, .input-sm { width: auto; padding: 6px 10px; font-size: 13px; }
 }
 .cfg-field.changed { border-color: var(--accent-dark); }
 .cfg-field label { display: block; font-size: 13px; margin-bottom: 6px; }
-.cfg-field .hint { color: var(--muted); font-size: 12px; margin-top: 5px; }
+.cfg-field .hint {
+  color: var(--muted);
+  font-size: 12px;
+  margin-top: 5px;
+  /* Описания из конфига бывают в абзац: показываем начало, остальное — в
+     подсказке при наведении. */
+  display: -webkit-box;
+  -webkit-line-clamp: 3;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+}
 .cfg-field .key { color: var(--muted); font-family: var(--mono); font-size: 11px; }
 
 /* ---------- Моды ---------- */
@@ -477,6 +521,15 @@ input.input-sm, .input-sm { width: auto; padding: 6px 10px; font-size: 13px; }
   line-height: 1.5;
 }
 
+.release-version {
+  margin: 14px 0 6px;
+  font-size: 13px;
+  color: var(--accent);
+  text-transform: none;
+  letter-spacing: 0;
+}
+.release-version:first-child { margin-top: 0; }
+
 .release-notes ul { margin: 0; padding-left: 20px; }
 .release-notes li { margin-bottom: 5px; }
 .release-notes li:last-child { margin-bottom: 0; }