fix: 갱신 비용에 따라 접속 점수를 기록

revision 확인과 서버 event 기반 선택 갱신은 무가점으로 두고 PostgreSQL projection을 다시 만드는 초기·수동·복구 갱신만 1점을 기록한다. 인증 범위에 묶인 1회용 realtime 증표와 회귀 검증을 추가한다.

app/game-api/src/router/dashboard/index.ts

@@ -10,6 +10,12 @@ import {
     type DashboardSourceSlice,
 } from '../../services/dashboardSourceRevision.js';
 import { createReadModelDelta } from '../../services/readModelDeltaCache.js';
+import {
+    DASHBOARD_PROJECTION_ACCESS_WEIGHT,
+    formatGeneralAccessLimitMessage,
+    getGeneralAccessState,
+    recordGeneralAccessWeight,
+} from '../../services/generalAccess.js';
 import { getBoardAccess } from '../board/index.js';
 import { getGeneralContext } from '../general/index.js';
 import { getTurnCommandTable } from '../turns/index.js';
@@ -39,6 +45,31 @@ const zContextBundleInput = z.object({
     forceSnapshot: z.boolean().optional(),
 });
 
+type DashboardSliceRequest = {
+    included: boolean;
+    sourceState: DashboardSourceRevisionState | null;
+    slice: DashboardSourceSlice;
+    knownContent?: string;
+    knownSource?: string;
+    forceSnapshot?: boolean;
+};
+
+export const requiresDashboardProjection = (request: DashboardSliceRequest): boolean => {
+    if (!request.included) return false;
+    const sourceRevision = request.sourceState?.sourceRevisions[request.slice];
+    return !(
+        sourceRevision !== undefined &&
+        request.knownContent !== undefined &&
+        canUseDashboardSourceRevision({
+            state: request.sourceState,
+            slice: request.slice,
+            knownContent: request.knownContent,
+            knownSource: request.knownSource,
+            forceSnapshot: request.forceSnapshot,
+        })
+    );
+};
+
 const createDashboardSliceDelta = async <T>(options: {
     included: boolean;
     sourceState: DashboardSourceRevisionState | null;
@@ -54,17 +85,7 @@ const createDashboardSliceDelta = async <T>(options: {
     }
 
     const sourceRevision = options.sourceState?.sourceRevisions[options.slice];
-    if (
-        sourceRevision !== undefined &&
-        options.knownContent !== undefined &&
-        canUseDashboardSourceRevision({
-            state: options.sourceState,
-            slice: options.slice,
-            knownContent: options.knownContent,
-            knownSource: options.knownSource,
-            forceSnapshot: options.forceSnapshot,
-        })
-    ) {
+    if (!requiresDashboardProjection(options) && options.knownContent !== undefined) {
         return {
             kind: 'unchanged',
             revision: options.knownContent,
@@ -102,9 +123,48 @@ export const dashboardRouter = router({
                 )?.id ??
                 null;
         }
-        const sourceState = generalId
-            ? await readDashboardSourceRevisionState(ctx.db, generalId, authUser)
-            : null;
+        let sourceState = generalId ? await readDashboardSourceRevisionState(ctx.db, generalId, authUser) : null;
+        const buildSliceRequests = (): DashboardSliceRequest[] => [
+            {
+                included: input.include.context,
+                sourceState,
+                slice: 'context',
+                knownContent: input.known?.context,
+                knownSource: input.knownSource?.context,
+                forceSnapshot: input.forceSnapshot,
+            },
+            {
+                included: input.include.commandTable && generalId !== null,
+                sourceState,
+                slice: 'commandTable',
+                knownContent: input.known?.commandTable,
+                knownSource: input.knownSource?.commandTable,
+                forceSnapshot: input.forceSnapshot,
+            },
+            {
+                included: input.include.boardAccess && generalId !== null,
+                sourceState,
+                slice: 'boardAccess',
+                knownContent: input.known?.boardAccess,
+                knownSource: input.knownSource?.boardAccess,
+                forceSnapshot: input.forceSnapshot,
+            },
+        ];
+        const sliceRequests = buildSliceRequests();
+        const rebuildsPostgresProjection = sliceRequests.some(requiresDashboardProjection);
+        if (rebuildsPostgresProjection && ctx.generalAccessTracking === true && ctx.realtimeAccessGranted !== true) {
+            const recorded = await recordGeneralAccessWeight(ctx, DASHBOARD_PROJECTION_ACCESS_WEIGHT);
+            const accessState = await getGeneralAccessState(ctx);
+            if (accessState?.level === 2) {
+                throw new TRPCError({
+                    code: 'TOO_MANY_REQUESTS',
+                    message: formatGeneralAccessLimitMessage(accessState),
+                });
+            }
+            if (recorded && generalId !== null) {
+                sourceState = await readDashboardSourceRevisionState(ctx.db, generalId, authUser);
+            }
+        }
 
         const [contextDelta, commandTableDelta, boardAccessDelta] = await Promise.all([
             createDashboardSliceDelta({