Formatting

compose.yaml

···
       - ./prometheus.yml:/etc/prometheus/prometheus.yml
       - prometheus-data:/prometheus
     command:
-      - '--config.file=/etc/prometheus/prometheus.yml'
-      - '--storage.tsdb.path=/prometheus'
+      - "--config.file=/etc/prometheus/prometheus.yml"
+      - "--storage.tsdb.path=/prometheus"
     networks:
       - skywatch-network
     depends_on:

eslint.config.mjs

···
 import eslint from "@eslint/js";
 import stylistic from "@stylistic/eslint-plugin";
+import { defineConfig } from "eslint/config";
 import prettier from "eslint-config-prettier";
 import importPlugin from "eslint-plugin-import";
 import tseslint from "typescript-eslint";
 
-export default tseslint.config(
+export default defineConfig(
   eslint.configs.recommended,
   ...tseslint.configs.strictTypeChecked,
   ...tseslint.configs.stylisticTypeChecked,
···
     rules: {
       // TypeScript specific rules
       "@typescript-eslint/no-unused-vars": [
-        "error",
+        "warn",
         { argsIgnorePattern: "^_" },
       ],
-      "@typescript-eslint/no-explicit-any": "error",
+      "@typescript-eslint/no-explicit-any": "warn",
       "@typescript-eslint/no-unsafe-assignment": "error",
       "@typescript-eslint/no-unsafe-member-access": "error",
       "@typescript-eslint/no-unsafe-call": "error",
       "@typescript-eslint/no-unsafe-return": "error",
       "@typescript-eslint/no-unsafe-argument": "error",
-      "@typescript-eslint/prefer-nullish-coalescing": "error",
-      "@typescript-eslint/prefer-optional-chain": "error",
+      "@typescript-eslint/prefer-nullish-coalescing": "warn",
+      "@typescript-eslint/prefer-optional-chain": "warn",
       "@typescript-eslint/no-non-null-assertion": "error",
       "@typescript-eslint/consistent-type-imports": "error",
       "@typescript-eslint/consistent-type-exports": "error",
···
       "no-console": "warn",
       "no-debugger": "error",
       "no-var": "error",
-      "prefer-const": "error",
-      "prefer-template": "error",
-      "object-shorthand": "error",
-      "prefer-destructuring": ["error", { object: true, array: false }],
+      "prefer-const": "warn",
+      "prefer-template": "warn",
+      "object-shorthand": "warn",
+      "prefer-destructuring": ["warn", { object: true, array: false }],
 
       // Import rules
       "import/order": [
-        "error",
+        "warn",
         {
           groups: [
             "builtin",
···
             "sibling",
             "index",
           ],
-          "newlines-between": "always",
+          pathGroups: [
+            {
+              pattern: "@atproto/**",
+              group: "external",
+              position: "after",
+            },
+            {
+              pattern: "@skyware/**",
+              group: "external",
+              position: "after",
+            },
+            {
+              pattern: "@clavata/**",
+              group: "external",
+              position: "after",
+            },
+          ],
+          pathGroupsExcludedImportTypes: ["builtin"],
+          "newlines-between": "never",
           alphabetize: { order: "asc", caseInsensitive: true },
         },
       ],
-      "import/no-duplicates": "error",
+      "import/no-duplicates": "warn",
       "import/no-unresolved": "off", // TypeScript handles this
 
       // Security-focused rules
···
       "no-unreachable": "error",
       "no-unreachable-loop": "error",
 
-      // Style preferences
-      "@stylistic/indent": ["error", 2],
-      "@stylistic/quotes": ["error", "double"],
-      "@stylistic/semi": ["error", "always"],
-      //"@stylistic/comma-dangle": ["error", "es5"],
-      "@stylistic/object-curly-spacing": ["error", "always"],
-      "@stylistic/array-bracket-spacing": ["error", "never"],
-      "@stylistic/space-before-function-paren": [
-        "error",
-        {
-          anonymous: "always",
-          named: "never",
-          asyncArrow: "always",
-        },
-      ],
+      // Style preferences (prettier handles these)
+      "@stylistic/indent": "off",
+      "@stylistic/quotes": "off",
+      "@stylistic/semi": "off",
+      "@stylistic/object-curly-spacing": "off",
+      "@stylistic/array-bracket-spacing": "off",
+      "@stylistic/space-before-function-paren": "off",
     },
   },
   {

prometheus.yml

···
   evaluation_interval: 15s
 
 scrape_configs:
-  - job_name: 'skywatch-automod'
+  - job_name: "skywatch-automod"
     static_configs:
-      - targets: ['automod:4101']
+      - targets: ["automod:4101"]
         labels:
-          service: 'automod'
+          service: "automod"

src/accountThreshold.ts

···
         const shouldLabel = config.toLabel !== false;
 
         if (shouldLabel) {
-          await createAccountLabel(did, config.accountLabel, config.accountComment);
+          await createAccountLabel(
+            did,
+            config.accountLabel,
+            config.accountComment,
+          );
           accountLabelsThresholdAppliedCounter.inc({
             account_label: config.accountLabel,
             action: "label",

src/agent.ts

···
 import { Agent, setGlobalDispatcher } from "undici";
 import { AtpAgent } from "@atproto/api";
 import { BSKY_HANDLE, BSKY_PASSWORD, OZONE_PDS } from "./config.js";
-import { loadSession, saveSession, type SessionData } from "./session.js";
 import { updateRateLimitState } from "./limits.js";
 import { logger } from "./logger.js";
+import { type SessionData, loadSession, saveSession } from "./session.js";
 
 setGlobalDispatcher(
   new Agent({
···
   }
 
   const refreshIn = JWT_LIFETIME_MS * REFRESH_AT_PERCENT;
-  logger.debug(`Scheduling session refresh in ${(refreshIn / 1000 / 60).toFixed(1)} minutes`);
+  logger.debug(
+    `Scheduling session refresh in ${(refreshIn / 1000 / 60).toFixed(1)} minutes`,
+  );
 
   refreshTimer = setTimeout(() => {
     refreshSession().catch((error) => {

src/limits.ts

···
 import { pRateLimit } from "p-ratelimit";
-import { logger } from "./logger.js";
 import { Counter, Gauge, Histogram } from "prom-client";
+import { logger } from "./logger.js";
 
 interface RateLimitState {
   limit: number;
···
       remaining: rateLimitState.remaining,
       resetIn: rateLimitState.reset - Math.floor(Date.now() / 1000),
     },
-    "Rate limit state updated"
+    "Rate limit state updated",
   );
 }
 
···
 
     if (delayMs > 0) {
       logger.warn(
-        `Rate limit critical (${state.remaining}/${state.limit} remaining). Waiting ${delaySeconds}s until reset...`
+        `Rate limit critical (${state.remaining}/${state.limit} remaining). Waiting ${delaySeconds}s until reset...`,
       );
 
       const waitStart = Date.now();

src/moderation.ts

···
   });
 };
 
-
 export const createPostReport = async (
   uri: string,
   cid: string,
···
     }
   });
 };
-
 
 export const checkRecordLabels = async (
   uri: string,

src/rules/account/age.ts

···
+import { ACCOUNT_AGE_CHECKS } from "../../../rules/accountAge.js";
+import { GLOBAL_ALLOW } from "../../../rules/constants.js";
+import {
+  checkAccountLabels,
+  createAccountLabel,
+} from "../../accountModeration.js";
 import { agent, isLoggedIn } from "../../agent.js";
 import { PLC_URL } from "../../config.js";
-import { GLOBAL_ALLOW } from "../../../rules/constants.js";
 import { logger } from "../../logger.js";
-import { checkAccountLabels, createAccountLabel } from "../../accountModeration.js";
-import { ACCOUNT_AGE_CHECKS } from "../../../rules/accountAge.js";
 
 interface InteractionContext {
   // For replies

src/rules/account/countStarterPacks.ts

···
+import { createAccountLabel } from "../../accountModeration.js";
 import { agent, isLoggedIn } from "../../agent.js";
 import { limit } from "../../limits.js";
 import { logger } from "../../logger.js";
-import { createAccountLabel } from "../../accountModeration.js";
 
 const ALLOWED_DIDS = ["did:plc:gpunjjgvlyb4racypz3yfiq4"];
 

src/rules/account/tests/age.test.ts

···
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { ACCOUNT_AGE_CHECKS } from "../../../../rules/accountAge.js";
+import { GLOBAL_ALLOW } from "../../../../rules/constants.js";
+import {
+  checkAccountLabels,
+  createAccountLabel,
+} from "../../../accountModeration.js";
 import { agent } from "../../../agent.js";
-import { GLOBAL_ALLOW } from "../../../../rules/constants.js";
 import { logger } from "../../../logger.js";
-import { checkAccountLabels, createAccountLabel } from "../../../accountModeration.js";
 import {
   calculateAccountAge,
   checkAccountAge,
   getAccountCreationDate,
 } from "../age.js";
-import { ACCOUNT_AGE_CHECKS } from "../../../../rules/accountAge.js";
 
 // Mock dependencies
 vi.mock("../../../agent.js", () => ({

src/rules/account/tests/countStarterPacks.test.ts

···
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { createAccountLabel } from "../../../accountModeration.js";
 import { agent } from "../../../agent.js";
 import { limit } from "../../../limits.js";
 import { logger } from "../../../logger.js";
-import { createAccountLabel } from "../../../accountModeration.js";
 import { countStarterPacks } from "../countStarterPacks.js";
 
 // Mock dependencies

src/rules/facets/facets.ts

···
-import { logger } from "../../logger.js";
 import { createAccountLabel } from "../../accountModeration.js";
+import { logger } from "../../logger.js";
 import { Facet } from "../../types.js";
 
 // Threshold for duplicate facet positions before flagging as spam

src/rules/facets/tests/facets.test.ts

···
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { logger } from "../../../logger.js";
 import { createAccountLabel } from "../../../accountModeration.js";
+import { logger } from "../../../logger.js";
 import { Facet } from "../../../types.js";
 import {
   FACET_SPAM_ALLOWLIST,

src/rules/handles/checkHandles.ts

···
 import { GLOBAL_ALLOW } from "../../../rules/constants.js";
-import { logger } from "../../logger.js";
+import { HANDLE_CHECKS } from "../../../rules/handles.js";
 import {
   createAccountComment,
   createAccountLabel,
   createAccountReport,
 } from "../../accountModeration.js";
-import { HANDLE_CHECKS } from "../../../rules/handles.js";
+import { logger } from "../../logger.js";
 
 export const checkHandle = async (
   did: string,

src/rules/profiles/checkProfiles.ts

···
 import { GLOBAL_ALLOW } from "../../../rules/constants.js";
-import { logger } from "../../logger.js";
+import { PROFILE_CHECKS } from "../../../rules/profiles.js";
 import {
   createAccountComment,
   createAccountLabel,
   createAccountReport,
 } from "../../accountModeration.js";
-import { PROFILE_CHECKS } from "../../../rules/profiles.js";
+import { logger } from "../../logger.js";
 import { getLanguage } from "../../utils/getLanguage.js";
 
 export const checkDescription = async (

src/rules/profiles/tests/checkProfiles.test.ts

···
 import { beforeEach, describe, expect, it, vi } from "vitest";
-import { logger } from "../../../logger.js";
 import {
   createAccountComment,
   createAccountLabel,
   createAccountReport,
 } from "../../../accountModeration.js";
+import { logger } from "../../../logger.js";
 import { getLanguage } from "../../../utils/getLanguage.js";
 import { checkDescription, checkDisplayName } from "../checkProfiles.js";
 
···
           expect.any(String),
         );
       });
-
     });
   });
 

src/session.ts

···
-import { readFileSync, writeFileSync, unlinkSync, chmodSync, existsSync } from "node:fs";
+import {
+  chmodSync,
+  existsSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
 import { join } from "node:path";
 import { logger } from "./logger.js";
 
···
     logger.info("Loaded existing session from file");
     return session;
   } catch (error) {
-    logger.error({ error }, "Failed to load session file, will authenticate fresh");
+    logger.error(
+      { error },
+      "Failed to load session file, will authenticate fresh",
+    );
     return null;
   }
 }

src/tests/accountThreshold.test.ts

···
 import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  createAccountComment,
+  createAccountLabel,
+  createAccountReport,
+} from "../accountModeration.js";
+import {
+  checkAccountThreshold,
+  loadThresholdConfigs,
+} from "../accountThreshold.js";
+import { logger } from "../logger.js";
+import {
+  accountLabelsThresholdAppliedCounter,
+  accountThresholdChecksCounter,
+  accountThresholdMetCounter,
+} from "../metrics.js";
+import {
+  getPostLabelCountInWindow,
+  trackPostLabelForAccount,
+} from "../redis.js";
 
 vi.mock("../logger.js", () => ({
   logger: {
···
     inc: vi.fn(),
   },
 }));
-
-import {
-  checkAccountThreshold,
-  loadThresholdConfigs,
-} from "../accountThreshold.js";
-import { logger } from "../logger.js";
-import {
-  accountLabelsThresholdAppliedCounter,
-  accountThresholdChecksCounter,
-  accountThresholdMetCounter,
-} from "../metrics.js";
-import {
-  createAccountComment,
-  createAccountLabel,
-  createAccountReport,
-} from "../accountModeration.js";
-import {
-  getPostLabelCountInWindow,
-  trackPostLabelForAccount,
-} from "../redis.js";
 
 describe("Account Threshold Logic", () => {
   afterEach(() => {

src/tests/moderation.test.ts

···
 import { beforeEach, describe, expect, it, vi } from "vitest";
+// --- Imports Second ---
+import { checkAccountLabels } from "../accountModeration.js";
+import { agent } from "../agent.js";
+import { logger } from "../logger.js";
+import { createPostLabel } from "../moderation.js";
+import { tryClaimPostLabel } from "../redis.js";
 
 // --- Mocks First ---
 
···
   limit: vi.fn((fn) => fn()),
 }));
 
-// --- Imports Second ---
-
-import { checkAccountLabels } from "../accountModeration.js";
-import { agent } from "../agent.js";
-import { logger } from "../logger.js";
-import { createPostLabel } from "../moderation.js";
-import { tryClaimPostLabel } from "../redis.js";
-
 describe("Moderation Logic", () => {
   beforeEach(() => {
     vi.clearAllMocks();
···
       vi.mocked(agent.tools.ozone.moderation.getRepo).mockResolvedValueOnce({
         data: {
           labels: [
-            { val: "spam", src: "did:plc:test", uri: "at://test", cts: "2024-01-01T00:00:00Z" },
-            { val: "window-reply", src: "did:plc:test", uri: "at://test", cts: "2024-01-01T00:00:00Z" }
-          ]
+            {
+              val: "spam",
+              src: "did:plc:test",
+              uri: "at://test",
+              cts: "2024-01-01T00:00:00Z",
+            },
+            {
+              val: "window-reply",
+              src: "did:plc:test",
+              uri: "at://test",
+              cts: "2024-01-01T00:00:00Z",
+            },
+          ],
         },
       } as any);
-      const result = await checkAccountLabels("did:plc:test123", "window-reply");
+      const result = await checkAccountLabels(
+        "did:plc:test123",
+        "window-reply",
+      );
       expect(result).toBe(true);
     });
   });
···
       await createPostLabel(URI, CID, LABEL, COMMENT, undefined);
 
       expect(vi.mocked(tryClaimPostLabel)).toHaveBeenCalledWith(URI, LABEL);
-      expect(vi.mocked(agent.tools.ozone.moderation.getRecord)).not.toHaveBeenCalled();
-      expect(vi.mocked(agent.tools.ozone.moderation.emitEvent)).not.toHaveBeenCalled();
+      expect(
+        vi.mocked(agent.tools.ozone.moderation.getRecord),
+      ).not.toHaveBeenCalled();
+      expect(
+        vi.mocked(agent.tools.ozone.moderation.emitEvent),
+      ).not.toHaveBeenCalled();
     });
 
     it("should skip event if claimed but already labeled via API", async () => {
       vi.mocked(tryClaimPostLabel).mockResolvedValue(true);
       vi.mocked(agent.tools.ozone.moderation.getRecord).mockResolvedValue({
-        data: { labels: [{ val: LABEL, src: "did:plc:test", uri: URI, cts: "2024-01-01T00:00:00Z" }] },
+        data: {
+          labels: [
+            {
+              val: LABEL,
+              src: "did:plc:test",
+              uri: URI,
+              cts: "2024-01-01T00:00:00Z",
+            },
+          ],
+        },
       } as any);
 
       await createPostLabel(URI, CID, LABEL, COMMENT, undefined);
 
       expect(vi.mocked(tryClaimPostLabel)).toHaveBeenCalledWith(URI, LABEL);
-      expect(vi.mocked(agent.tools.ozone.moderation.getRecord)).toHaveBeenCalledWith(
-        { uri: URI },
-        expect.any(Object),
-      );
-      expect(vi.mocked(agent.tools.ozone.moderation.emitEvent)).not.toHaveBeenCalled();
+      expect(
+        vi.mocked(agent.tools.ozone.moderation.getRecord),
+      ).toHaveBeenCalledWith({ uri: URI }, expect.any(Object));
+      expect(
+        vi.mocked(agent.tools.ozone.moderation.emitEvent),
+      ).not.toHaveBeenCalled();
     });
 
     it("should emit event if claimed and not labeled anywhere", async () => {
···
       vi.mocked(agent.tools.ozone.moderation.getRecord).mockResolvedValue({
         data: { labels: [] },
       } as any);
-      vi.mocked(agent.tools.ozone.moderation.emitEvent).mockResolvedValue({ success: true } as any);
+      vi.mocked(agent.tools.ozone.moderation.emitEvent).mockResolvedValue({
+        success: true,
+      } as any);
 
       await createPostLabel(URI, CID, LABEL, COMMENT, undefined);
 
       expect(vi.mocked(tryClaimPostLabel)).toHaveBeenCalledWith(URI, LABEL);
-      expect(vi.mocked(agent.tools.ozone.moderation.getRecord)).toHaveBeenCalledWith(
-        { uri: URI },
-        expect.any(Object),
-      );
-      expect(vi.mocked(agent.tools.ozone.moderation.emitEvent)).toHaveBeenCalled();
+      expect(
+        vi.mocked(agent.tools.ozone.moderation.getRecord),
+      ).toHaveBeenCalledWith({ uri: URI }, expect.any(Object));
+      expect(
+        vi.mocked(agent.tools.ozone.moderation.emitEvent),
+      ).toHaveBeenCalled();
     });
   });
