diff --git a/app/components/RequiredHiddenInput.module.css b/app/components/RequiredHiddenInput.module.css
deleted file mode 100644
index f99cb2609..000000000
--- a/app/components/RequiredHiddenInput.module.css
+++ /dev/null
@@ -1,8 +0,0 @@
-.input {
-	position: absolute;
-	width: 0;
-	height: 0;
-	border: none;
-	opacity: 0;
-	pointer-events: none;
-}
diff --git a/app/components/RequiredHiddenInput.tsx b/app/components/RequiredHiddenInput.tsx
deleted file mode 100644
index 9b02afbc7..000000000
--- a/app/components/RequiredHiddenInput.tsx
+++ /dev/null
@@ -1,23 +0,0 @@
-import styles from "./RequiredHiddenInput.module.css";
-
-export function RequiredHiddenInput({
-	value,
-	isValid,
-	name,
-}: {
-	value: string;
-	isValid: boolean;
-	name: string;
-}) {
-	return (
-		<input
-			className={styles.input}
-			name={name}
-			value={isValid ? value : []}
-			// empty onChange is because otherwise it will give a React error in console
-			// readOnly can't be set as then validation is not active
-			onChange={() => null}
-			required
-		/>
-	);
-}
diff --git a/app/features/calendar/actions/calendar.new.server.ts b/app/features/calendar/actions/calendar.new.server.ts
index 4e5a313d6..dcc32868f 100644
--- a/app/features/calendar/actions/calendar.new.server.ts
+++ b/app/features/calendar/actions/calendar.new.server.ts
@@ -4,7 +4,6 @@ import type { CalendarEventTag } from "~/db/tables";
 import { requireUser } from "~/features/auth/core/user.server";
 import * as BadgeRepository from "~/features/badges/BadgeRepository.server";
 import * as CalendarRepository from "~/features/calendar/CalendarRepository.server";
-import { newCalendarEventActionSchema } from "~/features/calendar/calendar-schemas.server";
 import * as ShowcaseTournaments from "~/features/front-page/core/ShowcaseTournaments.server";
 import { MapPool } from "~/features/map-list-generator/core/map-pool";
 import { notify } from "~/features/notifications/core/notify.server";
@@ -12,6 +11,7 @@ import {
 	clearTournamentDataCache,
 	tournamentFromDB,
 } from "~/features/tournament-bracket/core/Tournament.server";
