merge: implement monthly nation level update

2026-07-25 17:20:17 +00:00
parent 7afb2ac63f 41d70a475c
commit cec0ccb1b4
8 changed files with 1089 additions and 17 deletions
@@ -384,6 +384,7 @@ export const createDatabaseTurnHooks = async (
            deletedEvents,
            lifecycleEvents,
            pendingNeutralAuctions,
+            inheritancePointAdjustments,
        } = changes;
        const reservedTurnChanges = options?.reservedTurns?.peekDirtyState();

@@ -435,6 +436,26 @@ export const createDatabaseTurnHooks = async (
                asRecord(world.getScenarioConfig().const)
            );

+            if (inheritancePointAdjustments.length > 0) {
+                const grouped = new Map<string, { userId: string; key: string; amount: number }>();
+                for (const entry of inheritancePointAdjustments) {
+                    const groupKey = `${entry.userId}\u0000${entry.key}`;
+                    const current = grouped.get(groupKey);
+                    if (current) {
+                        current.amount += entry.amount;
+                    } else {
+                        grouped.set(groupKey, { ...entry });
+                    }
+                }
+                for (const entry of grouped.values()) {
+                    await prisma.inheritancePoint.upsert({
+                        where: { userId_key: { userId: entry.userId, key: entry.key } },
+                        update: { value: { increment: entry.amount } },
+                        create: { userId: entry.userId, key: entry.key, value: entry.amount },
+                    });
+                }
+            }
+
            if (deletedNationSnapshots.length > 0) {
                const nationIds = deletedNationSnapshots.map((snapshot) => snapshot.nation.id);
                const historyRows = await prisma.logEntry.findMany({
@@ -110,6 +110,7 @@ export interface TurnWorldChanges {
    deletedEvents: number[];
    lifecycleEvents: GeneralLifecycleEvent[];
    pendingNeutralAuctions: PendingNeutralAuction[];
+    inheritancePointAdjustments: Array<{ userId: string; key: string; amount: number }>;
 }

 const compareTurnOrder = (left: TurnGeneral, right: TurnGeneral): number => {
@@ -279,6 +280,7 @@ export class InMemoryTurnWorld {
    private readonly messages: MessageDraft[] = [];
    private readonly lifecycleEvents: GeneralLifecycleEvent[] = [];
    private readonly pendingNeutralAuctions: PendingNeutralAuction[] = [];
+    private readonly inheritancePointAdjustments: Array<{ userId: string; key: string; amount: number }> = [];
    private readonly scenarioConfig: ScenarioConfig;
    private checkpoint?: TurnCheckpoint;
    private state: TurnWorldState;
@@ -348,6 +350,13 @@ export class InMemoryTurnWorld {
        });
    }

+    queueInheritancePointAdjustment(userId: string, key: string, amount: number): void {
+        if (!userId || !Number.isFinite(amount) || amount === 0) {
+            return;
+        }
+        this.inheritancePointAdjustments.push({ userId, key, amount });
+    }
+
    getScenarioConfig(): ScenarioConfig {
        return this.scenarioConfig;
    }
@@ -840,6 +849,7 @@ export class InMemoryTurnWorld {
            detail: { ...auction.detail },
            closeAt: new Date(auction.closeAt.getTime()),
        }));
+        const inheritancePointAdjustments = this.inheritancePointAdjustments.map((entry) => ({ ...entry }));

        return {
            generals,
@@ -860,6 +870,7 @@ export class InMemoryTurnWorld {
            deletedEvents,
            lifecycleEvents,
            pendingNeutralAuctions,
+            inheritancePointAdjustments,
        };
    }

@@ -886,6 +897,7 @@ export class InMemoryTurnWorld {
        this.messages.splice(0, changes.messages.length);
        this.lifecycleEvents.splice(0, changes.lifecycleEvents.length);
        this.pendingNeutralAuctions.splice(0, changes.pendingNeutralAuctions.length);
+        this.inheritancePointAdjustments.splice(0, changes.inheritancePointAdjustments.length);
    }

    consumeDirtyState(): TurnWorldChanges {
@@ -16,7 +16,7 @@ export type MonthlyEventActionHandler = (
    args: readonly unknown[],
    environment: MonthlyEventEnvironment,
    event: TurnEvent
-) => void;
+) => void | Promise<void>;

 export type MonthlyEventActionRegistry = ReadonlyMap<string, MonthlyEventActionHandler>;

@@ -180,7 +180,7 @@ export const createMonthlyEventHandler = (options: {
    startYear: number;
    actions?: MonthlyEventActionRegistry;
 }): TurnCalendarHandler => {
-    const dispatch = (targetCode: 'pre_month' | 'month', context: TurnCalendarContext): void => {
+    const dispatch = async (targetCode: 'pre_month' | 'month', context: TurnCalendarContext): Promise<void> => {
        const world = options.getWorld();
        if (!world) {
            return;
@@ -209,7 +209,7 @@ export const createMonthlyEventHandler = (options: {
                if (!handler) {
                    throw new Error(`Unsupported monthly event action: ${action.name} (eventId=${event.id})`);
                }
-                handler(action.args, environment, event);
+                await handler(action.args, environment, event);
            }
        }
    };
@@ -0,0 +1,370 @@
+import { JosaUtil, LiteHashDRBG, RandUtil } from '@sammo-ts/common';
+import {
+    LogCategory,
+    LogFormat,
+    LogScope,
+    countOccupiedUniqueItems,
+    createItemModuleRegistry,
+    equipNewItem,
+    resolveUniqueConfig,
+    type ItemModule,
+} from '@sammo-ts/logic';
+import { buildLegacyDefaultUniqueItemPool } from '@sammo-ts/logic/rewards/legacyUniqueItemPool.js';
+import { simpleSerialize } from '@sammo-ts/logic/war/utils.js';
+
+import type { InMemoryTurnWorld } from './inMemoryWorld.js';
+import type { MonthlyEventActionHandler } from './monthlyEventHandler.js';
+import type { InMemoryReservedTurnStore } from './reservedTurnStore.js';
+import type { TurnGeneral } from './types.js';
+
+const NATION_LEVEL_CITY_COUNTS = [0, 1, 2, 5, 8, 11, 16, 21] as const;
+const NATION_LEVEL_NAMES = ['방랑군', '호족', '군벌', '주자사', '주목', '공', '왕', '황제'] as const;
+// Legacy Util::range(minChiefLevel, 12) is Python-style and excludes 12.
+const EXCLUSIVE_MAX_CHIEF_LEVEL = 12;
+
+const resolveNationChiefLevel = (nationLevel: number): number => {
+    if (nationLevel >= 6) return 5;
+    if (nationLevel >= 4) return 7;
+    if (nationLevel >= 2) return 9;
+    return 11;
+};
+
+const readNumber = (value: unknown, fallback = 0): number => {
+    if (typeof value === 'number' && Number.isFinite(value)) {
+        return value;
+    }
+    if (typeof value === 'string') {
+        const parsed = Number(value);
+        if (Number.isFinite(parsed)) {
+            return parsed;
+        }
+    }
+    return fallback;
+};
+
+const resolveHiddenSeed = (world: InMemoryTurnWorld): string | number => {
+    const state = world.getState();
+    const rawSeed = state.meta.hiddenSeed ?? state.meta.seed ?? state.id;
+    return typeof rawSeed === 'string' || typeof rawSeed === 'number' ? rawSeed : String(rawSeed);
+};
+
+const countNonBuyableItems = (general: TurnGeneral, itemRegistry: Map<string, ItemModule>): number =>
+    Object.values(general.role.items).filter((itemKey) => {
+        if (!itemKey) return false;
+        return itemRegistry.get(itemKey)?.buyable === false;
+    }).length;
+
+const addCount = (target: Map<string, number>, source: ReadonlyMap<string, number>): void => {
+    for (const [key, value] of source) {
+        target.set(key, (target.get(key) ?? 0) + value);
+    }
+};
+
+const giveRandomUniqueItem = (options: {
+    world: InMemoryTurnWorld;
+    general: TurnGeneral;
+    nationName: string;
+    rng: RandUtil;
+    itemRegistry: Map<string, ItemModule>;
+    allItems: Record<string, Record<string, number>>;
+    additionalOccupiedCounts: ReadonlyMap<string, number>;
+    year: number;
+    month: number;
+}): boolean => {
+    const invalidSlots = new Set<string>();
+    for (const [slot, itemKey] of Object.entries(options.general.role.items)) {
+        if (itemKey && options.itemRegistry.get(itemKey)?.buyable === false) {
+            invalidSlots.add(slot);
+        }
+    }
+
+    const occupiedCounts = countOccupiedUniqueItems(
+        options.world.listGenerals().map((general) => general.role.items),
+        options.itemRegistry
+    );
+    addCount(occupiedCounts, options.additionalOccupiedCounts);
+
+    const available: Array<[ItemModule, number]> = [];
+    for (const [slot, itemEntries] of Object.entries(options.allItems)) {
+        if (invalidSlots.has(slot)) {
+            continue;
+        }
+        for (const [itemKey, count] of Object.entries(itemEntries)) {
+            const item = options.itemRegistry.get(itemKey);
+            if (!item || item.buyable || count <= 0) {
+                continue;
+            }
+            const remain = count - (occupiedCounts.get(itemKey) ?? 0);
+            if (remain > 0) {
+                available.push([item, remain]);
+            }
+        }
+    }
+    if (available.length === 0) {
+        return false;
+    }
+
+    const item = options.rng.choiceUsingWeightPair(available);
+    const nextGeneral = options.world.getGeneralById(options.general.id);
+    if (!nextGeneral) {
+        return false;
+    }
+    equipNewItem(nextGeneral, item.slot, item.key, {
+        ...(item.initialCharges === undefined ? {} : { charges: item.initialCharges }),
+    });
+    options.world.updateGeneral(nextGeneral.id, {
+        role: nextGeneral.role,
+        itemInventory: nextGeneral.itemInventory,
+    });
+
+    const josaYi = JosaUtil.pick(nextGeneral.name, '이');
+    const josaUl = JosaUtil.pick(item.rawName, '을');
+    options.world.pushLog({
+        scope: LogScope.GENERAL,
+        category: LogCategory.ACTION,
+        generalId: nextGeneral.id,
+        text: `<C>${item.name}</>${josaUl} 습득했습니다!`,
+        format: LogFormat.MONTH,
+        year: options.year,
+        month: options.month,
+    });
+    options.world.pushLog({
+        scope: LogScope.GENERAL,
+        category: LogCategory.HISTORY,
+        generalId: nextGeneral.id,
+        text: `<C>${item.name}</>${josaUl} 습득`,
+        format: LogFormat.YEAR_MONTH,
+        year: options.year,
+        month: options.month,
+    });
+    options.world.pushLog({
+        scope: LogScope.SYSTEM,
+        category: LogCategory.SUMMARY,
+        text: `<Y>${nextGeneral.name}</>${josaYi} <C>${item.name}</>${josaUl} 습득했습니다!`,
+        format: LogFormat.MONTH,
+        year: options.year,
+        month: options.month,
+    });
+    options.world.pushLog({
+        scope: LogScope.SYSTEM,
+        category: LogCategory.HISTORY,
+        text: `<C><b>【작위보상】</b></><D><b>${options.nationName}</b></>의 <Y>${nextGeneral.name}</>${josaYi} <C>${item.name}</>${josaUl} 습득했습니다!`,
+        format: LogFormat.YEAR_MONTH,
+        year: options.year,
+        month: options.month,
+    });
+    return true;
+};
+
+const pushLevelLogs = (options: {
+    world: InMemoryTurnWorld;
+    nationId: number;
+    nationName: string;
+    lordName: string;
+    oldLevel: number;
+    newLevel: number;
+    year: number;
+    month: number;
+}): void => {
+    const oldLevelName = NATION_LEVEL_NAMES[options.oldLevel];
+    const levelName = NATION_LEVEL_NAMES[options.newLevel];
+    if (oldLevelName === undefined || levelName === undefined) {
+        throw new Error(`Unsupported nation level transition: ${options.oldLevel} -> ${options.newLevel}`);
+    }
+    const josaYi = JosaUtil.pick(options.lordName, '이');
+    const josaRo = JosaUtil.pick(levelName, '로');
+    let globalText: string | null = null;
+    let nationText: string | null = null;
+
+    if (options.newLevel === 7) {
+        globalText = `<Y><b>【작위】</b></><D><b>${options.nationName}</b></> ${oldLevelName} <Y>${options.lordName}</>${josaYi} <C>${levelName}</>${josaRo} 옹립되었습니다.`;
+        nationText = `<D><b>${options.nationName}</b></> ${oldLevelName} <Y>${options.lordName}</>${josaYi} <C>${levelName}</>${josaRo} 옹립`;
+    } else if (options.newLevel === 6) {
+        globalText = `<Y><b>【작위】</b></><D><b>${options.nationName}</b></>의 <Y>${options.lordName}</>${josaYi} <C>${levelName}</>${josaRo} 책봉되었습니다.`;
+        nationText = `<D><b>${options.nationName}</b></>의 <Y>${options.lordName}</>${josaYi} <C>${levelName}</>${josaRo} 책봉`;
+    } else if (options.newLevel >= 3) {
+        globalText = `<Y><b>【작위】</b></><D><b>${options.nationName}</b></>의 <Y>${options.lordName}</>${josaYi} <C>${levelName}</>${josaRo} 임명되었습니다.`;
+        nationText = `<D><b>${options.nationName}</b></>의 <Y>${options.lordName}</>${josaYi} <C>${levelName}</>${josaRo} 임명됨`;
+    } else if (options.newLevel === 2) {
+        const josaRa = JosaUtil.pick(options.nationName, '라');
+        globalText = `<Y><b>【작위】</b></><Y>${options.lordName}</>${josaYi} 독립하여 <D><b>${options.nationName}</b></>${josaRa}는 <C>${levelName}</>${josaRo} 나섰습니다.`;
+        nationText = `<Y>${options.lordName}</>${josaYi} 독립하여 <D><b>${options.nationName}</b></>${josaRa}는 <C>${levelName}</>${josaRo} 나서다`;
+    }
+    if (globalText) {
+        options.world.pushLog({
+            scope: LogScope.SYSTEM,
+            category: LogCategory.HISTORY,
+            text: globalText,
+            format: LogFormat.YEAR_MONTH,
+            year: options.year,
+            month: options.month,
+        });
+    }
+    if (nationText) {
+        options.world.pushLog({
+            scope: LogScope.NATION,
+            category: LogCategory.HISTORY,
+            nationId: options.nationId,
+            text: nationText,
+            format: LogFormat.YEAR_MONTH,
+            year: options.year,
+            month: options.month,
+        });
+    }
+};
+
+export const createUpdateNationLevelHandler = (options: {
+    getWorld: () => InMemoryTurnWorld | null;
+    reservedTurns: InMemoryReservedTurnStore;
+    itemModules: ItemModule[];
+    loadAdditionalOccupiedUniqueCounts?: () => Promise<Map<string, number>>;
+}): MonthlyEventActionHandler => {
+    const itemRegistry = createItemModuleRegistry(options.itemModules);
+
+    return async (_args, environment) => {
+        const world = options.getWorld();
+        if (!world) {
+            return;
+        }
+        const uniqueConfig = resolveUniqueConfig(world.getScenarioConfig().const);
+        if (Object.keys(uniqueConfig.allItems).length === 0) {
+            uniqueConfig.allItems = buildLegacyDefaultUniqueItemPool(itemRegistry);
+        }
+        const additionalOccupiedCounts = options.loadAdditionalOccupiedUniqueCounts
+            ? await options.loadAdditionalOccupiedUniqueCounts()
+            : new Map<string, number>();
+        const cityCounts = new Map<number, number>();
+        for (const city of world.listCities()) {
+            if (city.level >= 4) {
+                cityCounts.set(city.nationId, (cityCounts.get(city.nationId) ?? 0) + 1);
+            }
+        }
+        const state = world.getState();
+        const worldKillturn = readNumber(state.meta.killturn);
+        const turnMinutes = state.tickSeconds / 60;
+        if (!(turnMinutes > 0)) {
+            throw new Error('UpdateNationLevel requires a positive turn term.');
+        }
+        const targetKillturn = worldKillturn - (24 * 60) / turnMinutes;
+        const hiddenSeed = resolveHiddenSeed(world);
+
+        for (const nation of world.listNations().sort((left, right) => left.id - right.id)) {
+            const cityCount = cityCounts.get(nation.id) ?? 0;
+            let newLevel = 0;
+            for (let level = 0; level < NATION_LEVEL_CITY_COUNTS.length; level += 1) {
+                if (cityCount < NATION_LEVEL_CITY_COUNTS[level]!) {
+                    break;
+                }
+                newLevel = level;
+            }
+            if (newLevel <= nation.level) {
+                continue;
+            }
+
+            const oldLevel = nation.level;
+            const levelDiff = newLevel - oldLevel;
+            const lord = world
+                .listGenerals()
+                .sort((left, right) => left.id - right.id)
+                .find((general) => general.nationId === nation.id && general.officerLevel === 12);
+            const nextMeta = newLevel === 7 ? { ...nation.meta, can_국기변경: 1, can_국호변경: 1 } : { ...nation.meta };
+            world.updateNation(nation.id, {
+                level: newLevel,
+                gold: nation.gold + newLevel * 1000,
+                rice: nation.rice + newLevel * 1000,
+                meta: nextMeta,
+            });
+            pushLevelLogs({
+                world,
+                nationId: nation.id,
+                nationName: nation.name,
+                lordName: lord?.name ?? '',
+                oldLevel,
+                newLevel,
+                year: environment.year,
+                month: environment.month,
+            });
+
+            for (
+                let officerLevel = resolveNationChiefLevel(newLevel);
+                officerLevel < EXCLUSIVE_MAX_CHIEF_LEVEL;
+                officerLevel += 1
+            ) {
+                options.reservedTurns.ensureNationTurns(nation.id, officerLevel);
+            }
+
+            const eligible = world
+                .listGenerals()
+                .filter(
+                    (general) =>
+                        general.nationId === nation.id &&
+                        general.npcState < 2 &&
+                        readNumber(general.meta.killturn, Number.NEGATIVE_INFINITY) >= targetKillturn
+                )
+                .sort((left, right) => left.id - right.id);
+            const chief = eligible.find((general) => general.officerLevel === 12);
+            const relativeYear = environment.year - environment.startyear;
+            let maxTrialCountByYear = 1;
+            for (const [targetYear, targetTrialCount] of uniqueConfig.maxUniqueItemLimit) {
+                if (relativeYear < targetYear) {
+                    break;
+                }
+                maxTrialCountByYear = targetTrialCount;
+            }
+            const itemTypeCount = Object.keys(uniqueConfig.allItems).length;
+            const candidates: Array<[TurnGeneral, number]> = [];
+            for (const general of eligible) {
+                const trialCount =
+                    Math.min(maxTrialCountByYear, itemTypeCount) - countNonBuyableItems(general, itemRegistry);
+                if (trialCount <= 0) {
+                    continue;
+                }
+                let score = readNumber(general.meta.belong) + 10;
+                if (general.officerLevel === 12) score += 60;
+                else if (general.officerLevel === 11) score += 30;
+                else if (general.officerLevel > 4) score += 15;
+                score *= 2 ** trialCount;
+                candidates.push([general, score]);
+            }
+            const nationRng = new RandUtil(
+                new LiteHashDRBG(
+                    simpleSerialize(hiddenSeed, 'nationLevelUp', environment.year, environment.month, nation.id)
+                )
+            );
+            for (let index = 0; index < levelDiff && candidates.length > 0; index += 1) {
+                const winner = nationRng.choiceUsingWeightPair(candidates);
+                const winnerIndex = candidates.findIndex(([general]) => general.id === winner.id);
+                if (winnerIndex >= 0) {
+                    candidates.splice(winnerIndex, 1);
+                }
+                const itemRng = new RandUtil(
+                    new LiteHashDRBG(
+                        simpleSerialize(
+                            hiddenSeed,
+                            'givenUnique',
+                            environment.year,
+                            environment.month,
+                            nation.id,
+                            winner.id
+                        )
+                    )
+                );
+                giveRandomUniqueItem({
+                    world,
+                    general: winner,
+                    nationName: nation.name,
+                    rng: itemRng,
+                    itemRegistry,
+                    allItems: uniqueConfig.allItems,
+                    additionalOccupiedCounts,
+                    year: environment.year,
+                    month: environment.month,
+                });
+            }
+            const isUnited = readNumber(state.meta.isunited ?? state.meta.isUnited);
+            if (chief?.userId && isUnited === 0) {
+                world.queueInheritancePointAdjustment(chief.userId, 'unifier', 250 * levelDiff);
+            }
+        }
+    };
+};
@@ -75,6 +75,7 @@ type ReservedTurnDatabaseClient = Pick<TurnEngineDatabaseClient, 'generalTurn' |
 export interface ReservedTurnChanges {
    generalIds: number[];
    nationKeys: string[];
+    nationInitializationKeys: string[];
 }

 export class InMemoryReservedTurnStore {
@@ -82,6 +83,7 @@ export class InMemoryReservedTurnStore {
    private readonly nationTurns = new Map<string, ReservedTurnEntry[]>();
    private readonly dirtyGeneralIds = new Set<number>();
    private readonly dirtyNationKeys = new Set<string>();
+    private readonly pendingNationInitializationKeys = new Set<string>();
    private readonly maxGeneralTurns: number;
    private readonly maxNationTurns: number;

@@ -164,7 +166,7 @@ export class InMemoryReservedTurnStore {

    async refreshNationTurns(nationId: number, officerLevel: number): Promise<void> {
        const key = buildNationKey(nationId, officerLevel);
-        if (this.dirtyNationKeys.has(key)) {
+        if (this.dirtyNationKeys.has(key) || this.pendingNationInitializationKeys.has(key)) {
            return;
        }
        const rows = await this.prisma.nationTurn.findMany({
@@ -205,6 +207,12 @@ export class InMemoryReservedTurnStore {
        return list[turnIdx] ?? createDefaultEntry();
    }

+    ensureNationTurns(nationId: number, officerLevel: number): void {
+        const key = buildNationKey(nationId, officerLevel);
+        this.getNationTurns(nationId, officerLevel);
+        this.pendingNationInitializationKeys.add(key);
+    }
+
    shiftGeneralTurns(generalId: number, amount: number): void {
        const list = this.getGeneralTurns(generalId);
        this.generalTurns.set(generalId, applyShift(list, amount));
@@ -222,6 +230,7 @@ export class InMemoryReservedTurnStore {
        return {
            generalIds: Array.from(this.dirtyGeneralIds),
            nationKeys: Array.from(this.dirtyNationKeys),
+            nationInitializationKeys: Array.from(this.pendingNationInitializationKeys),
        };
    }

@@ -232,6 +241,9 @@ export class InMemoryReservedTurnStore {
        for (const key of changes.nationKeys) {
            this.dirtyNationKeys.delete(key);
        }
+        for (const key of changes.nationInitializationKeys) {
+            this.pendingNationInitializationKeys.delete(key);
+        }
    }

    async persistChanges(prisma: ReservedTurnDatabaseClient, changes: ReservedTurnChanges): Promise<void> {
@@ -266,6 +278,26 @@ export class InMemoryReservedTurnStore {
                })),
            });
        }
+
+        for (const key of changes.nationInitializationKeys) {
+            if (changes.nationKeys.includes(key)) {
+                continue;
+            }
+            const [nationIdRaw, officerLevelRaw] = key.split(':');
+            const nationId = Number(nationIdRaw);
+            const officerLevel = Number(officerLevelRaw);
+            const turns = this.getNationTurns(nationId, officerLevel);
+            await prisma.nationTurn.createMany({
+                data: turns.map((entry, turnIdx) => ({
+                    nationId,
+                    officerLevel,
+                    turnIdx,
+                    actionCode: normalizeAction(entry.action),
+                    arg: asJson(normalizeArgs(entry.args)),
+                })),
+                skipDuplicates: true,
+            });
+        }
    }

    async flushChanges(): Promise<void> {
@@ -47,6 +47,7 @@ import {
 } from './monthlyEventHandler.js';
 import { createRaiseDisasterHandler } from './monthlyDisasterAction.js';
 import { createUpdateCitySupplyHandler } from './monthlyCitySupplyAction.js';
+import { createUpdateNationLevelHandler } from './monthlyNationLevelAction.js';
 import { DatabaseTurnDaemonLease, TurnDaemonLeaseUnavailableError } from '../lifecycle/databaseTurnDaemonLease.js';

 export interface TurnDaemonRuntimeOptions {
@@ -95,6 +96,30 @@ const buildFixedSchedule = (tickMinutes: number): TurnSchedule => ({
    entries: [{ startMinute: 0, tickMinutes }],
 });

+const loadOccupiedAuctionUniqueCounts = async (databaseUrl: string): Promise<Map<string, number>> => {
+    const connector = createGamePostgresConnector({ url: databaseUrl });
+    await connector.connect();
+    try {
+        const rows = await connector.prisma.auction.findMany({
+            where: {
+                type: 'UNIQUE_ITEM',
+                status: { in: ['OPEN', 'FINALIZING'] },
+                targetCode: { not: null },
+            },
+            select: { targetCode: true },
+        });
+        const counts = new Map<string, number>();
+        for (const row of rows) {
+            if (row.targetCode) {
+                counts.set(row.targetCode, (counts.get(row.targetCode) ?? 0) + 1);
+            }
+        }
+        return counts;
+    } finally {
+        await connector.disconnect();
+    }
+};
+
 const resolveRedisConfig = (redisUrl?: string, env: NodeJS.ProcessEnv = process.env) => {
    if (redisUrl) {
        return { url: redisUrl };
@@ -119,11 +144,18 @@ const createTurnDaemonRuntimeWithLease = async (
    const tickMinutes = resolveTickMinutes(state.tickSeconds, options.tickMinutes);
    const resolvedState = options.tickMinutes ? { ...state, tickSeconds: tickMinutes * 60 } : state;
    const schedule = options.schedule ?? buildFixedSchedule(tickMinutes);
-    const reservedTurnStoreHandle = options.generalTurnHandler
-        ? null
-        : await createReservedTurnStore({
-              databaseUrl: options.databaseUrl,
-          });
+    const hasEventAction = (name: string): boolean =>
+        snapshot.events.some(
+            (event) =>
+                Array.isArray(event.action) &&
+                event.action.some((action) => Array.isArray(action) && action[0] === name)
+        );
+    const reservedTurnStoreHandle =
+        options.generalTurnHandler && !hasEventAction('UpdateNationLevel')
+            ? null
+            : await createReservedTurnStore({
+                  databaseUrl: options.databaseUrl,
+              });
    const commandProfile =
        options.commandProfile ??
        (options.commandProfilePath
@@ -148,12 +180,6 @@ const createTurnDaemonRuntimeWithLease = async (
        scenarioConfig: snapshot.scenarioConfig,
        nationTraits: nationTraitMap,
    });
-    const hasEventAction = (name: string): boolean =>
-        snapshot.events.some(
-            (event) =>
-                Array.isArray(event.action) &&
-                event.action.some((action) => Array.isArray(action) && action[0] === name)
-        );
    const eventActions = new Map<string, MonthlyEventActionHandler>();
    eventActions.set(
        'RandomizeCityTradeRate',
@@ -175,8 +201,19 @@ const createTurnDaemonRuntimeWithLease = async (
            map: snapshot.map,
        })
    );
-    eventActions.set('ProcessIncome', (_args, environment) => {
-        void incomeHandler.onMonthChanged?.({
+    if (reservedTurnStoreHandle) {
+        eventActions.set(
+            'UpdateNationLevel',
+            createUpdateNationLevelHandler({
+                getWorld: () => worldRef,
+                reservedTurns: reservedTurnStoreHandle.store,
+                itemModules: monthlyActionModules.itemModules,
+                loadAdditionalOccupiedUniqueCounts: () => loadOccupiedAuctionUniqueCounts(options.databaseUrl),
+            })
+        );
+    }
+    eventActions.set('ProcessIncome', async (_args, environment) => {
+        await incomeHandler.onMonthChanged?.({
            previousYear: environment.month === 1 ? environment.year - 1 : environment.year,
            previousMonth: environment.month === 1 ? 12 : environment.month - 1,
            currentYear: environment.year,
@@ -0,0 +1,288 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+    ITEM_KEYS,
+    LogCategory,
+    LogScope,
+    loadItemModules,
+    type City,
+    type ItemModule,
+    type Nation,
+} from '@sammo-ts/logic';
+
+import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
+import { createUpdateNationLevelHandler } from '../src/turn/monthlyNationLevelAction.js';
+import { InMemoryReservedTurnStore } from '../src/turn/reservedTurnStore.js';
+import type { TurnEvent, TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
+
+const uniqueHorse: ItemModule = {
+    key: 'test_unique_horse',
+    name: '시험명마',
+    rawName: '시험명마',
+    info: '',
+    slot: 'horse',
+    cost: null,
+    buyable: false,
+    consumable: false,
+    reqSecu: 0,
+    unique: true,
+};
+
+const buildCity = (id: number, nationId = 1, level = 4): City => ({
+    id,
+    name: `도시${id}`,
+    nationId,
+    level,
+    state: 0,
+    population: 1_000,
+    populationMax: 2_000,
+    agriculture: 500,
+    agricultureMax: 1_000,
+    commerce: 500,
+    commerceMax: 1_000,
+    security: 500,
+    securityMax: 1_000,
+    supplyState: 1,
+    frontState: 0,
+    defence: 500,
+    defenceMax: 1_000,
+    wall: 500,
+    wallMax: 1_000,
+    meta: {},
+});
+
+const buildNation = (level: number): Nation => ({
+    id: 1,
+    name: '위',
+    color: '#000000',
+    capitalCityId: 1,
+    chiefGeneralId: 1,
+    gold: 10_000,
+    rice: 20_000,
+    power: 0,
+    level,
+    typeCode: 'che_중립',
+    meta: { marker: 1 },
+});
+
+const buildGeneral = (id: number, patch: Partial<TurnGeneral> = {}): TurnGeneral => ({
+    id,
+    userId: `user-${id}`,
+    name: id === 1 ? '조조' : `장수${id}`,
+    nationId: 1,
+    cityId: 1,
+    troopId: 0,
+    stats: { leadership: 90, strength: 70, intelligence: 90 },
+    experience: 0,
+    dedication: 0,
+    officerLevel: id === 1 ? 12 : 5,
+    role: {
+        personality: null,
+        specialDomestic: null,
+        specialWar: null,
+        items: { horse: null, weapon: null, book: null, item: null },
+    },
+    injury: 0,
+    gold: 1_000,
+    rice: 1_000,
+    crew: 100,
+    crewTypeId: 1100,
+    train: 100,
+    atmos: 100,
+    age: 30,
+    npcState: 0,
+    triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} },
+    meta: { killturn: 1_000, belong: 5 },
+    turnTime: new Date('0193-01-01T00:00:00.000Z'),
+    ...patch,
+});
+
+const event: TurnEvent = {
+    id: 1,
+    targetCode: 'month',
+    priority: 1_000,
+    condition: true,
+    action: [['UpdateNationLevel']],
+    meta: {},
+};
+
+const buildHarness = async (
+    nationLevel: number,
+    cityCount: number,
+    options: {
+        hiddenSeed?: string;
+        itemModules?: ItemModule[];
+        configConst?: Record<string, unknown>;
+        additionalOccupiedCounts?: Map<string, number>;
+    } = {}
+) => {
+    const state: TurnWorldState = {
+        id: 1,
+        currentYear: 193,
+        currentMonth: 1,
+        tickSeconds: 600,
+        lastTurnTime: new Date('0193-01-01T00:00:00.000Z'),
+        meta: { hiddenSeed: options.hiddenSeed ?? 'nation-level-test', killturn: 1_000 },
+    };
+    const snapshot: TurnWorldSnapshot = {
+        scenarioConfig: {
+            stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 70 },
+            iconPath: '',
+            map: {},
+            const:
+                options.configConst ??
+                ({
+                    allItems: { horse: { [uniqueHorse.key]: 1 } },
+                    maxUniqueItemLimit: [[-1, 1]],
+                } satisfies Record<string, unknown>),
+            environment: { mapName: 'test', unitSet: 'default' },
+        },
+        map: {
+            id: 'test',
+            name: 'test',
+            cities: [],
+            defaults: { trust: 50, trade: 100, supplyState: 1, frontState: 0 },
+        },
+        generals: [buildGeneral(1), buildGeneral(2, { meta: { killturn: 850, belong: 30 } })],
+        cities: Array.from({ length: cityCount }, (_, index) => buildCity(index + 1)),
+        nations: [buildNation(nationLevel)],
+        troops: [],
+        diplomacy: [],
+        events: [event],
+        initialEvents: [],
+    };
+    const world = new InMemoryTurnWorld(state, snapshot, {
+        schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
+    });
+    const prisma = {
+        generalTurn: {
+            findMany: vi.fn(async () => []),
+            deleteMany: vi.fn(async () => ({ count: 0 })),
+            createMany: vi.fn(async () => ({ count: 0 })),
+        },
+        nationTurn: {
+            findMany: vi.fn(async () => []),
+            deleteMany: vi.fn(async () => ({ count: 0 })),
+            createMany: vi.fn(async () => ({ count: 0 })),
+        },
+    };
+    const reservedTurns = new InMemoryReservedTurnStore(prisma, { maxGeneralTurns: 30, maxNationTurns: 12 });
+    await reservedTurns.loadAll();
+    const handler = createUpdateNationLevelHandler({
+        getWorld: () => world,
+        reservedTurns,
+        itemModules: options.itemModules ?? [uniqueHorse],
+        loadAdditionalOccupiedUniqueCounts: options.additionalOccupiedCounts
+            ? async () => options.additionalOccupiedCounts!
+            : undefined,
+    });
+    return { world, reservedTurns, handler };
+};
+
+describe('UpdateNationLevel monthly action', () => {
+    it('raises only upward, initializes new chief turns, rewards a unique item, and credits the chief', async () => {
+        const { world, reservedTurns, handler } = await buildHarness(0, 2);
+
+        await handler([], { year: 193, month: 2, startyear: 190, currentEventID: 1, turnTime: new Date() }, event);
+
+        expect(world.getNationById(1)).toMatchObject({
+            level: 2,
+            gold: 12_000,
+            rice: 22_000,
+            meta: { marker: 1 },
+        });
+        expect(reservedTurns.peekDirtyState().nationInitializationKeys).toEqual(['1:9', '1:10', '1:11']);
+        expect(world.getGeneralById(1)?.role.items.horse).toBe(uniqueHorse.key);
+        expect(world.getGeneralById(2)?.role.items.horse).toBeNull();
+        expect(world.peekDirtyState().inheritancePointAdjustments).toEqual([
+            { userId: 'user-1', key: 'unifier', amount: 500 },
+        ]);
+        expect(world.peekDirtyState().logs).toEqual(
+            expect.arrayContaining([
+                {
+                    scope: LogScope.SYSTEM,
+                    category: LogCategory.HISTORY,
+                    text: '<Y><b>【작위】</b></><Y>조조</>가 독립하여 <D><b>위</b></>라는 <C>군벌</>로 나섰습니다.',
+                    format: 2,
+                    year: 193,
+                    month: 2,
+                },
+                {
+                    scope: LogScope.NATION,
+                    category: LogCategory.HISTORY,
+                    nationId: 1,
+                    text: '<Y>조조</>가 독립하여 <D><b>위</b></>라는 <C>군벌</>로 나서다',
+                    format: 2,
+                    year: 193,
+                    month: 2,
+                },
+                expect.objectContaining({ scope: LogScope.GENERAL, category: LogCategory.ACTION, generalId: 1 }),
+                expect.objectContaining({
+                    scope: LogScope.SYSTEM,
+                    category: LogCategory.HISTORY,
+                    text: expect.stringContaining('작위보상'),
+                }),
+            ])
+        );
+    });
+
+    it('does not downgrade or pay rewards when the qualifying city count is below the current level', async () => {
+        const { world, reservedTurns, handler } = await buildHarness(3, 1);
+
+        await handler([], { year: 193, month: 2, startyear: 190, currentEventID: 1, turnTime: new Date() }, event);
+
+        expect(world.getNationById(1)).toMatchObject({ level: 3, gold: 10_000, rice: 20_000 });
+        expect(reservedTurns.peekDirtyState().nationInitializationKeys).toEqual([]);
+        expect(world.peekDirtyState().inheritancePointAdjustments).toEqual([]);
+        expect(world.peekDirtyState().logs).toEqual([]);
+    });
+
+    it('sets both rename permissions only on promotion to emperor', async () => {
+        const { world, handler } = await buildHarness(6, 21);
+
+        await handler([], { year: 203, month: 1, startyear: 190, currentEventID: 1, turnTime: new Date() }, event);
+
+        expect(world.getNationById(1)).toMatchObject({
+            level: 7,
+            gold: 17_000,
+            rice: 27_000,
+            meta: { marker: 1, can_국기변경: 1, can_국호변경: 1 },
+        });
+        expect(world.peekDirtyState().inheritancePointAdjustments).toEqual([
+            { userId: 'user-1', key: 'unifier', amount: 250 },
+        ]);
+    });
+
+    it('does not duplicate a unique item reserved by an unfinished auction', async () => {
+        const { world, handler } = await buildHarness(0, 1, {
+            additionalOccupiedCounts: new Map([[uniqueHorse.key, 1]]),
+        });
+
+        await handler([], { year: 193, month: 2, startyear: 190, currentEventID: 1, turnTime: new Date() }, event);
+
+        expect(world.getGeneralById(1)?.role.items.horse).toBeNull();
+        expect(world.peekDirtyState().logs.some((entry) => entry.text.includes('작위보상'))).toBe(false);
+        expect(world.peekDirtyState().inheritancePointAdjustments).toEqual([
+            { userId: 'user-1', key: 'unifier', amount: 250 },
+        ]);
+    });
+});
+
+describe.skipIf(!process.env.LEGACY_HIDDEN_SEED)('UpdateNationLevel legacy fixed-seed comparison', () => {
+    it('selects the same unique item as the isolated legacy fixture', async () => {
+        const itemModules = await loadItemModules([...ITEM_KEYS]);
+        const { world, handler } = await buildHarness(0, 2, {
+            hiddenSeed: process.env.LEGACY_HIDDEN_SEED!,
+            itemModules,
+            configConst: { maxUniqueItemLimit: [[-1, 1]] },
+        });
+
+        await handler([], { year: 193, month: 2, startyear: 190, currentEventID: 1, turnTime: new Date() }, event);
+
+        expect(world.getGeneralById(1)?.role.items).toEqual({
+            horse: null,
+            weapon: null,
+            book: 'che_서적_13_관자',
+            item: null,
+        });
+    });
+});
@@ -0,0 +1,312 @@
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { createGamePostgresConnector, type GamePrismaClient } from '@sammo-ts/infra';
+import type { City, ItemModule, Nation } from '@sammo-ts/logic';
+
+import { createDatabaseTurnHooks } from '../src/turn/databaseHooks.js';
+import { InMemoryTurnWorld } from '../src/turn/inMemoryWorld.js';
+import { createUpdateNationLevelHandler } from '../src/turn/monthlyNationLevelAction.js';
+import { InMemoryReservedTurnStore } from '../src/turn/reservedTurnStore.js';
+import type { TurnEvent, TurnGeneral, TurnWorldSnapshot, TurnWorldState } from '../src/turn/types.js';
+
+const databaseUrl = process.env.INPUT_EVENT_DATABASE_URL;
+const integration = describe.skipIf(!databaseUrl);
+const nationId = 990_061;
+const generalId = 990_061;
+const cityIds = [990_061, 990_062] as const;
+const userId = 'monthly-nation-level-user';
+const itemKey = 'test_monthly_nation_unique';
+
+const uniqueHorse: ItemModule = {
+    key: itemKey,
+    name: '작위시험마',
+    rawName: '작위시험마',
+    info: '',
+    slot: 'horse',
+    cost: null,
+    buyable: false,
+    consumable: false,
+    reqSecu: 0,
+    unique: true,
+};
+
+const nation: Nation = {
+    id: nationId,
+    name: '작위저장국',
+    color: '#000000',
+    capitalCityId: cityIds[0],
+    chiefGeneralId: generalId,
+    gold: 10_000,
+    rice: 20_000,
+    power: 0,
+    level: 0,
+    typeCode: 'che_중립',
+    meta: {},
+};
+
+const buildCity = (id: number): City => ({
+    id,
+    name: `작위도시${id}`,
+    nationId,
+    level: 4,
+    state: 0,
+    population: 1_000,
+    populationMax: 2_000,
+    agriculture: 500,
+    agricultureMax: 1_000,
+    commerce: 500,
+    commerceMax: 1_000,
+    security: 500,
+    securityMax: 1_000,
+    supplyState: 1,
+    frontState: 0,
+    defence: 500,
+    defenceMax: 1_000,
+    wall: 500,
+    wallMax: 1_000,
+    meta: { trust: 50, region: 1 },
+});
+
+const general: TurnGeneral = {
+    id: generalId,
+    userId,
+    name: '조조',
+    nationId,
+    cityId: cityIds[0],
+    troopId: 0,
+    stats: { leadership: 90, strength: 70, intelligence: 90 },
+    experience: 0,
+    dedication: 0,
+    officerLevel: 12,
+    role: {
+        personality: null,
+        specialDomestic: null,
+        specialWar: null,
+        items: { horse: null, weapon: null, book: null, item: null },
+    },
+    injury: 0,
+    gold: 1_000,
+    rice: 1_000,
+    crew: 100,
+    crewTypeId: 1100,
+    train: 100,
+    atmos: 100,
+    age: 30,
+    npcState: 0,
+    triggerState: { flags: {}, counters: {}, modifiers: {}, meta: {} },
+    meta: { killturn: 1_000, belong: 10 },
+    turnTime: new Date('0193-01-01T00:00:00.000Z'),
+};
+
+const event: TurnEvent = {
+    id: 1,
+    targetCode: 'month',
+    priority: 1_000,
+    condition: true,
+    action: [['UpdateNationLevel']],
+    meta: {},
+};
+
+integration('monthly nation level database persistence', () => {
+    let db: GamePrismaClient;
+    let closeDb: (() => Promise<void>) | undefined;
+
+    beforeAll(async () => {
+        const connector = createGamePostgresConnector({ url: databaseUrl! });
+        await connector.connect();
+        db = connector.prisma;
+        closeDb = () => connector.disconnect();
+        await db.logEntry.deleteMany({ where: { OR: [{ nationId }, { generalId }] } });
+        await db.nationTurn.deleteMany({ where: { nationId } });
+        await db.inheritancePoint.deleteMany({ where: { userId } });
+        await db.general.deleteMany({ where: { id: generalId } });
+        await db.city.deleteMany({ where: { id: { in: [...cityIds] } } });
+        await db.nation.deleteMany({ where: { id: nationId } });
+    });
+
+    afterAll(async () => {
+        await db.logEntry.deleteMany({ where: { OR: [{ nationId }, { generalId }] } });
+        await db.nationTurn.deleteMany({ where: { nationId } });
+        await db.inheritancePoint.deleteMany({ where: { userId } });
+        await db.general.deleteMany({ where: { id: generalId } });
+        await db.city.deleteMany({ where: { id: { in: [...cityIds] } } });
+        await db.nation.deleteMany({ where: { id: nationId } });
+        await closeDb?.();
+    });
+
+    it('commits nation resources, chief turns, unique reward, logs, and unifier points together', async () => {
+        await db.nation.create({
+            data: {
+                id: nation.id,
+                name: nation.name,
+                color: nation.color,
+                capitalCityId: nation.capitalCityId,
+                chiefGeneralId: nation.chiefGeneralId,
+                gold: nation.gold,
+                rice: nation.rice,
+                tech: nation.power,
+                level: nation.level,
+                typeCode: nation.typeCode,
+                meta: {},
+            },
+        });
+        const cities = cityIds.map(buildCity);
+        await db.city.createMany({
+            data: cities.map((city) => ({
+                id: city.id,
+                name: city.name,
+                level: city.level,
+                nationId: city.nationId,
+                supplyState: city.supplyState,
+                frontState: city.frontState,
+                population: city.population,
+                populationMax: city.populationMax,
+                agriculture: city.agriculture,
+                agricultureMax: city.agricultureMax,
+                commerce: city.commerce,
+                commerceMax: city.commerceMax,
+                security: city.security,
+                securityMax: city.securityMax,
+                trust: 50,
+                defence: city.defence,
+                defenceMax: city.defenceMax,
+                wall: city.wall,
+                wallMax: city.wallMax,
+                region: 1,
+                conflict: {},
+                meta: {},
+            })),
+        });
+        await db.general.create({
+            data: {
+                id: general.id,
+                userId,
+                name: general.name,
+                nationId,
+                cityId: general.cityId,
+                troopId: 0,
+                npcState: 0,
+                leadership: general.stats.leadership,
+                strength: general.stats.strength,
+                intel: general.stats.intelligence,
+                experience: 0,
+                dedication: 0,
+                officerLevel: 12,
+                injury: 0,
+                gold: 1_000,
+                rice: 1_000,
+                crew: 100,
+                crewTypeId: 1100,
+                train: 100,
+                atmos: 100,
+                age: 30,
+                turnTime: general.turnTime,
+                meta: general.meta,
+            },
+        });
+        await db.nationTurn.create({
+            data: {
+                nationId,
+                officerLevel: 9,
+                turnIdx: 0,
+                actionCode: 'che_포상',
+                arg: { amount: 100 },
+            },
+        });
+        const stateRow = await db.worldState.create({
+            data: {
+                scenarioCode: 'monthly-nation-level-persistence',
+                currentYear: 193,
+                currentMonth: 2,
+                tickSeconds: 600,
+                config: {},
+                meta: { hiddenSeed: 'nation-level-persistence', killturn: 1_000 },
+            },
+        });
+        const state: TurnWorldState = {
+            id: stateRow.id,
+            currentYear: 193,
+            currentMonth: 2,
+            tickSeconds: 600,
+            lastTurnTime: new Date('2026-07-25T00:20:00.000Z'),
+            meta: { hiddenSeed: 'nation-level-persistence', killturn: 1_000 },
+        };
+        const snapshot: TurnWorldSnapshot = {
+            scenarioConfig: {
+                stat: { total: 300, min: 10, max: 100, npcTotal: 150, npcMax: 50, npcMin: 10, chiefMin: 70 },
+                iconPath: '',
+                map: {},
+                const: { allItems: { horse: { [itemKey]: 1 } }, maxUniqueItemLimit: [[-1, 1]] },
+                environment: { mapName: 'test', unitSet: 'default' },
+            },
+            map: {
+                id: 'test',
+                name: 'test',
+                cities: [],
+                defaults: { trust: 50, trade: 100, supplyState: 1, frontState: 0 },
+            },
+            generals: [general],
+            cities,
+            nations: [nation],
+            troops: [],
+            diplomacy: [],
+            events: [event],
+            initialEvents: [],
+        };
+        const world = new InMemoryTurnWorld(state, snapshot, {
+            schedule: { entries: [{ startMinute: 0, tickMinutes: 10 }] },
+        });
+        const reservedTurns = new InMemoryReservedTurnStore(db, { maxGeneralTurns: 30, maxNationTurns: 12 });
+        await reservedTurns.loadAll();
+        const handler = createUpdateNationLevelHandler({
+            getWorld: () => world,
+            reservedTurns,
+            itemModules: [uniqueHorse],
+        });
+        const dbHooks = await createDatabaseTurnHooks(databaseUrl!, world, { reservedTurns });
+
+        try {
+            await handler(
+                [],
+                { year: 193, month: 2, startyear: 190, currentEventID: 1, turnTime: state.lastTurnTime },
+                event
+            );
+            await dbHooks.hooks.flushChanges?.({
+                lastTurnTime: state.lastTurnTime.toISOString(),
+                processedGenerals: 0,
+                processedTurns: 1,
+                durationMs: 0,
+                partial: false,
+            });
+
+            expect(await db.nation.findUniqueOrThrow({ where: { id: nationId } })).toMatchObject({
+                level: 2,
+                gold: 12_000,
+                rice: 22_000,
+            });
+            expect(await db.general.findUniqueOrThrow({ where: { id: generalId } })).toMatchObject({
+                horseCode: itemKey,
+            });
+            expect(await db.nationTurn.count({ where: { nationId } })).toBe(36);
+            expect(
+                await db.nationTurn.findUniqueOrThrow({
+                    where: {
+                        nationId_officerLevel_turnIdx: {
+                            nationId,
+                            officerLevel: 9,
+                            turnIdx: 0,
+                        },
+                    },
+                })
+            ).toMatchObject({ actionCode: 'che_포상', arg: { amount: 100 } });
+            expect(
+                await db.inheritancePoint.findUniqueOrThrow({ where: { userId_key: { userId, key: 'unifier' } } })
+            ).toMatchObject({
+                value: 500,
+            });
+            expect(await db.logEntry.count({ where: { OR: [{ nationId }, { generalId }] } })).toBeGreaterThanOrEqual(3);
+        } finally {
+            await dbHooks.close();
+            await db.worldState.delete({ where: { id: stateRow.id } });
+        }
+    });
+});