-});
+});

src/tests/redis.test.ts

···
-import { afterEach, describe, expect, it, vi } from 'vitest';
+// Import the mocked redis first to get a reference to the mock client
+import { createClient } from "redis";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { logger } from "../logger.js";
+// Import the modules to be tested
+import {
+  connectRedis,
+  disconnectRedis,
+  getPostLabelCountInWindow,
+  trackPostLabelForAccount,
+  tryClaimAccountLabel,
+  tryClaimPostLabel,
+} from "../redis.js";
 
 // Mock the 'redis' module in a way that avoids hoisting issues.
 // The mock implementation is self-contained.
-vi.mock('redis', () => {
+vi.mock("redis", () => {
   const mockClient = {
     on: vi.fn(),
     connect: vi.fn(),
···
   };
 });
 
-// Import the mocked redis first to get a reference to the mock client
-import { createClient } from 'redis';
 const mockRedisClient = createClient();
 
-// Import the modules to be tested
-import {
-  tryClaimPostLabel,
-  tryClaimAccountLabel,
-  connectRedis,
-  disconnectRedis,
-  trackPostLabelForAccount,
-  getPostLabelCountInWindow,
-} from '../redis.js';
-import { logger } from '../logger.js';
-
 // Suppress logger output during tests
-vi.mock('../logger.js', () => ({
+vi.mock("../logger.js", () => ({
   logger: {
     info: vi.fn(),
     warn: vi.fn(),
···
   },
 }));
 
-describe('Redis Cache Logic', () => {
+describe("Redis Cache Logic", () => {
   afterEach(() => {
     vi.clearAllMocks();
   });
 
-  describe('Connection', () => {
-    it('should call redisClient.connect on connectRedis', async () => {
+  describe("Connection", () => {
+    it("should call redisClient.connect on connectRedis", async () => {
       await connectRedis();
       expect(mockRedisClient.connect).toHaveBeenCalled();
     });
 
-    it('should call redisClient.quit on disconnectRedis', async () => {
+    it("should call redisClient.quit on disconnectRedis", async () => {
       await disconnectRedis();
       expect(mockRedisClient.quit).toHaveBeenCalled();
     });
   });
 
-  describe('tryClaimPostLabel', () => {
-    it('should return true and set key if key does not exist', async () => {
-      vi.mocked(mockRedisClient.set).mockResolvedValue('OK');
-      const result = await tryClaimPostLabel('at://uri', 'test-label');
+  describe("tryClaimPostLabel", () => {
+    it("should return true and set key if key does not exist", async () => {
+      vi.mocked(mockRedisClient.set).mockResolvedValue("OK");
+      const result = await tryClaimPostLabel("at://uri", "test-label");
       expect(result).toBe(true);
       expect(mockRedisClient.set).toHaveBeenCalledWith(
-        'post-label:at://uri:test-label',
-        '1',
-        { NX: true, EX: 60 * 60 * 24 * 7 }
+        "post-label:at://uri:test-label",
+        "1",
+        { NX: true, EX: 60 * 60 * 24 * 7 },
       );
     });
 
-    it('should return false if key already exists', async () => {
+    it("should return false if key already exists", async () => {
       vi.mocked(mockRedisClient.set).mockResolvedValue(null);
-      const result = await tryClaimPostLabel('at://uri', 'test-label');
+      const result = await tryClaimPostLabel("at://uri", "test-label");
       expect(result).toBe(false);
     });
 
-    it('should return true and log warning on Redis error', async () => {
-      const redisError = new Error('Redis down');
+    it("should return true and log warning on Redis error", async () => {
+      const redisError = new Error("Redis down");
       vi.mocked(mockRedisClient.set).mockRejectedValue(redisError);
-      const result = await tryClaimPostLabel('at://uri', 'test-label');
+      const result = await tryClaimPostLabel("at://uri", "test-label");
       expect(result).toBe(true);
       expect(logger.warn).toHaveBeenCalledWith(
-        { err: redisError, atURI: 'at://uri', label: 'test-label' },
-        'Error claiming post label in Redis, allowing through'
+        { err: redisError, atURI: "at://uri", label: "test-label" },
+        "Error claiming post label in Redis, allowing through",
       );
     });
   });
 
-  describe('tryClaimAccountLabel', () => {
-    it('should return true and set key if key does not exist', async () => {
-      vi.mocked(mockRedisClient.set).mockResolvedValue('OK');
-      const result = await tryClaimAccountLabel('did:plc:123', 'test-label');
+  describe("tryClaimAccountLabel", () => {
+    it("should return true and set key if key does not exist", async () => {
+      vi.mocked(mockRedisClient.set).mockResolvedValue("OK");
+      const result = await tryClaimAccountLabel("did:plc:123", "test-label");
       expect(result).toBe(true);
       expect(mockRedisClient.set).toHaveBeenCalledWith(
-        'account-label:did:plc:123:test-label',
-        '1',
-        { NX: true, EX: 60 * 60 * 24 * 7 }
+        "account-label:did:plc:123:test-label",
+        "1",
+        { NX: true, EX: 60 * 60 * 24 * 7 },
       );
     });
 
-    it('should return false if key already exists', async () => {
+    it("should return false if key already exists", async () => {
       vi.mocked(mockRedisClient.set).mockResolvedValue(null);
-      const result = await tryClaimAccountLabel('did:plc:123', 'test-label');
+      const result = await tryClaimAccountLabel("did:plc:123", "test-label");
       expect(result).toBe(false);
     });
   });
 
-  describe('trackPostLabelForAccount', () => {
-    it('should track post label with correct timestamp and TTL', async () => {
+  describe("trackPostLabelForAccount", () => {
+    it("should track post label with correct timestamp and TTL", async () => {
       vi.mocked(mockRedisClient.zRemRangeByScore).mockResolvedValue(0);
       vi.mocked(mockRedisClient.zAdd).mockResolvedValue(1);
       vi.mocked(mockRedisClient.expire).mockResolvedValue(true);
···
       const timestamp = 1640000000000000; // microseconds
       const windowDays = 5;
 
-      await trackPostLabelForAccount('did:plc:123', 'test-label', timestamp, windowDays);
+      await trackPostLabelForAccount(
+        "did:plc:123",
+        "test-label",
+        timestamp,
+        windowDays,
+      );
 
-      const expectedKey = 'account-post-labels:did:plc:123:test-label:5';
+      const expectedKey = "account-post-labels:did:plc:123:test-label:5";
       const windowStartTime = timestamp - windowDays * 24 * 60 * 60 * 1000000;
 
       expect(mockRedisClient.zRemRangeByScore).toHaveBeenCalledWith(
         expectedKey,
-        '-inf',
-        windowStartTime
+        "-inf",
+        windowStartTime,
       );
       expect(mockRedisClient.zAdd).toHaveBeenCalledWith(expectedKey, {
         score: timestamp,
···
       });
       expect(mockRedisClient.expire).toHaveBeenCalledWith(
         expectedKey,
-        (windowDays + 1) * 24 * 60 * 60
+        (windowDays + 1) * 24 * 60 * 60,
       );
     });
 
-    it('should throw error on Redis failure', async () => {
-      const redisError = new Error('Redis down');
+    it("should throw error on Redis failure", async () => {
+      const redisError = new Error("Redis down");
       vi.mocked(mockRedisClient.zRemRangeByScore).mockRejectedValue(redisError);
 
       await expect(
-        trackPostLabelForAccount('did:plc:123', 'test-label', 1640000000000000, 5)
-      ).rejects.toThrow('Redis down');
+        trackPostLabelForAccount(
+          "did:plc:123",
+          "test-label",
+          1640000000000000,
+          5,
+        ),
+      ).rejects.toThrow("Redis down");
 
       expect(logger.error).toHaveBeenCalled();
     });
   });
 
-  describe('getPostLabelCountInWindow', () => {
-    it('should count posts for single label', async () => {
+  describe("getPostLabelCountInWindow", () => {
+    it("should count posts for single label", async () => {
       vi.mocked(mockRedisClient.zCount).mockResolvedValue(3);
 
       const currentTime = 1640000000000000;
       const windowDays = 5;
       const count = await getPostLabelCountInWindow(
-        'did:plc:123',
-        ['test-label'],
+        "did:plc:123",
+        ["test-label"],
         windowDays,
-        currentTime
+        currentTime,
       );
 
       expect(count).toBe(3);
       const windowStartTime = currentTime - windowDays * 24 * 60 * 60 * 1000000;
       expect(mockRedisClient.zCount).toHaveBeenCalledWith(
-        'account-post-labels:did:plc:123:test-label:5',
+        "account-post-labels:did:plc:123:test-label:5",
         windowStartTime,
-        '+inf'
+        "+inf",
       );
     });
 
-    it('should sum counts for multiple labels (OR logic)', async () => {
+    it("should sum counts for multiple labels (OR logic)", async () => {
       vi.mocked(mockRedisClient.zCount)
         .mockResolvedValueOnce(3)
         .mockResolvedValueOnce(2)
···
       const currentTime = 1640000000000000;
       const windowDays = 5;
       const count = await getPostLabelCountInWindow(
-        'did:plc:123',
-        ['label-1', 'label-2', 'label-3'],
+        "did:plc:123",
+        ["label-1", "label-2", "label-3"],
         windowDays,
-        currentTime
+        currentTime,
       );
 
       expect(count).toBe(6);
       expect(mockRedisClient.zCount).toHaveBeenCalledTimes(3);
     });
 
-    it('should return 0 when no posts in window', async () => {
+    it("should return 0 when no posts in window", async () => {
       vi.mocked(mockRedisClient.zCount).mockResolvedValue(0);
 
       const count = await getPostLabelCountInWindow(
-        'did:plc:123',
-        ['test-label'],
+        "did:plc:123",
+        ["test-label"],
         5,
-        1640000000000000
+        1640000000000000,
       );
 
       expect(count).toBe(0);
     });
 
-    it('should throw error on Redis failure', async () => {
-      const redisError = new Error('Redis down');
+    it("should throw error on Redis failure", async () => {
+      const redisError = new Error("Redis down");
       vi.mocked(mockRedisClient.zCount).mockRejectedValue(redisError);
 
       await expect(
-        getPostLabelCountInWindow('did:plc:123', ['test-label'], 5, 1640000000000000)
-      ).rejects.toThrow('Redis down');
+        getPostLabelCountInWindow(
+          "did:plc:123",
+          ["test-label"],
+          5,
+          1640000000000000,
+        ),
+      ).rejects.toThrow("Redis down");
 
       expect(logger.error).toHaveBeenCalled();
     });
   });
-});
+});