Merge branch 'main' into feature/nation-personnel-finance-parity

# Conflicts: # docs/frontend-legacy-parity.md
2026-07-26 04:35:16 +00:00
parent 625476c86e dc74a9a2be
commit 200d883b5b
32 changed files with 2629 additions and 1485 deletions
@@ -7,7 +7,8 @@ import type { TournamentState } from '../../tournament/types.js';

 import { TournamentStore } from '../../tournament/store.js';
 import { buildTournamentKeys } from '../../tournament/keys.js';
-import { authedProcedure, procedure, router } from '../../trpc.js';
+import { authedProcedure, router } from '../../trpc.js';
+import { getMyGeneral } from '../shared/general.js';

 const hasAdminRole = (roles: string[], profileName: string): boolean => {
    if (roles.includes('superuser') || roles.includes('admin') || roles.includes('admin.superuser')) {
@@ -110,13 +111,24 @@ const zSeedParticipants = z.object({
    includeNpc: z.boolean().optional(),
 });

+const tournamentRankTypes = ['tt', 'tl', 'ts', 'ti'] as const;
+
+const tournamentRankInfo = {
+    tt: { title: '전 력 전', statLabel: '종합' },
+    tl: { title: '통 솔 전', statLabel: '통솔' },
+    ts: { title: '일 기 토', statLabel: '무력' },
+    ti: { title: '설 전', statLabel: '지력' },
+} as const;
+
 export const tournamentRouter = router({
-    getState: procedure.query(async ({ ctx }) => {
+    getState: authedProcedure.query(async ({ ctx }) => {
+        await getMyGeneral(ctx);
        const store = new TournamentStore(ctx.redis, buildTournamentKeys(ctx.profile.name));
        return store.getState();
    }),
    getAdminStatus: adminProcedure.query(async () => ({ ok: true })),
-    getSnapshot: procedure.query(async ({ ctx }) => {
+    getSnapshot: authedProcedure.query(async ({ ctx }) => {
+        await getMyGeneral(ctx);
        const store = new TournamentStore(ctx.redis, buildTournamentKeys(ctx.profile.name));
        const [state, participants, matches, bets] = await Promise.all([
            store.getState(),
@@ -124,66 +136,156 @@ export const tournamentRouter = router({
            store.getMatches(),
            store.getBettingEntries(),
        ]);
-        return { state, participants, matches, bets };
+        return { state, participants, matches, betCount: bets.length };
+    }),
+    getRankings: authedProcedure.query(async ({ ctx }) => {
+        await getMyGeneral(ctx);
+        const rankTypeNames = tournamentRankTypes.flatMap((prefix) => [
+            `${prefix}p`,
+            `${prefix}g`,
+            `${prefix}w`,
+            `${prefix}d`,
+            `${prefix}l`,
+        ]);
+        const candidateRows = await Promise.all(
+            tournamentRankTypes.map((prefix) =>
+                ctx.db.rankData.findMany({
+                    where: { type: `${prefix}g` },
+                    orderBy: { value: 'desc' },
+                    take: 40,
+                    select: { generalId: true },
+                })
+            )
+        );
+        const candidateIdsByPrefix = new Map(
+            tournamentRankTypes.map((prefix, index) => [
+                prefix,
+                new Set((candidateRows[index] ?? []).map((row) => row.generalId)),
+            ])
+        );
+        const candidateIds = new Set(candidateRows.flatMap((rows) => rows.map((row) => row.generalId)));
+        const scoreRows = await ctx.db.rankData.findMany({
+            where: { generalId: { in: [...candidateIds] }, type: { in: rankTypeNames } },
+            select: { generalId: true, type: true, value: true },
+        });
+        const rankMap = new Map<number, Record<string, number>>();
+        for (const row of scoreRows) {
+            const ranks = rankMap.get(row.generalId) ?? {};
+            ranks[row.type] = row.value;
+            rankMap.set(row.generalId, ranks);
+        }
+        const generals = await ctx.db.general.findMany({
+            where: { id: { in: [...rankMap.keys()] } },
+            select: { id: true, name: true, npcState: true, leadership: true, strength: true, intel: true },
+        });
+
+        return tournamentRankTypes.map((prefix) => {
+            const entries = generals
+                .filter((general) => candidateIdsByPrefix.get(prefix)?.has(general.id))
+                .map((general) => {
+                    const ranks = rankMap.get(general.id) ?? {};
+                    const win = ranks[`${prefix}w`] ?? 0;
+                    const draw = ranks[`${prefix}d`] ?? 0;
+                    const lose = ranks[`${prefix}l`] ?? 0;
+                    const score = ranks[`${prefix}g`] ?? 0;
+                    const stat =
+                        prefix === 'tt'
+                            ? general.leadership + general.strength + general.intel
+                            : prefix === 'tl'
+                              ? general.leadership
+                              : prefix === 'ts'
+                                ? general.strength
+                                : general.intel;
+                    return {
+                        generalId: general.id,
+                        name: general.name,
+                        npcState: general.npcState,
+                        stat,
+                        games: win + draw + lose,
+                        win,
+                        draw,
+                        lose,
+                        score,
+                        prizes: ranks[`${prefix}p`] ?? 0,
+                    };
+                })
+                .sort(
+                    (lhs, rhs) =>
+                        rhs.score - lhs.score ||
+                        rhs.games - lhs.games ||
+                        rhs.win - lhs.win ||
+                        rhs.draw - lhs.draw ||
+                        lhs.lose - rhs.lose
+                )
+                .slice(0, 30)
+                .map((entry, index) => ({ rank: index + 1, ...entry }));
+            return { prefix, ...tournamentRankInfo[prefix], entries };
+        });
    }),
    setState: adminProcedure.input(zTournamentState).mutation(async ({ ctx, input }) => {
        const store = new TournamentStore(ctx.redis, buildTournamentKeys(ctx.profile.name));
-        await store.setState({
-            ...input,
-            type: input.type as TournamentType,
+        return store.withMutationLock(async () => {
+            await store.setState({
+                ...input,
+                type: input.type as TournamentType,
+            });
+            return { ok: true };
        });
-        return { ok: true };
    }),
    patchState: adminProcedure.input(zTournamentState.partial()).mutation(async ({ ctx, input }) => {
        const store = new TournamentStore(ctx.redis, buildTournamentKeys(ctx.profile.name));
-        const current = await store.getState();
-        if (!current) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'Tournament state not found.' });
-        }
-        const next = {
-            ...current,
-            ...input,
-            type: (input.type !== undefined ? input.type : current.type) as TournamentType,
-        };
-        await store.setState(next);
-        return { ok: true };
+        return store.withMutationLock(async () => {
+            const current = await store.getState();
+            if (!current) {
+                throw new TRPCError({ code: 'NOT_FOUND', message: 'Tournament state not found.' });
+            }
+            const next = {
+                ...current,
+                ...input,
+                type: (input.type !== undefined ? input.type : current.type) as TournamentType,
+            };
+            await store.setState(next);
+            return { ok: true };
+        });
    }),
    setParticipants: adminProcedure.input(z.array(zParticipant)).mutation(async ({ ctx, input }) => {
        const store = new TournamentStore(ctx.redis, buildTournamentKeys(ctx.profile.name));
-        await store.setParticipants(input);
-        return { ok: true, count: input.length };
+        return store.withMutationLock(async () => {
+            await store.setParticipants(input);
+            return { ok: true, count: input.length };
+        });
    }),
    setMatches: adminProcedure.input(z.array(zMatch)).mutation(async ({ ctx, input }) => {
        const store = new TournamentStore(ctx.redis, buildTournamentKeys(ctx.profile.name));
-        await store.setMatches(input);
-        return { ok: true, count: input.length };
+        return store.withMutationLock(async () => {
+            await store.setMatches(input);
+            return { ok: true, count: input.length };
+        });
    }),
    setBettingEntries: adminProcedure.input(z.array(zBetEntry)).mutation(async ({ ctx, input }) => {
        const store = new TournamentStore(ctx.redis, buildTournamentKeys(ctx.profile.name));
-        await store.setBettingEntries(input);
-        return { ok: true, count: input.length };
+        return store.withMutationLock(async () => {
+            await store.setBettingEntries(input);
+            return { ok: true, count: input.length };
+        });
    }),
    seedParticipants: adminProcedure.input(zSeedParticipants).mutation(async ({ ctx, input }) => {
        const limit = input.limit ?? 64;
        const includeNpc = input.includeNpc ?? true;
        const store = new TournamentStore(ctx.redis, buildTournamentKeys(ctx.profile.name));

-        const generals = input.generalIds && input.generalIds.length > 0
-            ? await ctx.db.general.findMany({
-                  where: { id: { in: input.generalIds } },
-                  select: { id: true, name: true, leadership: true, strength: true, intel: true, meta: true },
-              })
-            : await ctx.db.general.findMany({
-                  where: includeNpc ? {} : { npcState: 0 },
-                  orderBy: [
-                      { leadership: 'desc' },
-                      { strength: 'desc' },
-                      { intel: 'desc' },
-                      { id: 'asc' },
-                  ],
-                  take: limit,
-                  select: { id: true, name: true, leadership: true, strength: true, intel: true, meta: true },
-              });
+        const generals =
+            input.generalIds && input.generalIds.length > 0
+                ? await ctx.db.general.findMany({
+                      where: { id: { in: input.generalIds } },
+                      select: { id: true, name: true, leadership: true, strength: true, intel: true, meta: true },
+                  })
+                : await ctx.db.general.findMany({
+                      where: includeNpc ? {} : { npcState: 0 },
+                      orderBy: [{ leadership: 'desc' }, { strength: 'desc' }, { intel: 'desc' }, { id: 'asc' }],
+                      take: limit,
+                      select: { id: true, name: true, leadership: true, strength: true, intel: true, meta: true },
+                  });

        const participants = generals.map((general) => {
            const meta = asRecord(general.meta);
@@ -198,10 +300,13 @@ export const tournamentRouter = router({
            };
        });

-        await store.setParticipants(participants);
-        return { ok: true, count: participants.length };
+        return store.withMutationLock(async () => {
+            await store.setParticipants(participants);
+            return { ok: true, count: participants.length };
+        });
    }),
    getBettingSummary: authedProcedure.query(async ({ ctx }) => {
+        const general = await getMyGeneral(ctx);
        const store = new TournamentStore(ctx.redis, buildTournamentKeys(ctx.profile.name));
        const [state, entries, matches] = await Promise.all([
            store.getState(),
@@ -225,18 +330,13 @@ export const tournamentRouter = router({
        const myTotals: Record<number, number> = {};
        let totalAmount = 0;
        let myAmount = 0;
-        const userId = ctx.auth?.user.id;
-        const general = userId
-            ? await ctx.db.general.findFirst({ where: { userId }, select: { id: true } })
-            : null;
-
        for (const entry of entries) {
            if (!candidateIds.has(entry.targetId)) {
                continue;
            }
            totals[entry.targetId] = (totals[entry.targetId] ?? 0) + entry.amount;
            totalAmount += entry.amount;
-            if (general && entry.generalId === general.id) {
+            if (entry.generalId === general.id) {
                myTotals[entry.targetId] = (myTotals[entry.targetId] ?? 0) + entry.amount;
                myAmount += entry.amount;
            }
@@ -245,199 +345,254 @@ export const tournamentRouter = router({
        return { state, totals, myTotals, totalAmount, myAmount };
    }),
    join: authedProcedure.mutation(async ({ ctx }) => {
-        const userId = ctx.auth?.user.id;
-        if (!userId) {
-            throw new TRPCError({ code: 'UNAUTHORIZED' });
-        }
+        const general = await getMyGeneral(ctx);
        const store = new TournamentStore(ctx.redis, buildTournamentKeys(ctx.profile.name));
-        const state = await store.getState();
-        if (!state || state.stage !== 1 || state.participantsLockedAt) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: '참가 신청 기간이 아닙니다.' });
-        }
+        return store.withMutationLock(async () => {
+            const state = await store.getState();
+            if (!state || state.stage !== 1 || state.participantsLockedAt) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '참가 신청 기간이 아닙니다.' });
+            }

-        const participants = await store.getParticipants();
+            const [participants, worldState] = await Promise.all([
+                store.getParticipants(),
+                ctx.db.worldState.findFirst(),
+            ]);
+            if (participants.some((entry) => entry.id === general.id)) {
+                return { ok: true, count: participants.length };
+            }
+            if (participants.length >= 64) {
+                throw new TRPCError({ code: 'BAD_REQUEST', message: '참가 인원이 가득 찼습니다.' });
+            }

-        const general = await ctx.db.general.findFirst({
-            where: { userId },
-            select: { id: true, name: true, leadership: true, strength: true, intel: true, meta: true },
+            const config = asRecord(worldState?.config ?? {});
+            const constValues = asRecord(config.const ?? config);
+            const develCost = resolveNumber(constValues, ['develCost', 'develcost', 'develrate'], 0);
+            const feeResult = await ctx.turnDaemon.requestCommand({
+                type: 'adjustGeneralResources',
+                reason: 'tournamentJoin',
+                adjustments: [{ generalId: general.id, goldDelta: -develCost, minGoldAfter: 0 }],
+            });
+            if (!feeResult || feeResult.type !== 'adjustGeneralResources') {
+                throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: 'Unexpected response' });
+            }
+            if (!feeResult.ok || feeResult.processed !== 1) {
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message: feeResult.ok ? '금이 부족합니다.' : feeResult.reason,
+                });
+            }
+
+            const settingResult = await ctx.turnDaemon.requestCommand({
+                type: 'setMySetting',
+                generalId: general.id,
+                settings: { tnmt: 1 },
+            });
+            if (!settingResult || settingResult.type !== 'setMySetting' || !settingResult.ok) {
+                await ctx.turnDaemon.requestCommand({
+                    type: 'adjustGeneralResources',
+                    reason: 'tournamentJoinRollback',
+                    adjustments: [{ generalId: general.id, goldDelta: develCost }],
+                });
+                throw new TRPCError({
+                    code: 'BAD_REQUEST',
+                    message:
+                        settingResult && settingResult.type === 'setMySetting'
+                            ? (settingResult.reason ?? '요청에 실패했습니다.')
+                            : 'Unexpected response',
+                });
+            }
+
+            const meta = asRecord(general.meta);
+            const level = typeof meta.explevel === 'number' ? meta.explevel : 0;
+            const next = participants.concat({
+                id: general.id,
+                name: general.name,
+                leadership: general.leadership,
+                strength: general.strength,
+                intel: general.intel,
+                level,
+            });
+
+            try {
+                await store.setParticipants(next);
+            } catch (error) {
+                await Promise.all([
+                    ctx.turnDaemon.requestCommand({
+                        type: 'adjustGeneralResources',
+                        reason: 'tournamentJoinRollback',
+                        adjustments: [{ generalId: general.id, goldDelta: develCost }],
+                    }),
+                    ctx.turnDaemon.requestCommand({
+                        type: 'setMySetting',
+                        generalId: general.id,
+                        settings: { tnmt: 0 },
+                    }),
+                ]);
+                throw error;
+            }
+            return { ok: true, count: next.length };
        });
-        if (!general) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: '장수 정보를 찾을 수 없습니다.' });
-        }
-
-        const result = await ctx.turnDaemon.requestCommand({
-            type: 'setMySetting',
-            generalId: general.id,
-            settings: { tnmt: 1 },
-        });
-        if (!result || result.type !== 'setMySetting') {
-            throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: 'Unexpected response' });
-        }
-        if (!result.ok) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: result.reason ?? '요청에 실패했습니다.' });
-        }
-
-        const already = participants.find((entry) => entry.id === general.id);
-        if (already) {
-            return { ok: true, count: participants.length };
-        }
-
-        if (participants.length >= 64) {
-            throw new TRPCError({ code: 'BAD_REQUEST', message: '참가 인원이 가득 찼습니다.' });
-        }
-
-        const meta = asRecord(general.meta);
-        const level = typeof meta.explevel === 'number' ? meta.explevel : 0;
-        const next = participants.concat({
-            id: general.id,
-            name: general.name,
-            leadership: general.leadership,
-            strength: general.strength,
-            intel: general.intel,
-            level,
-        });
-
-        await store.setParticipants(next);
-        return { ok: true, count: next.length };
    }),
    cancel: adminProcedure.mutation(async ({ ctx }) => {
        const store = new TournamentStore(ctx.redis, buildTournamentKeys(ctx.profile.name));
-        const state = await store.getState();
-        if (!state) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'Tournament state not found.' });
-        }
-
-        const [participants, bets] = await Promise.all([
-            store.getParticipants(),
-            store.getBettingEntries(),
-        ]);
-
-        const worldState = await ctx.db.worldState.findFirst();
-        const config = asRecord(worldState?.config ?? {});
-        const constValues = asRecord(config.const ?? config);
-        const develCost = resolveNumber(constValues, ['develCost', 'develcost', 'develrate'], 0);
-
-        const refundMap = new Map<number, number>();
-        for (const participant of participants) {
-            if (participant.id <= 0) {
-                continue;
+        return store.withMutationLock(async () => {
+            const state = await store.getState();
+            if (!state) {
+                throw new TRPCError({ code: 'NOT_FOUND', message: 'Tournament state not found.' });
            }
-            if (participant.groupId !== undefined && participant.groupId >= 0 && participant.groupId < 8) {
-                refundMap.set(participant.id, (refundMap.get(participant.id) ?? 0) + develCost);
+
+            const [participants, bets] = await Promise.all([store.getParticipants(), store.getBettingEntries()]);
+
+            const worldState = await ctx.db.worldState.findFirst();
+            const config = asRecord(worldState?.config ?? {});
+            const constValues = asRecord(config.const ?? config);
+            const develCost = resolveNumber(constValues, ['develCost', 'develcost', 'develrate'], 0);
+
+            const refundMap = new Map<number, number>();
+            for (const participant of participants) {
+                if (participant.id <= 0) {
+                    continue;
+                }
+                if (participant.groupId !== undefined && participant.groupId >= 0 && participant.groupId < 8) {
+                    refundMap.set(participant.id, (refundMap.get(participant.id) ?? 0) + develCost);
+                }
+            }
+            for (const bet of bets) {
+                refundMap.set(bet.generalId, (refundMap.get(bet.generalId) ?? 0) + bet.amount);
            }
-        }
-        for (const bet of bets) {
-            refundMap.set(bet.generalId, (refundMap.get(bet.generalId) ?? 0) + bet.amount);
-        }

-        if (refundMap.size > 0) {
-            await ctx.turnDaemon.sendCommand({
-                type: 'tournamentRefund',
-                refunds: Array.from(refundMap.entries()).map(([generalId, amount]) => ({
-                    generalId,
-                    amount,
-                })),
-                reason: 'cancel',
-            });
-        }
+            if (refundMap.size > 0) {
+                await ctx.turnDaemon.sendCommand({
+                    type: 'tournamentRefund',
+                    refunds: Array.from(refundMap.entries()).map(([generalId, amount]) => ({
+                        generalId,
+                        amount,
+                    })),
+                    reason: 'cancel',
+                });
+            }

-        await Promise.all([
-            store.setParticipants([]),
-            store.setMatches([]),
-            store.setBettingEntries([]),
-        ]);
+            await Promise.all([store.setParticipants([]), store.setMatches([]), store.setBettingEntries([])]);

-        const nextState: TournamentState = {
-            ...state,
-            stage: 0,
-            phase: 0,
-            auto: false,
-            winnerId: undefined,
-            bettingSettled: true,
-            rewardSettled: false,
-            bettingCloseAt: undefined,
-            participantsLockedAt: undefined,
-            nextAt: new Date().toISOString(),
-        };
-        await store.setState(nextState);
-        return { ok: true };
+            const nextState: TournamentState = {
+                ...state,
+                stage: 0,
+                phase: 0,
+                auto: false,
+                winnerId: undefined,
+                bettingSettled: true,
+                rewardSettled: false,
+                bettingCloseAt: undefined,
+                participantsLockedAt: undefined,
+                nextAt: new Date().toISOString(),
+            };
+            await store.setState(nextState);
+            return { ok: true };
+        });
    }),
    placeBet: authedProcedure
        .input(
            z.object({
                targetId: z.number().int().positive(),
-                amount: z.number().int().positive(),
+                amount: z.number().int().min(10),
            })
        )
        .mutation(async ({ ctx, input }) => {
-            const userId = ctx.auth?.user.id;
-            if (!userId) {
-                throw new TRPCError({ code: 'UNAUTHORIZED' });
-            }
+            const general = await getMyGeneral(ctx);
            const store = new TournamentStore(ctx.redis, buildTournamentKeys(ctx.profile.name));
-            const state = await store.getState();
-            if (!state || state.stage !== 6) {
-                throw new TRPCError({ code: 'BAD_REQUEST', message: '베팅 기간이 아닙니다.' });
-            }
-            const closeAt = state.bettingCloseAt ? new Date(state.bettingCloseAt).getTime() : 0;
-            if (closeAt && closeAt <= Date.now()) {
-                throw new TRPCError({ code: 'BAD_REQUEST', message: '베팅이 마감되었습니다.' });
-            }
-
-            const matches = await store.getMatches();
-            const candidateIds = new Set<number>();
-            for (const match of matches) {
-                if (match.stage === 7) {
-                    candidateIds.add(match.attackerId);
-                    candidateIds.add(match.defenderId);
+            return store.withMutationLock(async () => {
+                const state = await store.getState();
+                if (!state || state.stage !== 6) {
+                    throw new TRPCError({ code: 'BAD_REQUEST', message: '베팅 기간이 아닙니다.' });
+                }
+                const closeAt = state.bettingCloseAt ? new Date(state.bettingCloseAt).getTime() : 0;
+                if (closeAt && closeAt <= Date.now()) {
+                    throw new TRPCError({ code: 'BAD_REQUEST', message: '베팅이 마감되었습니다.' });
                }
-            }
-            if (!candidateIds.has(input.targetId)) {
-                throw new TRPCError({ code: 'BAD_REQUEST', message: '올바르지 않은 베팅 대상입니다.' });
-            }

-            const general = await ctx.db.general.findFirst({
-                where: { userId },
-                select: { id: true, gold: true },
-            });
-            if (!general) {
-                throw new TRPCError({ code: 'PRECONDITION_FAILED', message: '장수가 존재하지 않습니다.' });
-            }
+                const [matches, entries] = await Promise.all([store.getMatches(), store.getBettingEntries()]);
+                const candidateIds = new Set<number>();
+                for (const match of matches) {
+                    if (match.stage === 7) {
+                        candidateIds.add(match.attackerId);
+                        candidateIds.add(match.defenderId);
+                    }
+                }
+                if (!candidateIds.has(input.targetId)) {
+                    throw new TRPCError({ code: 'BAD_REQUEST', message: '올바르지 않은 베팅 대상입니다.' });
+                }

-            const minRemainGold = 500;
-            if (general.gold - input.amount < minRemainGold) {
-                throw new TRPCError({ code: 'BAD_REQUEST', message: '소지금이 부족합니다.' });
-            }
+                const previousBetAmount = entries
+                    .filter((entry) => entry.generalId === general.id)
+                    .reduce((sum, entry) => sum + entry.amount, 0);
+                if (previousBetAmount + input.amount > 1_000) {
+                    throw new TRPCError({
+                        code: 'BAD_REQUEST',
+                        message: `${1_000 - previousBetAmount}금까지만 베팅 가능합니다.`,
+                    });
+                }

-            const adjustResult = await ctx.turnDaemon.requestCommand({
-                type: 'adjustGeneralResources',
-                reason: 'tournamentBet',
-                adjustments: [{ generalId: general.id, goldDelta: -input.amount }],
-            });
-            if (!adjustResult || adjustResult.type !== 'adjustGeneralResources') {
-                throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: 'Unexpected response' });
-            }
-            if (!adjustResult.ok) {
-                throw new TRPCError({ code: 'BAD_REQUEST', message: adjustResult.reason });
-            }
+                const adjustResult = await ctx.turnDaemon.requestCommand({
+                    type: 'adjustGeneralResources',
+                    reason: 'tournamentBet',
+                    adjustments: [{ generalId: general.id, goldDelta: -input.amount, minGoldAfter: 500 }],
+                });
+                if (!adjustResult || adjustResult.type !== 'adjustGeneralResources') {
+                    throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: 'Unexpected response' });
+                }
+                if (!adjustResult.ok || adjustResult.processed !== 1) {
+                    throw new TRPCError({
+                        code: 'BAD_REQUEST',
+                        message: adjustResult.ok ? '금이 부족합니다.' : adjustResult.reason,
+                    });
+                }

-            await ctx.turnDaemon.sendCommand({
-                type: 'adjustGeneralMeta',
-                reason: 'tournamentBet',
-                adjustments: [
-                    {
+                const rankResult = await ctx.turnDaemon.requestCommand({
+                    type: 'adjustGeneralMeta',
+                    reason: 'tournamentBet',
+                    adjustments: [
+                        {
+                            generalId: general.id,
+                            metaDelta: { betgold: input.amount },
+                        },
+                    ],
+                });
+                if (!rankResult || rankResult.type !== 'adjustGeneralMeta' || !rankResult.ok) {
+                    await ctx.turnDaemon.requestCommand({
+                        type: 'adjustGeneralResources',
+                        reason: 'tournamentBetRollback',
+                        adjustments: [{ generalId: general.id, goldDelta: input.amount }],
+                    });
+                    throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: '베팅 기록을 저장하지 못했습니다.' });
+                }
+
+                try {
+                    await store.appendBettingEntry({
                        generalId: general.id,
-                        metaDelta: { rank_betgold: input.amount },
-                    },
-                ],
+                        targetId: input.targetId,
+                        amount: input.amount,
+                    });
+                } catch (error) {
+                    await Promise.all([
+                        ctx.turnDaemon.requestCommand({
+                            type: 'adjustGeneralResources',
+                            reason: 'tournamentBetRollback',
+                            adjustments: [{ generalId: general.id, goldDelta: input.amount }],
+                        }),
+                        ctx.turnDaemon.requestCommand({
+                            type: 'adjustGeneralMeta',
+                            reason: 'tournamentBetRollback',
+                            adjustments: [
+                                {
+                                    generalId: general.id,
+                                    metaDelta: { betgold: -input.amount },
+                                },
+                            ],
+                        }),
+                    ]);
+                    throw error;
+                }
+                return { ok: true };
            });