+import { parseFormDataWithImages } from "~/form/parse.server";
 import { rankedModesShort } from "~/modules/in-game-lists/modes";
 import { requireRole } from "~/modules/permissions/guards.server";
 import {
@@ -22,33 +22,36 @@ import {
 	badRequestIfFalsy,
 	errorToast,
 	errorToastIfFalsy,
-	parseFormData,
-	uploadImageIfSubmitted,
 } from "~/utils/remix.server";
+import { pathnameFromPotentialURL } from "~/utils/strings";
 import { calendarEventPage } from "~/utils/urls";
 import { CALENDAR_EVENT } from "../calendar-constants";
+import { calendarNewSchemaServer } from "../calendar-new-schemas.server";
 import { canEditCalendarEvent, regClosesAtDate } from "../calendar-utils";
 import { findValidOrganizations } from "../loaders/calendar.new.server";
 
 export const action: ActionFunction = async ({ request }) => {
 	const user = requireUser();
 
-	const { avatarFileName, formData } = await uploadImageIfSubmitted({
+	const result = await parseFormDataWithImages({
 		request,
-		fileNamePrefix: "tournament-logo",
-	});
-	const data = await parseFormData({
-		formData,
-		schema: newCalendarEventActionSchema,
+		schema: calendarNewSchemaServer,
 	});
+	if (!result.success) {
+		return { fieldErrors: result.fieldErrors };
+	}
+	const data = result.data;
 
 	const isEditing = Boolean(data.eventToEditId);
 	const isAddingTournament = data.toToolsEnabled;
+	const organizationId = data.organizationId
+		? Number(data.organizationId)
+		: null;
 
-	if (data.organizationId) {
+	if (organizationId) {
 		await validateOrganization({
 			userId: user.id,
-			organizationId: data.organizationId,
+			organizationId,
 			isTournamentAdder: user.roles.includes("TOURNAMENT_ADDER"),
 		});
 	} else if (!isEditing) {
@@ -59,69 +62,70 @@ export const action: ActionFunction = async ({ request }) => {
 
 	const managedBadges = await BadgeRepository.findManagedByUserId(user.id);
 
-	const startTimes = data.date.map((date) => dateToDatabaseTimestamp(date));
+	const dates =
+		isAddingTournament && data.startTime ? [data.startTime] : data.date;
+	const startTimes = dates.map((date) => dateToDatabaseTimestamp(date));
 	const commonArgs = {
 		authorId: user.id,
-		organizationId: data.organizationId ?? null,
+		organizationId,
 		name: data.name,
 		description: data.description,
 		rules: data.rules,
 		startTimes,
-		bracketUrl: data.bracketUrl,
-		discordInviteCode: data.discordInviteCode,
-		tags: data.tags
-			? data.tags
-					.sort(
-						(a, b) =>
-							CALENDAR_EVENT.TAGS.indexOf(a as CalendarEventTag) -
-							CALENDAR_EVENT.TAGS.indexOf(b as CalendarEventTag),
-					)
-					.join(",")
-			: data.tags,
-		badges:
-			data.badges?.filter((badge) =>
-				managedBadges.some((mb) => mb.id === badge),
-			) ?? [],
-		// newly uploaded avatar
-		avatarFileName,
-		// reused avatar either via edit or template
+		bracketUrl: data.bracketUrl || "https://sendou.ink",
+		discordInviteCode: data.discordInviteCode
+			? pathnameFromPotentialURL(data.discordInviteCode)
+			: data.discordInviteCode,
+		tags:
+			data.tags.length > 0
+				? data.tags
+						.toSorted(
+							(a, b) =>
+								CALENDAR_EVENT.TAGS.indexOf(a as CalendarEventTag) -
+								CALENDAR_EVENT.TAGS.indexOf(b as CalendarEventTag),
+						)
+						.join(",")
+				: null,
+		badges: data.badges.filter((badge) =>
+			managedBadges.some((mb) => mb.id === badge),
+		),
+		// resolved by parseFormDataWithImages from the `image()` field
 		avatarImgId: data.avatarImgId ?? undefined,
-		autoValidateAvatar: user.roles.includes("SUPPORTER"),
 		toToolsEnabled: Number(data.toToolsEnabled),
 		toToolsMode:
 			rankedModesShort.find((mode) => mode === data.toToolsMode) ?? null,
 		bracketProgression: data.bracketProgression ?? null,
-		minMembersPerTeam: data.minMembersPerTeam ?? undefined,
-		maxMembersPerTeam: data.maxMembersPerTeam ?? undefined,
-		isRanked: data.isRanked ?? undefined,
-		isTest: data.isTest ?? undefined,
-		isDraft: data.isDraft ?? undefined,
-		isInvitational: data.isInvitational ?? false,
-		enableNoScreenToggle: data.enableNoScreenToggle ?? undefined,
-		enableSubs: data.enableSubs ?? undefined,
-		requireInGameNames: data.requireInGameNames ?? undefined,
-		requireSendouQParticipation: data.requireSendouQParticipation ?? undefined,
-		autonomousSubs: data.autonomousSubs ?? undefined,
+		minMembersPerTeam: Number(data.minMembersPerTeam),
+		maxMembersPerTeam:
+			data.minMembersPerTeam === "4" && data.maxMembersPerTeam
+				? data.maxMembersPerTeam
+				: undefined,
+		isRanked: data.isRanked,
+		isTest: data.isTest,
+		isDraft: data.isDraft,
+		isInvitational: data.isInvitational,
+		enableNoScreenToggle: data.enableNoScreenToggle,
+		enableSubs: data.enableSubs,
+		requireInGameNames: data.requireInGameNames,
+		requireSendouQParticipation: data.requireSendouQParticipation,
+		autonomousSubs: data.autonomousSubs,
 		tournamentToCopyId: data.tournamentToCopyId,
-		regClosesAt: data.regClosesAt
-			? dateToDatabaseTimestamp(
-					regClosesAtDate({
-						startTime: databaseTimestampToDate(startTimes[0]),
-						closesAt: data.regClosesAt,
-					}),
-				)
-			: undefined,
+		regClosesAt:
+			isAddingTournament && data.regClosesAt
+				? dateToDatabaseTimestamp(
+						regClosesAtDate({
+							startTime: databaseTimestampToDate(startTimes[0]),
+							closesAt: data.regClosesAt,
+						}),
+					)
+				: undefined,
 	};
 	errorToastIfFalsy(
 		!commonArgs.toToolsEnabled || commonArgs.bracketProgression,
 		"Bracket progression must be set for tournaments",
 	);
 
-	const deserializedMaps = (() => {
-		if (!data.pool) return;
-
-		return MapPool.toDbList(data.pool);
-	})();
+	const deserializedMaps = data.pool ? MapPool.toDbList(data.pool) : undefined;
 
 	if (data.eventToEditId) {
 		const eventToEdit = badRequestIfFalsy(
diff --git a/app/features/calendar/calendar-constants.ts b/app/features/calendar/calendar-constants.ts
index def725b17..252212559 100644
--- a/app/features/calendar/calendar-constants.ts
+++ b/app/features/calendar/calendar-constants.ts
@@ -64,7 +64,6 @@ export const CALENDAR_EVENT = {
 	MAX_AMOUNT_OF_DATES: 5,
 	/** Calendar event tag that is persisted in the database */
 	TAGS: Object.keys(tags) as Array<CalendarEventTag>,
-	AVATAR_SIZE: 512,
 };
 
 export const REG_CLOSES_AT_OPTIONS = [
diff --git a/app/features/calendar/calendar-new-schemas.server.ts b/app/features/calendar/calendar-new-schemas.server.ts
new file mode 100644
index 000000000..dbfd10b4b
--- /dev/null
+++ b/app/features/calendar/calendar-new-schemas.server.ts
@@ -0,0 +1,8 @@
+import {
+	calendarNewBaseSchema,
+	calendarNewSyncRefine,
+} from "./calendar-new-schemas";
+
+export const calendarNewSchemaServer = calendarNewBaseSchema.superRefine(
+	calendarNewSyncRefine,
+);
diff --git a/app/features/calendar/calendar-new-schemas.ts b/app/features/calendar/calendar-new-schemas.ts
new file mode 100644
index 000000000..684c7bd2e
--- /dev/null
+++ b/app/features/calendar/calendar-new-schemas.ts
@@ -0,0 +1,226 @@
+import { z } from "zod";
+import { MapPool } from "~/features/map-list-generator/core/map-pool";
+import {
+	array,
+	badges,
+	checkboxGroup,
+	customField,
+	datetimeOptional,
+	datetimeRequired,
+	idConstantOptional,
+	image,
+	numberFieldOptional,
+	select,
+	selectDynamicOptional,
+	textAreaOptional,
+	textFieldOptional,
+	textFieldRequired,
+	toggle,
+} from "~/form/fields";
+import { rankedModesShort } from "~/modules/in-game-lists/modes";
+import { CALENDAR_EVENT, REG_CLOSES_AT_OPTIONS } from "./calendar-constants";
+import { bracketProgressionSchema } from "./calendar-schemas";
+import { calendarEventMaxDate, calendarEventMinDate } from "./calendar-utils";
+
+/** Single date row of the {@link calendarNewBaseSchema} `date` array (calendar events). */
+const calendarEventDateField = datetimeRequired({
+	label: "labels.date",
+	min: calendarEventMinDate,
+	max: calendarEventMaxDate,
+});
+
+export const calendarNewBaseSchema = z.object({
+	// discriminates between a calendar event and a tournament; seeded from the loader, no visible control
+	toToolsEnabled: customField({ initialValue: false }, z.boolean()), // xxx: use "stringConstant" instead
+	eventToEditId: idConstantOptional(),
+	tournamentToCopyId: idConstantOptional(),
+	name: textFieldRequired({
+		label: "labels.name",
+		minLength: CALENDAR_EVENT.NAME_MIN_LENGTH,
+		maxLength: CALENDAR_EVENT.NAME_MAX_LENGTH,
+	}),
+	description: textAreaOptional({
+		label: "labels.description",
+		maxLength: CALENDAR_EVENT.DESCRIPTION_MAX_LENGTH,
+	}),
+	organizationId: selectDynamicOptional({ label: "labels.organization" }),
+	rules: textAreaOptional({
+		label: "labels.rules",
+		bottomText: "bottomTexts.bioMarkdown",
+		maxLength: CALENDAR_EVENT.RULES_MAX_LENGTH,
+	}),
+	// calendar events can span multiple dates; tournaments always have exactly one
+	// (`startTime`). Only the relevant field is rendered, and the other stays at its
+	// empty initial value — `calendarNewSyncRefine` enforces the right one per type.
+	date: array({
+		label: "labels.dates",
+		max: CALENDAR_EVENT.MAX_AMOUNT_OF_DATES,
+		field: calendarEventDateField,
+	}),
+	startTime: datetimeOptional({
+		label: "labels.date",
+		bottomText: "bottomTexts.tournamentStartTime",
+		min: calendarEventMinDate,
+		max: calendarEventMaxDate,
+	}),
+	bracketUrl: textFieldOptional({
+		label: "labels.bracketUrl",
+		maxLength: CALENDAR_EVENT.BRACKET_URL_MAX_LENGTH,
+		validate: "url",
+	}),
+	discordInviteCode: textFieldOptional({
+		label: "labels.discordInvite",
+		maxLength: CALENDAR_EVENT.DISCORD_INVITE_CODE_MAX_LENGTH,
+		leftAddon: "https://discord.gg/",
+	}),
+	tags: checkboxGroup({
+		label: "labels.tags",
+		items: CALENDAR_EVENT.TAGS.map((tag) => ({
+			value: tag,
+			label: `options.tag.${tag}` as const,
+		})),
+	}),
+	badges: badges({ label: "labels.badges", maxCount: 50 }),
+	avatarImgId: image({
+		label: "labels.logo",
+		bottomText: "bottomTexts.avatarValidation",
+		autoValidate: true,
+	}),
+	regClosesAt: select({
+		label: "labels.regClosesAt",
+		bottomText: "bottomTexts.regClosesAt",
+		items: REG_CLOSES_AT_OPTIONS.map((option) => ({
+			value: option,
+			label: `options.regClosesAt.${option}` as const,
+		})),
+	}),
+	minMembersPerTeam: select({
+		label: "labels.playersCount",
+		items: [4, 3, 2, 1].map((count) => ({
+			value: String(count),
+			label: () => `${count}v${count}`,
+		})),
+	}),
+	maxMembersPerTeam: numberFieldOptional({
+		label: "labels.maxTeamSize",
+		bottomText: "bottomTexts.maxTeamSize",
+	}),
+	toToolsMode: select({
+		label: "labels.mapPickingStyle",
+		items: [
+			{ value: "ALL", label: "options.toToolsMode.ALL" },
+			{ value: "SZ", label: "options.toToolsMode.SZ" },
+			{ value: "TC", label: "options.toToolsMode.TC" },
+			{ value: "RM", label: "options.toToolsMode.RM" },
+			{ value: "CB", label: "options.toToolsMode.CB" },
+			{ value: "TO", label: "options.toToolsMode.TO" },
+		],
+	}),
+	pool: customField({ initialValue: "" }, z.string().optional()),
+	bracketProgression: customField(
+		{ initialValue: null },
+		bracketProgressionSchema.nullish(),
+	),
+	isRanked: toggle({
+		label: "labels.ranked",
+		bottomText: "bottomTexts.ranked",
+	}),
+	enableNoScreenToggle: toggle({
+		label: "labels.splattercolorScreenToggle",
+		bottomText: "bottomTexts.splattercolorScreen",
+	}),
+	enableSubs: toggle({
+		label: "labels.lfgTab",
+		bottomText: "bottomTexts.lfgTab",
+	}),
+	autonomousSubs: toggle({
+		label: "labels.autonomousSubs",
+		bottomText: "bottomTexts.autonomousSubs",
+	}),
+	requireInGameNames: toggle({
+		label: "labels.requireInGameNames",
+		bottomText: "bottomTexts.requireInGameNames",
+	}),
+	isInvitational: toggle({
+		label: "labels.invitational",
+		bottomText: "bottomTexts.invitational",
+	}),
+	isTest: toggle({ label: "labels.test", bottomText: "bottomTexts.test" }),
+	isDraft: toggle({
+		label: "labels.draft",
+		bottomText: "bottomTexts.draftInfo",
+	}),
+	requireSendouQParticipation: toggle({
+		label: "labels.requireSendouQ",
+		bottomText: "bottomTexts.requireSendouQ",
+	}),
+});
+
+/** Shared sync cross-field rules, reused by the server schema (see `*.server.ts`). */
+export function calendarNewSyncRefine(
+	data: z.infer<typeof calendarNewBaseSchema>,
+	ctx: z.RefinementCtx,
+) {
+	// a calendar event needs at least one date; a tournament needs its single start time
+	if (!data.toToolsEnabled && data.date.length < 1) {
+		ctx.addIssue({
+			path: ["date"],
+			code: z.ZodIssueCode.custom,
+			message: "forms:errors.required",
+		});
+	}
+
+	if (data.toToolsEnabled && !data.startTime) {
+		ctx.addIssue({
+			path: ["startTime"],
+			code: z.ZodIssueCode.custom,
+			message: "forms:errors.required",
+		});
+	}
+
+	// a calendar event needs a bracket URL; tournaments default to sendou.ink in the action
+	if (!data.toToolsEnabled && !data.bracketUrl) {
+		ctx.addIssue({
+			path: ["bracketUrl"],
+			code: z.ZodIssueCode.custom,
+			message: "forms:errors.bracketUrlRequired",
+		});
+	}
+
+	if (data.toToolsEnabled && !data.bracketProgression) {
+		ctx.addIssue({
+			path: ["bracketProgression"],
+			code: z.ZodIssueCode.custom,
+			message: "forms:errors.bracketProgressionRequired",
+		});
+	}
+
+	// "Prepicked by teams - All modes" requires one tiebreaker map per ranked mode
+	if (data.toToolsEnabled && data.toToolsMode === "ALL") {
+		const maps = data.pool ? MapPool.toDbList(data.pool) : [];
+		const isValid =
+			maps.length === rankedModesShort.length &&
+			rankedModesShort.every((mode) => maps.some((map) => map.mode === mode));
+
+		if (!isValid) {
+			ctx.addIssue({
+				path: ["pool"],
+				code: z.ZodIssueCode.custom,
+				message: "forms:errors.allModePool",
+			});
+		}
+	}
+
+	if (
+		data.toToolsEnabled &&
+		data.minMembersPerTeam === "4" &&
+		data.maxMembersPerTeam &&
+		(data.maxMembersPerTeam < 4 || data.maxMembersPerTeam > 10)
+	) {
+		ctx.addIssue({
+			path: ["maxMembersPerTeam"],
+			code: z.ZodIssueCode.custom,
+			message: "forms:errors.maxMembersRange",
+		});
+	}
+}
diff --git a/app/features/calendar/calendar-new.module.css b/app/features/calendar/calendar-new.module.css
deleted file mode 100644
index d3a842319..000000000
--- a/app/features/calendar/calendar-new.module.css
+++ /dev/null
@@ -1,22 +0,0 @@
-.badges {
-	width: max-content;
-	padding: var(--s-2);
-	border-radius: var(--radius-box);
-	background-color: var(--color-bg-badge);
-	font-size: var(--font-sm);
-	font-weight: var(--weight-semi);
-}
-
-:global(html.light) .badges {
-	color: var(--color-text-inverse);
-}
-
-.dayLabel {
-	margin: 0;
-}
-
-.avatarPreview {
-	width: 124px;
-	height: 124px;
-	border-radius: var(--radius-avatar);
-}
diff --git a/app/features/calendar/calendar-schemas.server.ts b/app/features/calendar/calendar-schemas.server.ts
deleted file mode 100644
index 4e2b1b114..000000000
--- a/app/features/calendar/calendar-schemas.server.ts
+++ /dev/null
@@ -1,133 +0,0 @@
-import { z } from "zod";
-import * as CalendarRepository from "~/features/calendar/CalendarRepository.server";
-import {
-	bracketProgressionSchema,
-	calendarEventTagSchema,
-} from "~/features/calendar/calendar-schemas";
-import { MapPool } from "~/features/map-list-generator/core/map-pool";
-import { rankedModesShort } from "~/modules/in-game-lists/modes";
-import {
-	actualNumber,
-	checkboxValueToBoolean,
-	date,
-	falsyToNull,
-	id,
-	processMany,
-	removeDuplicates,
-	safeJSONParse,
-	toArray,
-} from "~/utils/zod";
-import { CALENDAR_EVENT, REG_CLOSES_AT_OPTIONS } from "./calendar-constants";
-import { calendarEventMaxDate, calendarEventMinDate } from "./calendar-utils";
-
-export const newCalendarEventActionSchema = z
-	.object({
-		eventToEditId: z.preprocess(actualNumber, id.nullish()),
-		tournamentToCopyId: z.preprocess(actualNumber, id.nullish()),
-		organizationId: z.preprocess(actualNumber, id.nullish()),
-		name: z
-			.string()
-			.min(CALENDAR_EVENT.NAME_MIN_LENGTH)
-			.max(CALENDAR_EVENT.NAME_MAX_LENGTH),
-		description: z.preprocess(
-			falsyToNull,
-			z.string().max(CALENDAR_EVENT.DESCRIPTION_MAX_LENGTH).nullable(),
-		),
-		rules: z.preprocess(
-			falsyToNull,
-			z.string().max(CALENDAR_EVENT.RULES_MAX_LENGTH).nullable(),
-		),
-		date: z.preprocess(
-			toArray,
-			z
-				.array(
-					z.preprocess(
-						date,
-						z.date().min(calendarEventMinDate()).max(calendarEventMaxDate()),
-					),
-				)
-				.min(1)
-				.max(CALENDAR_EVENT.MAX_AMOUNT_OF_DATES),
-		),
-		bracketUrl: z
-			.string()
-			.url()
-			.max(CALENDAR_EVENT.BRACKET_URL_MAX_LENGTH)
-			.default("https://sendou.ink"),
-		discordInviteCode: z.preprocess(
-			falsyToNull,
-			z.string().max(CALENDAR_EVENT.DISCORD_INVITE_CODE_MAX_LENGTH).nullable(),
-		),
-		tags: z.preprocess(
-			processMany(safeJSONParse, removeDuplicates),
-			z.array(calendarEventTagSchema).nullable(),
-		),
-		badges: z.preprocess(
-			processMany(safeJSONParse, removeDuplicates),
-			z.array(id).nullable(),
-		),
-		avatarImgId: id.nullish(),
-		pool: z.string().optional(),
-		toToolsEnabled: z.preprocess(checkboxValueToBoolean, z.boolean()),
-		toToolsMode: z.enum(["ALL", "TO", "SZ", "TC", "RM", "CB"]).optional(),
-		isRanked: z.preprocess(checkboxValueToBoolean, z.boolean().nullish()),
-		isTest: z.preprocess(checkboxValueToBoolean, z.boolean().nullish()),
-		isDraft: z.preprocess(checkboxValueToBoolean, z.boolean().nullish()),
-		regClosesAt: z.enum(REG_CLOSES_AT_OPTIONS).nullish(),
-		enableNoScreenToggle: z.preprocess(
-			checkboxValueToBoolean,
-			z.boolean().nullish(),
-		),
-		enableSubs: z.preprocess(checkboxValueToBoolean, z.boolean().nullish()),
-		autonomousSubs: z.preprocess(checkboxValueToBoolean, z.boolean().nullish()),
-		isInvitational: z.preprocess(checkboxValueToBoolean, z.boolean().nullish()),
-		requireInGameNames: z.preprocess(
-			checkboxValueToBoolean,
-			z.boolean().nullish(),
-		),
-		requireSendouQParticipation: z.preprocess(
-			checkboxValueToBoolean,
-			z.boolean().nullish(),
-		),
-		minMembersPerTeam: z.preprocess(
-			actualNumber,
-			z.number().int().min(1).max(4).nullish(),
-		),
-		maxMembersPerTeam: z.preprocess(
-			actualNumber,
-			z.number().int().min(4).max(10).nullish(),
-		),
-		bracketProgression: bracketProgressionSchema.nullish(),
-	})
-	.refine(
-		async (schema) => {
-			if (schema.eventToEditId) {
-				const eventToEdit = await CalendarRepository.findById(
-					schema.eventToEditId,
-				);
-				return schema.date.length === 1 || !eventToEdit?.tournamentId;
-			}
-			return schema.date.length === 1 || !schema.toToolsEnabled;
-		},
-		{
-			message: "Tournament must have exactly one date",
-		},
-	)
-	.refine(
-		(schema) => {
-			if (schema.toToolsMode !== "ALL") {
-				return true;
-			}
-
-			const maps = schema.pool ? MapPool.toDbList(schema.pool) : [];
-
-			return (
-				maps.length === 4 &&
-				rankedModesShort.every((mode) => maps.some((map) => map.mode === mode))
-			);
-		},
-		{
-			message:
-				'Map pool must contain a map for each ranked mode if using "Prepicked by teams - All modes"',
-		},
-	);
diff --git a/app/features/calendar/calendar-schemas.ts b/app/features/calendar/calendar-schemas.ts
index a08da1c9f..9784c8315 100644
--- a/app/features/calendar/calendar-schemas.ts
+++ b/app/features/calendar/calendar-schemas.ts
@@ -25,7 +25,7 @@ import {
 import { CALENDAR_EVENT, CALENDAR_EVENT_RESULT } from "./calendar-constants";
 import * as CalendarEvent from "./core/CalendarEvent";
 
-export const calendarEventTagSchema = z
+const calendarEventTagSchema = z
 	.string()
 	.refine((val) => CALENDAR_EVENT.TAGS.includes(val as CalendarEventTag));
 
diff --git a/app/features/calendar/components/BracketProgressionSelector.tsx b/app/features/calendar/components/BracketProgressionSelector.tsx
index 65593e517..d4b3da1df 100644
--- a/app/features/calendar/components/BracketProgressionSelector.tsx
+++ b/app/features/calendar/components/BracketProgressionSelector.tsx
@@ -25,12 +25,13 @@ const defaultBracket = (): Progression.InputBracket => ({
 export function BracketProgressionSelector({
 	initialBrackets,
 	isInvitationalTournament,
-	setErrored,
+	onChange,
 	isTournamentInProgress,
 }: {
 	initialBrackets?: Progression.InputBracket[];
 	isInvitationalTournament: boolean;
-	setErrored: (errored: boolean) => void;
+	/** Emits the validated brackets while valid, or `null` while invalid/incomplete. */
+	onChange: (value: Progression.ParsedBracket[] | null) => void;
 	isTournamentInProgress: boolean;
 }) {
 	const [brackets, setBrackets] = React.useState<Progression.InputBracket[]>(
@@ -75,24 +76,21 @@ export function BracketProgressionSelector({
 	};
 
 	const validated = Progression.validatedBrackets(brackets);
+	// `validatedBrackets` returns a fresh array each render, so emit only when the
+	// serialized result actually changes — otherwise `onChange` would loop the form store.
+	const serialized = Progression.isBrackets(validated)
+		? JSON.stringify(validated)
+		: null;
+	const lastSerialized = React.useRef<string | null | undefined>(undefined);
 
 	React.useEffect(() => {
-		if (Progression.isError(validated)) {
-			setErrored(true);
-		} else {
-			setErrored(false);
-		}
-	}, [validated, setErrored]);
+		if (lastSerialized.current === serialized) return;
+		lastSerialized.current = serialized;
+		onChange(serialized ? JSON.parse(serialized) : null);
+	}, [serialized, onChange]);
 
 	return (
 		<div className="stack lg items-start">
-			{Progression.isBrackets(validated) ? (
-				<input
-					type="hidden"
-					name="bracketProgression"
-					value={JSON.stringify(validated)}
-				/>
-			) : null}
 			<div className="stack lg">
 				{brackets.map((bracket, i) => (
 					<TournamentFormatBracketSelector
diff --git a/app/features/calendar/loaders/calendar.new.server.ts b/app/features/calendar/loaders/calendar.new.server.ts
index c7be12c54..ac8980549 100644
--- a/app/features/calendar/loaders/calendar.new.server.ts
+++ b/app/features/calendar/loaders/calendar.new.server.ts
@@ -93,6 +93,18 @@ export const loader = async ({ url }: LoaderFunctionArgs) => {
 			}
 		: undefined;
 
+	// the badges the user can pick from, plus any already-attached prize badges they no
+	// longer manage (so an existing selection still renders and stays removable)
+	const badgeOptions = R.uniqueBy(
+		[...managedBadges, ...(eventToEdit?.badgePrizes ?? [])].map((badge) => ({
+			id: badge.id,
+			code: badge.code,
+			displayName: badge.displayName,
+			hue: badge.hue,
+		})),
+		(badge) => badge.id,
+	);
+
 	return {
 		isAddingTournament: Boolean(
 			url.searchParams.has("tournament") ||
@@ -100,6 +112,7 @@ export const loader = async ({ url }: LoaderFunctionArgs) => {
 				eventToEdit?.tournament,
 		),
 		managedBadges,
+		badgeOptions,
 		eventToEdit: canEditEvent ? eventToEdit : undefined,
 		eventToCopy,
 		recentTournaments:
diff --git a/app/features/calendar/routes/calendar.new.tsx b/app/features/calendar/routes/calendar.new.tsx
index d0a8107bc..4b7e27bde 100644
--- a/app/features/calendar/routes/calendar.new.tsx
+++ b/app/features/calendar/routes/calendar.new.tsx
@@ -1,57 +1,34 @@
-import clsx from "clsx";
-import Compressor from "compressorjs";
-import { Trash, X } from "lucide-react";
 import * as React from "react";
 import { useTranslation } from "react-i18next";
 import type { MetaFunction } from "react-router";
-import { Form, Link, useFetcher, useLoaderData } from "react-router";
+import { Form, Link, useLoaderData } from "react-router";
 import type { AlertVariation } from "~/components/Alert";
 import { Alert } from "~/components/Alert";
-import { Badge } from "~/components/Badge";
-import { DateInput } from "~/components/DateInput";
 import { Divider } from "~/components/Divider";
 import { SendouButton } from "~/components/elements/Button";
-import { SendouSwitch } from "~/components/elements/Switch";
 import { FormMessage } from "~/components/FormMessage";
-import { Input } from "~/components/Input";
-import { Label } from "~/components/Label";
 import { Main } from "~/components/Main";
 import { MapPoolSelector } from "~/components/MapPoolSelector";
-import { RequiredHiddenInput } from "~/components/RequiredHiddenInput";
 import { SubmitButton } from "~/components/SubmitButton";
-import type { CalendarEventTag, Tables } from "~/db/tables";
+import type { Tables } from "~/db/tables";
 import { MapPool } from "~/features/map-list-generator/core/map-pool";
 import * as Progression from "~/features/tournament-bracket/core/Progression";
+import { type CustomFieldRenderProps, FormField } from "~/form/FormField";
+import { existingImage } from "~/form/image-field";
+import { SendouForm, useFormFieldContext } from "~/form/SendouForm";
+import { errorMessageId } from "~/form/utils";
 import { useDateTimeFormat } from "~/hooks/intl/useDateTimeFormat";
-import { useHydrated } from "~/hooks/useHydrated";
 import type { RankedModeShort } from "~/modules/in-game-lists/types";
 import { useHasRole } from "~/modules/permissions/hooks";
-import {
-	databaseTimestampToDate,
-	getDateAtNextFullHour,
-	getDateWithHoursOffset,
-} from "~/utils/dates";
-import invariant from "~/utils/invariant";
-import { logger } from "~/utils/logger";
+import { databaseTimestampToDate, getDateAtNextFullHour } from "~/utils/dates";
 import { metaTags } from "~/utils/remix";
 import type { SendouRouteHandle } from "~/utils/remix.server";
-import { pathnameFromPotentialURL } from "~/utils/strings";
 import { CREATING_TOURNAMENT_DOC_LINK, FAQ_PAGE } from "~/utils/urls";
 import { action } from "../actions/calendar.new.server";
-import {
-	CALENDAR_EVENT,
-	REG_CLOSES_AT_OPTIONS,
-	type RegClosesAtOption,
-} from "../calendar-constants";
-import styles from "../calendar-new.module.css";
-import {
-	calendarEventMaxDate,
-	calendarEventMinDate,
-	datesToRegClosesAt,
-	regClosesAtToDisplayName,
-} from "../calendar-utils";
+import type { RegClosesAtOption } from "../calendar-constants";
+import { calendarNewBaseSchema } from "../calendar-new-schemas";
+import { datesToRegClosesAt } from "../calendar-utils";
 import { BracketProgressionSelector } from "../components/BracketProgressionSelector";
-import { Tags } from "../components/Tags";
 import { loader } from "../loaders/calendar.new.server";
 
 export { action, loader };
@@ -71,6 +48,18 @@ export const handle: SendouRouteHandle = {
 	i18n: ["calendar", "game-misc", "tournament"],
 };
 
+const mapPickingStyleToShort: Record<
+	Tables["Tournament"]["mapPickingStyle"],
+	"ALL" | "TO" | RankedModeShort
+> = {
+	TO: "TO",
+	AUTO_ALL: "ALL",
+	AUTO_SZ: "SZ",
+	AUTO_TC: "TC",
+	AUTO_RM: "RM",
+	AUTO_CB: "CB",
+};
+
 const useBaseEvent = () => {
 	const { eventToEdit, eventToCopy } = useLoaderData<typeof loader>();
 
@@ -81,6 +70,7 @@ export default function CalendarNewEventPage() {
 	const baseEvent = useBaseEvent();
 	const isCalendarEventAdder = useHasRole("CALENDAR_EVENT_ADDER");
 	const data = useLoaderData<typeof loader>();
+	const defaultValues = useDefaultValues();
 
 	if (!data.eventToEdit && !isCalendarEventAdder) {
 		return (
@@ -128,12 +118,106 @@ export default function CalendarNewEventPage() {
 					) : null}
 				</div>
 				{data.isAddingTournament ? <TemplateTournamentForm /> : null}
-				<EventForm key={baseEvent?.eventId} />
+				<SendouForm
+					key={baseEvent?.eventId}
+					schema={calendarNewBaseSchema}
+					defaultValues={defaultValues}
+					submitButtonTestId="submit-button"
+					fullWidth
+				>
+					<CalendarNewFields />
+				</SendouForm>
 			</div>
 		</Main>
 	);
 }
 
+function useDefaultValues() {
+	const data = useLoaderData<typeof loader>();
+	const baseEvent = useBaseEvent();
+	const tournamentCtx = baseEvent?.tournament?.ctx;
+	const settings = tournamentCtx?.settings;
+
+	const regClosesAt: RegClosesAtOption = tournamentCtx?.settings.regClosesAt
+		? datesToRegClosesAt({
+				startTime: databaseTimestampToDate(tournamentCtx.startTime),
+				regClosesAt: databaseTimestampToDate(
+					tournamentCtx.settings.regClosesAt,
+				),
+			})
+		: "0";
+
+	const toToolsMode = baseEvent?.mapPickingStyle
+		? mapPickingStyleToShort[baseEvent.mapPickingStyle]
+		: "ALL";
+
+	const pool = (() => {
+		if (!baseEvent) return "";
+		if (!data.isAddingTournament || toToolsMode === "TO") {
+			return baseEvent.mapPool ? new MapPool(baseEvent.mapPool).serialized : "";
+		}
+		if (toToolsMode === "ALL") {
+			return baseEvent.tieBreakerMapPool
+				? new MapPool(baseEvent.tieBreakerMapPool).serialized
+				: "";
+		}
+		return "";
+	})();
+
+	return {
+		toToolsEnabled: data.isAddingTournament,
+		eventToEditId: data.eventToEdit?.eventId,
+		tournamentToCopyId: data.eventToCopy?.tournamentId ?? undefined,
+		name: data.eventToEdit?.name ?? "",
+		description: baseEvent?.description ?? "",
+		organizationId: baseEvent?.organization?.id
+			? String(baseEvent.organization.id)
+			: null,
+		rules: baseEvent?.rules ?? "",
+		date: data.isAddingTournament
+			? []
+			: (data.eventToEdit?.startTimes?.map((t) =>
+					databaseTimestampToDate(t),
+				) ?? [getDateAtNextFullHour(new Date())]),
+		startTime: data.isAddingTournament
+			? data.eventToEdit?.startTimes?.[0]
+				? databaseTimestampToDate(data.eventToEdit.startTimes[0])
+				: getDateAtNextFullHour(new Date())
+			: null,
+		// tournaments hide this field, so seed a valid URL to satisfy the url-format
+		// validation (the action coalesces to the same default)
+		bracketUrl: data.isAddingTournament
+			? "https://sendou.ink"
+			: (data.eventToEdit?.bracketUrl ?? ""),
+		discordInviteCode: baseEvent?.discordInviteCode ?? "",
+		tags: baseEvent?.tags ?? [],
+		badges: baseEvent?.badgePrizes?.map((b) => b.id) ?? [],
+		avatarImgId: existingImage(
+			baseEvent?.avatarImgId,
+			baseEvent?.tournament?.ctx.logoUrl,
+		),
+		regClosesAt,
+		minMembersPerTeam: String(settings?.minMembersPerTeam ?? 4) as
+			| "1"
+			| "2"
+			| "3"
+			| "4",
+		maxMembersPerTeam: settings?.maxMembersPerTeam ?? undefined,
+		toToolsMode,
+		pool,
+		bracketProgression: settings?.bracketProgression ?? null,
+		isRanked: settings?.isRanked ?? true,
+		enableNoScreenToggle: settings?.enableNoScreenToggle ?? true,
+		enableSubs: settings?.enableSubs ?? true,
+		autonomousSubs: settings?.autonomousSubs ?? true,
+		requireInGameNames: settings?.requireInGameNames ?? false,
+		isInvitational: settings?.isInvitational ?? false,
+		isTest: settings?.isTest ?? false,
+		isDraft: settings?.isDraft ?? false,
+		requireSendouQParticipation: settings?.requireSendouQParticipation ?? false,
+	};
+}
+
 function TemplateTournamentForm() {
 	const { recentTournaments } = useLoaderData<typeof loader>();
 	const [eventId, setEventId] = React.useState("");
@@ -161,7 +245,9 @@ function TemplateTournamentForm() {
 							</option>
 						))}
 					</select>
-					<SubmitButton isDisabled={!eventId}>Use template</SubmitButton>
+					<SubmitButton isDisabled={!eventId} testId="use-template-button">
+						Use template
+					</SubmitButton>
 				</Form>
 			</div>
 			<hr />
@@ -169,1046 +255,286 @@ function TemplateTournamentForm() {
 	);
 }
 
-function EventForm() {
-	const fetcher = useFetcher();
-	const { t } = useTranslation();
-	const { eventToEdit, eventToCopy } = useLoaderData<typeof loader>();
-	const ref = React.useRef<HTMLFormElement>(null);
-	const [avatarImg, setAvatarImg] = React.useState<File | null>(null);
-	const baseEvent = useBaseEvent();
-	const [isInvitational, setIsInvitational] = React.useState(
-		baseEvent?.tournament?.ctx.settings.isInvitational ?? false,
-	);
+function CalendarNewFields() {
 	const data = useLoaderData<typeof loader>();
-	const [bracketProgressionErrored, setBracketProgressionErrored] =
-		React.useState(false);
-
-	const handleSubmit = () => {
-		const isValid = ref.current?.checkValidity();
-		if (!isValid) {
-			ref.current?.reportValidity();
-			return;
-		}
-
-		const formData = new FormData(ref.current!);
-
-		// if "avatarImgId" it means they want to reuse an existing avatar
-		const includeImage = avatarImg && !formData.has("avatarImgId");
-
-		if (includeImage) {
-			// replace with the compressed version
-			formData.delete("img");
-			formData.append("img", avatarImg, avatarImg.name);
-		}
-
-		fetcher.submit(formData, {
-			encType: includeImage ? "multipart/form-data" : undefined,
-			method: "post",
-		});
-	};
-
-	const submitButtonDisabled = () => {
-		if (fetcher.state !== "idle") return true;
-		if (bracketProgressionErrored) return true;
-
-		return false;
-	};
-
-	return (
-		<Form className="stack md" ref={ref}>
-			{eventToEdit && (
-				<input type="hidden" name="eventToEditId" value={eventToEdit.eventId} />
-			)}
-			{eventToCopy?.tournamentId ? (
-				<input
-					type="hidden"
-					name="tournamentToCopyId"
-					value={eventToCopy.tournamentId}
-				/>
-			) : null}
-			{data.isAddingTournament ? (
-				<input type="hidden" name="toToolsEnabled" value="on" />
-			) : null}
-			<NameInput />
-			<DescriptionTextarea supportsMarkdown={data.isAddingTournament} />
-			<OrganizationSelect />
-			{data.isAddingTournament ? <RulesTextarea supportsMarkdown /> : null}
-			<DatesInput allowMultiDate={!data.isAddingTournament} />
-			{!data.isAddingTournament ? <BracketUrlInput /> : null}
-			<DiscordLinkInput />
-			<TagsAdder />
-			<BadgesAdder />
-			{data.isAddingTournament ? (
-				<AvatarImageInput avatarImg={avatarImg} setAvatarImg={setAvatarImg} />
-			) : null}
-			{data.isAddingTournament ? (
-				<>
-					<Divider>Tournament settings</Divider>
-					<MemberCountSelect />
-					<RegClosesAtSelect />
-					<RankedToggle />
-					<EnableNoScreenToggle />
-					<EnableSubsToggle />
-					<AutonomousSubsToggle />
-					<RequireIGNToggle />
-					<InvitationalToggle
-						isInvitational={isInvitational}
-						setIsInvitational={setIsInvitational}
-					/>
-					{!eventToEdit ? <TestToggle /> : null}
-					<DraftToggle />
-					<AdminOnlySettings />
-				</>
-			) : null}
-			{data.isAddingTournament ? (
-				<TournamentMapPickingStyleSelect />
-			) : (
-				<MapPoolSection />
-			)}
-			{data.isAddingTournament ? (
-				<div className="stack md w-full">
-					<Divider smallText>Tournament format</Divider>
-					<BracketProgressionSelector
-						initialBrackets={
-							baseEvent?.tournament?.ctx.settings.bracketProgression
-								? Progression.validatedBracketsToInputFormat(
-										baseEvent.tournament?.ctx.settings.bracketProgression,
-									)
-								: undefined
-						}
-						isInvitationalTournament={isInvitational}
-						setErrored={setBracketProgressionErrored}
-						isTournamentInProgress={false}
-					/>
-				</div>
-			) : null}
-			<SendouButton
-				className="mt-4"
-				onPress={handleSubmit}
-				isDisabled={submitButtonDisabled()}
-				data-testid="submit-button"
-			>
-				{t("actions.submit")}
-			</SendouButton>
-		</Form>
-	);
-}
-
-function NameInput() {
-	const { t } = useTranslation();
-	const { eventToEdit } = useLoaderData<typeof loader>();
-
-	return (
-		<div>
-			<Label htmlFor="name" required>
-				{t("forms.name")}
-			</Label>
-			<input
-				name="name"
-				id="name"
-				required
-				minLength={CALENDAR_EVENT.NAME_MIN_LENGTH}
-				maxLength={CALENDAR_EVENT.NAME_MAX_LENGTH}
-				defaultValue={eventToEdit?.name}
-				data-testid="calendar-event-name-input"
-			/>
-		</div>
-	);
-}
-
-function DescriptionTextarea({
-	supportsMarkdown,
-}: {
-	supportsMarkdown?: boolean;
-}) {
-	const { t } = useTranslation();
-	const baseEvent = useBaseEvent();
-	const [value, setValue] = React.useState(baseEvent?.description ?? "");
-
-	return (
-		<div>
-			<Label
-				htmlFor="description"
-				valueLimits={{
-					current: value.length,
-					max: CALENDAR_EVENT.DESCRIPTION_MAX_LENGTH,
-				}}
-			>
-				{t("forms.description")}
-			</Label>
-			<textarea
-				id="description"
-				name="description"
-				value={value}
-				onChange={(e) => setValue(e.target.value)}
-				maxLength={CALENDAR_EVENT.DESCRIPTION_MAX_LENGTH}
-			/>
-			{supportsMarkdown ? (
-				<FormMessage type="info">Supports Markdown</FormMessage>
-			) : null}
-		</div>
-	);
-}
-
-function OrganizationSelect() {
-	const id = React.useId();
-	const data = useLoaderData<typeof loader>();
-	const baseEvent = useBaseEvent();
-
-	if (data.organizations.length === 0) return null;
-
-	return (
-		<div>
-			<Label htmlFor={id}>Organization</Label>
-			<select
-				id={id}
-				name="organizationId"
-				defaultValue={baseEvent?.organization?.id ?? ""}
-			>
-				{data.organizations.includes("NO_ORG") ? (
-					<option key="NO_ORG" value="">
-						None
-					</option>
-				) : null}
-				{data.organizations
-					.filter((org) => typeof org !== "string")
-					.map((org) => (
-						<option key={org.id} value={org.id}>
-							{org.name}
-						</option>
-					))}
-			</select>
-		</div>
-	);
-}
-
-function RulesTextarea({ supportsMarkdown }: { supportsMarkdown?: boolean }) {
-	const baseEvent = useBaseEvent();
-	const [value, setValue] = React.useState(baseEvent?.rules ?? "");
-
-	return (
-		<div>
-			<Label
-				htmlFor="rules"
-				valueLimits={{
-					current: value.length,
-					max: CALENDAR_EVENT.RULES_MAX_LENGTH,
-				}}
-			>
-				Rules
-			</Label>
-			<textarea
-				id="rules"
-				name="rules"
-				value={value}
-				onChange={(e) => setValue(e.target.value)}
-				maxLength={CALENDAR_EVENT.RULES_MAX_LENGTH}
-			/>
-			{supportsMarkdown ? (
-				<FormMessage type="info">Supports Markdown</FormMessage>
-			) : null}
-		</div>
-	);
-}
-
-function AddButton({ onAdd, id }: { onAdd: () => void; id?: string }) {
-	const { t } = useTranslation();
-
-	return (
-		<SendouButton size="small" variant="outlined" onPress={onAdd} id={id}>
-			{t("actions.add")}
-		</SendouButton>
-	);
-}
-
-function DatesInput({ allowMultiDate }: { allowMultiDate?: boolean }) {
-	const { t } = useTranslation(["common", "calendar"]);
-	const { eventToEdit } = useLoaderData<typeof loader>();
-
-	// Using array index as a key can mess up internal state, especially when
-	// removing elements from the middle. So we just count up for every date we
-	// create.
-	const keyCounter = React.useRef(0);
-	const getKey = () => ++keyCounter.current;
-
-	// React hook that keeps track of child DateInput's dates
-	// (necessary for determining additional Date's defaultValues)
-	const [_datesInputState, setDatesInputState] = React.useState<
-		Array<{
-			key: number;
-			date: Date | null;
-		}>
-	>(() => {
-		// Initialize datesInputState by retrieving pre-existing events if they exist
-		if (eventToEdit?.startTimes) {
-			return eventToEdit.startTimes.map((t) => ({
-				key: getKey(),
-				date: databaseTimestampToDate(t),
-			}));
-		}
-
-		// Initial date rounded to next full hour from now
-		return [{ key: getKey(), date: getDateAtNextFullHour(new Date()) }];
-	});
-
-	const datesInputState = allowMultiDate
-		? _datesInputState
-		: _datesInputState.filter((_, i) => i === 0);
-
-	const datesCount = datesInputState.length;
-
-	const isHydrated = useHydrated();
-	const usersTimeZone = isHydrated
-		? Intl.DateTimeFormat().resolvedOptions().timeZone
-		: "";
-	const NEW_CALENDAR_EVENT_HOURS_OFFSET = 24;
-
-	const addDate = () =>
-		setDatesInputState((current) => {
-			// .reverse() is mutating, but map/filter returns a new array anyway.
-			const lastValidDate = current
-				.map((e) => e.date)
-				.filter((date) => date !== null)
-				.reverse()[0];
-
-			const addedDate = lastValidDate
-				? getDateWithHoursOffset(lastValidDate, NEW_CALENDAR_EVENT_HOURS_OFFSET)
-				: getDateAtNextFullHour(new Date());
-
-			return [...current, { key: getKey(), date: addedDate }];
-		});
-
-	return (
-		<div className="stack md">
-			<fieldset>
-				<legend>
-					{t("calendar:forms.dates")} <span className="text-error">*</span>
-				</legend>
-				<div className="stack sm items-start">
-					<div className="stack sm">
-						{datesInputState.map(({ date, key }, i) => {
-							return (
-								<div key={key} className="stack horizontal sm items-center">
-									<label
-										id={`date-input-${key}-label`}
-										className={styles.dayLabel}
-										htmlFor={`date-input-${key}`}
-									>
-										{t("calendar:day", {
-											number: i + 1,
-										})}
-									</label>
-									<DateInput
-										id={`date-input-${key}`}
-										name="date"
-										suppressHydrationWarning
-										defaultValue={eventToEdit && date ? date : undefined}
-										min={calendarEventMinDate()}
-										max={calendarEventMaxDate()}
-										required
-										onChange={(newDate: Date | null) => {
-											setDatesInputState((current) =>
-												current.map((entry) =>
-													entry.key === key
-														? { ...entry, date: newDate }
-														: entry,
-												),
-											);
-										}}
-									/>
-									{/* "Remove" button */}
-									{datesCount > 1 && (
-										<SendouButton
-											size="small"
-											onPress={() => {
-												setDatesInputState((current) =>
-													current.filter((e) => e.key !== key),
-												);
-											}}
-											aria-controls={`date-input-${key}`}
-											aria-label={t("common:actions.remove")}
-											aria-describedby={`date-input-${key}-label`}
-											icon={<X />}
-											variant="minimal-destructive"
-										/>
-									)}
-								</div>
-							);
-						})}
-					</div>
-					{datesCount < CALENDAR_EVENT.MAX_AMOUNT_OF_DATES &&
-						allowMultiDate && <AddButton onAdd={addDate} />}
-					<FormMessage type="info" className={clsx({ invisible: !isHydrated })}>
-						{t("calendar:inYourTimeZone")} {usersTimeZone}
-					</FormMessage>
-				</div>
-			</fieldset>
-		</div>
-	);
-}
-
-function BracketUrlInput() {
-	const { t } = useTranslation("calendar");
-	const { eventToEdit } = useLoaderData<typeof loader>();
-
-	return (
-		<div>
-			<Label htmlFor="bracketUrl" required>
-				{t("forms.bracketUrl")}
-			</Label>
-			<input
-				name="bracketUrl"
-				type="url"
-				required
-				maxLength={CALENDAR_EVENT.BRACKET_URL_MAX_LENGTH}
-				defaultValue={eventToEdit?.bracketUrl}
-			/>
-		</div>
-	);
-}
-
-function DiscordLinkInput() {
-	const { t } = useTranslation("calendar");
-	const baseEvent = useBaseEvent();
-	const [value, setValue] = React.useState(baseEvent?.discordInviteCode ?? "");
-
-	return (
-		<div className="stack">
-			<Label htmlFor="discordInviteCode">{t("forms.discordInvite")}</Label>
-			<Input
-				name="discordInviteCode"
-				leftAddon="https://discord.gg/"
-				maxLength={CALENDAR_EVENT.DISCORD_INVITE_CODE_MAX_LENGTH}
-				value={value}
-				onChange={(e) => setValue(pathnameFromPotentialURL(e.target.value))}
-			/>
-		</div>
-	);
-}
-
-function TagsAdder() {
-	const { t } = useTranslation(["common", "calendar"]);
-	const baseEvent = useBaseEvent();
-	const [tags, setTags] = React.useState(baseEvent?.tags ?? []);
-	const id = React.useId();
-
-	const tagsForSelect = CALENDAR_EVENT.TAGS.filter(
-		(tag) => !tags.includes(tag),
-	);
-
-	return (
-		<div className="stack sm">
-			<input
-				type="hidden"
-				name="tags"
-				value={JSON.stringify(tags.length > 0 ? tags : null)}
-			/>
-			<div>
-				<label htmlFor={id}>{t("calendar:forms.tags")}</label>
-				<select
-					id={id}
-					onChange={(e) =>
-						setTags([...tags, e.target.value as CalendarEventTag])
-					}
-				>
-					<option value="">{t("calendar:forms.tags.placeholder")}</option>
-					{tagsForSelect.map((tag) => (
-						<option key={tag} value={tag}>
-							{t(`common:tag.name.${tag}`)}
-						</option>
-					))}
-				</select>
-			</div>
-			<Tags
-				tags={tags}
-				onDelete={(tagToDelete) =>
-					setTags(tags.filter((tag) => tag !== tagToDelete))
-				}
-			/>
-		</div>
-	);
-}
-
-function BadgesAdder() {
-	const { t } = useTranslation("calendar");
-	const baseEvent = useBaseEvent();
-	const { managedBadges } = useLoaderData<typeof loader>();
-	const [badges, setBadges] = React.useState(baseEvent?.badgePrizes ?? []);
-	const id = React.useId();
-
-	const input = (
-		<input
-			type="hidden"
-			name="badges"
-			value={JSON.stringify(badges.length > 0 ? badges.map((b) => b.id) : null)}
-		/>
-	);
-
-	if (managedBadges.length === 0) return input;
-
-	const handleBadgeDelete = (badgeId: Tables["Badge"]["id"]) => {
-		setBadges(badges.filter((badge) => badge.id !== badgeId));
-	};
-
-	const badgesForSelect = managedBadges.filter(
-		(badge) => !badges.some((b) => b.id === badge.id),
-	);
-
-	return (
-		<div className="stack md">
-			{input}
-			<div>
-				<label htmlFor={id}>{t("forms.badges")}</label>
-				<select
-					id={id}
-					onChange={(e) => {
-						setBadges([
-							...badges,
-							managedBadges.find(
-								(badge) => badge.id === Number(e.target.value),
-							)!,
-						]);
-					}}
-				>
-					<option value="">{t("forms.badges.placeholder")}</option>
-					{badgesForSelect.map((badge) => (
-						<option key={badge.id} value={badge.id}>
-							{badge.displayName}
-						</option>
-					))}
-				</select>
-			</div>
-			{badges.length > 0 && (
-				<div className={styles.badges}>
-					{badges.map((badge) => (
-						<div className="stack horizontal md items-center" key={badge.id}>
-							<Badge badge={badge} isAnimated size={32} />
-							<span>{badge.displayName}</span>
-							<SendouButton
-								className="ml-auto"
-								onPress={() => handleBadgeDelete(badge.id)}
-								icon={<Trash />}
-								variant="minimal-destructive"
-								aria-label="Remove badge"
-							/>
-						</div>
-					))}
-				</div>
-			)}
-		</div>
-	);
-}
-
-function AvatarImageInput({
-	avatarImg,
-	setAvatarImg,
-}: {
-	avatarImg: File | null;
-	setAvatarImg: (img: File | null) => void;
-}) {
-	const baseEvent = useBaseEvent();
-	const [showPrevious, setShowPrevious] = React.useState(true);
-
-	if (
-		baseEvent?.avatarImgId &&
-		baseEvent?.tournament?.ctx.logoUrl &&
-		showPrevious
-	) {
-		return (
-			<div className="stack horizontal md flex-wrap">
-				<input type="hidden" name="avatarImgId" value={baseEvent.avatarImgId} />
-				<div className="stack md items-center">
-					<img
-						src={baseEvent.tournament.ctx.logoUrl}
-						alt=""
-						className={styles.avatarPreview}
-					/>
-					<SendouButton
-						variant="outlined"
-						size="small"
-						onPress={() => setShowPrevious(false)}
-					>
-						Edit logo
-					</SendouButton>
-				</div>
-			</div>
-		);
-	}
-
-	const hasPreviousAvatar = Boolean(baseEvent?.avatarImgId);
-
-	return (
-		<div>
-			<Label htmlFor="avatarImage">Logo</Label>
-			<input
-				id="avatarImage"
-				type="file"
-				name="img"
-				accept="image/png, image/jpeg, image/jpg, image/webp"
-				onChange={(e) => {
-					const uploadedFile = e.target.files?.[0];
-					if (!uploadedFile) {
-						setAvatarImg(null);
-						return;
-					}
-
-					new Compressor(uploadedFile, {
-						width: CALENDAR_EVENT.AVATAR_SIZE,
-						height: CALENDAR_EVENT.AVATAR_SIZE,
-						maxHeight: CALENDAR_EVENT.AVATAR_SIZE,
-						maxWidth: CALENDAR_EVENT.AVATAR_SIZE,
-						resize: "cover",
-						success(result) {
-							invariant(result instanceof Blob);
-							const file = new File([result], "img.webp", {
-								type: "image/webp",
-							});
-
-							setAvatarImg(file);
-						},
-						error(err) {
-							logger.error(err.message);
-						},
-					});
-				}}
-			/>
-			{avatarImg && (
-				<div className="mt-4 stack horizontal md flex-wrap">
-					<img
-						src={URL.createObjectURL(avatarImg)}
-						alt=""
-						className={styles.avatarPreview}
-					/>
-				</div>
-			)}
-			<FormMessage type="info">
-				Note that for non-patrons there is a validation process before avatar is
-				shown.
-			</FormMessage>
-			{hasPreviousAvatar && (
-				<SendouButton
-					variant="minimal-destructive"
-					size="small"
-					onPress={() => setShowPrevious(true)}
-					className="mt-2"
-				>
-					Cancel changing avatar image
-				</SendouButton>
-			)}
-		</div>
-	);
-}
-
-function RankedToggle() {
-	const baseEvent = useBaseEvent();
-	const [isRanked, setIsRanked] = React.useState(
-		baseEvent?.tournament?.ctx.settings.isRanked ?? true,
-	);
-	const id = React.useId();
-
-	return (
-		<div>
-			<label htmlFor={id}>Ranked</label>
-			<SendouSwitch
-				name="isRanked"
-				id={id}
-				isSelected={isRanked}
-				onChange={setIsRanked}
-			/>
-			<FormMessage type="info">
-				Ranked tournaments affect SP. Tournaments that don&apos;t have open
-				registration (skill capped) or &quot;gimmick tournaments&quot; must
-				always be hosted as unranked. Any tournament hosted during off-season is
-				always unranked no matter what is chosen here.
-			</FormMessage>
-		</div>
-	);
-}
-
-function EnableNoScreenToggle() {
-	const baseEvent = useBaseEvent();
-	const [enableNoScreen, setEnableNoScreen] = React.useState(
-		baseEvent?.tournament?.ctx.settings.enableNoScreenToggle ?? true,
-	);
-	const id = React.useId();
-
-	return (
-		<div>
-			<label htmlFor={id}>Splattercolor Screen toggle</label>
-			<SendouSwitch
-				name="enableNoScreenToggle"
-				id={id}
-				isSelected={enableNoScreen}
-				onChange={setEnableNoScreen}
-			/>
-			<FormMessage type="info">
-				Ban Splattercolor Screen in matches depending on the teams' preferences.
-			</FormMessage>
-		</div>
-	);
-}
-
-function EnableSubsToggle() {
-	const baseEvent = useBaseEvent();
-	const [enableSubs, setEnableSubs] = React.useState(
-		baseEvent?.tournament?.ctx.settings.enableSubs ?? true,
-	);
-	const id = React.useId();
-
-	return (
-		<div>
-			<label htmlFor={id}>LFG tab</label>
-			<SendouSwitch
-				name="enableSubs"
-				id={id}
-				isSelected={enableSubs}
-				onChange={setEnableSubs}
-			/>
-			<FormMessage type="info">
-				Allow participants to look for more members via the LFG feature and sign
-				up as subs (after registration is closed).
-			</FormMessage>
-		</div>
-	);
-}
-
-function AutonomousSubsToggle() {
-	const baseEvent = useBaseEvent();
-	const [autonomousSubs, setAutonomousSubs] = React.useState(
-		baseEvent?.tournament?.ctx.settings.autonomousSubs ?? true,
-	);
-	const id = React.useId();
-
-	return (
-		<div>
-			<label htmlFor={id}>Autonomous subs</label>
-			<SendouSwitch
-				name="autonomousSubs"
-				id={id}
-				isSelected={autonomousSubs}
-				onChange={setAutonomousSubs}
-			/>
-			<FormMessage type="info">
-				If enabled teams can add subs on their own while the tournament is in
-				progress. When disabled needs to be done by the TO&apos;s.
-			</FormMessage>
-		</div>
-	);
-}
-
-function RequireIGNToggle() {
-	const baseEvent = useBaseEvent();
-	const [requireIGNs, setRequireIGNs] = React.useState(
-		baseEvent?.tournament?.ctx.settings.requireInGameNames ?? false,
-	);
-	const id = React.useId();
-
-	return (
-		<div>
-			<label htmlFor={id}>Require in-game names</label>
-			<SendouSwitch
-				name="requireInGameNames"
-				id={id}
-				isSelected={requireIGNs}
-				onChange={setRequireIGNs}
-			/>
-			<FormMessage type="info">
-				If enabled players can&apos;t join the tournament without an in-game
-				name (e.g. Sendou#1234). Players can&apos;t change the IGNs after the
-				registration closes.
-			</FormMessage>
-		</div>
-	);
-}
-
-function InvitationalToggle({
-	isInvitational,
-	setIsInvitational,
-}: {
-	isInvitational: boolean;
-	setIsInvitational: (value: boolean) => void;
-}) {
-	const id = React.useId();
-
-	return (
-		<div>
-			<label htmlFor={id}>Invitational</label>
-			<SendouSwitch
-				name="isInvitational"
-				id={id}
-				isSelected={isInvitational}
-				onChange={setIsInvitational}
-			/>
-			<FormMessage type="info">
-				No open registration or subs list. All teams must be added by the
-				organizer.
-			</FormMessage>
-		</div>
-	);
-}
-
-function TestToggle() {
-	const baseEvent = useBaseEvent();
-	const [isTest, setIsTest] = React.useState(
-		baseEvent?.tournament?.ctx.settings.isTest ?? false,
-	);
-	const id = React.useId();
-
-	return (
-		<div>
-			<label htmlFor={id}>Test</label>
-			<SendouSwitch
-				name="isTest"
-				id={id}
-				isSelected={isTest}
-				onChange={setIsTest}
-			/>
-			<FormMessage type="info">
-				Test tournaments don't appear on the calendar, don't send notifications
-				to players, and won't show up in players' profiles or results
-			</FormMessage>
-		</div>
-	);
-}
-
-function DraftToggle() {
-	const { t } = useTranslation(["calendar"]);
-	const { eventToEdit } = useLoaderData<typeof loader>();
-	const baseEvent = useBaseEvent();
-	const [isDraft, setIsDraft] = React.useState(
-		baseEvent?.tournament?.ctx.settings.isDraft ?? false,
-	);
-	const id = React.useId();
-
-	// once a tournament is published, it can't be flipped back to draft (users may have already saved it)
-	if (eventToEdit && !eventToEdit.tournament?.ctx.settings.isDraft) {
-		return null;
-	}
-
-	return (
-		<div>
-			<label htmlFor={id}>{t("calendar:forms.draft")}</label>
-			<SendouSwitch
-				name="isDraft"
-				id={id}
-				isSelected={isDraft}
-				onChange={setIsDraft}
-			/>
-			<FormMessage type="info">{t("calendar:forms.draftInfo")}</FormMessage>
-		</div>
-	);
-}
-
-function AdminOnlySettings() {
+	const { values } = useFormFieldContext();
 	const isAdmin = useHasRole("ADMIN");
 
-	if (!isAdmin) return null;
+	const isTournament = Boolean(values.toToolsEnabled);
+	const isEditing = Boolean(data.eventToEdit);
 
-	return <RequireSendouQParticipationToggle />;
-}
-
-function RequireSendouQParticipationToggle() {
-	const baseEvent = useBaseEvent();
-	const [requireSendouQParticipation, setRequireSendouQParticipation] =
-		React.useState(
-			baseEvent?.tournament?.ctx.settings.requireSendouQParticipation ?? false,
-		);
-	const id = React.useId();
+	const organizationOptions = data.organizations
+		.filter(
+			(org): org is Exclude<(typeof data.organizations)[number], string> =>
+				typeof org !== "string",
+		)
+		.map((org) => ({ value: String(org.id), label: org.name }));
 
 	return (
-		<div>
-			<label htmlFor={id}>Require SendouQ participation</label>
-			<SendouSwitch
-				name="requireSendouQParticipation"
-				id={id}
-				isSelected={requireSendouQParticipation}
-				onChange={setRequireSendouQParticipation}
-			/>
-			<FormMessage type="info">
-				Players must have played enough SendouQ matches this season to register
-			</FormMessage>
+		<div className="stack md">
+			<FormField name="name" />
+			<DescriptionField isTournament={isTournament} />
+			{data.organizations.length > 0 ? (
+				<FormField name="organizationId" options={organizationOptions} />
+			) : null}
+			{isTournament ? <FormField name="rules" /> : null}
+			{isTournament ? (
+				<FormField name="startTime" />
+			) : (
+				<FormField name="date" />
+			)}
+			{!isTournament ? <FormField name="bracketUrl" /> : null}
+			<FormField name="discordInviteCode" />
+			<FormField name="tags" />
+			{data.badgeOptions.length > 0 ? (
+				<FormField name="badges" options={data.badgeOptions} />
+			) : null}
+			{isTournament ? <FormField name="avatarImgId" /> : null}
+			{isTournament ? (
+				<>
+					<Divider smallText className="mt-4">
+						Tournament settings
+					</Divider>
+					<MemberCountFields />
+					<FormField name="regClosesAt" />
+					<FormField name="isRanked" />
+					<FormField name="enableNoScreenToggle" />
+					<FormField name="enableSubs" />
+					<FormField name="autonomousSubs" />
+					<FormField name="requireInGameNames" />
+					<FormField name="isInvitational" />
+					{!isEditing ? <FormField name="isTest" /> : null}
+					<DraftField />
+					{isAdmin ? <FormField name="requireSendouQParticipation" /> : null}
+				</>
+			) : null}
+			<MapsSection isTournament={isTournament} />
+			{isTournament ? <BracketProgressionField /> : null}
 		</div>
 	);
 }
 
-function RegClosesAtSelect() {
-	const baseEvent = useBaseEvent();
-	const [regClosesAt, setRegClosesAt] = React.useState<RegClosesAtOption>(
-		baseEvent?.tournament?.ctx.settings.regClosesAt
-			? datesToRegClosesAt({
-					startTime: databaseTimestampToDate(
-						baseEvent.tournament.ctx.startTime,
-					),
-					regClosesAt: databaseTimestampToDate(
-						baseEvent.tournament.ctx.settings.regClosesAt,
-					),
-				})
-			: "0",
-	);
-	const id = React.useId();
+function DescriptionField({ isTournament }: { isTournament: boolean }) {
+	const { t } = useTranslation(["forms"]);
 
 	return (
-		<div>
-			<label htmlFor={id}>Registration closes at</label>
-			<select
-				name="regClosesAt"
-				value={regClosesAt}
-				onChange={(e) => setRegClosesAt(e.target.value as RegClosesAtOption)}
-			>
-				{REG_CLOSES_AT_OPTIONS.map((option) => (
-					<option key={option} value={option}>
-						{regClosesAtToDisplayName(option)}
-					</option>
-				))}
-			</select>
-			<FormMessage type="info">
-				All times relative to the reported tournament start time e.g. &quot;30
-				minutes&quot; means &quot;30 minutes before event start time&quot;.
-				After registration closes only TO&apos;s can make changes to team
-				rosters.
-			</FormMessage>
+		<div className="stack xs">
+			<FormField name="description" />
+			{isTournament ? (
+				<FormMessage type="info">
+					{t("forms:bottomTexts.bioMarkdown")}
+				</FormMessage>
+			) : null}
 		</div>
 	);
 }
 
-const mapPickingStyleToShort: Record<
-	Tables["Tournament"]["mapPickingStyle"],
-	"ALL" | "TO" | RankedModeShort
-> = {
-	TO: "TO",
-	AUTO_ALL: "ALL",
-	AUTO_SZ: "SZ",
-	AUTO_TC: "TC",
-	AUTO_RM: "RM",
-	AUTO_CB: "CB",
-};
-function TournamentMapPickingStyleSelect() {
-	const { t } = useTranslation(["common"]);
-	const id = React.useId();
-	const { eventToEdit } = useLoaderData<typeof loader>();
-	const baseEvent = useBaseEvent();
-	const [mode, setMode] = React.useState<"ALL" | "TO" | RankedModeShort>(
-		baseEvent?.mapPickingStyle
-			? mapPickingStyleToShort[baseEvent.mapPickingStyle]
-			: "ALL",
-	);
-	const [mapPool, setMapPool] = React.useState<MapPool>(
-		baseEvent?.mapPool ? new MapPool(baseEvent.mapPool) : MapPool.EMPTY,
-	);
+function MemberCountFields() {
+	const { values } = useFormFieldContext();
 
-	// can't change toToolsMode in editing
-	// and also can't change tiebreaker maps in editing
-	// because otherwise some team's picks that they already made
-	// might start to overlap with tiebreaker maps
-	if (eventToEdit && mode !== "TO") {
+	return (
+		<>
+			<FormField name="minMembersPerTeam" />
+			{values.minMembersPerTeam === "4" ? (
+				<FormField name="maxMembersPerTeam" />
+			) : null}
+		</>
+	);
+}
+
+function DraftField() {
+	const data = useLoaderData<typeof loader>();
+
+	// once a tournament is published, it can't be flipped back to draft (users may have already saved it)
+	if (data.eventToEdit && !data.eventToEdit.tournament?.ctx.settings.isDraft) {
 		return null;
 	}
 
+	return <FormField name="isDraft" />;
+}
+
+function MapsSection({ isTournament }: { isTournament: boolean }) {
+	const { values, setValue } = useFormFieldContext();
+	const data = useLoaderData<typeof loader>();
+	const mode = values.toToolsMode as "ALL" | "TO" | RankedModeShort;
+
+	// reset the (polymorphic) pool when switching map picking style so a previous
+	// mode's maps don't leak into the new one
+	const previousMode = React.useRef(mode);
+	React.useEffect(() => {
+		if (previousMode.current === mode) return;
+		previousMode.current = mode;
+		setValue("pool", "");
+	}, [mode, setValue]);
+
+	if (!isTournament) {
+		return <CalendarMapPoolField />;
+	}
+
+	const isEditing = Boolean(data.eventToEdit);
+
+	// can't change map picking style after creation
+	if (isEditing) {
+		if (mode !== "TO") return null;
+
+		return (
+			<div className="stack md w-full">
+				<Divider smallText className="mt-4">
+					Tournament maps
+				</Divider>
+				<TournamentMapPoolField />
+			</div>
+		);
+	}
+
 	return (
 		<div className="stack md w-full">
-			<Divider>Tournament maps</Divider>
-			<div>
-				<label htmlFor={id}>Map picking style</label>
-				<select
-					onChange={(e) => setMode(e.target.value as RankedModeShort)}
-					name="toToolsMode"
-					defaultValue={mode}
-					id={id}
-					disabled={Boolean(eventToEdit)}
-				>
-					<option value="ALL">Prepicked by teams - All modes</option>
-					<option value="SZ">Prepicked by teams - SZ only</option>
-					<option value="TC">Prepicked by teams - TC only</option>
-					<option value="RM">Prepicked by teams - RM only</option>
-					<option value="CB">Prepicked by teams - CB only</option>
-					<option value="TO">Picked by TO</option>
-				</select>
-			</div>
-			{mode === "ALL" ? <CounterPickMapPoolSection /> : null}
-			{mode === "TO" ? (
-				<>
-					<input type="hidden" name="pool" value={mapPool.serialized} />
+			<Divider smallText className="mt-4">
+				Tournament maps
+			</Divider>
+			<FormField name="toToolsMode" />
+			{mode === "ALL" ? <TiebreakerMapPoolField /> : null}
+			{mode === "TO" ? <TournamentMapPoolField /> : null}
+		</div>
+	);
+}
 
+function CalendarMapPoolField() {
+	const { t } = useTranslation(["common"]);
+	const baseEvent = useBaseEvent();
+	const [include, setInclude] = React.useState(Boolean(baseEvent?.mapPool));
+	const id = React.useId();
+
+	return (
+		<FormField name="pool">
+			{({ value, onChange }: CustomFieldRenderProps) => {
+				if (!include) {
+					return (
+						<div>
+							<label htmlFor={id}>{t("common:maps.mapPool")}</label>
+							<SendouButton
+								size="small"
+								variant="outlined"
+								id={id}
+								onPress={() => setInclude(true)}
+							>
+								{t("common:actions.add")}
+							</SendouButton>
+						</div>
+					);
+				}
+
+				const mapPool = value ? new MapPool(value as string) : MapPool.EMPTY;
+
+				return (
 					<MapPoolSelector
 						className="w-full"
 						mapPool={mapPool}
 						title={t("common:maps.mapPool")}
-						handleMapPoolChange={setMapPool}
+						handleRemoval={() => {
+							onChange("");
+							setInclude(false);
+						}}
+						handleMapPoolChange={(newPool) => onChange(newPool.serialized)}
 						allowBulkEdit
 					/>
-				</>
-			) : null}
-		</div>
+				);
+			}}
+		</FormField>
 	);
 }
 
-function MapPoolSection() {
-	const { t } = useTranslation(["game-misc", "common"]);
-
-	const baseEvent = useBaseEvent();
-	const [mapPool, setMapPool] = React.useState<MapPool>(
-		baseEvent?.mapPool ? new MapPool(baseEvent.mapPool) : MapPool.EMPTY,
-	);
-	const [includeMapPool, setIncludeMapPool] = React.useState(
-		Boolean(baseEvent?.mapPool),
-	);
-
-	const id = React.useId();
-
-	return includeMapPool ? (
-		<>
-			<input type="hidden" name="pool" value={mapPool.serialized} />
-
-			<MapPoolSelector
-				className="w-full"
-				mapPool={mapPool}
-				title={t("common:maps.mapPool")}
-				handleRemoval={() => setIncludeMapPool(false)}
-				handleMapPoolChange={setMapPool}
-				allowBulkEdit
-			/>
-		</>
-	) : (
-		<div>
-			<label htmlFor={id}>{t("common:maps.mapPool")}</label>
-			<AddButton onAdd={() => setIncludeMapPool(true)} id={id} />
-		</div>
-	);
-}
-
-function CounterPickMapPoolSection() {
+function TournamentMapPoolField() {
 	const { t } = useTranslation(["common"]);
-	const baseEvent = useBaseEvent();
-	const [mapPool, setMapPool] = React.useState<MapPool>(
-		baseEvent?.tieBreakerMapPool
-			? new MapPool(baseEvent.tieBreakerMapPool)
-			: MapPool.EMPTY,
-	);
 
 	return (
-		<>
-			<RequiredHiddenInput
-				value={mapPool.serialized}
-				name="pool"
-				isValid={validateTiebreakerMapPool(mapPool) === "VALID"}
-			/>
+		<FormField name="pool">
+			{({ value, onChange }: CustomFieldRenderProps) => {
+				const mapPool = value ? new MapPool(value as string) : MapPool.EMPTY;
 
-			<MapPoolSelector
-				className="w-full"
-				mapPool={mapPool}
-				handleMapPoolChange={setMapPool}
-				title={t("common:maps.tieBreakerMapPool")}
-				modesToInclude={["SZ", "TC", "RM", "CB"]}
-				hideBanned
-				info={
-					<div>
-						<MapPoolValidationStatusMessage
-							status={validateTiebreakerMapPool(mapPool)}
+				return (
+					<MapPoolSelector
+						className="w-full"
+						mapPool={mapPool}
+						title={t("common:maps.mapPool")}
+						handleMapPoolChange={(newPool) => onChange(newPool.serialized)}
+						allowBulkEdit
+					/>
+				);
+			}}
+		</FormField>
+	);
+}
+
+function TiebreakerMapPoolField() {
+	const { t } = useTranslation(["common"]);
+
+	return (
+		<FormField name="pool">
+			{({ value, onChange, error }: CustomFieldRenderProps) => {
+				const mapPool = value ? new MapPool(value as string) : MapPool.EMPTY;
+				const status = validateTiebreakerMapPool(mapPool);
+
+				return (
+					<>
+						<MapPoolSelector
+							className="w-full"
+							mapPool={mapPool}
+							title={t("common:maps.tieBreakerMapPool")}
+							modesToInclude={["SZ", "TC", "RM", "CB"]}
+							hideBanned
+							handleMapPoolChange={(newPool) => onChange(newPool.serialized)}
+							info={<MapPoolValidationStatusMessage status={status} />}
 						/>
-					</div>
-				}
-			/>
-		</>
+						{error ? (
+							<FormMessage id={errorMessageId("pool")} type="error">
+								{t(error as never)}
+							</FormMessage>
+						) : null}
+					</>
+				);
+			}}
+		</FormField>
+	);
+}
+
+function BracketProgressionField() {
+	const { t } = useTranslation();
+	const { values } = useFormFieldContext();
+	const baseEvent = useBaseEvent();
+
+	const initialBrackets = baseEvent?.tournament?.ctx.settings.bracketProgression
+		? Progression.validatedBracketsToInputFormat(
+				baseEvent.tournament.ctx.settings.bracketProgression,
+			)
+		: undefined;
+
+	return (
+		<div className="stack md w-full">
+			<Divider smallText className="mt-4">
+				Tournament format
+			</Divider>
+			<FormField name="bracketProgression">
+				{({ onChange, error }: CustomFieldRenderProps) => (
+					<>
+						<BracketProgressionSelector
+							initialBrackets={initialBrackets}
+							isInvitationalTournament={Boolean(values.isInvitational)}
+							onChange={onChange}
+							isTournamentInProgress={false}
+						/>
+						{error ? (
+							<FormMessage
+								id={errorMessageId("bracketProgression")}
+								type="error"
+							>
+								{t(error as never)}
+							</FormMessage>
+						) : null}
+					</>
+				)}
+			</FormField>
+		</div>
 	);
 }
 
@@ -1263,59 +589,3 @@ function MapPoolValidationStatusMessage({
 		</div>
 	);
 }
-
-function MemberCountSelect() {
-	const baseEvent = useBaseEvent();
-	const id = React.useId();
-	const [memberCount, setMemberCount] = React.useState(
-		baseEvent?.tournament?.ctx.settings.minMembersPerTeam ?? 4,
-	);
-
-	return (
-		<>
-			<div>
-				<label htmlFor={id}>Players count</label>
-				<select
-					id={id}
-					name="minMembersPerTeam"
-					value={memberCount}
-					onChange={(e) => setMemberCount(Number(e.target.value))}
-					className="input__extra-small"
-				>
-					{[4, 3, 2, 1].map((count) => (
-						<option key={count} value={count}>
-							{`${count}v${count}`}
-						</option>
-					))}
-				</select>
-			</div>
-			{memberCount === 4 ? <MaxTeamMemberCountInput /> : null}
-		</>
-	);
-}
-
-function MaxTeamMemberCountInput() {
-	const baseEvent = useBaseEvent();
-	const id = React.useId();
-
-	return (
-		<div>
-			<label htmlFor={id}>Max team size</label>
-			<input
-				type="number"
-				id={id}
-				name="maxMembersPerTeam"
-				min={4}
-				max={10}
-				defaultValue={
-					baseEvent?.tournament?.ctx.settings.maxMembersPerTeam ?? undefined
-				}
-				className="input__extra-small"
-			/>
-			<FormMessage type="info">
-				Maximum number of players that can be registered per team. Doesn't apply
-				to tournament organizers. Default is 6.
-			</FormMessage>
-		</div>
-	);
-}
diff --git a/app/features/tournament-admin/routes/to.$id.admin.brackets.tsx b/app/features/tournament-admin/routes/to.$id.admin.brackets.tsx
index 610a9b1e8..e7cdcd064 100644
--- a/app/features/tournament-admin/routes/to.$id.admin.brackets.tsx
+++ b/app/features/tournament-admin/routes/to.$id.admin.brackets.tsx
@@ -125,8 +125,9 @@ function BracketReset() {
 function BracketProgressionEdit() {
 	const tournament = useTournament();
 	const fetcher = useFetcher();
-	const [bracketProgressionErrored, setBracketProgressionErrored] =
-		React.useState(false);
+	const [bracketProgression, setBracketProgression] = React.useState<
+		Progression.ParsedBracket[] | null
+	>(tournament.ctx.settings.bracketProgression);
 
 	const disabledBracketIdxs = tournament.brackets
 		.filter((bracket) => !bracket.preview)
@@ -134,6 +135,13 @@ function BracketProgressionEdit() {
 
 	return (
 		<fetcher.Form method="post">
+			{bracketProgression ? (
+				<input
+					type="hidden"
+					name="bracketProgression"
+					value={JSON.stringify(bracketProgression)}
+				/>
+			) : null}
 			<BracketProgressionSelector
 				initialBrackets={Progression.validatedBracketsToInputFormat(
 					tournament.ctx.settings.bracketProgression,
@@ -142,13 +150,13 @@ function BracketProgressionEdit() {
 					disabled: disabledBracketIdxs.includes(idx),
 				}))}
 				isInvitationalTournament={tournament.isInvitational}
-				setErrored={setBracketProgressionErrored}
+				onChange={setBracketProgression}
 				isTournamentInProgress
 			/>
 			<div className="stack md horizontal justify-center mt-6">
 				<SubmitButton
 					_action="UPDATE_TOURNAMENT_PROGRESSION"
-					isDisabled={bracketProgressionErrored}
+					isDisabled={!bracketProgression}
 				>
 					Save changes
 				</SubmitButton>
diff --git a/app/form/SendouForm.tsx b/app/form/SendouForm.tsx
index 908ccd6f8..5f53b8961 100644
--- a/app/form/SendouForm.tsx
+++ b/app/form/SendouForm.tsx
@@ -4,6 +4,7 @@ import { flushSync } from "react-dom";
 import { useTranslation } from "react-i18next";
 import type { FetcherWithComponents } from "react-router";
 import { useFetcher, useLocation } from "react-router";
+import { isPlainObject } from "remeda";
 import type { z } from "zod";
 import { FormMessage } from "~/components/FormMessage";
 import { SubmitButton } from "~/components/SubmitButton";
@@ -632,10 +633,12 @@ function buildInitialValues<T extends z.ZodRawShape>(
 		const defaultValue = defaultValues?.[key as keyof typeof defaultValues];
 		if (defaultValue !== undefined) {
 			if (formField?.type === "array" && Array.isArray(defaultValue)) {
+				// only object-array (fieldset) items get a stable `_key`; spreading would
+				// collapse non-plain objects like `Date` into `{}`, so leave those intact
 				result[key] = (defaultValue as unknown[]).map((item) =>
-					typeof item === "object" && item !== null
+					isPlainObject(item)
 						? {
-								...(item as Record<string, unknown>),
+								...item,
 								_key: crypto.randomUUID(),
 							}
 						: item,
diff --git a/app/form/fields/ArrayFormField.module.css b/app/form/fields/ArrayFormField.module.css
index 36ea747e1..2f477af8a 100644
--- a/app/form/fields/ArrayFormField.module.css
+++ b/app/form/fields/ArrayFormField.module.css
@@ -35,4 +35,5 @@
 
 .removeButton {
 	height: var(--field-size);
+	align-self: flex-end;
 }
diff --git a/app/utils/dates.ts b/app/utils/dates.ts
index 522cfd2b5..453d2dfbf 100644
--- a/app/utils/dates.ts
+++ b/app/utils/dates.ts
@@ -197,18 +197,6 @@ function prefixZero(number: number) {
 	return number < 10 ? `0${number}` : number;
 }
 
-/**
- * Retrieves a new Date object that is offset by several hours.
- *
- * NOTE: it is important that we work with & return a copy of the date here,
- *  otherwise we will just be mutating the original date passed into this function.
- */
-export function getDateWithHoursOffset(date: Date, hoursOffset: number) {
-	const copiedDate = new Date(date.getTime());
-	copiedDate.setHours(date.getHours() + hoursOffset);
-	return copiedDate;
-}
-
 export function getDateAtNextFullHour(date: Date) {
 	const copiedDate = new Date(date.getTime());
 	if (
diff --git a/app/utils/remix.server.ts b/app/utils/remix.server.ts
index 4ed7a0e65..ba42a0fa8 100644
--- a/app/utils/remix.server.ts
+++ b/app/utils/remix.server.ts
@@ -1,15 +1,12 @@
 import type { FileUpload } from "@remix-run/form-data-parser";
 import { parseFormData as parseMultipartFormData } from "@remix-run/form-data-parser";
 import type { Namespace, TFunction } from "i18next";
-import { nanoid } from "nanoid";
 import type { Ok, Result } from "neverthrow";
 import type { Params, UIMatch } from "react-router";
 import { data, redirect } from "react-router";
 import type { z } from "zod";
 import type { navItems } from "~/components/layout/nav-items";
 import { ServerConfig } from "~/config.server";
-import { uploadStreamToS3 } from "~/features/img-upload/s3.server";
-import invariant from "./invariant";
 import { logger } from "./logger";
 
 export function notFoundIfFalsy<T>(value: T | null | undefined): T {
@@ -387,58 +384,3 @@ export async function safeParseMultipartFormData(
 		throw err;
 	}
 }
-
-export async function uploadImageIfSubmitted({
-	request,
-	fileNamePrefix,
-}: {
-	request: Request;
-	fileNamePrefix: string;
-}) {
-	const preDecidedFilename = `${fileNamePrefix}-${nanoid()}-${Date.now()}`;
-
-	const uploadHandler = async (fileUpload: FileUpload) => {
-		if (fileUpload.fieldName === "img") {
-			const [, ending] = fileUpload.name.split(".");
-			invariant(ending);
-			const newFilename = `${preDecidedFilename}.${ending}`;
-
-			const uploadedFileLocation = await uploadStreamToS3(
-				fileUpload.stream(),
-				newFilename,
-			);
-			return uploadedFileLocation;
-		}
-		return null;
-	};
-
-	let formData: FormData;
-
-	try {
-		formData = await safeParseMultipartFormData(request, uploadHandler);
-		const imgSrc = formData.get("img") as string | null;
-		if (!imgSrc) {
-			throw new TypeError("No image submitted");
-		}
-
-		const urlParts = imgSrc.split("/");
-		const fileName = urlParts[urlParts.length - 1];
-		invariant(fileName);
-
-		return {
-			avatarFileName: fileName,
-			formData,
-		};
-	} catch (err) {
-		// user did not submit image
-		if (err instanceof TypeError) {
-			return {
-				avatarFileName: undefined,
-				// @ts-expect-error: TODO: jank but temporary jank. Later lets refactor to a more general and robust way of sending images
-				formData,
-			};
-		}
-
-		throw err;
-	}
-}
diff --git a/e2e/calendar.spec.ts b/e2e/calendar.spec.ts
index 157118197..80e7ac641 100644
--- a/e2e/calendar.spec.ts
+++ b/e2e/calendar.spec.ts
@@ -1,6 +1,14 @@
 import type { Page } from "@playwright/test";
 import { NZAP_TEST_ID } from "~/db/seed/constants";
-import { calendarPage } from "~/utils/urls";
+import { calendarNewBaseSchema } from "~/features/calendar/calendar-new-schemas";
+import {
+	CALENDAR_NEW_PAGE,
+	calendarPage,
+	TOURNAMENT_NEW_PAGE,
+	tournamentBracketsPage,
+	tournamentInfoPage,
+	tournamentRulesPage,
+} from "~/utils/urls";
 import {
 	expect,
 	expectIsHydrated,
@@ -10,6 +18,56 @@ import {
 	seed,
 	test,
 } from "./helpers/playwright";
+import { createFormHelpers } from "./helpers/playwright-form";
+
+// the `date` datetime inputs use the array item's label ("Date"), not the
+// array's own label, so they're driven directly rather than via the form helper
+async function fillFirstDate(page: Page, date: Date) {
+	const fill = (segment: string, value: string) =>
+		page
+			.getByRole("spinbutton", { name: new RegExp(`^${segment}, Date`) })
+			.first()
+			.fill(value);
+
+	const hours = date.getHours();
+	await fill("year", String(date.getFullYear()));
+	await fill("month", String(date.getMonth() + 1));
+	await fill("day", String(date.getDate()));
+	await fill("hour", String(hours % 12 || 12));
+	await fill("minute", date.getMinutes().toString().padStart(2, "0"));
+	await fill("AM/PM", hours >= 12 ? "PM" : "AM");
+}
+
+// the TO map pool grid exposes each map as a mode button inside a group labelled
+// by its stage name, so a small pool is built by clicking a few of them
+async function fillBasicMapPool(
+	page: Page,
+	maps: Array<{ stage: string; mode: string }>,
+) {
+	for (const { stage, mode } of maps) {
+		await page
+			.getByRole("group", { name: stage })
+			.getByRole("button", { name: mode })
+			.click();
+	}
+}
+
+// a freshly added bracket is already a follow-up (sources default on), so it only
+// needs its name, format and source placements filled in
+async function addFollowUpBracket(
+	page: Page,
+	{
+		name,
+		format,
+		placements,
+	}: { name: string; format: string; placements: string },
+) {
+	await page.getByTestId("add-bracket-button").click();
+
+	await page.getByLabel("Bracket's name").last().fill(name);
+	await page.getByLabel("Format").last().selectOption(format);
+	await page.getByTestId("placements-input").last().fill(placements);
+}
 
 const SENDOU_INK_TOURNAMENTS_COUNT = 6;
 
@@ -140,4 +198,77 @@ test.describe("Calendar", () => {
 			await gb.context.close();
 		}
 	});
+
+	test("creates a new calendar event", async ({ page }) => {
+		await seed(page);
+		await impersonate(page);
+		await navigate({ page, url: CALENDAR_NEW_PAGE });
+
+		const form = createFormHelpers(page, calendarNewBaseSchema);
+
+		await form.fill("name", "Test Calendar Event");
+		await fillFirstDate(page, new Date(2027, 0, 15, 17, 0));
+		await form.fill("bracketUrl", "https://sendou.ink/test-bracket");
+
+		await form.submit();
+
+		await expect(page).toHaveURL(/\/calendar\/\d+/);
+	});
+
+	test("creates a new tournament with a map pool and follow-up bracket", async ({
+		page,
+	}) => {
+		await seed(page);
+		await impersonate(page);
+		await navigate({ page, url: TOURNAMENT_NEW_PAGE });
+
+		const form = createFormHelpers(page, calendarNewBaseSchema);
+
+		const startTime = new Date(2027, 0, 15, 17, 0);
+		const mapPool = [
+			{ stage: "Scorch Gorge", mode: "Splat Zones" },
+			{ stage: "Eeltail Alley", mode: "Tower Control" },
+			{ stage: "Hagglefish Market", mode: "Rainmaker" },
+		];
+
+		await form.fill("name", "Test Tournament");
+		await form.fill("description", "An automated test tournament");
+		await fillFirstDate(page, startTime);
+		await form.fill("discordInviteCode", "test-invite");
+
+		// flip a tournament setting away from its default
+		await form.check("requireInGameNames");
+
+		// "Picked by TO" allows an arbitrary map pool, unlike the validated tiebreaker modes
+		await form.select("toToolsMode", "TO");
+		await fillBasicMapPool(page, mapPool);
+
+		await addFollowUpBracket(page, {
+			name: "Underground bracket",
+			format: "Single-elimination",
+			placements: "-1",
+		});
+
+		await form.submit();
+
+		await expect(page).toHaveURL(/\/to\/\d+/);
+		const tournamentId = Number(page.url().match(/\/to\/(\d+)/)?.[1]);
+
+		// start time round-trips (match the machine-readable ISO so it's timezone-agnostic)
+		await navigate({ page, url: tournamentInfoPage(tournamentId) });
+		await expect(
+			page.locator(`time[datetime="${startTime.toISOString()}"]`).first(),
+		).toBeVisible();
+
+		// the follow-up bracket shows up (the tab label drops the "bracket" suffix)
+		await navigate({ page, url: tournamentBracketsPage({ tournamentId }) });
+		await expect(page.getByRole("tab", { name: "Underground" })).toBeVisible();
+
+		// the TO map pool round-trips onto the rules page
+		await navigate({ page, url: tournamentRulesPage(tournamentId) });
+		for (const { stage, mode } of mapPool) {
+			await expect(page.getByText(stage, { exact: true })).toBeVisible();
+			await expect(page.getByAltText(mode).first()).toBeVisible();
+		}
+	});
 });
diff --git a/e2e/helpers/playwright-form.ts b/e2e/helpers/playwright-form.ts
index 25d5ae8d1..ad49f0db0 100644
--- a/e2e/helpers/playwright-form.ts
+++ b/e2e/helpers/playwright-form.ts
@@ -92,6 +92,14 @@ export function createFormHelpers<T extends z.ZodRawShape>(
 		return resolveTranslation(metadata.label);
 	};
 
+	// match the whole label (allowing the trailing space and optional required " *" the
+	// Label component always renders) so a short label like "Name" doesn't also pick up
+	// "Bracket's name" or "Require in-game names"
+	const byLabel = (label: string) => {
+		const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		return page.getByLabel(new RegExp(`^${escaped} *\\*?$`, "i"));
+	};
+
 	const getItemLabel = (name: string, itemValue: string): string => {
 		const metadata = getFieldMetadata(name);
 		if (!metadata || !("items" in metadata) || !Array.isArray(metadata.items)) {
@@ -117,12 +125,12 @@ export function createFormHelpers<T extends z.ZodRawShape>(
 
 		async fill(name, value) {
 			const label = getLabel(String(name));
-			await page.getByLabel(label).fill(value);
+			await byLabel(label).fill(value);
 		},
 
 		async check(name) {
 			const label = getLabel(String(name));
-			const locator = page.getByLabel(label);
+			const locator = byLabel(label);
 			const isChecked = await locator.isChecked();
 			if (!isChecked) {
 				await locator.click({ force: true });
@@ -131,7 +139,7 @@ export function createFormHelpers<T extends z.ZodRawShape>(
 
 		async uncheck(name) {
 			const label = getLabel(String(name));
-			const locator = page.getByLabel(label);
+			const locator = byLabel(label);
 			const isChecked = await locator.isChecked();
 			if (isChecked) {
 				await locator.click({ force: true });
@@ -167,7 +175,7 @@ export function createFormHelpers<T extends z.ZodRawShape>(
 
 		async select(name, optionValue) {
 			const label = getLabel(String(name));
-			const locator = page.getByLabel(label);
+			const locator = byLabel(label);
 			const tagName = await locator.evaluate((el) => el.tagName.toLowerCase());
 
 			const metadata = getFieldMetadata(String(name));
diff --git a/e2e/org.spec.ts b/e2e/org.spec.ts
index 0cf13780b..81ab0462a 100644
--- a/e2e/org.spec.ts
+++ b/e2e/org.spec.ts
@@ -89,9 +89,7 @@ test.describe("Tournament Organization", () => {
 
 		await page.getByTestId("admin-tab").click();
 		await page.getByTestId("edit-event-info-button").click();
-		await expect(page.getByTestId("calendar-event-name-input")).toHaveValue(
-			"PICNIC #2",
-		);
+		await expect(page.getByLabel(/^Name *\*?$/)).toHaveValue("PICNIC #2");
 	});
 
 	test("banned player cannot join a tournament of that organization", async ({
diff --git a/locales/da/forms.json b/locales/da/forms.json
index 640b862c7..194137ba0 100644
--- a/locales/da/forms.json
+++ b/locales/da/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/de/forms.json b/locales/de/forms.json
index ec36e3319..1b8c8c1c4 100644
--- a/locales/de/forms.json
+++ b/locales/de/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/en/forms.json b/locales/en/forms.json
index 315dd0378..151516aee 100644
--- a/locales/en/forms.json
+++ b/locales/en/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "Reason for cancellation",
 	"bottomTexts.scrimCancelReasonHelp": "Explain why you are cancelling the scrim. This will be visible to the other team.",
 	"bottomTexts.bioMarkdown": "Supports Markdown",
+	"bottomTexts.tournamentStartTime": "Start times for additional brackets are set in the tournament format section below",
 	"labels.division": "Division",
 	"options.division.both": "Both divisions",
 	"options.division.tentatek": "Tentatek only",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "Checked in team can't go below the minimum roster size",
 	"regImportTeam": "Import team",
 	"labels.regImportSourceTournament": "Tournament",
-	"errors.regImportTournamentRequired": "Select a tournament"
+	"errors.regImportTournamentRequired": "Select a tournament",
+	"labels.organization": "Organization",
+	"labels.rules": "Rules",
+	"labels.dates": "Dates",
+	"labels.date": "Date",
+	"labels.bracketUrl": "Bracket URL",
+	"labels.discordInvite": "Discord server invite URL",
+	"labels.tags": "Tags",
+	"labels.badges": "Badge prizes",
+	"labels.regClosesAt": "Registration closes at",
+	"labels.playersCount": "Players count",
+	"labels.maxTeamSize": "Max team size",
+	"labels.ranked": "Ranked",
+	"labels.splattercolorScreenToggle": "Splattercolor Screen toggle",
+	"labels.lfgTab": "LFG tab",
+	"labels.autonomousSubs": "Autonomous subs",
+	"labels.requireInGameNames": "Require in-game names",
+	"labels.invitational": "Invitational",
+	"labels.test": "Test",
+	"labels.draft": "Draft",
+	"labels.requireSendouQ": "Require SendouQ participation",
+	"labels.mapPickingStyle": "Map picking style",
+	"bottomTexts.regClosesAt": "All times relative to the reported tournament start time e.g. \"30 minutes\" means \"30 minutes before event start time\". After registration closes only TO's can make changes to team rosters.",
+	"bottomTexts.maxTeamSize": "Maximum number of players that can be registered per team. Doesn't apply to tournament organizers. Default is 6.",
+	"bottomTexts.avatarValidation": "Note that for non-patrons there is a validation process before avatar is shown.",
+	"bottomTexts.ranked": "Ranked tournaments affect SP. Tournaments that don't have open registration (skill capped) or \"gimmick tournaments\" must always be hosted as unranked. Any tournament hosted during off-season is always unranked no matter what is chosen here.",
+	"bottomTexts.splattercolorScreen": "Ban Splattercolor Screen in matches depending on the teams' preferences.",
+	"bottomTexts.lfgTab": "Allow participants to look for more members via the LFG feature and sign up as subs (after registration is closed).",
+	"bottomTexts.autonomousSubs": "If enabled teams can add subs on their own while the tournament is in progress. When disabled needs to be done by the TO's.",
+	"bottomTexts.requireInGameNames": "If enabled players can't join the tournament without an in-game name (e.g. Sendou#1234). Players can't change the IGNs after the registration closes.",
+	"bottomTexts.invitational": "No open registration or subs list. All teams must be added by the organizer.",
+	"bottomTexts.test": "Test tournaments don't appear on the calendar, don't send notifications to players, and won't show up in players' profiles or results",
+	"bottomTexts.draftInfo": "Draft tournaments are hidden and only visible to organizers. The tournament must be opened (by disabling this toggle) before any bracket can be started.",
+	"bottomTexts.requireSendouQ": "Players must have played enough SendouQ matches this season to register",
+	"options.toToolsMode.ALL": "Prepicked by teams - All modes",
+	"options.toToolsMode.SZ": "Prepicked by teams - SZ only",
+	"options.toToolsMode.TC": "Prepicked by teams - TC only",
+	"options.toToolsMode.RM": "Prepicked by teams - RM only",
+	"options.toToolsMode.CB": "Prepicked by teams - CB only",
+	"options.toToolsMode.TO": "Picked by TO",
+	"options.regClosesAt.0": "At the start time",
+	"options.regClosesAt.5min": "5 minutes",
+	"options.regClosesAt.10min": "10 minutes",
+	"options.regClosesAt.15min": "15 minutes",
+	"options.regClosesAt.30min": "30 minutes",
+	"options.regClosesAt.1h": "1 hour",
+	"options.regClosesAt.1h30min": "1 hour 30 minutes",
+	"options.regClosesAt.2h": "2 hours",
+	"options.regClosesAt.3h": "3 hours",
+	"options.regClosesAt.6h": "6 hours",
+	"options.regClosesAt.12h": "12 hours",
+	"options.regClosesAt.18h": "18 hours",
+	"options.regClosesAt.24h": "24 hours",
+	"options.regClosesAt.48h": "48 hours",
+	"options.regClosesAt.72h": "72 hours",
+	"errors.allModePool": "Map pool must contain a map for each ranked mode if using \"Prepicked by teams - All modes\"",
+	"errors.bracketUrlRequired": "Bracket URL is required",
+	"errors.bracketProgressionRequired": "Bracket progression must be set for tournaments",
+	"errors.maxMembersRange": "Max team size must be between 4 and 10"
 }
diff --git a/locales/es-ES/forms.json b/locales/es-ES/forms.json
index 34f93f800..ff1ba5d0d 100644
--- a/locales/es-ES/forms.json
+++ b/locales/es-ES/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "Motivo de la cancelación",
 	"bottomTexts.scrimCancelReasonHelp": "Explica por qué cancelas el scrim. Esto será visible para el otro equipo.",
 	"bottomTexts.bioMarkdown": "Compatible con Markdown",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "División",
 	"options.division.both": "Ambas divisiones",
 	"options.division.tentatek": "Solo Tentatek",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/es-US/forms.json b/locales/es-US/forms.json
index 5c718f7e6..181832366 100644
--- a/locales/es-US/forms.json
+++ b/locales/es-US/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/fr-CA/forms.json b/locales/fr-CA/forms.json
index 98b6080f3..facafc2ef 100644
--- a/locales/fr-CA/forms.json
+++ b/locales/fr-CA/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/fr-EU/forms.json b/locales/fr-EU/forms.json
index c27d8ebb0..785f15b61 100644
--- a/locales/fr-EU/forms.json
+++ b/locales/fr-EU/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/he/forms.json b/locales/he/forms.json
index 43cafd36e..256be064a 100644
--- a/locales/he/forms.json
+++ b/locales/he/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/it/forms.json b/locales/it/forms.json
index 2d1879109..b5cd8f0cb 100644
--- a/locales/it/forms.json
+++ b/locales/it/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/ja/forms.json b/locales/ja/forms.json
index 6af7634ea..d85f459ac 100644
--- a/locales/ja/forms.json
+++ b/locales/ja/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/ko/forms.json b/locales/ko/forms.json
index ce6d6c06b..17c84137e 100644
--- a/locales/ko/forms.json
+++ b/locales/ko/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/nl/forms.json b/locales/nl/forms.json
index 12e7bf49a..74a437675 100644
--- a/locales/nl/forms.json
+++ b/locales/nl/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/pl/forms.json b/locales/pl/forms.json
index 17721ebaa..f4233b324 100644
--- a/locales/pl/forms.json
+++ b/locales/pl/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/pt-BR/forms.json b/locales/pt-BR/forms.json
index 2135d211a..5b44072c9 100644
--- a/locales/pt-BR/forms.json
+++ b/locales/pt-BR/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/ru/forms.json b/locales/ru/forms.json
index 22766854e..71c532518 100644
--- a/locales/ru/forms.json
+++ b/locales/ru/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "",
 	"bottomTexts.scrimCancelReasonHelp": "",
 	"bottomTexts.bioMarkdown": "",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "",
 	"options.division.both": "",
 	"options.division.tentatek": "",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "",
 	"regImportTeam": "",
 	"labels.regImportSourceTournament": "",
-	"errors.regImportTournamentRequired": ""
+	"errors.regImportTournamentRequired": "",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }
diff --git a/locales/zh/forms.json b/locales/zh/forms.json
index 341663624..1f72de2c7 100644
--- a/locales/zh/forms.json
+++ b/locales/zh/forms.json
@@ -214,6 +214,7 @@
 	"labels.scrimCancelReason": "取消原因",
 	"bottomTexts.scrimCancelReasonHelp": "请说明取消这场对抗战的原因。该内容将对另一支队伍公开。",
 	"bottomTexts.bioMarkdown": "支持 Markdown 语法",
+	"bottomTexts.tournamentStartTime": "",
 	"labels.division": "组别",
 	"options.division.both": "均可",
 	"options.division.tentatek": "仅限艾洛眼",
@@ -299,5 +300,63 @@
 	"errors.regCheckedInBelowMinRoster": "已签到的队伍，其名单人数不能低于最低限制",
 	"regImportTeam": "导入队伍",
 	"labels.regImportSourceTournament": "赛事",
-	"errors.regImportTournamentRequired": "请选择一个赛事"
+	"errors.regImportTournamentRequired": "请选择一个赛事",
+	"labels.organization": "",
+	"labels.rules": "",
+	"labels.dates": "",
+	"labels.date": "",
+	"labels.bracketUrl": "",
+	"labels.discordInvite": "",
+	"labels.tags": "",
+	"labels.badges": "",
+	"labels.regClosesAt": "",
+	"labels.playersCount": "",
+	"labels.maxTeamSize": "",
+	"labels.ranked": "",
+	"labels.splattercolorScreenToggle": "",
+	"labels.lfgTab": "",
+	"labels.autonomousSubs": "",
+	"labels.requireInGameNames": "",
+	"labels.invitational": "",
+	"labels.test": "",
+	"labels.draft": "",
+	"labels.requireSendouQ": "",
+	"labels.mapPickingStyle": "",
+	"bottomTexts.regClosesAt": "",
+	"bottomTexts.maxTeamSize": "",
+	"bottomTexts.avatarValidation": "",
+	"bottomTexts.ranked": "",
+	"bottomTexts.splattercolorScreen": "",
+	"bottomTexts.lfgTab": "",
+	"bottomTexts.autonomousSubs": "",
+	"bottomTexts.requireInGameNames": "",
+	"bottomTexts.invitational": "",
+	"bottomTexts.test": "",
+	"bottomTexts.draftInfo": "",
+	"bottomTexts.requireSendouQ": "",
+	"options.toToolsMode.ALL": "",
+	"options.toToolsMode.SZ": "",
+	"options.toToolsMode.TC": "",
+	"options.toToolsMode.RM": "",
+	"options.toToolsMode.CB": "",
+	"options.toToolsMode.TO": "",
+	"options.regClosesAt.0": "",
+	"options.regClosesAt.5min": "",
+	"options.regClosesAt.10min": "",
+	"options.regClosesAt.15min": "",
+	"options.regClosesAt.30min": "",
+	"options.regClosesAt.1h": "",
+	"options.regClosesAt.1h30min": "",
+	"options.regClosesAt.2h": "",
+	"options.regClosesAt.3h": "",
+	"options.regClosesAt.6h": "",
+	"options.regClosesAt.12h": "",
+	"options.regClosesAt.18h": "",
+	"options.regClosesAt.24h": "",
+	"options.regClosesAt.48h": "",
+	"options.regClosesAt.72h": "",
+	"errors.allModePool": "",
+	"errors.bracketUrlRequired": "",
+	"errors.bracketProgressionRequired": "",
+	"errors.maxMembersRange": ""
 }