diff --git a/apps/web/src/lib/components/match-page/IconBanner.svelte b/apps/web/src/lib/components/match-page/IconBanner.svelte
new file mode 100644
index 000000000..37d47d02d
--- /dev/null
+++ b/apps/web/src/lib/components/match-page/IconBanner.svelte
@@ -0,0 +1,81 @@
+
+
+
+ {@render icon()}
+
+ {#if subtitle}
+
{subtitle}
+ {/if}
+ {#if joinPool}
+ {@render joinInfo({ pool: joinPool, pass: joinPass, host })}
+ {/if}
+ {#if screenLegal !== undefined}
+ {@render screenNotice(screenLegal)}
+ {/if}
+ {#if topRight}
+
{@render topRight()}
+ {/if}
+
+
{m.q_match_action_selectWinner()}
+ {#if actionButtons}
+
{@render actionButtons()}
+ {/if}
+
+
+ {@render teamRadioOption(teams[0], "alpha", "winner-radio-1")}
+
+
+
+ {shortStageName(stageName(stageId))}
+
+ {@render teamRadioOption(teams[1], "bravo", "winner-radio-2")}
+
+
+ {#if withKo}
+
+
+
+ {/if}
+
+
+
+
+ {m.q_match_action_confirmSetEnding()}
+
+
+
+
+
+
+
+
+
+ {modeShortName(mode)} {stageName(stageId)}
+
+
{@render children?.()}
+
+ {#if joinPool}
+ {@render joinInfo({ pool: joinPool, pass: joinPass, host })}
+ {/if}
+ {#if screenLegal !== undefined}
+ {@render screenNotice(screenLegal)}
+ {/if}
+
+
+
{m.q_match_pool()}
+
{pool}
+
+ {#if pass}
+
+
{m.q_match_password_short()}
+
{pass}
+
+ {/if}
+ {#if host}
+
+ {/if}
+
{@render children()}
+
+
diff --git a/apps/web/src/lib/components/match-page/MatchBannerScheduledTime.svelte b/apps/web/src/lib/components/match-page/MatchBannerScheduledTime.svelte
new file mode 100644
index 000000000..8f7de2d9b
--- /dev/null
+++ b/apps/web/src/lib/components/match-page/MatchBannerScheduledTime.svelte
@@ -0,0 +1,20 @@
+
+
+
diff --git a/apps/web/src/lib/components/match-page/MatchBannerTopRow.svelte b/apps/web/src/lib/components/match-page/MatchBannerTopRow.svelte
new file mode 100644
index 000000000..da88aaa7c
--- /dev/null
+++ b/apps/web/src/lib/components/match-page/MatchBannerTopRow.svelte
@@ -0,0 +1,63 @@
+
+
+
+ {#if score}
+ {@render scoreDisplay(score)}
+ {:else}
+
+ {/if}
+ {@render children?.()}
+
+
+ {score.alpha}-{score.bravo}
+
+
+ {#if score.isFinal}
+ {m.q_match_banner_final()}
+ {:else if score.count !== undefined}
+ {score.bestOf
+ ? m.q_match_banner_bestOf({ count: score.count })
+ : m.q_match_banner_playAll({ count: score.count })}
+ {/if}
+
+
{@render children?.()}
+
+
diff --git a/apps/web/src/lib/components/match-page/MatchPageHeader.svelte b/apps/web/src/lib/components/match-page/MatchPageHeader.svelte
new file mode 100644
index 000000000..366f66116
--- /dev/null
+++ b/apps/web/src/lib/components/match-page/MatchPageHeader.svelte
@@ -0,0 +1,36 @@
+
+
+
+
+
{@render children()}
+
{subtitle}
+
+ {#if topRight}
{@render topRight()}
{/if}
+
+ {@render teamRoster(teams[0], "alpha")}
+
+ {@render teamRoster(teams[1], "bravo")}
+
+ {@render teamHeader(team, side)}
+ {#if team.members.length > 0}
+
+ {#each team.members as member (member.id)}
+ -
+ {@render rosterMemberLink(member)}
+
+
+ {/each}
+
+ {/if}
+
+ {member.username}
+ {#if member.inGameName}
+ {member.inGameName}
+ {/if}
+
+
+
+{/snippet}
+
+
diff --git a/apps/web/src/lib/components/match-page/MatchTabs.svelte b/apps/web/src/lib/components/match-page/MatchTabs.svelte
new file mode 100644
index 000000000..94d549378
--- /dev/null
+++ b/apps/web/src/lib/components/match-page/MatchTabs.svelte
@@ -0,0 +1,72 @@
+
+
+
+ params.set({ tab: key as MatchTabsKey })}
+ disappearing={false}
+ padded={false}
+ >
+
+ {#each tabs as tab (tab)}
+ {@const Icon = TAB_ICONS[tab]}
+
+ {#snippet icon()}{/snippet}
+ {TAB_LABELS[tab]()}
+
+ {/each}
+
+
+ {@render children()}
+
+
+
+
diff --git a/apps/web/src/lib/components/match-page/MatchTimeline.svelte b/apps/web/src/lib/components/match-page/MatchTimeline.svelte
new file mode 100644
index 000000000..fe7d2a953
--- /dev/null
+++ b/apps/web/src/lib/components/match-page/MatchTimeline.svelte
@@ -0,0 +1,458 @@
+
+
+
+
+
+ {@render timelineHeader()}
+ {#if !compact}
+ {#each maps as map, i (`${map.timestamp}-${i}`)}
+ {@const previousMap = maps[i - 1]}
+ {@const substitutions = previousMap
+ ? inferSubstitutions(previousMap.rosters, map.rosters)
+ : []}
+
+ {#each substitutions as substitution (`${substitution.playerOut.id}-${substitution.playerIn.id}`)}
+ {@render timelineSubstitutionRow(substitution)}
+ {/each}
+ {@render timelineMapRow(map)}
+
+ {/each}
+ {/if}
+
+
+ {@render sideResult(
+ map.winner === "ALPHA" ? "WIN" : "LOSS",
+ map.ko && map.winner === "ALPHA",
+ )}
+
+
+
+
+
+
+ {shortStageName(stageName(map.stageId))}
+
+
+
+ {@render sideResult(
+ map.winner === "BRAVO" ? "WIN" : "LOSS",
+ map.ko && map.winner === "BRAVO",
+ )}
+
+
+
+
+{/snippet}
+
+{#snippet explainerIcon(icon: Snippet, description: string)}
+
+ {#snippet trigger(triggerProps)}
+
+ {/snippet}
+ {description}
+
+{/snippet}
+
+{#snippet substitutionIcon()}
+
+{/snippet}
+
+{#snippet timelineSubstitutionRow(substitution: InferredSubstitution)}
+
+
+ {#if substitution.side === "ALPHA"}
+ {@render substitutionDetail(substitution)}
+ {/if}
+
+
+ {@render explainerIcon(
+ substitutionIcon,
+ m.q_match_timeline_explainer_substitution(),
+ )}
+
+
+ {#if substitution.side === "BRAVO"}
+ {@render substitutionDetail(substitution)}
+ {/if}
+
+
+
{m.q_match_timeline_out()}
+
+
+
+ {substitution.playerOut.username}
+
+
+
{m.q_match_timeline_in()}
+
+
+
+ {substitution.playerIn.username}
+
+
+
+
+
+{:else}
+
+ {#if collapsible}
+
+ {/if}
+ {@render children()}
+
+{/if}
+
+
diff --git a/apps/web/src/lib/components/match-page/match-page-constants.ts b/apps/web/src/lib/components/match-page/match-page-constants.ts
new file mode 100644
index 000000000..983056e13
--- /dev/null
+++ b/apps/web/src/lib/components/match-page/match-page-constants.ts
@@ -0,0 +1,17 @@
+export const TAB_KEYS = {
+ ROSTERS: "rosters",
+ ACTION: "action",
+ RESULT: "result",
+ STATS: "stats",
+ ADMIN: "admin",
+} as const;
+
+export const MATCH_PAGE_TABS = [
+ "rosters",
+ "action",
+ "result",
+ "stats",
+ "admin",
+] as const;
+
+export type MatchTabsKey = (typeof TAB_KEYS)[keyof typeof TAB_KEYS];
diff --git a/apps/web/src/lib/components/match-page/match-page-search-params.test.ts b/apps/web/src/lib/components/match-page/match-page-search-params.test.ts
new file mode 100644
index 000000000..0a4a4cd83
--- /dev/null
+++ b/apps/web/src/lib/components/match-page/match-page-search-params.test.ts
@@ -0,0 +1,19 @@
+import { describe, expect, test } from "vitest";
+import { assertRoundTrips } from "#lib/modules/search-params/search-params-test-utils.ts";
+import { matchPageSearchParams } from "./match-page-search-params.ts";
+
+describe("matchPageSearchParams", () => {
+ test("round-trips representative values", () => {
+ assertRoundTrips(matchPageSearchParams, {
+ tab: [null, "rosters", "action", "result", "stats", "admin"],
+ });
+ });
+
+ test("decodes garbage to defaults", () => {
+ const parsed = matchPageSearchParams.parse(
+ new URLSearchParams("tab=nonsense"),
+ );
+
+ expect(parsed).toEqual({ tab: null });
+ });
+});
diff --git a/apps/web/src/lib/components/match-page/match-page-search-params.ts b/apps/web/src/lib/components/match-page/match-page-search-params.ts
new file mode 100644
index 000000000..8ca617195
--- /dev/null
+++ b/apps/web/src/lib/components/match-page/match-page-search-params.ts
@@ -0,0 +1,8 @@
+import * as v from "valibot";
+import * as SearchParams from "#lib/modules/search-params/search-params.ts";
+import { SP } from "#lib/modules/search-params/search-params.ts";
+import { MATCH_PAGE_TABS } from "./match-page-constants.ts";
+
+export const matchPageSearchParams = SearchParams.define({
+ tab: SP.param(v.nullable(v.picklist(MATCH_PAGE_TABS)), {}),
+});
diff --git a/apps/web/src/lib/components/match-page/match-page-utils.test.ts b/apps/web/src/lib/components/match-page/match-page-utils.test.ts
new file mode 100644
index 000000000..761da142a
--- /dev/null
+++ b/apps/web/src/lib/components/match-page/match-page-utils.test.ts
@@ -0,0 +1,142 @@
+import { describe, expect, test } from "vitest";
+import type { CommonUser } from "#lib/server/kysely.ts";
+import { inferSubstitutions, resolveRoomPass } from "./match-page-utils.ts";
+
+function user(id: number): CommonUser {
+ return {
+ id,
+ username: `user${id}`,
+ discordId: `discord${id}`,
+ discordAvatar: null,
+ customUrl: null,
+ customAvatarUrl: null,
+ };
+}
+
+describe("inferSubstitutions", () => {
+ test("returns an empty array when rosters are unchanged", () => {
+ const rosters = {
+ alpha: [user(1), user(2), user(3), user(4)],
+ bravo: [user(5), user(6), user(7), user(8)],
+ };
+
+ expect(inferSubstitutions(rosters, rosters)).toEqual([]);
+ });
+
+ test("detects a single substitution on alpha", () => {
+ const previous = {
+ alpha: [user(1), user(2), user(3), user(4)],
+ bravo: [user(5), user(6), user(7), user(8)],
+ };
+ const current = {
+ alpha: [user(1), user(2), user(3), user(9)],
+ bravo: previous.bravo,
+ };
+
+ expect(inferSubstitutions(previous, current)).toEqual([
+ { side: "ALPHA", playerOut: user(4), playerIn: user(9) },
+ ]);
+ });
+
+ test("detects substitutions on both sides in the same map transition", () => {
+ const previous = {
+ alpha: [user(1), user(2)],
+ bravo: [user(3), user(4)],
+ };
+ const current = {
+ alpha: [user(1), user(10)],
+ bravo: [user(11), user(4)],
+ };
+
+ expect(inferSubstitutions(previous, current)).toEqual([
+ { side: "ALPHA", playerOut: user(2), playerIn: user(10) },
+ { side: "BRAVO", playerOut: user(3), playerIn: user(11) },
+ ]);
+ });
+
+ test("pairs multiple substitutions on the same side by roster order", () => {
+ const previous = {
+ alpha: [user(1), user(2), user(3), user(4)],
+ bravo: [user(5), user(6)],
+ };
+ const current = {
+ alpha: [user(1), user(10), user(3), user(11)],
+ bravo: previous.bravo,
+ };
+
+ expect(inferSubstitutions(previous, current)).toEqual([
+ { side: "ALPHA", playerOut: user(2), playerIn: user(10) },
+ { side: "ALPHA", playerOut: user(4), playerIn: user(11) },
+ ]);
+ });
+
+ test("ignores unpaired leavers when no new player joined", () => {
+ const previous = {
+ alpha: [user(1), user(2), user(3), user(4)],
+ bravo: [user(5), user(6)],
+ };
+ const current = {
+ alpha: [user(1), user(2), user(3)],
+ bravo: previous.bravo,
+ };
+
+ expect(inferSubstitutions(previous, current)).toEqual([]);
+ });
+
+ test("ignores unpaired joiners when no player left", () => {
+ const previous = {
+ alpha: [user(1), user(2), user(3)],
+ bravo: [user(5), user(6)],
+ };
+ const current = {
+ alpha: [user(1), user(2), user(3), user(9)],
+ bravo: previous.bravo,
+ };
+
+ expect(inferSubstitutions(previous, current)).toEqual([]);
+ });
+
+ test("treats players switching sides as separate substitutions on each side", () => {
+ const previous = {
+ alpha: [user(1), user(2)],
+ bravo: [user(3), user(4)],
+ };
+ const current = {
+ alpha: [user(3), user(4)],
+ bravo: [user(1), user(2)],
+ };
+
+ expect(inferSubstitutions(previous, current)).toEqual([
+ { side: "ALPHA", playerOut: user(1), playerIn: user(3) },
+ { side: "ALPHA", playerOut: user(2), playerIn: user(4) },
+ { side: "BRAVO", playerOut: user(3), playerIn: user(1) },
+ { side: "BRAVO", playerOut: user(4), playerIn: user(2) },
+ ]);
+ });
+});
+
+describe("resolveRoomPass", () => {
+ test("returns a 4-digit password", () => {
+ const pass = resolveRoomPass(12345);
+
+ expect(pass).toMatch(/^\d{4}$/);
+ });
+
+ test("returns deterministic password for a given numeric seed", () => {
+ const pass1 = resolveRoomPass(12345);
+ const pass2 = resolveRoomPass(12345);
+ expect(pass1).toBe(pass2);
+ });
+
+ test("returns deterministic password for a given string seed", () => {
+ const pass1 = resolveRoomPass("test-seed");
+ const pass2 = resolveRoomPass("test-seed");
+ expect(pass1).toBe(pass2);
+ });
+
+ test("returns different passwords for different seeds", () => {
+ const pass1 = resolveRoomPass(1);
+ const pass2 = resolveRoomPass(2);
+ expect(pass1).not.toBe(pass2);
+ });
+});
diff --git a/apps/web/src/lib/components/match-page/match-page-utils.ts b/apps/web/src/lib/components/match-page/match-page-utils.ts
new file mode 100644
index 000000000..463cc7808
--- /dev/null
+++ b/apps/web/src/lib/components/match-page/match-page-utils.ts
@@ -0,0 +1,83 @@
+import { seededRandom } from "@sendou/utils/random";
+import * as R from "remeda";
+import type { CommonUser } from "#lib/server/kysely.ts";
+
+type MatchSide = "ALPHA" | "BRAVO";
+
+type Rosters = {
+ alpha: CommonUser[];
+ bravo: CommonUser[];
+};
+
+export interface InferredSubstitution {
+ side: MatchSide;
+ playerOut: CommonUser;
+ playerIn: CommonUser;
+}
+
+/**
+ * Compares the rosters of two consecutive maps and pairs up any
+ * players that dropped from a side with new players that joined the same side.
+ * The pairs are returned in roster order, so the first player out is paired with
+ * the first new player in. When the counts don't match, unpaired players are ignored.
+ */
+export function inferSubstitutions(
+ previousRosters: Rosters,
+ currentRosters: Rosters,
+): InferredSubstitution[] {
+ const result: InferredSubstitution[] = [];
+
+ for (const side of ["alpha", "bravo"] as const) {
+ const prevIds = new Set(previousRosters[side].map((u) => u.id));
+ const currIds = new Set(currentRosters[side].map((u) => u.id));
+
+ const out = previousRosters[side].filter((u) => !currIds.has(u.id));
+ const inn = currentRosters[side].filter((u) => !prevIds.has(u.id));
+
+ for (const [playerOut, playerIn] of R.zip(out, inn)) {
+ result.push({
+ side: side === "alpha" ? "ALPHA" : "BRAVO",
+ playerOut,
+ playerIn,
+ });
+ }
+ }
+
+ return result;
+}
+
+const NUM_MAP = {
+ "1": ["1", "2", "4"],
+ "2": ["2", "1", "3", "5"],
+ "3": ["3", "2", "6"],
+ "4": ["4", "1", "5", "7"],
+ "5": ["5", "2", "4", "6", "8"],
+ "6": ["6", "3", "5", "9"],
+ "7": ["7", "4", "8"],
+ "8": ["8", "7", "5", "9", "0"],
+ "9": ["9", "6", "8"],
+ "0": ["0", "8"],
+};
+
+/**
+ * Generates a deterministic 4-digit Splatoon private battle room password based on the provided seed.
+ *
+ * Given the same seed, this function will always return the same password.
+ */
+export function resolveRoomPass(seed: number | string) {
+ let pass = "5";
+ for (let i = 0; i < 3; i++) {
+ const { seededShuffle } = seededRandom(`${seed}-${i}`);
+
+ const key = pass[i] as keyof typeof NUM_MAP;
+ const opts = NUM_MAP[key];
+ const next = seededShuffle(opts)[0];
+ pass += next;
+ }
+
+ // prevent 5555 since many use it as a default pass
+ // making it a bit more common guess
+ if (pass === "5555") return "5800";
+
+ return pass;
+}
diff --git a/apps/web/src/lib/db/tables-json.ts b/apps/web/src/lib/db/tables-json.ts
index 9b4c0cf77..8b3fa9283 100644
--- a/apps/web/src/lib/db/tables-json.ts
+++ b/apps/web/src/lib/db/tables-json.ts
@@ -4,11 +4,14 @@
* so client code can import the types without touching server modules.
*/
+import type { ScrimFilters } from "#lib/features/scrims/scrims-types.ts";
+
export type XRankPlacementRegion = "WEST" | "JPN";
export interface UserPreferences {
disableBuildAbilitySorting?: boolean;
disallowScrimPickupsFromUntrusted?: boolean;
+ defaultScrimsFilters?: ScrimFilters;
/**
* What time format the user prefers?
*
diff --git a/apps/web/src/lib/features/chat/chat-state.svelte.ts b/apps/web/src/lib/features/chat/chat-state.svelte.ts
new file mode 100644
index 000000000..a687a6070
--- /dev/null
+++ b/apps/web/src/lib/features/chat/chat-state.svelte.ts
@@ -0,0 +1,24 @@
+/**
+ * Client-side chat UI state shared between the layout (sidebar/mobile panel)
+ * and pages that carry a chat room (e.g. a booked scrim). Written only from
+ * client-side lifecycles, so the module-level state can't leak between
+ * server-rendered requests.
+ */
+
+class ChatUiState {
+ /** Whether the desktop chat sidebar is open. */
+ sidebarOpen = $state(false);
+ /** The room the current route belongs to (a scrim page sets this on mount). */
+ routeChatRoomId = $state(null);
+ /** The room opened in the sidebar's single-room view. */
+ openRoomId = $state(null);
+
+ toggleSidebar() {
+ this.sidebarOpen = !this.sidebarOpen;
+ if (this.sidebarOpen && this.routeChatRoomId !== null) {
+ this.openRoomId = this.routeChatRoomId;
+ }
+ }
+}
+
+export const chatUi = new ChatUiState();
diff --git a/apps/web/src/lib/features/chat/chat.remote.ts b/apps/web/src/lib/features/chat/chat.remote.ts
new file mode 100644
index 000000000..e507d580e
--- /dev/null
+++ b/apps/web/src/lib/features/chat/chat.remote.ts
@@ -0,0 +1,152 @@
+import { error } from "@sveltejs/kit";
+import * as v from "valibot";
+import { getUser, requireUser } from "#lib/features/auth/user.server.ts";
+import * as Events from "#lib/server/events.ts";
+import { id } from "#lib/utils/schemas.ts";
+import { command, query } from "$app/server";
+import { CHAT } from "./chat-constants.ts";
+import { publishChatRoom } from "./chat.server.ts";
+import { canSendToRoom, roomLifecycle } from "./chat-utils.ts";
+import * as ChatRepository from "./ChatRepository.server.ts";
+
+/**
+ * A room's message stream: yields a fresh snapshot (messages, author display
+ * info, lifecycle) whenever anything about the room changes. Membership is
+ * checked server-side — knowing a room id is not enough to read it.
+ */
+export const getChatRoom = query.live(
+ v.object({ chatRoomId: id }),
+ async function* ({ chatRoomId }) {
+ const user = requireUser();
+ await requireRoomMember(chatRoomId, user);
+
+ yield await roomSnapshot(chatRoomId);
+
+ for await (const _ of Events.subscribe(
+ Events.chatRoomChannel(chatRoomId),
+ )) {
+ if (!(await ChatRepository.findRoomById(chatRoomId))) {
+ return;
+ }
+ yield await roomSnapshot(chatRoomId);
+ }
+ },
+);
+
+async function roomSnapshot(chatRoomId: number) {
+ const room = await ChatRepository.findRoomById(chatRoomId);
+ if (!room) error(404);
+
+ const messages = await ChatRepository.findMessagesByRoomId(chatRoomId);
+ const users = await ChatRepository.findChatUsersByUserIds([
+ ...new Set(
+ messages
+ .map((message) => message.userId)
+ .filter((userId) => userId !== null),
+ ),
+ ]);
+
+ return {
+ roomId: chatRoomId,
+ messages,
+ users,
+ lifecycle: roomLifecycle(room.inactiveAt),
+ };
+}
+
+/** The user's chat rooms with unseen counts, streamed live. */
+export const getChatRooms = query.live(async function* () {
+ const user = getUser();
+
+ if (!user) {
+ yield { rooms: [] };
+ return;
+ }
+
+ yield await roomsSnapshot(user.id);
+
+ for await (const _ of Events.subscribe(
+ Events.chatRoomsOfUserChannel(user.id),
+ )) {
+ yield await roomsSnapshot(user.id);
+ }
+});
+
+async function roomsSnapshot(userId: number) {
+ const rooms = await ChatRepository.findRoomsOfUser(userId);
+
+ return {
+ rooms: rooms.map((room) => ({
+ ...room,
+ unseenCount: room.unseenCount ?? 0,
+ lifecycle: roomLifecycle(room.inactiveAt),
+ })),
+ };
+}
+
+export const sendChatMessage = command(
+ v.object({
+ chatRoomId: id,
+ contents: v.pipe(
+ v.string(),
+ v.trim(),
+ v.minLength(1),
+ v.maxLength(CHAT.MESSAGE_MAX_LENGTH),
+ ),
+ }),
+ async ({ chatRoomId, contents }) => {
+ const user = requireUser();
+ const room = await requireRoomMember(chatRoomId, user);
+
+ if (!canSendToRoom(roomLifecycle(room.inactiveAt))) {
+ error(400, "Room is archived");
+ }
+
+ const message = await ChatRepository.insertMessage({
+ chatRoomId,
+ userId: user.id,
+ contents,
+ });
+ // the sender has obviously seen their own message
+ await ChatRepository.upsertRead({
+ chatRoomId,
+ userId: user.id,
+ lastSeenMessageId: message.id,
+ });
+
+ await publishChatRoom(chatRoomId);
+ },
+);
+
+/** Moves the reader's unseen marker up to the given message. */
+export const markChatRoomRead = command(
+ v.object({ chatRoomId: id, lastSeenMessageId: id }),
+ async ({ chatRoomId, lastSeenMessageId }) => {
+ const user = requireUser();
+ await requireRoomMember(chatRoomId, user);
+
+ await ChatRepository.upsertRead({
+ chatRoomId,
+ userId: user.id,
+ lastSeenMessageId,
+ });
+
+ // other tabs of the same user drop their unseen badge too
+ Events.publish(Events.chatRoomsOfUserChannel(user.id));
+ },
+);
+
+async function requireRoomMember(
+ chatRoomId: number,
+ user: { id: number; roles: string[] },
+) {
+ const room = await ChatRepository.findRoomById(chatRoomId);
+ if (!room) error(404, "Chat room not found");
+
+ const memberIds = await ChatRepository.findRoomMemberIds(chatRoomId);
+ if (!memberIds.includes(user.id) && !user.roles.includes("STAFF")) {
+ error(403, "Not a member of this chat room");
+ }
+
+ return room;
+}
diff --git a/apps/web/src/lib/features/chat/components/Chat.svelte b/apps/web/src/lib/features/chat/components/Chat.svelte
new file mode 100644
index 000000000..b9908d218
--- /dev/null
+++ b/apps/web/src/lib/features/chat/components/Chat.svelte
@@ -0,0 +1,318 @@
+
+
+
+
+
diff --git a/apps/web/src/lib/features/chat/components/ChatSidebar.svelte b/apps/web/src/lib/features/chat/components/ChatSidebar.svelte
new file mode 100644
index 000000000..22399f39b
--- /dev/null
+++ b/apps/web/src/lib/features/chat/components/ChatSidebar.svelte
@@ -0,0 +1,397 @@
+
+
+
+
+{#snippet roomItem(room: (typeof rooms)[number])}
+
+{/snippet}
+
+
diff --git a/apps/web/src/lib/features/friends/FriendRepository.server.ts b/apps/web/src/lib/features/friends/FriendRepository.server.ts
index 7e67ebd9d..bca7b121f 100644
--- a/apps/web/src/lib/features/friends/FriendRepository.server.ts
+++ b/apps/web/src/lib/features/friends/FriendRepository.server.ts
@@ -151,3 +151,112 @@ export async function findFriendIds(userId: number): Promise {
return rows.map((row) => row.friendId);
}
+
+/**
+ * The pending friend request between the two users regardless of direction, or `undefined` when
+ * there is none.
+ */
+export async function findFriendRequestBetween({
+ senderId,
+ receiverId,
+}: {
+ senderId: number;
+ receiverId: number;
+}) {
+ return db
+ .selectFrom("FriendRequest")
+ .select(["FriendRequest.id", "FriendRequest.senderId"])
+ .where((eb) =>
+ eb.or([
+ eb.and([
+ eb("FriendRequest.senderId", "=", senderId),
+ eb("FriendRequest.receiverId", "=", receiverId),
+ ]),
+ eb.and([
+ eb("FriendRequest.senderId", "=", receiverId),
+ eb("FriendRequest.receiverId", "=", senderId),
+ ]),
+ ]),
+ )
+ .executeTakeFirst();
+}
+
+/** Users who are friends with both given users. */
+export async function findMutualFriends({
+ loggedInUserId,
+ targetUserId,
+}: {
+ loggedInUserId: number;
+ targetUserId: number;
+}) {
+ return db
+ .selectFrom("Friendship as f1")
+ .innerJoin("Friendship as f2", (join) =>
+ join.on((eb) =>
+ eb.and([
+ eb(
+ eb
+ .case()
+ .when("f1.userOneId", "=", loggedInUserId)
+ .then(eb.ref("f1.userTwoId"))
+ .else(eb.ref("f1.userOneId"))
+ .end(),
+ "=",
+ eb
+ .case()
+ .when("f2.userOneId", "=", targetUserId)
+ .then(eb.ref("f2.userTwoId"))
+ .else(eb.ref("f2.userOneId"))
+ .end(),
+ ),
+ ]),
+ ),
+ )
+ .innerJoin("User", (join) =>
+ join.on((eb) =>
+ eb(
+ "User.id",
+ "=",
+ eb
+ .case()
+ .when("f1.userOneId", "=", loggedInUserId)
+ .then(eb.ref("f1.userTwoId"))
+ .else(eb.ref("f1.userOneId"))
+ .end(),
+ ),
+ ),
+ )
+ .where((eb) =>
+ eb.or([
+ eb("f1.userOneId", "=", loggedInUserId),
+ eb("f1.userTwoId", "=", loggedInUserId),
+ ]),
+ )
+ .where((eb) =>
+ eb.or([
+ eb("f2.userOneId", "=", targetUserId),
+ eb("f2.userTwoId", "=", targetUserId),
+ ]),
+ )
+ .select((eb) => commonUserSelect(eb))
+ .execute();
+}
+
+/** The friendship row between the two users, or `undefined` when they are not friends. */
+export async function findFriendship({
+ userOneId,
+ userTwoId,
+}: {
+ userOneId: number;
+ userTwoId: number;
+}) {
+ const minId = Math.min(userOneId, userTwoId);
+ const maxId = Math.max(userOneId, userTwoId);
+
+ return db
+ .selectFrom("Friendship")
+ .select("Friendship.id")
+ .where("Friendship.userOneId", "=", minId)
+ .where("Friendship.userTwoId", "=", maxId)
+ .executeTakeFirst();
+}
diff --git a/apps/web/src/lib/features/scrims/components/AssociationSelect.svelte b/apps/web/src/lib/features/scrims/components/AssociationSelect.svelte
new file mode 100644
index 000000000..458d382b8
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/AssociationSelect.svelte
@@ -0,0 +1,34 @@
+
+
+
diff --git a/apps/web/src/lib/features/scrims/components/BaseVisibilityFormField.svelte b/apps/web/src/lib/features/scrims/components/BaseVisibilityFormField.svelte
new file mode 100644
index 000000000..06bba2386
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/BaseVisibilityFormField.svelte
@@ -0,0 +1,45 @@
+
+
+
+ {#if noAssociations}
+
+ {m.scrims_forms_visibility_noneAvailable()}
+
+ {:else}
+
+ {/if}
+
diff --git a/apps/web/src/lib/features/scrims/components/DivsFilterPopover.svelte b/apps/web/src/lib/features/scrims/components/DivsFilterPopover.svelte
new file mode 100644
index 000000000..adeb561e7
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/DivsFilterPopover.svelte
@@ -0,0 +1,43 @@
+
+
+
diff --git a/apps/web/src/lib/features/scrims/components/MapsTournamentFormField.svelte b/apps/web/src/lib/features/scrims/components/MapsTournamentFormField.svelte
new file mode 100644
index 000000000..61201006c
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/MapsTournamentFormField.svelte
@@ -0,0 +1,12 @@
+
+
+{#if showField}
+
+{/if}
diff --git a/apps/web/src/lib/features/scrims/components/NewScrimForm.svelte b/apps/web/src/lib/features/scrims/components/NewScrimForm.svelte
new file mode 100644
index 000000000..9d2a0718d
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/NewScrimForm.svelte
@@ -0,0 +1,90 @@
+
+
+ 0
+ ? { mode: "TEAM", teamId: data.teams[0].id }
+ : {
+ mode: "PICKUP",
+ users: nullFilledArray(
+ SCRIM.MAX_PICKUP_SIZE_EXCLUDING_OWNER,
+ ) as unknown as number[],
+ },
+ managedByAnyone: true,
+ maps: "NO_PREFERENCE",
+ mapsTournamentId: null,
+ }}
+ onSubmit={handleSubmit}
+>
+
+ {#snippet children(props)}
+
+ {/snippet}
+
+
+
+
+
+
+ {#snippet children(props)}
+
+ {/snippet}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/apps/web/src/lib/features/scrims/components/NotFoundVisibilityFormField.svelte b/apps/web/src/lib/features/scrims/components/NotFoundVisibilityFormField.svelte
new file mode 100644
index 000000000..629a63cbc
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/NotFoundVisibilityFormField.svelte
@@ -0,0 +1,108 @@
+
+
+
+
+{#if !noAssociations && baseVisibility !== "PUBLIC"}
+
+
+
+
+
+ {#if notFoundVisibility.at}
+
+
+
+
+ {/if}
+
+
+
+
+ {#if children}{@render children()}{/if}
+
+ {#if footer && showFooter}
+
+ {@render footer()}
+
+ {/if}
+
+
+ {text}
+
+ {#if isOverflowing}
+
+ {/if}
+
+
+
+
+
+
diff --git a/apps/web/src/lib/features/scrims/components/ScrimMapListManager.svelte b/apps/web/src/lib/features/scrims/components/ScrimMapListManager.svelte
new file mode 100644
index 000000000..472092996
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/ScrimMapListManager.svelte
@@ -0,0 +1,130 @@
+
+
+ {
+ isOpen = open;
+ }}
+ collapsedLabel={m.scrims_mapByMap_manageMapLists()}
+ {standalone}
+>
+ {#snippet collapsedIcon()}{/snippet}
+
+ {#if !ownList}
+
+ {/if}
+
+ {#each sides as side (side)}
+ {@const list = data.mapByMap.mapLists.find(
+ (candidate) => candidate.side === side,
+ )}
+ {@const isOwn = side === viewerSide}
+
+
+
+ {#if list}
+ {#if list.tournament}
+ {list.tournament.name}
+ {:else}
+
+ {m.scrims_mapByMap_poolList({ count: list.mapList.length })}
+
+ {/if}
+ {#if isOwn}
+
+ removeMapList({ scrimPostId: data.post.id })}
+ >
+ {#snippet trigger(triggerProps)}
+
+ {/snippet}
+
+ {/if}
+ {:else}
+
+ {m.scrims_mapByMap_noListYet()}
+
+ {/if}
+
+
+ {/each}
+
+
+ {m.scrims_mapByMap_nonParticipantNotice()}
+
+
+ {:else if !currentMap}
+
+
+
+ {:else}
+ {#key currentMap.id}
+
+ {#snippet actionButtons()}
+
+
+ {#key `${currentMap.id}-${currentMap.mode}-${currentMap.stageId}`}
+
+ {#snippet trigger(triggerProps)}
+
+ {/snippet}
+
+ {/key}
+ {/snippet}
+ {#snippet secondaryAction()}
+
+ {/snippet}
+
+ {/key}
+ {/if}
+{/if}
+
+
diff --git a/apps/web/src/lib/features/scrims/components/ScrimMatchBanner.svelte b/apps/web/src/lib/features/scrims/components/ScrimMatchBanner.svelte
new file mode 100644
index 000000000..6be192aa8
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/ScrimMatchBanner.svelte
@@ -0,0 +1,79 @@
+
+
+{#snippet topRow()}
+
+
+
+{/snippet}
+
+{#if data.post.canceled}
+
+ {@render topRow()}
+
+ {#snippet icon()}{/snippet}
+
+
+{:else if currentMap}
+
+ {@render topRow()}
+
+
+{:else}
+
+ {@render topRow()}
+
+ {#snippet icon()}{/snippet}
+
+
+{/if}
diff --git a/apps/web/src/lib/features/scrims/components/ScrimMatchHeader.svelte b/apps/web/src/lib/features/scrims/components/ScrimMatchHeader.svelte
new file mode 100644
index 000000000..d19022976
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/ScrimMatchHeader.svelte
@@ -0,0 +1,71 @@
+
+
+
+ {#snippet topRight()}
+ {#if canCancel}
+
+ {/if}
+ {/snippet}
+ {#if opponentSide}
+ {m.scrims_page_vs({ opponent: Scrim.sideDisplayName(opponentSide) })}
+ {/if}
+
diff --git a/apps/web/src/lib/features/scrims/components/ScrimMatchStatsTab.svelte b/apps/web/src/lib/features/scrims/components/ScrimMatchStatsTab.svelte
new file mode 100644
index 000000000..eb7450c26
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/ScrimMatchStatsTab.svelte
@@ -0,0 +1,222 @@
+
+
+
+ {#if !viewerSide || maps.length === 0}
+ {m.scrims_mapByMap_stats_empty()}
+ {:else if stats}
+
+
+
+ {#each VIEW_OPTIONS as option (option)}
+ {
+ view = value as View;
+ }}
+ >
+ {viewLabel(option)}
+
+ {/each}
+
+ {#if ownPool}
+
+ {/if}
+
+
+ {#if view === "MODE"}
+ {@render statsTable(sortRows(stats.byMode), modeLabel)}
+ {:else if view === "STAGE"}
+ {@render statsTable(sortRows(stats.byStage), stageLabel)}
+ {:else}
+ {@render statsTable(sortRows(stats.byStageMode), stageModeLabel)}
+ {/if}
+
{m.scrims_mapByMap_stats_empty()}
+ {:else}
+
+
+
+ | {m.scrims_mapByMap_stats_col_label()} |
+ {m.scrims_mapByMap_stats_col_wins()} |
+ {m.scrims_mapByMap_stats_col_losses()} |
+ {m.scrims_mapByMap_stats_col_winPct()} |
+
+
+
+ {#each rows as row (row.key)}
+
+ | {@render label(row.key)} |
+ {row.wins} |
+ {row.losses} |
+ {Math.round(row.winRate * 100)}% |
+
+ {/each}
+
+
+ {/if}
+{/snippet}
+
+
diff --git a/apps/web/src/lib/features/scrims/components/ScrimMatchTabs.svelte b/apps/web/src/lib/features/scrims/components/ScrimMatchTabs.svelte
new file mode 100644
index 000000000..bb30e0c6a
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/ScrimMatchTabs.svelte
@@ -0,0 +1,109 @@
+
+
+
+
+
+
+
+
diff --git a/apps/web/src/lib/features/scrims/components/ScrimPage.svelte b/apps/web/src/lib/features/scrims/components/ScrimPage.svelte
new file mode 100644
index 000000000..301cec139
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/ScrimPage.svelte
@@ -0,0 +1,48 @@
+
+
+
+
+
+
+
+
+
diff --git a/apps/web/src/lib/features/scrims/components/ScrimPostCard.svelte b/apps/web/src/lib/features/scrims/components/ScrimPostCard.svelte
new file mode 100644
index 000000000..7a1867f83
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/ScrimPostCard.svelte
@@ -0,0 +1,419 @@
+
+
+
+
+ {#snippet avatar()}
+
+ {/snippet}
+ {#snippet rightIcons()}
+ {#if post.isPrivate}
+
+ {#snippet trigger(triggerProps)}
+
+ {/snippet}
+ {m.scrims_limitedVisibility()}
+
+ {/if}
+
+ {/snippet}
+
+
+ {@render infoItem("Start", startTime)}
+ {#if flexTimeDisplay}
+ {@render infoItem("Flex", flexText)}
+ {/if}
+ {#if post.divs}
+ {@render infoItem("Div", divsText)}
+ {/if}
+ {#if post.maps || post.mapsTournament}
+ {@render infoItem("Modes", modesContent)}
+ {/if}
+
+
+ {#if post.text}
+
+ {/if}
+
+ {#snippet footer()}
+ {@render actionButtons()}
+ {/snippet}
+
+
+
{label}
+
{@render content()}
+
+ {m.scrims_now()}
+ Canceled
+
+ {:else}
+ {m.scrims_now()}
+ {/if}
+ {:else if post.canceled}
+
+
+
+
+ Canceled
+
+ {:else}
+
+ {/if}
+{/snippet}
+
+{#snippet flexText()}
+ {flexTimeDisplay}
+{/snippet}
+
+{#snippet divsText()}
+ {post.divs!.max === post.divs!.min
+ ? post.divs!.max
+ : `${post.divs!.min}-${post.divs!.max}`}
+{/snippet}
+
+{#snippet modesContent()}
+ {#if post.mapsTournament}
+ {@const tournament = post.mapsTournament}
+
+ {#snippet trigger(triggerProps)}
+
+ {/snippet}
+
+
+ {:else}
+ {#each getModesList(post.maps!) as mode (mode)}
+
+ {/each}
+ {/if}
+{/snippet}
+
+{#snippet actionButtons()}
+ {#if action === "REQUEST"}
+
+ {#if isRequestModalOpen}
+ {
+ isRequestModalOpen = false;
+ }}
+ />
+ {/if}
+ {:else if action === "VIEW_REQUEST"}
+
+ {#if isViewRequestModalOpen && userRequest}
+
+ {/if}
+ {:else if action === "CONTACT"}
+
+ {#snippet icon()}{/snippet}
+ {m.scrims_actions_contact()}
+
+ {:else if action === "DELETE"}
+
+ deleteScrimPost({ scrimPostId: post.id }).updates(getScrimPosts)}
+ >
+ {#snippet trigger(triggerProps)}
+
+ {/snippet}
+
+ {/if}
+{/snippet}
+
+
diff --git a/apps/web/src/lib/features/scrims/components/ScrimRequestCard.svelte b/apps/web/src/lib/features/scrims/components/ScrimRequestCard.svelte
new file mode 100644
index 000000000..fff8f141d
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/ScrimRequestCard.svelte
@@ -0,0 +1,100 @@
+
+
+
+ {#snippet avatar()}
+
+ {/snippet}
+ {#snippet rightIcons()}
+
+ {/snippet}
+
+ {#if request.message}
+
+ {/if}
+
+ {#snippet footer()}
+ {#if canAccept}
+
+ acceptScrimRequest({ scrimPostRequestId: request.id }).updates(
+ getScrimPosts,
+ )}
+ >
+ {#snippet trigger(triggerProps)}
+
+ {/snippet}
+
+ {:else}
+
+ {#snippet trigger(triggerProps)}
+
+ {/snippet}
+ {m.scrims_acceptModal_prevented()}
+
+ {/if}
+ {/snippet}
+
diff --git a/apps/web/src/lib/features/scrims/components/ScrimRequestMembersList.svelte b/apps/web/src/lib/features/scrims/components/ScrimRequestMembersList.svelte
new file mode 100644
index 000000000..56fc1c579
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/components/ScrimRequestMembersList.svelte
@@ -0,0 +1,43 @@
+
+
+
+ {#each sortedUsers as user (user.id)}
+
+
+
+
+
+
+ {user.username}
+ {#if user.isOwner}
+
+ {m.scrims_cancelRequestModal_requester()}
+
+ {/if}
+
+
+
+ {/each}
+
+ {#each users as user (user.id)}
+
+
+
+
+
+ {user.username}
+
+
+ {/each}
+
+
+
+
+
+ {#if user && (filteredCount > 0 || pendingRequestsCount > 0)}
+
+ {#if filteredCount > 0}
+
+ {/if}
+ {#if pendingRequestsCount > 0}
+
+ {/if}
+
+ {/if}
+
+
+ {#each showFiltered ? posts : filteredPosts as post (post.id)}
+ {#if !(hasRequested(post) && !showRequestPending)}
+
+ {/if}
+ {/each}
+
+
+
+
+ {m.scrims_associations_title()}
+
+
+
+ {#key pendingRequestPostId}
+
0
+ ? "owned"
+ : data.posts.booked.length > 0
+ ? "booked"
+ : "available"}
+ >
+ {#if user}
+
+
+ {#snippet icon()}{/snippet}
+ {m.scrims_tabs_available()}
+
+
+ {#snippet icon()}{/snippet}
+ {m.scrims_tabs_owned()}
+
+
+ {#snippet icon()}{/snippet}
+ {m.scrims_tabs_booked()}
+
+
+ {/if}
+
+ {#if data.posts.neutral.length > 0}
+
+ {#each postsByDay(data.posts.neutral) as [day, dayPosts] (day)}
+
+ params.set({ pendingRequestPostId: null })}
+ teams={data.teams}
+ />
+ {/each}
+
+ {:else}
+
+ {m.scrims_noneAvailable()}
+
+ {/if}
+
+
+ {#if data.posts.owned.length > 0}
+
+ {#each postsByDay(data.posts.owned) as [day, dayPosts] (day)}
+
+
+
+
+
+ {#each dayPosts as post (post.id)}
+ {@const isAccepted = post.requests.some(
+ (request) => request.isAccepted,
+ )}
+ {@const canDelete =
+ user &&
+ post.permissions.DELETE_POST.includes(user.id) &&
+ !isAccepted}
+
+
+ {#if post.requests.length > 0}
+
+ {#each post.requests as request (request.id)}
+
+ {/each}
+
+ {:else}
+
+ {m.scrims_noRequestsYet()}
+
+ {/if}
+
+ {/each}
+
+
+ {/each}
+
+ {m.scrims_noOwnedPosts()}
+
+ {/if}
+
+
+ {#if data.posts.booked.length > 0}
+
+ {#each postsByDay(data.posts.booked) as [day, dayPosts] (day)}
+
+
+
+
+
+ {#each dayPosts as post (post.id)}
+ {@const acceptedRequest = post.requests.find(
+ (request) => request.isAccepted,
+ )}
+
+
+ {#if acceptedRequest}
+
+ {/if}
+
+ {/each}
+
+
+ {/each}
+
+ {m.scrims_noBookedScrims()}
+
+ {/if}
+
+
+ {/key}
+
+ {m.calendar_inYourTimeZone()}
+ {timeZone}
+
+
+
+
+
+ {#each fromValue.users as userId, i (`${pickupFieldsKey}-${i}`)}
+ handleUserChange(selectedUser, i)}
+ isRequired={i < 3}
+ label={m.scrims_forms_with_user({ nth: i + 2 })}
+ />
+ {/each}
+ {#if translatedError}
+
+ {translatedError}
+
+ {:else}
+
+ {m.scrims_forms_with_explanation()}
+
+ {/if}
+
+ {/if}
+
+
+
diff --git a/apps/web/src/lib/features/scrims/scrims.remote.ts b/apps/web/src/lib/features/scrims/scrims.remote.ts
new file mode 100644
index 000000000..3895a5202
--- /dev/null
+++ b/apps/web/src/lib/features/scrims/scrims.remote.ts
@@ -0,0 +1,963 @@
+import invariant from "@sendou/utils/invariant";
+import { logger } from "@sendou/utils/logger";
+import { assertUnreachable } from "@sendou/utils/types";
+import { add, sub } from "date-fns";
+import * as R from "remeda";
+import * as v from "valibot";
+import * as AssociationRepository from "#lib/features/associations/AssociationRepository.server.ts";
+import * as Association from "#lib/features/associations/core/Association.ts";
+import {
+ type AuthenticatedUser,
+ getUser,
+ requireUser,
+} from "#lib/features/auth/user.server.ts";
+import { userIsBanned } from "#lib/features/ban/banned.server.ts";
+import { ensureScrimChatRoom, markScrimChatRoomInactive, sendSystemMessage } from "#lib/features/chat/chat.server.ts";
+import { notify } from "#lib/features/notifications/core/notify.server.ts";
+import { resolveNotifications } from "#lib/features/notifications/core/resolve.server.ts";
+import * as SQGroupRepository from "#lib/features/sendouq/SQGroupRepository.server.ts";
+import * as TeamRepository from "#lib/features/team/TeamRepository.server.ts";
+import { getMemberRoleType } from "#lib/features/team/team-utils.ts";
+import * as UserCardRepository from "#lib/features/user-page/UserCardRepository.server.ts";
+import * as UserRepository from "#lib/features/user-page/UserRepository.server.ts";
+import { requirePermission } from "#lib/modules/permissions/guards.server.ts";
+import * as Events from "#lib/server/events.ts";
+import {
+ databaseTimestampToDate,
+ dateToDatabaseTimestamp,
+} from "#lib/utils/dates.ts";
+import {
+ ConcurrentModificationError,
+ DuplicateEntryError,
+} from "#lib/utils/errors.ts";
+import {
+ errorToast,
+ errorToastIfFalsy,
+ notFoundIfNullish,
+} from "#lib/utils/respond.server.ts";
+import { id } from "#lib/utils/schemas.ts";
+import { toDBBoolean } from "#lib/utils/sql.ts";
+import { command, query, requested } from "$app/server";
+import * as Scrim from "./Scrim.ts";
+import * as ScrimMapByMap from "./ScrimMapByMap.ts";
+import * as ScrimMapListRepository from "./ScrimMapListRepository.server.ts";
+import * as ScrimMapRepository from "./ScrimMapRepository.server.ts";
+import * as ScrimPickupRosterRepository from "./ScrimPickupRosterRepository.server.ts";
+import * as ScrimPostRepository from "./ScrimPostRepository.server.ts";
+import { LUTI_DIVS, SCRIM } from "./scrims-constants.ts";
+import {
+ acceptRequestSchema,
+ cancelRequestSchema,
+ cancelScrimFormSchema,
+ deletePostSchema,
+ type fromSchema,
+ newRequestSchema,
+ persistScrimFiltersSchema,
+ pickMapFormSchema,
+ type RANGE_END_OPTIONS,
+ removeMapListSchema,
+ replayMapSchema,
+ reportMapSchema,
+ scrimsFiltersSchema,
+ scrimsNewFormSchema,
+ submitMapListFormSchema,
+ undoMapSchema,
+} from "./scrims-schemas.ts";
+import type { LutiDiv } from "./scrims-types.ts";
+import {
+ dividePosts,
+ generateTimeOptions,
+ parseMapPoolInput,
+ serializeLutiDiv,
+} from "./scrims-utils.ts";
+
+const getScrimPostsSchema = v.object({
+ ...scrimsFiltersSchema.entries,
+ useDefaults: v.boolean(),
+});
+
+/** The `/scrims` page data: visible posts divided into tabs plus filter state. */
+export const getScrimPosts = query(
+ getScrimPostsSchema,
+ async ({ weekdayTimes, weekendTimes, divs, useDefaults }) => {
+ const user = getUser();
+
+ const associations = user
+ ? await AssociationRepository.findByMemberUserId(user.id)
+ : null;
+
+ const filtersFromSearchParams = { weekdayTimes, weekendTimes, divs };
+
+ // when the user cleared or edited the filters the URL is the whole truth
+ // even when it ends up holding no filters at all
+ const filters =
+ useDefaults && Scrim.filtersAreDefault(filtersFromSearchParams)
+ ? (user?.preferences?.defaultScrimsFilters ?? Scrim.defaultFilters())
+ : filtersFromSearchParams;
+
+ const posts = (await ScrimPostRepository.findAllRelevant())
+ .filter(
+ (post) =>
+ (user && Scrim.isParticipating(post, user.id)) ||
+ Association.isVisible({
+ associations,
+ visibility: post.visibility,
+ contentOwnerUserId: post.users.find((u) => u.isOwner)?.id,
+ }),
+ )
+ .map((post) => ({
+ ...post,
+ visibility: null,
+ isPrivate: !Association.isPublic({
+ visibility: post.visibility,
+ }),
+ }));
+
+ const cardUserIds = R.unique(
+ posts.flatMap((post) => [
+ ...post.users.map((postUser) => postUser.id),
+ ...post.requests.flatMap((request) =>
+ request.users.map((requestUser) => requestUser.id),
+ ),
+ ]),
+ );
+
+ return {
+ ...(await UserCardRepository.findAllByUserIds({
+ userIds: cardUserIds,
+ })),
+ posts: dividePosts(posts, user?.id),
+ teams: user ? await TeamRepository.findAllByMemberUserId(user.id) : [],
+ filters,
+ canSaveAsDefault:
+ user != null &&
+ !R.isDeepEqual(
+ filters,
+ user.preferences?.defaultScrimsFilters ?? Scrim.defaultFilters(),
+ ),
+ };
+ },
+);
+
+/** The `/scrims/new` page data. */
+export const getScrimsNewData = query(async () => {
+ const user = requireUser();
+
+ return {
+ teams: await TeamRepository.findAllByMemberUserId(user.id),
+ associations: await AssociationRepository.findByMemberUserId(user.id),
+ recentPickupRosters: await ScrimPickupRosterRepository.findAllOwnRecent(),
+ };
+});
+
+/**
+ * A booked scrim's page data, streamed live: map-by-map actions by either side
+ * wake the stream so both teams see reports/list changes without refreshing
+ * (what skalop's revalidation broadcasts did for the React app).
+ */
+export const getScrim = query.live(
+ v.object({ scrimPostId: id }),
+ async function* ({ scrimPostId }) {
+ yield await scrimSnapshot(scrimPostId);
+
+ for await (const _ of Events.subscribe(Events.scrimChannel(scrimPostId))) {
+ yield await scrimSnapshot(scrimPostId);
+ }
+ },
+);
+
+async function scrimSnapshot(scrimPostId: number) {
+ const user = requireUser();
+
+ const post = notFoundIfNullish(
+ await ScrimPostRepository.findById(scrimPostId),
+ );
+
+ if (!Scrim.isAccepted(post)) {
+ errorToast("Scrim is not accepted");
+ }
+
+ if (!Scrim.isParticipating(post, user.id) && !user.roles.includes("STAFF")) {
+ errorToast("Not a participant of this scrim");
+ }
+
+ // visiting the page addresses these notifications
+ await resolveNotifications({
+ userIds: [user.id],
+ type: "SCRIM_SCHEDULED",
+ meta: { id: post.id },
+ });
+ await resolveNotifications({
+ userIds: [user.id],
+ type: "SCRIM_STARTING_SOON",
+ meta: { id: post.id },
+ });
+
+ const participantIds = Scrim.participantIdsListFromAccepted(post);
+
+ const chatRoom = await ensureScrimChatRoom({
+ scrimPostId: post.id,
+ startsAt: Scrim.getStartTime(post),
+ });
+
+ return {
+ ...(await UserCardRepository.findAllByUserIds({
+ userIds: participantIds,
+ include: { friendCode: true },
+ })),
+ post,
+ chatRoomId:
+ user.roles.includes("STAFF") || participantIds.includes(user.id)
+ ? chatRoom.id
+ : undefined,
+ anyUserPrefersNoScreen:
+ await UserRepository.anyUserPrefersNoScreen(participantIds),
+ mapByMap: await resolveMapByMap({ post, user }),
+ };
+}
+
+async function resolveMapByMap({
+ post,
+ user,
+}: {
+ post: NonNullable>>;
+ user: AuthenticatedUser;
+}) {
+ const [mapLists, maps] = await Promise.all([
+ ScrimMapListRepository.findMapListsByScrimPostId(post.id),
+ ScrimMapRepository.findMapsByScrimPostId(post.id),
+ ]);
+
+ const pool = mapLists.length > 0 ? ScrimMapByMap.unionPool(mapLists) : null;
+ const currentMap = maps.find((m) => m.reportedAt === null) ?? null;
+ const viewerSide = Scrim.sideOfUser(post, user.id);
+ const locked = Scrim.isTrackingLocked(maps, mapLists);
+
+ const ownList = viewerSide
+ ? mapLists.find((l) => l.side === viewerSide)
+ : undefined;
+
+ return {
+ mapLists,
+ maps,
+ currentMap,
+ viewerSide,
+ locked,
+ pool: pool ? pool.stageModePairs : null,
+ ownPool: ownList?.mapList ?? null,
+ };
+}
+
+export const createScrimPost = command(
+ scrimsNewFormSchema,
+ async (data) => {
+ const user = requireUser();
+
+ if (data.from.mode === "PICKUP") {
+ const pickupUserError = await validatePickup(data.from.users, user.id);
+ if (pickupUserError) {
+ return { fieldErrors: { from: pickupUserError.error } };
+ }
+ }
+
+ const rangeEndDate = data.rangeEnd
+ ? resolveRangeEndToDate(data.at, data.rangeEnd as RangeEnd)
+ : null;
+
+ const resolvedDivs = data.divs
+ ? resolveDivs(data.divs as [LutiDiv | null, LutiDiv | null])
+ : null;
+
+ await ScrimPostRepository.insert({
+ startsAt: dateToDatabaseTimestamp(data.at),
+ rangeEndsAt: rangeEndDate
+ ? dateToDatabaseTimestamp(rangeEndDate)
+ : null,
+ maxDiv: resolvedDivs?.[0] ? serializeLutiDiv(resolvedDivs[0]) : null,
+ minDiv: resolvedDivs?.[1] ? serializeLutiDiv(resolvedDivs[1]) : null,
+ text: data.postText,
+ managedByAnyone: data.managedByAnyone,
+ maps:
+ data.maps === "NO_PREFERENCE" || data.maps === "TOURNAMENT"
+ ? null
+ : (data.maps as "SZ" | "RANKED" | "ALL"),
+ mapsTournamentId: data.mapsTournamentId,
+ isScheduledForFuture:
+ data.at >
+ // 10 minutes is an arbitrary threshold
+ add(new Date(), {
+ minutes: 10,
+ }),
+ visibility:
+ data.baseVisibility !== "PUBLIC"
+ ? {
+ forAssociation: data.baseVisibility,
+ notFoundInstructions: data.notFoundVisibility.at
+ ? [
+ {
+ at: dateToDatabaseTimestamp(
+ data.notFoundVisibility.at,
+ ),
+ forAssociation:
+ data.notFoundVisibility.forAssociation !== "PUBLIC"
+ ? data.notFoundVisibility.forAssociation
+ : null,
+ },
+ ]
+ : undefined,
+ }
+ : null,
+ teamId: data.from.mode === "TEAM" ? data.from.teamId : null,
+ users: (
+ await usersListForPost({ authorId: user.id, from: data.from })
+ ).map((userId) => ({
+ userId,
+ isOwner: toDBBoolean(user.id === userId),
+ })),
+ });
+
+ if (data.from.mode === "PICKUP") {
+ await ScrimPickupRosterRepository.upsertOwn(data.from.users);
+ }
+
+ Events.publish(Events.scrimPostsChannel());
+ return null;
+ },
+);
+
+export const deleteScrimPost = command(
+ deletePostSchema,
+ async ({ scrimPostId }) => {
+ requireUser();
+
+ const post = await findPost({ postId: scrimPostId });
+ requirePermission(post, "DELETE_POST");
+
+ errorToastIfFalsy(
+ !Scrim.isAccepted(post),
+ "Can't delete an accepted scrim, cancel it instead",
+ );
+
+ await ScrimPostRepository.deleteById(post.id);
+
+ // requests to the deleted post can no longer be accepted
+ await resolveNotifications({
+ userIds: post.users.filter((u) => u.isOwner).map((u) => u.id),
+ type: "SCRIM_NEW_REQUEST",
+ meta: { scrimPostId: post.id },
+ });
+
+ await requested(getScrimPosts, 5).refreshAll();
+ },
+);
+
+export const newScrimRequest = command(newRequestSchema, async (data) => {
+ const user = requireUser();
+
+ const post = await findPost({ postId: data.scrimPostId });
+
+ if (post.visibility) {
+ const associations = await AssociationRepository.findByMemberUserId(
+ user.id,
+ );
+ const canSeePost = Association.isVisible({
+ associations,
+ visibility: post.visibility,
+ contentOwnerUserId: post.users.find((u) => u.isOwner)?.id,
+ });
+ errorToastIfFalsy(canSeePost, "Post not found");
+ }
+
+ if (data.from.mode === "PICKUP") {
+ const pickupUserError = await validatePickup(data.from.users, user.id);
+ if (pickupUserError) {
+ return { fieldErrors: { from: pickupUserError.error } };
+ }
+ }
+
+ if (post.rangeEndsAt && !data.at) {
+ return {
+ fieldErrors: { at: "Please select a time for the scrim" },
+ };
+ }
+
+ if (post.rangeEndsAt && data.at) {
+ const validTimeOptions = generateTimeOptions(
+ databaseTimestampToDate(post.startsAt),
+ databaseTimestampToDate(post.rangeEndsAt),
+ );
+ const requestTime = data.at.getTime();
+
+ if (!validTimeOptions.includes(requestTime)) {
+ return {
+ fieldErrors: {
+ at: "Selected time must be one of the available options",
+ },
+ };
+ }
+ }
+
+ try {
+ await ScrimPostRepository.insertRequest({
+ scrimPostId: data.scrimPostId,
+ teamId: data.from.mode === "TEAM" ? data.from.teamId : null,
+ message: data.message,
+ startsAt:
+ post.rangeEndsAt && data.at ? dateToDatabaseTimestamp(data.at) : null,
+ users: (
+ await usersListForPost({ authorId: user.id, from: data.from })
+ ).map((userId) => ({
+ userId,
+ isOwner: toDBBoolean(user.id === userId),
+ })),
+ });
+ } catch (thrown) {
+ if (thrown instanceof DuplicateEntryError) {
+ errorToast("Your team has already requested this scrim");
+ }
+ throw thrown;
+ }
+
+ notify({
+ userIds: post.users
+ .filter((postUser) => postUser.isOwner)
+ .map((postUser) => postUser.id),
+ notification: {
+ type: "SCRIM_NEW_REQUEST",
+ meta: {
+ fromUserId: user.id,
+ fromUsername: user.username,
+ scrimPostId: post.id,
+ },
+ },
+ });
+
+ Events.publish(Events.scrimPostsChannel());
+ await requested(getScrimPosts, 5).refreshAll();
+ return null;
+});
+
+export const acceptScrimRequest = command(
+ acceptRequestSchema,
+ async ({ scrimPostRequestId }) => {
+ const user = requireUser();
+
+ const { post, request } = await findRequest({
+ requestId: scrimPostRequestId,
+ });
+ requirePermission(post, "MANAGE_REQUESTS");
+
+ errorToastIfFalsy(!request.isAccepted, "Request is already accepted");
+
+ try {
+ await ScrimPostRepository.acceptRequest(scrimPostRequestId);
+ } catch (thrown) {
+ if (thrown instanceof ConcurrentModificationError) {
+ errorToast(
+ "Another request for this scrim was already accepted by someone else",
+ );
+ }
+ throw thrown;
+ }
+
+ // accepting one request settles the post, the rest can no longer be accepted
+ await resolveNotifications({
+ userIds: post.users.filter((u) => u.isOwner).map((u) => u.id),
+ type: "SCRIM_NEW_REQUEST",
+ meta: { scrimPostId: post.id },
+ });
+
+ const fullPost = await ScrimPostRepository.findById(post.id);
+ if (fullPost) {
+ await ensureScrimChatRoom({
+ scrimPostId: fullPost.id,
+ startsAt: Scrim.getStartTime(fullPost),
+ });
+ }
+
+ const postTeamName = Scrim.sideDisplayName(post);
+ const requestTeamName = Scrim.sideDisplayName(request);
+
+ notify({
+ userIds: post.users.map((m) => m.id),
+ defaultSeenUserIds: [user.id],
+ notification: {
+ type: "SCRIM_SCHEDULED",
+ meta: { id: post.id, opponentTeamName: requestTeamName },
+ },
+ });
+
+ notify({
+ userIds: request.users.map((m) => m.id),
+ defaultSeenUserIds: [user.id],
+ notification: {
+ type: "SCRIM_SCHEDULED",
+ meta: { id: post.id, opponentTeamName: postTeamName },
+ },
+ });
+
+ if (fullPost) {
+ try {
+ const bookedAt = databaseTimestampToDate(Scrim.getStartTime(fullPost));
+ const startTime = dateToDatabaseTimestamp(
+ sub(bookedAt, { hours: SCRIM.AUTO_CANCEL_WINDOW_HOURS }),
+ );
+ const endTime = dateToDatabaseTimestamp(
+ add(bookedAt, { hours: SCRIM.AUTO_CANCEL_WINDOW_HOURS }),
+ );
+
+ const { posts, requestIds } =
+ await ScrimPostRepository.findPendingOverlapsForUsers({
+ userIds: Scrim.participantIdsListFromAccepted(fullPost),
+ startTime,
+ endTime,
+ excludePostId: post.id,
+ });
+
+ for (const requestId of requestIds) {
+ await ScrimPostRepository.deleteRequest(requestId);
+ }
+
+ for (const removed of posts) {
+ await ScrimPostRepository.deleteById(removed.id);
+ notify({
+ userIds: removed.memberIds,
+ defaultSeenUserIds: [user.id],
+ notification: {
+ type: "SCRIM_AUTO_DELETED",
+ meta: { at: removed.startsAt },
+ },
+ });
+ await resolveNotifications({
+ userIds: removed.memberIds,
+ type: "SCRIM_NEW_REQUEST",
+ meta: { scrimPostId: removed.id },
+ });
+ }
+ } catch (thrown) {
+ logger.error("Failed to auto-cancel overlapping scrims", thrown);
+ }
+ }
+
+ Events.publish(Events.scrimPostsChannel());
+ await requested(getScrimPosts, 5).refreshAll();
+ },
+);
+
+export const cancelScrimRequest = command(
+ cancelRequestSchema,
+ async ({ scrimPostRequestId }) => {
+ requireUser();
+
+ const { post, request } = await findRequest({
+ requestId: scrimPostRequestId,
+ });
+ requirePermission(request, "CANCEL");
+
+ errorToastIfFalsy(!request.isAccepted, "Can't cancel an accepted request");
+
+ await ScrimPostRepository.deleteRequest(scrimPostRequestId);
+
+ const requestOwner = request.users.find((u) => u.isOwner);
+ if (requestOwner) {
+ await resolveNotifications({
+ userIds: post.users.filter((u) => u.isOwner).map((u) => u.id),
+ type: "SCRIM_NEW_REQUEST",
+ meta: {
+ scrimPostId: post.id,
+ fromUserId: requestOwner.id,
+ },
+ });
+ }
+
+ Events.publish(Events.scrimPostsChannel());
+ await requested(getScrimPosts, 5).refreshAll();
+ },
+);
+
+export const persistScrimFilters = command(
+ persistScrimFiltersSchema,
+ async ({ filters }) => {
+ requireUser();
+
+ await UserRepository.updateOwnPreferences({
+ defaultScrimsFilters: filters,
+ });
+
+ await requested(getScrimPosts, 5).refreshAll();
+ },
+);
+
+export const cancelScrim = command(cancelScrimFormSchema, async (data) => {
+ const user = requireUser();
+
+ const post = notFoundIfNullish(
+ await ScrimPostRepository.findById(data.scrimPostId),
+ );
+
+ requirePermission(post, "MANAGE_TRACKING");
+ requirePermission(post, "CANCEL");
+
+ errorToastIfFalsy(Scrim.isAccepted(post), "Scrim is not accepted");
+ errorToastIfFalsy(!post.canceled, "Scrim is already canceled");
+
+ if (databaseTimestampToDate(Scrim.getStartTime(post)) < new Date()) {
+ errorToast("Cannot cancel a scrim that was already scheduled to start");
+ }
+
+ await ScrimPostRepository.cancelScrim(post.id, data.reason);
+
+ const acceptedRequest = post.requests.find((r) => r.isAccepted);
+ if (acceptedRequest) {
+ const postTeamName = Scrim.sideDisplayName(post);
+ const requestTeamName = Scrim.sideDisplayName(acceptedRequest);
+
+ notify({
+ userIds: post.users.map((m) => m.id),
+ defaultSeenUserIds: [user.id],
+ notification: {
+ type: "SCRIM_CANCELED",
+ meta: { id: post.id, opponentTeamName: requestTeamName },
+ },
+ });
+
+ notify({
+ userIds: acceptedRequest.users.map((m) => m.id),
+ defaultSeenUserIds: [user.id],
+ notification: {
+ type: "SCRIM_CANCELED",
+ meta: { id: post.id, opponentTeamName: postTeamName },
+ },
+ });
+
+ // the canceled scrim is no longer happening
+ const participantIds = [
+ ...post.users.map((m) => m.id),
+ ...acceptedRequest.users.map((m) => m.id),
+ ];
+ await resolveNotifications({
+ userIds: participantIds,
+ type: "SCRIM_SCHEDULED",
+ meta: { id: post.id },
+ });
+ await resolveNotifications({
+ userIds: participantIds,
+ type: "SCRIM_STARTING_SOON",
+ meta: { id: post.id },
+ });
+ }
+
+ await markScrimChatRoomInactive(post.id);
+
+ Events.publish(Events.scrimChannel(post.id));
+ Events.publish(Events.scrimPostsChannel());
+ await requested(getScrimPosts, 5).refreshAll();
+ return null;
+});
+
+export const submitMapList = command(submitMapListFormSchema, async (data) => {
+ const { post, viewerSide } = await requireMapByMapActor(data.scrimPostId);
+
+ if (data.source === "FROM_POST") {
+ errorToastIfFalsy(post.mapsTournament, "Post has no tournament to use");
+ }
+
+ const serializedPool =
+ data.source === "POOL"
+ ? (parseMapPoolInput(data.serializedPool!)?.serialized ?? null)
+ : null;
+
+ errorToastIfFalsy(
+ data.source !== "POOL" || serializedPool,
+ "Invalid map pool",
+ );
+
+ const resolvedSource: "POOL" | "TOURNAMENT" =
+ data.source === "POOL" ? "POOL" : "TOURNAMENT";
+
+ await ScrimMapListRepository.submitMapListAndGenerateIfNeeded({
+ scrimPostId: post.id,
+ side: viewerSide,
+ source: resolvedSource,
+ tournamentId:
+ data.source === "FROM_POST"
+ ? post.mapsTournament!.id
+ : (data.tournamentId ?? null),
+ serializedPool,
+ });
+
+ Events.publish(Events.scrimChannel(post.id));
+ return null;
+});
+
+export const removeMapList = command(
+ removeMapListSchema,
+ async ({ scrimPostId }) => {
+ const { post, viewerSide } = await requireMapByMapActor(scrimPostId);
+
+ await ScrimMapListRepository.deleteMapList(post.id, viewerSide);
+
+ Events.publish(Events.scrimChannel(post.id));
+ },
+);
+
+export const reportMap = command(reportMapSchema, async (data) => {
+ const { post, maps } = await requireMapByMapActor(data.scrimPostId);
+
+ const target = maps.find((m) => m.id === data.mapId);
+ errorToastIfFalsy(target, "Map not found");
+ errorToastIfFalsy(target!.reportedAt === null, "Map already reported");
+
+ await ScrimMapRepository.reportMapAndGenerateNext({
+ scrimPostId: post.id,
+ mapId: data.mapId,
+ winnerSide: data.winnerSide,
+ });
+
+ Events.publish(Events.scrimChannel(post.id));
+});
+
+export const undoMap = command(undoMapSchema, async ({ scrimPostId }) => {
+ const { post, maps } = await requireMapByMapActor(scrimPostId);
+
+ const latest = Scrim.lastReportedMap(maps);
+ errorToastIfFalsy(ScrimMapByMap.canUndo(latest, maps), "Nothing to undo");
+
+ await ScrimMapRepository.undoMostRecentMap(post.id);
+
+ Events.publish(Events.scrimChannel(post.id));
+});
+
+export const replayMap = command(replayMapSchema, async ({ scrimPostId }) => {
+ const { post, maps, user } = await requireMapByMapActor(scrimPostId);
+
+ const latest = Scrim.lastReportedMap(maps);
+ errorToastIfFalsy(latest, "No map to replay");
+
+ const currentMap = maps.find((m) => m.reportedAt === null);
+ errorToastIfFalsy(currentMap, "No current map to replace");
+
+ await ScrimMapRepository.replaceCurrentMap({
+ scrimPostId: post.id,
+ mode: latest!.mode,
+ stageId: latest!.stageId,
+ });
+
+ await broadcastMapChange({ post, type: "MAP_REPLAYED", user });
+ Events.publish(Events.scrimChannel(post.id));
+});
+
+export const pickMap = command(pickMapFormSchema, async (data) => {
+ const { post, maps, user } = await requireMapByMapActor(data.scrimPostId);
+
+ const currentMap = maps.find((m) => m.reportedAt === null);
+ errorToastIfFalsy(currentMap, "No current map to replace");
+
+ await ScrimMapRepository.replaceCurrentMap({
+ scrimPostId: post.id,
+ mode: data.mode,
+ stageId: data.stageId,
+ });
+
+ await broadcastMapChange({ post, type: "MAP_PICKED", user });
+ Events.publish(Events.scrimChannel(post.id));
+ return null;
+});
+
+/** Loads the post + map-by-map context, gating on tracking permission & lock. */
+async function requireMapByMapActor(scrimPostId: number) {
+ const user = requireUser();
+ const post = notFoundIfNullish(
+ await ScrimPostRepository.findById(scrimPostId),
+ );
+
+ requirePermission(post, "MANAGE_TRACKING");
+
+ const viewerSide = Scrim.sideOfUser(post, user.id);
+
+ const [maps, mapLists] = await Promise.all([
+ ScrimMapRepository.findMapsByScrimPostId(post.id),
+ ScrimMapListRepository.findMapListsByScrimPostId(post.id),
+ ]);
+
+ if (Scrim.isTrackingLocked(maps, mapLists)) {
+ errorToast("Tracking is locked");
+ }
+
+ return { user, post, viewerSide: viewerSide!, maps, mapLists };
+}
+
+async function broadcastMapChange({
+ post,
+ type,
+ user,
+}: {
+ post: { id: number };
+ type: "MAP_REPLAYED" | "MAP_PICKED";
+ user: AuthenticatedUser;
+}) {
+ const room = await ensureScrimChatRoom({
+ scrimPostId: post.id,
+ startsAt: Scrim.getStartTime(
+ notFoundIfNullish(await ScrimPostRepository.findById(post.id)),
+ ),
+ });
+ await sendSystemMessage({
+ chatRoomId: room.id,
+ type,
+ context: { name: user.username },
+ });
+}
+
+async function findPost({ postId }: { postId: number }) {
+ const posts = await ScrimPostRepository.findAllRelevant();
+ const post = posts.find((relevantPost) => relevantPost.id === postId);
+
+ errorToastIfFalsy(post, "Post not found");
+
+ return post!;
+}
+
+async function findRequest({ requestId }: { requestId: number }) {
+ const posts = await ScrimPostRepository.findAllRelevant();
+ const post = posts.find((relevantPost) =>
+ relevantPost.requests.some((request) => request.id === requestId),
+ );
+ const request = post?.requests.find(
+ (postRequest) => postRequest.id === requestId,
+ );
+
+ errorToastIfFalsy(post && request, "Request not found");
+
+ return { post: post!, request: request! };
+}
+
+const usersListForPost = async ({
+ from,
+ authorId,
+}: {
+ from: v.InferOutput;
+ authorId: number;
+}) => {
+ if (from.mode === "PICKUP") {
+ return [authorId, ...from.users];
+ }
+
+ const teamId = from.teamId;
+ const team = (await TeamRepository.findAllByMemberUserId(authorId)).find(
+ (memberTeam) => memberTeam.id === teamId,
+ );
+ errorToastIfFalsy(team, "User is not a member of this team");
+
+ const filteredMembers = team!.members.filter(
+ (member) => getMemberRoleType(member) !== "OTHER",
+ );
+
+ // handle case when all users are from excluded roles
+ const result = (
+ filteredMembers.length >= SCRIM.MIN_MEMBERS_PER_TEAM
+ ? filteredMembers
+ : team!.members
+ ).map((member) => member.id);
+
+ if (result.length < SCRIM.MIN_MEMBERS_PER_TEAM) {
+ errorToast("Your team does not have enough members (4) to scrim");
+ }
+
+ // ensure author is included in the list even if they match the ignore condition
+ return result.includes(authorId) ? result : [authorId, ...result];
+};
+
+/** Validates that a pickup roster can be put together by the author. */
+async function validatePickup(userIds: number[], authorId: number) {
+ if (userIds.includes(authorId)) {
+ return { error: "Don't add yourself to the pickup member list" };
+ }
+
+ const friendsError = await validatePickupFriends(userIds, authorId);
+ if (friendsError) {
+ return friendsError;
+ }
+
+ const unbannedError = await validatePickupAllUnbanned(userIds);
+ if (unbannedError) {
+ return unbannedError;
+ }
+
+ return null;
+}
+
+async function validatePickupFriends(userIds: number[], authorId: number) {
+ const unconsentingUsers: string[] = [];
+
+ const friendsData = await SQGroupRepository.findFriendsAndTeammates(authorId);
+
+ for (const userId of userIds) {
+ const user = await UserRepository.findLeanById(userId);
+ invariant(user, "User not found");
+
+ if (
+ user.preferences?.disallowScrimPickupsFromUntrusted &&
+ !friendsData.friends.some((friend) => friend.id === userId)
+ ) {
+ unconsentingUsers.push(user.username);
+ }
+ }
+
+ return unconsentingUsers.length === 0
+ ? null
+ : {
+ error: `Following users don't allow non-friends to add: ${unconsentingUsers.join(", ")}. Ask them to add you as a friend.`,
+ };
+}
+
+async function validatePickupAllUnbanned(userIds: number[]) {
+ const bannedFlags = await Promise.all(
+ userIds.map((userId) => userIsBanned(userId)),
+ );
+
+ return bannedFlags.every((banned) => !banned)
+ ? null
+ : {
+ error: "Pickup includes banned users.",
+ };
+}
+
+type RangeEnd = (typeof RANGE_END_OPTIONS)[number];
+
+function resolveRangeEndToDate(startDate: Date, rangeEnd: RangeEnd): Date {
+ switch (rangeEnd) {
+ case "+30min":
+ return add(startDate, { minutes: 30 });
+ case "+1hour":
+ return add(startDate, { hours: 1 });
+ case "+1.5hours":
+ return add(startDate, { hours: 1, minutes: 30 });
+ case "+2hours":
+ return add(startDate, { hours: 2 });
+ case "+2.5hours":
+ return add(startDate, { hours: 2, minutes: 30 });
+ case "+3hours":
+ return add(startDate, { hours: 3 });
+ default: {
+ assertUnreachable(rangeEnd);
+ }
+ }
+}
+
+function resolveDivs(
+ divs: [LutiDiv | null, LutiDiv | null],
+): [LutiDiv | null, LutiDiv | null] {
+ const [max, min] = divs;
+ if (!max || !min) return divs;
+
+ const maxIndex = LUTI_DIVS.indexOf(max);
+ const minIndex = LUTI_DIVS.indexOf(min);
+
+ if (minIndex < maxIndex) {
+ return [min, max];
+ }
+ return divs;
+}
+
+export type ScrimPageData = Awaited>;
diff --git a/apps/web/src/lib/features/user-page/components/MutualFriends.svelte b/apps/web/src/lib/features/user-page/components/MutualFriends.svelte
new file mode 100644
index 000000000..00a69ecb8
--- /dev/null
+++ b/apps/web/src/lib/features/user-page/components/MutualFriends.svelte
@@ -0,0 +1,75 @@
+
+
+
+
+{#if mutualFriends.length > 0}
+
+
+ {#each visibleFriends as friend (friend.id)}
+
+ {/each}
+
+ {#if overflowCount > 0}
+
+{overflowCount}
+ {/if}
+
+ {mutualFriends.length === 1
+ ? m.user_mutualFriends_count_one({ count: mutualFriends.length })
+ : m.user_mutualFriends_count_other({ count: mutualFriends.length })}
+
+
+
+ {#if note.text}
+
{note.text}
+ {/if}
+
+
+
+
+
+
+ {#if data.freeAgentPostId !== null}
+
+ {#snippet icon()}{/snippet}
+ {m.user_card_freeAgent()}
+
+ {/if}
+
+
+
+
+
+
+
{data.username}
+ {#if data.customUrl}
+
{data.customUrl}
+ {/if}
+ {#if data.friendCode}
+
SW-{data.friendCode}
+ {:else}
+
+
{"\u{200b}"}
+ {/if}
+
+
+ {#if showNoteView && data.privateNote}
+ {@render noteView(data.privateNote)}
+ {:else}
+ {#if stats.length > 0}
+
+ {#each stats as stat, i (stat.type)}
+ {#if i > 0}{/if}
+ {@render statView(stat)}
+ {/each}
+
+ {/if}
+ {#if !isOwnCard && withMutualFriends}
+
+ {#if friendship !== undefined}
+ {#if friendship.mutualFriends.length === 0}
+ {m.user_card_noMutualFriends()}
+ {:else}
+
+ {/if}
+ {/if}
+
+ {/if}
+ {#if data.shortBio}
+
{data.shortBio}
+ {/if}
+
+ {m.user_card_viewUserPage()}
+
+ {/if}
+