-
-            await store.appendBettingEntry({
-                generalId: general.id,
-                targetId: input.targetId,
-                amount: input.amount,
-            });
-
-            return { ok: true };
        }),
 });
@@ -1,9 +1,19 @@
+import { randomUUID } from 'node:crypto';
+
 import type { TournamentKeys } from './keys.js';
 import type { TournamentBetEntry, TournamentMatchEntry, TournamentParticipantEntry, TournamentState } from './types.js';

 interface RedisClientLike {
    get(key: string): Promise<string | null>;
-    set(key: string, value: string): Promise<unknown>;
+    set(
+        key: string,
+        value: string,
+        options?: {
+            NX?: boolean;
+            PX?: number;
+        }
+    ): Promise<unknown>;
+    del?(key: string): Promise<unknown>;
 }

 const safeJsonParse = <T>(raw: string | null): T | null => {
@@ -18,7 +28,34 @@ const safeJsonParse = <T>(raw: string | null): T | null => {
 };

 export class TournamentStore {
-    constructor(private readonly redis: RedisClientLike, private readonly keys: TournamentKeys) {}
+    constructor(
+        private readonly redis: RedisClientLike,
+        private readonly keys: TournamentKeys
+    ) {}
+
+    async withMutationLock<T>(operation: () => Promise<T>, timeoutMs = 2_000): Promise<T> {
+        if (!this.redis.del) {
+            return operation();
+        }
+
+        const lockKey = `${this.keys.stateKey}:mutation-lock`;
+        const token = randomUUID();
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+            const acquired = await this.redis.set(lockKey, token, { NX: true, PX: 30_000 });
+            if (acquired) {
+                try {
+                    return await operation();
+                } finally {
+                    if ((await this.redis.get(lockKey)) === token) {
+                        await this.redis.del(lockKey);
+                    }
+                }
+            }
+            await new Promise((resolve) => setTimeout(resolve, 10));
+        }
+        throw new Error('토너먼트 요청이 처리 중입니다. 잠시 후 다시 시도해주세요.');
+    }

    async getState(): Promise<TournamentState | null> {
        return safeJsonParse<TournamentState>(await this.redis.get(this.keys.stateKey));
@@ -54,7 +91,14 @@ export class TournamentStore {

    async appendBettingEntry(entry: TournamentBetEntry): Promise<TournamentBetEntry[]> {
        const entries = await this.getBettingEntries();
-        entries.push(entry);
+        const existing = entries.find(
+            (candidate) => candidate.generalId === entry.generalId && candidate.targetId === entry.targetId
+        );
+        if (existing) {
+            existing.amount += entry.amount;
+        } else {
+            entries.push(entry);
+        }
        await this.setBettingEntries(entries);
        return entries;
    }
@@ -518,7 +518,6 @@ export const settleTournamentOutcome = async (options: {
    return settledState;
 };

-
 export const runTournamentWorker = async (): Promise<void> => {
    const config = resolveGameApiConfigFromEnv();
    const postgres = createGamePostgresConnector(resolvePostgresConfigFromEnv({ schema: config.profile }));
@@ -555,25 +554,36 @@ export const runTournamentWorker = async (): Promise<void> => {
        }

        try {
-            const worldState = await postgres.prisma.worldState.findFirst();
-            const baseSeed = (worldState?.meta as Record<string, unknown> | null)?.hiddenSeed ?? 'tournament';
-            let nextState = state;
-            if (isBattleStage(state.stage)) {
-                nextState = await applyBattle(store, state, String(baseSeed), daemonTransport);
-            } else if (isPreBattleStage(state.stage)) {
-                nextState = await applyPreBattleStage(
-                    store,
-                    postgres.prisma,
-                    state,
-                    String(baseSeed),
-                    daemonTransport
-                );
-            }
+            await store.withMutationLock(async () => {
+                const lockedState = await store.getState();
+                if (!lockedState || !lockedState.auto) {
+                    return;
+                }
+                const lockedNextAt = new Date(lockedState.nextAt).getTime();
+                if (Number.isFinite(lockedNextAt) && lockedNextAt > Date.now()) {
+                    return;
+                }

-            await settleTournamentOutcome({
-                store,
-                daemonTransport,
-                state: nextState,
+                const worldState = await postgres.prisma.worldState.findFirst();
+                const baseSeed = (worldState?.meta as Record<string, unknown> | null)?.hiddenSeed ?? 'tournament';
+                let nextState = lockedState;
+                if (isBattleStage(lockedState.stage)) {
+                    nextState = await applyBattle(store, lockedState, String(baseSeed), daemonTransport);
+                } else if (isPreBattleStage(lockedState.stage)) {
+                    nextState = await applyPreBattleStage(
+                        store,
+                        postgres.prisma,
+                        lockedState,
+                        String(baseSeed),
+                        daemonTransport
+                    );
+                }
+
+                await settleTournamentOutcome({
+                    store,
+                    daemonTransport,
+                    state: nextState,
+                });
            });
        } catch (error) {
            const message = error instanceof Error ? error.message : 'Unknown error';
@@ -652,7 +652,7 @@ export const seedNpcBets = async (options: {
        reason: 'tournamentNpcBet',
        adjustments: npcBetList.map((npc) => ({
            generalId: npc.id as number,
-            metaDelta: { rank_betgold: betGold },
+            metaDelta: { betgold: betGold },
        })),
    });
    await store.setBettingEntries(entries);
@@ -0,0 +1,336 @@
+import { describe, expect, it } from 'vitest';
+
+import type { TurnDaemonCommand, TurnDaemonCommandResult } from '@sammo-ts/common';
+import type { GameSessionTokenPayload } from '@sammo-ts/common/auth/gameToken';
+import type { RedisConnector } from '@sammo-ts/infra';
+
+import { InMemoryFlushStore } from '../src/auth/flushStore.js';
+import { RedisAccessTokenStore } from '../src/auth/accessTokenStore.js';
+import type { DatabaseClient, GameApiContext, GeneralRow } from '../src/context.js';
+import type { TurnDaemonTransport } from '../src/daemon/transport.js';
+import { appRouter } from '../src/router.js';
+
+class MemoryRedis {
+    private readonly values = new Map<string, string>();
+
+    async get(key: string): Promise<string | null> {
+        return this.values.get(key) ?? null;
+    }
+
+    async set(key: string, value: string, options?: { NX?: boolean }): Promise<string | null> {
+        if (options?.NX && this.values.has(key)) {
+            return null;
+        }
+        this.values.set(key, value);
+        return 'OK';
+    }
+
+    async del(key: string): Promise<number> {
+        return this.values.delete(key) ? 1 : 0;
+    }
+}
+
+class TournamentTransport implements TurnDaemonTransport {
+    readonly commands: TurnDaemonCommand[] = [];
+    readonly gold = new Map<number, number>();
+    failNextRankUpdate = false;
+
+    async sendCommand(command: TurnDaemonCommand): Promise<string> {
+        this.commands.push(command);
+        return `command-${this.commands.length}`;
+    }
+
+    async requestCommand(command: TurnDaemonCommand): Promise<TurnDaemonCommandResult | null> {
+        this.commands.push(command);
+        if (command.type === 'adjustGeneralResources') {
+            const adjustment = command.adjustments[0];
+            if (!adjustment) {
+                return { type: 'adjustGeneralResources', ok: false, reason: '조정 대상이 없습니다.' };
+            }
+            const nextGold = (this.gold.get(adjustment.generalId) ?? 0) + (adjustment.goldDelta ?? 0);
+            if (nextGold < (adjustment.minGoldAfter ?? 0)) {
+                return { type: 'adjustGeneralResources', ok: false, reason: '자원이 부족합니다.' };
+            }
+            this.gold.set(adjustment.generalId, nextGold);
+            return {
+                type: 'adjustGeneralResources',
+                ok: true,
+                processed: 1,
+                missing: 0,
+                totalGoldDelta: adjustment.goldDelta ?? 0,
+                totalRiceDelta: 0,
+            };
+        }
+        if (command.type === 'setMySetting') {
+            return { type: 'setMySetting', ok: true, generalId: command.generalId };
+        }
+        if (command.type === 'adjustGeneralMeta') {
+            if (this.failNextRankUpdate) {
+                this.failNextRankUpdate = false;
+                return { type: 'adjustGeneralMeta', ok: false, reason: 'rank update failed' };
+            }
+            return { type: 'adjustGeneralMeta', ok: true, processed: 1, missing: 0 };
+        }
+        return null;
+    }
+
+    async requestStatus() {
+        return null;
+    }
+}
+
+const buildGeneral = (id: number, userId: string, gold = 2_000): GeneralRow =>
+    ({
+        id,
+        userId,
+        name: `장수${id}`,
+        leadership: 70 + id,
+        strength: 60 + id,
+        intel: 50 + id,
+        gold,
+        meta: { explevel: 5 },
+    }) as unknown as GeneralRow;
+
+const buildAuth = (userId: string, roles: string[] = []): GameSessionTokenPayload => ({
+    version: 1,
+    profile: 'che:default',
+    issuedAt: '2026-07-26T00:00:00.000Z',
+    expiresAt: '2026-07-27T00:00:00.000Z',
+    sessionId: `session-${userId}`,
+    user: {
+        id: userId,
+        username: userId,
+        displayName: userId,
+        roles,
+    },
+    sanctions: {},
+});
+
+const buildContext = (options: {
+    redis: MemoryRedis;
+    transport: TournamentTransport;
+    generals: GeneralRow[];
+    userId: string;
+    roles?: string[];
+    develCost?: number;
+    rankRows?: Array<{ generalId: number; type: string; value: number }>;
+}): GameApiContext => {
+    const db = {
+        general: {
+            findFirst: async ({ where }: { where: { userId: string } }) =>
+                options.generals.find((general) => general.userId === where.userId) ?? null,
+            findMany: async ({ where }: { where: { id: { in: number[] } } }) =>
+                options.generals.filter((general) => where.id.in.includes(general.id)),
+        },
+        rankData: {
+            findMany: async () => options.rankRows ?? [],
+        },
+        worldState: {
+            findFirst: async () => ({ config: { const: { develCost: options.develCost ?? 200 } } }),
+        },
+    } as unknown as DatabaseClient;
+    return {
+        db,
+        redis: options.redis as unknown as RedisConnector['client'],
+        turnDaemon: options.transport,
+        battleSim: {} as GameApiContext['battleSim'],
+        profile: { id: 'che', scenario: 'default', name: 'che:default' },
+        uploadDir: 'uploads',
+        uploadPath: '/uploads',
+        uploadPublicUrl: null,
+        auth: buildAuth(options.userId, options.roles),
+        accessTokenStore: new RedisAccessTokenStore(options.redis, 'che:default'),
+        flushStore: new InMemoryFlushStore(),
+        gameTokenSecret: 'test-secret',
+    };
+};
+
+const setTournamentFixture = async (redis: MemoryRedis, state: Record<string, unknown>) => {
+    const prefix = 'sammo:che:default:tournament';
+    await redis.set(`${prefix}:state`, JSON.stringify(state));
+    await redis.set(
+        `${prefix}:participants`,
+        JSON.stringify([
+            { id: 11, name: '후보11', leadership: 80, strength: 70, intel: 60, level: 5 },
+            { id: 12, name: '후보12', leadership: 70, strength: 80, intel: 60, level: 5 },
+        ])
+    );
+    await redis.set(
+        `${prefix}:matches`,
+        JSON.stringify([{ id: 1, stage: 7, roundIndex: 0, attackerId: 11, defenderId: 12 }])
+    );
+    await redis.set(`${prefix}:betting`, '[]');
+};
+
+describe('tournament router permissions and mutations', () => {
+    it('charges the authenticated general once when joining', async () => {
+        const redis = new MemoryRedis();
+        const transport = new TournamentTransport();
+        const general = buildGeneral(1, 'user-1');
+        transport.gold.set(general.id, general.gold);
+        await setTournamentFixture(redis, {
+            stage: 1,
+            phase: 0,
+            type: 0,
+            auto: true,
+            openYear: 193,
+            openMonth: 1,
+            termSeconds: 60,
+            nextAt: '2026-07-26T01:00:00.000Z',
+        });
+        await redis.set('sammo:che:default:tournament:participants', '[]');
+        const caller = appRouter.createCaller(
+            buildContext({ redis, transport, generals: [general], userId: 'user-1', develCost: 200 })
+        );
+
+        await expect(caller.tournament.join()).resolves.toEqual({ ok: true, count: 1 });
+        await expect(caller.tournament.join()).resolves.toEqual({ ok: true, count: 1 });
+
+        expect(transport.gold.get(general.id)).toBe(1_800);
+        expect(transport.commands.filter((command) => command.type === 'adjustGeneralResources')).toHaveLength(1);
+    });
+
+    it('serializes concurrent bets and enforces the legacy per-user 1000 limit', async () => {
+        const redis = new MemoryRedis();
+        const transport = new TournamentTransport();
+        const general = buildGeneral(1, 'user-1', 3_000);
+        transport.gold.set(general.id, general.gold);
+        await setTournamentFixture(redis, {
+            stage: 6,
+            phase: 0,
+            type: 0,
+            auto: true,
+            openYear: 193,
+            openMonth: 1,
+            termSeconds: 60,
+            nextAt: '2026-07-26T01:00:00.000Z',
+            bettingCloseAt: '2099-01-01T00:00:00.000Z',
+        });
+        const caller = appRouter.createCaller(
+            buildContext({ redis, transport, generals: [general], userId: 'user-1' })
+        );
+
+        const results = await Promise.allSettled([
+            caller.tournament.placeBet({ targetId: 11, amount: 600 }),
+            caller.tournament.placeBet({ targetId: 12, amount: 600 }),
+        ]);
+
+        expect(results.filter((result) => result.status === 'fulfilled')).toHaveLength(1);
+        expect(results.filter((result) => result.status === 'rejected')).toHaveLength(1);
+        const summary = await caller.tournament.getBettingSummary();
+        expect(summary.myAmount).toBe(600);
+        expect(summary.totalAmount).toBe(600);
+        expect(transport.gold.get(general.id)).toBe(2_400);
+    });
+
+    it('keeps another user from reading my bet identity and requires that user to own a general', async () => {
+        const redis = new MemoryRedis();
+        const transport = new TournamentTransport();
+        const owner = buildGeneral(1, 'user-1');
+        const other = buildGeneral(2, 'user-2');
+        await setTournamentFixture(redis, {
+            stage: 6,
+            phase: 0,
+            type: 0,
+            auto: true,
+            openYear: 193,
+            openMonth: 1,
+            termSeconds: 60,
+            nextAt: '2026-07-26T01:00:00.000Z',
+        });
+        await redis.set(
+            'sammo:che:default:tournament:betting',
+            JSON.stringify([{ generalId: owner.id, targetId: 11, amount: 300 }])
+        );
+
+        const otherCaller = appRouter.createCaller(
+            buildContext({ redis, transport, generals: [owner, other], userId: 'user-2' })
+        );
+        const snapshot = await otherCaller.tournament.getSnapshot();
+        expect(snapshot).toMatchObject({ betCount: 1 });
+        expect(snapshot).not.toHaveProperty('bets');
+        expect((await otherCaller.tournament.getBettingSummary()).myAmount).toBe(0);
+
+        const generalLessCaller = appRouter.createCaller(
+            buildContext({ redis, transport, generals: [owner], userId: 'user-3' })
+        );
+        await expect(generalLessCaller.tournament.getSnapshot()).rejects.toMatchObject({ code: 'NOT_FOUND' });
+        await expect(generalLessCaller.tournament.join()).rejects.toMatchObject({ code: 'NOT_FOUND' });
+    });
+
+    it('limits tournament administration to global or profile-scoped roles', async () => {
+        const redis = new MemoryRedis();
+        const transport = new TournamentTransport();
+        const general = buildGeneral(1, 'user-1');
+        const userCaller = appRouter.createCaller(
+            buildContext({ redis, transport, generals: [general], userId: 'user-1', roles: ['user'] })
+        );
+        await expect(userCaller.tournament.getAdminStatus()).rejects.toMatchObject({ code: 'FORBIDDEN' });
+
+        const adminCaller = appRouter.createCaller(
+            buildContext({
+                redis,
+                transport,
+                generals: [general],
+                userId: 'user-1',
+                roles: ['admin.tournament:che:default'],
+            })
+        );
+        await expect(adminCaller.tournament.getAdminStatus()).resolves.toEqual({ ok: true });
+    });
+
+    it('returns the legacy tournament rank ordering only to a user who owns a general', async () => {
+        const redis = new MemoryRedis();
+        const transport = new TournamentTransport();
+        const first = buildGeneral(1, 'user-1');
+        const second = buildGeneral(2, 'user-2');
+        const rankRows = [
+            { generalId: first.id, type: 'ttg', value: 20 },
+            { generalId: first.id, type: 'ttw', value: 3 },
+            { generalId: second.id, type: 'ttg', value: 20 },
+            { generalId: second.id, type: 'ttw', value: 4 },
+        ];
+        const ownerCaller = appRouter.createCaller(
+            buildContext({ redis, transport, generals: [first, second], userId: 'user-1', rankRows })
+        );
+        const sections = await ownerCaller.tournament.getRankings();
+        expect(sections).toHaveLength(4);
+        expect(sections[0]?.entries.map((entry) => entry.generalId)).toEqual([second.id, first.id]);
+
+        const generalLessCaller = appRouter.createCaller(
+            buildContext({ redis, transport, generals: [first, second], userId: 'user-3', rankRows })
+        );
+        await expect(generalLessCaller.tournament.getRankings()).rejects.toMatchObject({ code: 'NOT_FOUND' });
+    });
+
+    it('refunds gold when the tournament bet rank update fails', async () => {
+        const redis = new MemoryRedis();
+        const transport = new TournamentTransport();
+        const general = buildGeneral(1, 'user-1', 2_000);
+        transport.gold.set(general.id, general.gold);
+        transport.failNextRankUpdate = true;
+        await setTournamentFixture(redis, {
+            stage: 6,
+            phase: 0,
+            type: 0,
+            auto: true,
+            openYear: 193,
+            openMonth: 1,
+            termSeconds: 60,
+            nextAt: '2026-07-26T01:00:00.000Z',
+            bettingCloseAt: '2099-01-01T00:00:00.000Z',
+        });
+        const caller = appRouter.createCaller(
+            buildContext({ redis, transport, generals: [general], userId: 'user-1' })
+        );
+
+        await expect(caller.tournament.placeBet({ targetId: 11, amount: 100 })).rejects.toMatchObject({
+            code: 'INTERNAL_SERVER_ERROR',
+        });
+        expect(transport.gold.get(general.id)).toBe(2_000);
+        await expect(caller.tournament.getBettingSummary()).resolves.toMatchObject({
+            totalAmount: 0,
+            myAmount: 0,
+        });
+    });
+});
@@ -209,6 +209,33 @@ const runTournamentToCompletion = async (options: {
 const delayTick = async (): Promise<void> => new Promise((resolve) => setTimeout(resolve, 0));

 describe('tournament worker (in-memory)', () => {
+    it('locks 64 applicants into eight groups of eight', async () => {
+        const redis = new MemoryRedis();
+        const store = new TournamentStore(redis, buildTournamentKeys('test-groups'));
+        const state = createTournamentState({ stage: 1 });
+        await store.setParticipants(createParticipants(16, 16, 32));
+        await store.setState(state);
+
+        const next = await applyPreBattleStage(
+            store,
+            createPrismaMock({ baseSeed: 'seed' }),
+            state,
+            'seed',
+            createNoopDaemonTransport()
+        );
+        const grouped = await store.getParticipants();
+
+        expect(next).toMatchObject({ stage: 2, phase: 0 });
+        expect(next.participantsLockedAt).toBeTruthy();
+        for (let groupId = 0; groupId < 8; groupId += 1) {
+            const entries = grouped.filter((entry) => entry.groupId === groupId);
+            expect(entries).toHaveLength(8);
+            expect(entries.map((entry) => entry.groupNo).sort((a, b) => Number(a) - Number(b))).toEqual([
+                0, 1, 2, 3, 4, 5, 6, 7,
+            ]);
+        }
+    });
+
    it('64명 고정 seed 대진에서 15번 참가자가 결승을 이긴다', async () => {
        const redis = new MemoryRedis();
        const store = new TournamentStore(redis, buildTournamentKeys('test'));