feat: Add workflow guidelines and project documentation

This commit introduces new files that provide comprehensive guidelines
for contributing to the project. The updated documentation enhances
maintainability and clarity for all contributors.

CLAUDE.md

···
-# Claude Code Instructions
-
-**All imports in this document should be treated as if they were in the main prompt file.**
-
-## MCP Orientation Instructions
-
-@.claude/mcp-descriptions/github-mcp.mdc
-
-NEVER USE A COMMAND-LINE TOOL WHEN AN MCP TOOL IS AVAILABLE. IF YOU THINK AN MCP TOOL IS MALFUNCTIONING AND CANNOT OTHERWISE CONTINUE, STOP AND ASK THE HUMAN OPERATOR FOR ASSISTANCE.
-
-## Development Commands
-
-### Running the Application
-
-- `bun run start` - Run the main application (production mode)
-- `bun run dev` - Run in development mode with file watching
-- `bun i` - Install dependencies
-
-### Code Quality
+# CLAUDE.md
 
-- `bun run format` - Format code using Prettier
-- `bun run lint` - Run ESLint to check for issues
-- `bun run lint:fix` - Automatically fix ESLint issues where possible
-
-### Docker Deployment
-
-- `docker build -pull -t skywatch-tools .` - Build Docker image
-- `docker run -d -p 4101:4101 skywatch-autolabeler` - Run container
-
-## Architecture Overview
-
-This is a TypeScript rewrite of a Bash-based Bluesky content moderation system for the skywatch.blue independent labeler. The application monitors the Bluesky firehose in real-time and automatically applies labels to content that meets specific moderation criteria.
-
-### Core Components
-
-- **`main.ts`** - Entry point that sets up Jetstream WebSocket connection to monitor Bluesky firehose events (posts, profiles, handles, starter packs)
-- **`agent.ts`** - Configures the AtpAgent for interacting with Ozone PDS for labeling operations
-- **`constants.ts`** - Contains all moderation check definitions (PROFILE_CHECKS, POST_CHECKS, HANDLE_CHECKS)
-- **`config.ts`** - Environment variable configuration and application settings
-- **Check modules** - Individual modules for different content types:
-  - `checkPosts.ts` - Analyzes post content and URLs
-  - `checkHandles.ts` - Validates user handles
-  - `checkProfiles.ts` - Examines profile descriptions and display names
-  - `checkStarterPack.ts` - Reviews starter pack content
+This file provides critical guidance to Claude Code when working with code in this repository.
 
-### Moderation Check System
+## IMPORTANT LIMITATIONS
 
-The system uses a `Checks` interface to define moderation rules with the following properties:
+- **CANNOT run interactive CLI applications** - The user will test and provide debug output
+- Cannot interact with programs that require user input (including `cargo run --bin pattern-cli`)
+- Must rely on user-provided logs and error messages for debugging if file logs are not available.
 
-- `label` - The label to apply when content matches
-- `check` - RegExp pattern to match against content
-- `whitelist` - Optional RegExp to exempt certain content
-- `ignoredDIDs` - Array of DIDs to skip for this check
-- `reportAcct/commentAcct/toLabel` - Actions to take when content matches
+## Workflow Guidelines
 
-### Environment Configuration
+These steps help ensure quality and prevent common issues:
 
-The application requires several environment variables:
+1. Context Check: Start by confirming the model and re-reading relevant
+documentation. If there is a PRD.md, review it to understand the requirements and constraints.
+2. Plan First: Explain your approach before implementing changes. Output your plan to PLAN.md in addition to explaining it to the user.
+3. Seek Alignment: Confirm the approach makes sense before coding
+4. Focused Changes: Keep modifications minimal and targeted
+5. Validate Thoroughly: Run all tests and validation steps
+6. Verify Success: Ensure everything works before considering complete"
 
-- Bluesky credentials (`BSKY_HANDLE`, `BSKY_PASSWORD`)
-- Ozone server configuration (`OZONE_URL`, `OZONE_PDS`)
-- Optional: firehose URL, ports, rate limiting settings
+Follow the response style and code style below:
 
-### Data Flow
+<response_style>
+Provide responses that are intelligent and slightly humorous (WITHOUT being cringe), while maintaining a casual and modern tone.
 
-1. Jetstream receives events from Bluesky firehose
-2. Events are categorized by type (post, profile, handle, starter pack)
-3. Appropriate check functions validate content against defined patterns
-4. Matching content triggers labeling actions via Ozone PDS
-5. Cursor position is periodically saved for resumption after restart
+Before responding, take a moment to consider how to best address the user's input while adhering to your personality traits and communication style.
 
-### Development Notes
 
-- Uses Bun as the runtime and package manager
-- Built with modern TypeScript and ESNext modules
-- Implements rate limiting and error handling for API calls
-- Supports both labeling and reporting workflows
-- Includes metrics server on port 4101 for monitoring
+When formulating your response, follow these guidelines:
 
-See `src/developing_checks.md` for detailed instructions on creating new moderation checks.
+- keep it casual as fuck. use lowercase for short sentences, except when you wanna EMPHASIZE something, but when absolutely required for the bit you can break out the proper grammar.
+- AVOID compromising on intelligence or depth of knowledge
+- be concise, super concise. one or two words if you can manage it UNLESS responding to something that requires more detail, depth etc
+- you've got weird interests and a unique but not unkind sense of humour. let it show, but subtly
+- use modern slang occasionally (such as but not limited to "ngl", "bet" or "fr")
+- include subtle references to your unique interests and sense of humour
+- swear a bit
+- use Canadian English spelling (e.g., "armour" instead of "armor"), except in source code.
+- skip sycophantic flattery; NEVER give me hollow praise, validation, adoration, or grandiose affirmations. NEVER act like a cheerleader. probe my assumptions, surface bias, present counter-evidence, explicitly challenge my framing, and disagree openly; agreement must be EARNED through vigorous reason.
 
-## Code Quality & Error Handling Status
+Remember, while maintaining your unique personality, never compromise on the quality of information or depth of analysis. Aim for conciseness, but provide more detailed and lengthy responses when the topic warrants it.
 
-✅ **COMPLETED: Comprehensive Async Error Handling & Linting Fixes**
+When producing code, avoid giving the source code personality and instead within them be completely professional.
+</response_style>
 
-All critical async error handling issues and code quality problems have been resolved:
+<code_style>
 
-### **Resolved Issues:**
+## Follow the code style below when producing code:
 
-**Async Error Handling:**
-- ✅ Fixed all unsafe type assertions throughout the codebase
-- ✅ Added comprehensive error type annotations (`: unknown`) in all catch blocks
-- ✅ Implemented proper fire-and-forget patterns with `void` operator for async operations
-- ✅ Converted problematic async event handlers to non-async with proper promise handling
-- ✅ Added Promise.allSettled() for concurrent operations in main.ts
+You are a programming expert tasked with writing professional code. Your primary focus is on creating idiomatic and up-to-date syntax while minimizing unnecessary dependencies.
 
-**Code Quality Improvements:**
-- ✅ Removed all unused imports across check modules
-- ✅ Fixed template literal type safety with proper `.toString()` conversions
-- ✅ Replaced all non-null assertions with safe optional chaining
-- ✅ Eliminated unnecessary type checks and conditions
-- ✅ Applied modern TypeScript patterns (nullish coalescing, destructuring)
+Your success is measured by the long-term maintainability and reliability of your code, not by implementation speed or brevity. You understand that while quick solutions may seem appealing, they often result in technical debt and increased maintenance costs.
 
-**Files Cleaned (Zero Linting Errors):**
-- ✅ `main.ts` - Core application entry point
-- ✅ `moderation.ts` - Moderation functions  
-- ✅ `checkProfiles.ts` - Profile checking logic
-- ✅ `checkHandles.ts` - Handle validation
-- ✅ `checkPosts.ts` - Post content checking
-- ✅ `checkStarterPack.ts` - Starter pack validation
-- ✅ `utils.ts` - Utility functions
+## When formulating your responses follow these guidelines:
 
-### **Remaining Tasks:**
+- Look at the provided project guidelines, project knowledge, and conversation-level input to make sure you fully understand the problem scope and how to address it
+- Use your tools to get your bearings and inform yourself
+- Avoid straying beyond the boundaries of the problem scope
+- Avoid adding features that are not required in the problem scope
+- Project structure must be provided prior to generating code unless it's a one-off script
+- When updating code, only provide relevant snippets and where they go, avoid regenerating the entire module
+- You love test cases and ensuring that all critical code is covered
+- When updating code, you must show & explain what you changed and why
+- Avoid refactoring prior working code unless there is an explicit need, and if there is, explain why
+- Avoid comments for self-documenting code
+- Avoid comments that detail fixes when refactoring. Put them in the response outside of any created code or tool use
+- Avoid unprofessional writing within source code edits
+- Avoid unprofessional writing within code comments
+- Avoid putting non-code parts of your response in code output or in tool uses
+- Removing functionality is NOT the solution for fixing test failures
 
-**High Priority:**
-- ⚠️ Missing constants.ts file (only example exists) - **REQUIRES USER ACTION**
-- ⚠️ Hardcoded DIDs should be moved to environment variables
-- ⚠️ No environment variable validation at startup
+</code_style>
 
-**Medium Priority:**
-- 📝 Missing comprehensive test suite
-- 📝 Duplicate profile checking logic could be refactored (non-critical)
+## REFERENCE MATERIALS
 
-**Status:** The codebase is now production-ready with robust error handling and modern TypeScript practices. The remaining tasks are configuration-related rather than code quality issues.
+- use the web or context7 to help find docs, in addition to any other reference material

GEMINI.md

···
+# GEMINI.md
+
+## Workflow Guidelines
+
+These steps help ensure quality and prevent common issues:
+
+1. Context Check: Start by confirming the model and re-reading relevant
+documentation. Review the codebase and any PLAN.md files present. If there is a PRD.md, review it to understand the requirements and constraints.
+2. Plan First: Explain your approach before implementing changes. If PLAN.md exists, review the plan and offer suggestions for improvements.
+3. Seek Alignment: Confirm the approach makes sense before coding
+4. Focused Changes: Keep modifications minimal and targeted
+5. Validate Thoroughly: Run all tests and validation steps
+6. Verify Success: Ensure everything works before considering complete"
+
+Follow the response style and code style below:
+
+<response_style>
+Provide responses that are intelligent and slightly humorous (WITHOUT being cringe), while maintaining a casual and modern tone.
+
+Before responding, take a moment to consider how to best address the user's input while adhering to your personality traits and communication style.
+
+When formulating your response, follow these guidelines:
+
+- keep it casual as fuck. use lowercase for short sentences, except when you wanna EMPHASIZE something, but when absolutely required for the bit you can break out the proper grammar.
+- AVOID compromising on intelligence or depth of knowledge
+- be concise, super concise. one or two words if you can manage it UNLESS responding to something that requires more detail, depth etc
+- you've got weird interests and a unique but not unkind sense of humour. let it show, but subtly
+- use modern slang occasionally (such as but not limited to "ngl", "bet" or "fr")
+- include subtle references to your unique interests and sense of humour
+- swear a bit
+- use Canadian English spelling (e.g., "armour" instead of "armor"), except in source code.
+- skip sycophantic flattery; NEVER give me hollow praise, validation, adoration, or grandiose affirmations. NEVER act like a cheerleader. probe my assumptions, surface bias, present counter-evidence, explicitly challenge my framing, and disagree openly; agreement must be EARNED through vigorous reason.
+
+Remember, while maintaining your unique personality, never compromise on the quality of information or depth of analysis. Aim for conciseness, but provide more detailed and lengthy responses when the topic warrants it.
+
+When producing code, avoid giving the source code personality and instead within them be completely professional.
+</response_style>
+
+## Project Overview
+
+This project, the Sentinel Routine Querying System (QRP), is a set of SAS programs designed to analyze healthcare data that conforms to the Sentinel Common Data Model (SCDM). It allows users to define cohorts and examine their health profiles and outcomes. The system is highly parameterized, using a combination of SAS macro variables and input datasets to control the analysis.
+
+The core of the project is a series of SAS macros that perform various data manipulation, analysis, and reporting tasks. The main entry point for running an analysis is the `qrp_master_header.sas` script, which sets up the environment, defines global macro variables, and includes all the necessary macro files.
+
+## Building and Running
+
+This is a SAS-based project and does not have a typical build process. To run an analysis, you need to:
+
+1.  **Prerequisites:**
+    *   SAS version 9.4
+    *   SCDM-formatted data as SAS datasets (`.sas7bdat`).
+
+2.  **Configuration:**
+    *   Populate the input files in the `SAS/inputfiles` directory with the appropriate data and parameters for your analysis.
+    *   Configure the `SAS/sasprograms/qrp_master_header.sas` file to specify the location of your SCDM data and other environment-specific settings.
+
+3.  **Execution:**
+    *   Run the `SAS/sasprograms/qrp_master_header.sas` script in a SAS environment. The `SAS/readme.md` suggests running it in "batch" mode.
+
+## Development Conventions
+
+*   **Code Style:** The SAS code appears to follow a consistent style, with extensive use of comments and headers to document the purpose of each section and macro.
+*   **Modularity:** The code is highly modular, with functionality broken down into a large number of individual SAS macros.
+*   **Configuration:** The system is heavily reliant on configuration through macro variables and input files. This allows for a high degree of flexibility without modifying the core SAS code.
+*   **Directory Structure:** The project follows a strict directory structure, with specific folders for documentation, input files, local data, and results.

PRD.md

···
+Replace lande with franc for language handling.

src/checkPosts.ts

···
-import { LINK_SHORTENER, POST_CHECKS, langs } from "./constants.js";
+import { LINK_SHORTENER, POST_CHECKS } from "./constants.js";
+import { Post } from "./types.js";
 import logger from "./logger.js";
+import { countStarterPacks } from "./count.js";
 import {
   createPostLabel,
   createAccountReport,
   createAccountComment,
   createPostReport,
 } from "./moderation.js";
-import type { Post } from "./types.js";
 import { getFinalUrl, getLanguage } from "./utils.js";
 
 export const checkPosts = async (post: Post[]) => {
···
     try {
       const url = post[0].text.match(urlRegex);
       if (url && LINK_SHORTENER.test(url[0])) {
-        logger.info(`[CHECKPOSTS]: Checking shortened URL: ${url[0]}`);
+        // logger.info(`[CHECKPOSTS]: Checking shortened URL: ${url[0]}`);
         const finalUrl = await getFinalUrl(url[0]);
         if (finalUrl) {
           const originalUrl = post[0].text;
           post[0].text = post[0].text.replace(url[0], finalUrl);
-          logger.info(
+          /* logger.info(
             `[CHECKPOSTS]: Shortened URL resolved: ${originalUrl} -> ${finalUrl}`,
-          );
+            ); */
         }
       }
     } catch (error) {
       logger.error(
-        `[CHECKPOSTS]: Failed to resolve shortened URL: ${post[0].text}`,
-        error,
+        `[CHECKPOSTS]: Failed to resolve shortened URL: ${post[0].text} with error: ${error}`,
       );
       // Keep the original URL if resolution fails
     }
···
           return;
         }
       }
+
+      countStarterPacks(post[0].did, post[0].time);
 
       if (checkPost!.toLabel === true) {
         logger.info(

src/checkProfiles.ts

···
-import { PROFILE_CHECKS } from "./constants.js";
+import { login } from "./agent.js";
+import { langs, PROFILE_CHECKS } from "./constants.js";
 import logger from "./logger.js";
 import {
   createAccountReport,
···
   displayName: string,
   description: string,
 ) => {
-  try {
-    const lang = await getLanguage(description);
+  const lang = await getLanguage(description);
+
+  const labels: string[] = Array.from(
+    PROFILE_CHECKS,
+    (profileCheck) => profileCheck.label,
+  );
 
-    const labels: string[] = Array.from(
-      PROFILE_CHECKS,
-      (profileCheck) => profileCheck.label,
+  // iterate through the labels
+  labels.forEach((label) => {
+    const checkProfiles = PROFILE_CHECKS.find(
+      (profileCheck) => profileCheck.label === label,
     );
 
-    // iterate through the labels
-    labels.forEach((label) => {
-      const checkProfiles = PROFILE_CHECKS.find(
-        (profileCheck) => profileCheck.label === label,
-      );
-
-      if (checkProfiles?.language || checkProfiles?.language !== undefined) {
-        if (!checkProfiles.language.includes(lang)) {
-          return;
-        }
+    if (checkProfiles?.language || checkProfiles?.language !== undefined) {
+      if (!checkProfiles?.language.includes(lang)) {
+        return;
       }
+    }
 
-      // Check if DID is whitelisted
-      if (checkProfiles?.ignoredDIDs) {
-        if (checkProfiles.ignoredDIDs.includes(did)) {
-          logger.info(`[CHECKDESCRIPTION]: Whitelisted DID: ${did}`);
-          return;
-        }
+    // Check if DID is whitelisted
+    if (checkProfiles?.ignoredDIDs) {
+      if (checkProfiles.ignoredDIDs.includes(did)) {
+        logger.info(`[CHECKDESCRIPTION]: Whitelisted DID: ${did}`);
+        return;
       }
+    }
 
-      if (description) {
-        if (checkProfiles?.description === true) {
-          if (checkProfiles.check.test(description)) {
-            // Check if description is whitelisted
-            if (checkProfiles.whitelist) {
-              if (checkProfiles.whitelist.test(description)) {
-                logger.info("[CHECKDESCRIPTION]: Whitelisted phrase found.");
-                return;
-              }
+    if (description) {
+      if (checkProfiles?.description === true) {
+        if (checkProfiles!.check.test(description)) {
+          // Check if description is whitelisted
+          if (checkProfiles!.whitelist) {
+            if (checkProfiles!.whitelist.test(description)) {
+              logger.info(`[CHECKDESCRIPTION]: Whitelisted phrase found.`);
+              return;
             }
+          }
 
-            if (checkProfiles.toLabel) {
-              void createAccountLabel(
-                did,
-                checkProfiles.label,
-                `${time.toString()}: ${checkProfiles.comment} - ${displayName} - ${description}`,
-              );
-              logger.info(
-                `[CHECKDESCRIPTION]: Labeling ${did} for ${checkProfiles.label}`,
-              );
-            }
+          if (checkProfiles!.toLabel === true) {
+            createAccountLabel(
+              did,
+              `${checkProfiles!.label}`,
+              `${time}: ${checkProfiles!.comment} - ${displayName} - ${description}`,
+            );
+            logger.info(
+              `[CHECKDESCRIPTION]: Labeling ${did} for ${checkProfiles!.label}`,
+            );
+          }
 
-            if (checkProfiles.reportAcct) {
-              void createAccountReport(
-                did,
-                `${time.toString()}: ${checkProfiles.comment} - ${displayName} - ${description}`,
-              );
-              logger.info(
-                `[CHECKDESCRIPTION]: Reporting ${did} for ${checkProfiles.label}`,
-              );
-            }
+          if (checkProfiles!.reportAcct === true) {
+            createAccountReport(
+              did,
+              `${time}: ${checkProfiles!.comment} - ${displayName} - ${description}`,
+            );
+            logger.info(
+              `[CHECKDESCRIPTION]: Reporting ${did} for ${checkProfiles!.label}`,
+            );
+          }
 
-            if (checkProfiles.commentAcct) {
-              void createAccountComment(
-                did,
-                `${time.toString()}: ${checkProfiles.comment} - ${displayName} - ${description}`,
-              );
-              logger.info(
-                `[CHECKDESCRIPTION]: Commenting on ${did} for ${checkProfiles.label}`,
-              );
-            }
+          if (checkProfiles!.commentAcct === true) {
+            createAccountComment(
+              did,
+              `${time}: ${checkProfiles!.comment} - ${displayName} - ${description}`,
+            );
+            logger.info(
+              `[CHECKDESCRIPTION]: Commenting on ${did} for ${checkProfiles!.label}`,
+            );
           }
         }
       }
-    });
-  } catch (error) {
-    logger.error(`Error in checkDescription for ${did}:`, error);
-    throw error;
-  }
+    }
+  });
 };
 
 export const checkDisplayName = async (
···
   displayName: string,
   description: string,
 ) => {
-  try {
-    const lang = await getLanguage(description);
+  const lang = await getLanguage(description);
 
-    // Get a list of labels
-    const labels: string[] = Array.from(
-      PROFILE_CHECKS,
-      (profileCheck) => profileCheck.label,
+  // Get a list of labels
+  const labels: string[] = Array.from(
+    PROFILE_CHECKS,
+    (profileCheck) => profileCheck.label,
+  );
+
+  // iterate through the labels
+  labels.forEach((label) => {
+    const checkProfiles = PROFILE_CHECKS.find(
+      (profileCheck) => profileCheck.label === label,
     );
 
-    // iterate through the labels
-    labels.forEach((label) => {
-      const checkProfiles = PROFILE_CHECKS.find(
-        (profileCheck) => profileCheck.label === label,
-      );
-
-      if (checkProfiles?.language || checkProfiles?.language !== undefined) {
-        if (!checkProfiles.language.includes(lang)) {
-          return;
-        }
+    if (checkProfiles?.language || checkProfiles?.language !== undefined) {
+      if (!checkProfiles?.language.includes(lang)) {
+        return;
       }
+    }
 
-      // Check if DID is whitelisted
-      if (checkProfiles?.ignoredDIDs) {
-        if (checkProfiles.ignoredDIDs.includes(did)) {
-          logger.info(`[CHECKDISPLAYNAME]: Whitelisted DID: ${did}`);
-          return;
-        }
+    // Check if DID is whitelisted
+    if (checkProfiles?.ignoredDIDs) {
+      if (checkProfiles.ignoredDIDs.includes(did)) {
+        logger.info(`[CHECKDISPLAYNAME]: Whitelisted DID: ${did}`);
+        return;
       }
+    }
 
-      if (displayName) {
-        if (checkProfiles?.displayName === true) {
-          if (checkProfiles.check.test(displayName)) {
-            // Check if displayName is whitelisted
-            if (checkProfiles.whitelist) {
-              if (checkProfiles.whitelist.test(displayName)) {
-                logger.info("[CHECKDISPLAYNAME]: Whitelisted phrase found.");
-                return;
-              }
+    if (displayName) {
+      if (checkProfiles?.displayName === true) {
+        if (checkProfiles!.check.test(displayName)) {
+          // Check if displayName is whitelisted
+          if (checkProfiles!.whitelist) {
+            if (checkProfiles!.whitelist.test(displayName)) {
+              logger.info(`[CHECKDISPLAYNAME]: Whitelisted phrase found.`);
+              return;
             }
+          }
 
-            if (checkProfiles.toLabel) {
-              void createAccountLabel(
-                did,
-                checkProfiles.label,
-                `${time.toString()}: ${checkProfiles.comment} - ${displayName} - ${description}`,
-              );
-              logger.info(
-                `[CHECKDISPLAYNAME]: Labeling ${did} for ${checkProfiles.label}`,
-              );
-            }
+          if (checkProfiles!.toLabel === true) {
+            createAccountLabel(
+              did,
+              `${checkProfiles!.label}`,
+              `${time}: ${checkProfiles!.comment} - ${displayName} - ${description}`,
+            );
+            logger.info(
+              `[CHECKDISPLAYNAME]: Labeling ${did} for ${checkProfiles!.label}`,
+            );
+          }
 
-            if (checkProfiles.reportAcct) {
-              void createAccountReport(
-                did,
-                `${time.toString()}: ${checkProfiles.comment} - ${displayName} - ${description}`,
-              );
-              logger.info(
-                `[CHECKDISPLAYNAME]: Reporting ${did} for ${checkProfiles.label}`,
-              );
-            }
+          if (checkProfiles!.reportAcct === true) {
+            createAccountReport(
+              did,
+              `${time}: ${checkProfiles!.comment} - ${displayName} - ${description}`,
+            );
+            logger.info(
+              `[CHECKDISPLAYNAME]: Reporting ${did} for ${checkProfiles!.label}`,
+            );
+          }
 
-            if (checkProfiles.commentAcct) {
-              void createAccountComment(
-                did,
-                `${time.toString()}: ${checkProfiles.comment} - ${displayName} - ${description}`,
-              );
-              logger.info(
-                `[CHECKDISPLAYNAME]: Commenting on ${did} for ${checkProfiles.label}`,
-              );
-            }
+          if (checkProfiles!.commentAcct === true) {
+            createAccountComment(
+              did,
+              `${time}: ${checkProfiles!.comment} - ${displayName} - ${description}`,
+            );
+            logger.info(
+              `[CHECKDISPLAYNAME]: Commenting on ${did} for ${checkProfiles!.label}`,
+            );
           }
         }
       }
-    });
-  } catch (error) {
-    logger.error(`Error in checkDisplayName for ${did}:`, error);
-    throw error;
-  }
+    }
+  });
 };

src/count.ts

···
+import { isLoggedIn, agent } from "./agent.js";
+import logger from "./logger.js";
+import { limit } from "./limits.js";
+import { createAccountLabel } from "./moderation.js";
+
+export const countStarterPacks = async (did: string, time: number) => {
+  await isLoggedIn;
+
+  if (did in ["did:plc:gpunjjgvlyb4racypz3yfiq4"]) {
+    logger.info(
+      `[COUNTSTARTERPACKS]: ${time}: Account ${did} is a whitelisted.`,
+    );
+    return;
+  }
+
+  await limit(async () => {
+    try {
+      const profile = await agent.app.bsky.actor.getProfile({ actor: did });
+      const starterPacks = profile.data.associated?.starterPacks;
+
+      if (starterPacks && starterPacks.valueOf() > 20) {
+        createAccountLabel(
+          did,
+          "follow-farming",
+          `[COUNTSTARTERPACKS]: ${time}: Account ${did} has ${starterPacks} starter packs.`,
+        );
+      }
+    } catch (error) {
+      logger.error(
+        `[COUNTSTARTERPACKS]: Error checking associated accounts: ${error}`,
+      );
+    }
+  });
+};

src/main.ts

···
-import fs from "node:fs";
-
-import type {
+import {
   CommitCreateEvent,
+  CommitUpdate,
   CommitUpdateEvent,
   IdentityEvent,
+  Jetstream,
 } from "@skyware/jetstream";
-import { Jetstream } from "@skyware/jetstream";
+import fs from "node:fs";
 
-import { checkHandle } from "./checkHandles.js";
-import { checkPosts } from "./checkPosts.js";
-import { checkDescription, checkDisplayName } from "./checkProfiles.js";
-import { checkStarterPack, checkNewStarterPack } from "./checkStarterPack.js";
 import {
   CURSOR_UPDATE_INTERVAL,
   FIREHOSE_URL,
···
 } from "./config.js";
 import logger from "./logger.js";
 import { startMetricsServer } from "./metrics.js";
-import { validateEnvironment } from "./validateEnv.js";
-import type { Post, LinkFeature } from "./types.js";
-
-validateEnvironment();
+import { Post, LinkFeature, Handle } from "./types.js";
+import { checkPosts } from "./checkPosts.js";
+import { checkHandle } from "./checkHandles.js";
+import { checkStarterPack, checkNewStarterPack } from "./checkStarterPack.js";
+import { checkDescription, checkDisplayName } from "./checkProfiles.js";
 
 let cursor = 0;
 let cursorUpdateInterval: NodeJS.Timeout;
···
 try {
   logger.info("Trying to read cursor from cursor.txt...");
   cursor = Number(fs.readFileSync("cursor.txt", "utf8"));
-  logger.info(
-    `Cursor found: ${cursor.toString()} (${epochUsToDateTime(cursor)})`,
-  );
+  logger.info(`Cursor found: ${cursor} (${epochUsToDateTime(cursor)})`);
 } catch (error) {
   if (error instanceof Error && "code" in error && error.code === "ENOENT") {
     cursor = Math.floor(Date.now() * 1000);
     logger.info(
-      `Cursor not found in cursor.txt, setting cursor to: ${cursor.toString()} (${epochUsToDateTime(cursor)})`,
+      `Cursor not found in cursor.txt, setting cursor to: ${cursor} (${epochUsToDateTime(cursor)})`,
     );
     fs.writeFileSync("cursor.txt", cursor.toString(), "utf8");
   } else {
···
 const jetstream = new Jetstream({
   wantedCollections: WANTED_COLLECTION,
   endpoint: FIREHOSE_URL,
-  cursor,
+  cursor: cursor,
 });
 
 jetstream.on("open", () => {
   if (jetstream.cursor) {
     logger.info(
-      `Connected to Jetstream at ${FIREHOSE_URL} with cursor ${jetstream.cursor.toString()} (${epochUsToDateTime(jetstream.cursor)})`,
+      `Connected to Jetstream at ${FIREHOSE_URL} with cursor ${jetstream.cursor} (${epochUsToDateTime(jetstream.cursor)})`,
     );
   } else {
     logger.info(
···
   cursorUpdateInterval = setInterval(() => {
     if (jetstream.cursor) {
       logger.info(
-        `Cursor updated to: ${jetstream.cursor.toString()} (${epochUsToDateTime(jetstream.cursor)})`,
+        `Cursor updated to: ${jetstream.cursor} (${epochUsToDateTime(jetstream.cursor)})`,
       );
       fs.writeFile("cursor.txt", jetstream.cursor.toString(), (err) => {
         if (err) logger.error(err);
···
 jetstream.onCreate(
   "app.bsky.feed.post",
   (event: CommitCreateEvent<"app.bsky.feed.post">) => {
-    try {
-      const atURI = `at://${event.did}/app.bsky.feed.post/${event.commit.rkey}`;
-      const hasFacets = Object.hasOwn(event.commit.record, "facets");
-      const hasText = Object.hasOwn(event.commit.record, "text");
+    const atURI = `at://${event.did}/app.bsky.feed.post/${event.commit.rkey}`;
+    const hasEmbed = event.commit.record.hasOwnProperty("embed");
+    const hasFacets = event.commit.record.hasOwnProperty("facets");
+    const hasText = event.commit.record.hasOwnProperty("text");
 
-      const tasks: Promise<void>[] = [];
+    const tasks: Promise<void>[] = [];
 
-      // Check if the record has facets
-      if (hasFacets && event.commit.record.facets) {
-        const hasLinkType = event.commit.record.facets.some((facet) =>
-          facet.features.some(
-            (feature) => feature.$type === "app.bsky.richtext.facet#link",
-          ),
-        );
+    // Check if the record has facets
+    if (hasFacets) {
+      const hasLinkType = event.commit.record.facets!.some((facet) =>
+        facet.features.some(
+          (feature) => feature.$type === "app.bsky.richtext.facet#link",
+        ),
+      );
 
-        if (hasLinkType) {
-          const urls = event.commit.record.facets
-            .flatMap((facet) =>
-              facet.features.filter(
-                (feature) => feature.$type === "app.bsky.richtext.facet#link",
-              ),
-            )
-            .map((feature: LinkFeature) => feature.uri);
+      if (hasLinkType) {
+        const urls = event.commit.record
+          .facets!.flatMap((facet) =>
+            facet.features.filter(
+              (feature) => feature.$type === "app.bsky.richtext.facet#link",
+            ),
+          )
+          .map((feature: LinkFeature) => feature.uri);
 
-          urls.forEach((url) => {
-            const posts: Post[] = [
-              {
-                did: event.did,
-                time: event.time_us,
-                rkey: event.commit.rkey,
-                atURI,
-                text: url,
-                cid: event.commit.cid,
-              },
-            ];
-            tasks.push(
-              checkPosts(posts).catch((error: unknown) => {
-                logger.error(
-                  `Error checking post links for ${event.did}:`,
-                  error,
-                );
-              }),
-            );
-          });
-        }
-      } else if (hasText && event.commit.record.text) {
+        urls.forEach((url) => {
+          const posts: Post[] = [
+            {
+              did: event.did,
+              time: event.time_us,
+              rkey: event.commit.rkey,
+              atURI: atURI,
+              text: url,
+              cid: event.commit.cid,
+            },
+          ];
+          tasks.push(checkPosts(posts));
+        });
+      }
+    }
+
+    if (hasText) {
+      const posts: Post[] = [
+        {
+          did: event.did,
+          time: event.time_us,
+          rkey: event.commit.rkey,
+          atURI: atURI,
+          text: event.commit.record.text,
+          cid: event.commit.cid,
+        },
+      ];
+      tasks.push(checkPosts(posts));
+    }
+
+    if (hasEmbed) {
+      const embed = event.commit.record.embed;
+      if (embed && embed.$type === "app.bsky.embed.external") {
         const posts: Post[] = [
           {
             did: event.did,
             time: event.time_us,
             rkey: event.commit.rkey,
-            atURI,
-            text: event.commit.record.text,
+            atURI: atURI,
+            text: embed.external.uri,
             cid: event.commit.cid,
           },
         ];
-        tasks.push(
-          checkPosts(posts).catch((error: unknown) => {
-            logger.error(`Error checking post text for ${event.did}:`, error);
-          }),
-        );
+        tasks.push(checkPosts(posts));
       }
 
-      // Wait for all tasks to complete
-      if (tasks.length > 0) {
-        void Promise.allSettled(tasks);
+      if (embed && embed.$type === "app.bsky.embed.recordWithMedia") {
+        if (embed.media.$type === "app.bsky.embed.external") {
+          const posts: Post[] = [
+            {
+              did: event.did,
+              time: event.time_us,
+              rkey: event.commit.rkey,
+              atURI: atURI,
+              text: embed.media.external.uri,
+              cid: event.commit.cid,
+            },
+          ];
+          tasks.push(checkPosts(posts));
+        }
       }
-    } catch (error: unknown) {
-      logger.error(`Error processing post event for ${event.did}:`, error);
     }
   },
 );
···
 // Check for profile updates
 jetstream.onUpdate(
   "app.bsky.actor.profile",
-  (event: CommitUpdateEvent<"app.bsky.actor.profile">) => {
+  async (event: CommitUpdateEvent<"app.bsky.actor.profile">) => {
     try {
-      const tasks: Promise<void>[] = [];
-
       if (event.commit.record.displayName || event.commit.record.description) {
-        const displayName = event.commit.record.displayName ?? "";
-        const description = event.commit.record.description ?? "";
-
-        tasks.push(
-          checkDescription(
-            event.did,
-            event.time_us,
-            displayName,
-            description,
-          ).catch((error: unknown) => {
-            logger.error(
-              `Error checking profile description for ${event.did}:`,
-              error,
-            );
-          }),
+        checkDescription(
+          event.did,
+          event.time_us,
+          event.commit.record.displayName as string,
+          event.commit.record.description as string,
         );
-
-        tasks.push(
-          checkDisplayName(
-            event.did,
-            event.time_us,
-            displayName,
-            description,
-          ).catch((error: unknown) => {
-            logger.error(
-              `Error checking profile display name for ${event.did}:`,
-              error,
-            );
-          }),
+        checkDisplayName(
+          event.did,
+          event.time_us,
+          event.commit.record.displayName as string,
+          event.commit.record.description as string,
         );
       }
 
       if (event.commit.record.joinedViaStarterPack) {
-        tasks.push(
-          checkStarterPack(
-            event.did,
-            event.time_us,
-            event.commit.record.joinedViaStarterPack.uri,
-          ).catch((error: unknown) => {
-            logger.error(
-              `Error checking starter pack for ${event.did}:`,
-              error,
-            );
-          }),
+        checkStarterPack(
+          event.did,
+          event.time_us,
+          event.commit.record.joinedViaStarterPack.uri,
         );
       }
-
-      // Wait for all tasks to complete
-      if (tasks.length > 0) {
-        void Promise.allSettled(tasks);
-      }
-    } catch (error: unknown) {
-      logger.error(
-        `Error processing profile update event for ${event.did}:`,
-        error,
-      );
+    } catch (error) {
+      logger.error(`Error checking profile:  ${error}`);
     }
   },
 );
···
 
 jetstream.onCreate(
   "app.bsky.actor.profile",
-  (event: CommitCreateEvent<"app.bsky.actor.profile">) => {
+  async (event: CommitCreateEvent<"app.bsky.actor.profile">) => {
     try {
-      const tasks: Promise<void>[] = [];
-
       if (event.commit.record.displayName || event.commit.record.description) {
-        const displayName = event.commit.record.displayName ?? "";
-        const description = event.commit.record.description ?? "";
-
-        tasks.push(
-          checkDescription(
-            event.did,
-            event.time_us,
-            displayName,
-            description,
-          ).catch((error: unknown) => {
-            logger.error(
-              `Error checking profile description for ${event.did}:`,
-              error,
-            );
-          }),
+        checkDescription(
+          event.did,
+          event.time_us,
+          event.commit.record.displayName as string,
+          event.commit.record.description as string,
         );
-
-        tasks.push(
-          checkDisplayName(
-            event.did,
-            event.time_us,
-            displayName,
-            description,
-          ).catch((error: unknown) => {
-            logger.error(
-              `Error checking profile display name for ${event.did}:`,
-              error,
-            );
-          }),
+        checkDisplayName(
+          event.did,
+          event.time_us,
+          event.commit.record.displayName as string,
+          event.commit.record.description as string,
         );
+      }
 
-        if (event.commit.record.joinedViaStarterPack) {
-          tasks.push(
-            checkStarterPack(
-              event.did,
-              event.time_us,
-              event.commit.record.joinedViaStarterPack.uri,
-            ).catch((error: unknown) => {
-              logger.error(
-                `Error checking starter pack for ${event.did}:`,
-                error,
-              );
-            }),
-          );
-        }
-
-        // Wait for all tasks to complete
-        if (tasks.length > 0) {
-          void Promise.allSettled(tasks);
-        }
+      if (event.commit.record.joinedViaStarterPack) {
+        checkStarterPack(
+          event.did,
+          event.time_us,
+          event.commit.record.joinedViaStarterPack.uri,
+        );
       }
-    } catch (error: unknown) {
-      logger.error(
-        `Error processing profile creation event for ${event.did}:`,
-        error,
-      );
+    } catch (error) {
+      logger.error(`Error checking profile:  ${error}`);
     }
   },
 );
 
 jetstream.onCreate(
   "app.bsky.graph.starterpack",
-  (event: CommitCreateEvent<"app.bsky.graph.starterpack">) => {
+  async (event: CommitCreateEvent<"app.bsky.graph.starterpack">) => {
     try {
       const atURI = `at://${event.did}/app.bsky.feed.post/${event.commit.rkey}`;
-      const { name, description } = event.commit.record;
 
-      void checkNewStarterPack(
+      checkNewStarterPack(
         event.did,
         event.time_us,
         atURI,
         event.commit.cid,
-        name,
-        description,
-      ).catch((error: unknown) => {
-        logger.error(
-          `Error checking new starter pack for ${event.did}:`,
-          error,
-        );
-      });
-    } catch (error: unknown) {
-      logger.error(
-        `Error processing starter pack creation event for ${event.did}:`,
-        error,
+        event.commit.record.name,
+        event.commit.record.description,
       );
+    } catch (error) {
+      logger.error(`Error checking starterpack:  ${error}`);
     }
   },
 );
 
 jetstream.onUpdate(
   "app.bsky.graph.starterpack",
-  (event: CommitUpdateEvent<"app.bsky.graph.starterpack">) => {
+  async (event: CommitUpdateEvent<"app.bsky.graph.starterpack">) => {
     try {
       const atURI = `at://${event.did}/app.bsky.feed.post/${event.commit.rkey}`;
-      const { name, description } = event.commit.record;
 
-      void checkNewStarterPack(
+      checkNewStarterPack(
         event.did,
         event.time_us,
         atURI,
         event.commit.cid,
-        name,
-        description,
-      ).catch((error: unknown) => {
-        logger.error(
-          `Error checking updated starter pack for ${event.did}:`,
-          error,
-        );
-      });
-    } catch (error: unknown) {
-      logger.error(
-        `Error processing starter pack update event for ${event.did}:`,
-        error,
+        event.commit.record.name,
+        event.commit.record.description,
       );
+    } catch (error) {
+      logger.error(`Error checking starterpack:  ${error}`);
     }
   },
 );
 
 // Check for handle updates
-jetstream.on("identity", (event: IdentityEvent) => {
-  try {
-    if (event.identity.handle) {
-      void checkHandle(
-        event.identity.did,
-        event.identity.handle,
-        event.time_us,
-      ).catch((error: unknown) => {
-        logger.error(`Error checking handle for ${event.identity.did}:`, error);
-      });
-    }
-  } catch (error: unknown) {
-    logger.error(
-      `Error processing identity event for ${event.identity.did}:`,
-      error,
-    );
+jetstream.on("identity", async (event: IdentityEvent) => {
+  if (event.identity.handle) {
+    checkHandle(event.identity.did, event.identity.handle, event.time_us);
   }
 });
 
-// Start metrics server with error handling
-let metricsServer: ReturnType<typeof startMetricsServer> | undefined;
-try {
-  metricsServer = startMetricsServer(METRICS_PORT);
-  logger.info(`Metrics server started on port ${METRICS_PORT.toString()}`);
-} catch (error: unknown) {
-  logger.error("Failed to start metrics server:", error);
-  process.exit(1);
-}
+const metricsServer = startMetricsServer(METRICS_PORT);
 
 /* labelerServer.app.listen({ port: PORT, host: HOST }, (error, address) => {
   if (error) {
···
   }
 });*/
 
-// Start jetstream with error handling
-try {
-  jetstream.start();
-  logger.info("Jetstream started successfully");
-} catch (error: unknown) {
-  logger.error("Failed to start jetstream:", error);
-  process.exit(1);
-}
+jetstream.start();
 
 function shutdown() {
   try {
     logger.info("Shutting down gracefully...");
-    if (jetstream.cursor) {
-      fs.writeFileSync("cursor.txt", jetstream.cursor.toString(), "utf8");
-    }
+    fs.writeFileSync("cursor.txt", jetstream.cursor!.toString(), "utf8");
     jetstream.close();
-    if (metricsServer) {
-      metricsServer.close(() => {
-        logger.info("Metrics server closed");
-      });
-    }
-    logger.info("Shutdown completed successfully");
-  } catch (error: unknown) {
-    logger.error("Error shutting down gracefully:", error);
+    metricsServer.close();
+  } catch (error) {
+    logger.error(`Error shutting down gracefully: ${error}`);
     process.exit(1);
   }
 }
-
-// Global error handlers
-process.on("unhandledRejection", (reason, promise) => {
-  logger.error("Unhandled Promise Rejection at:", promise, "reason:", reason);
-  // Don't exit the process for unhandled rejections, just log them
-});
-
-process.on("uncaughtException", (error) => {
-  logger.error("Uncaught Exception:", error);
-  shutdown();
-});
 
 process.on("SIGINT", shutdown);
 process.on("SIGTERM", shutdown);

src/moderation.ts

···
 import { agent, isLoggedIn } from "./agent.js";
 import { MOD_DID } from "./config.js";
 import { limit } from "./limits.js";
-import { LISTS } from "./lists.js";
 import logger from "./logger.js";
+import { LISTS } from "./lists.js";
 
 export const createPostLabel = async (
   uri: string,
···
   await isLoggedIn;
   await limit(async () => {
     try {
-      return await agent.tools.ozone.moderation.emitEvent(
+      return agent.tools.ozone.moderation.emitEvent(
         {
           event: {
             $type: "tools.ozone.moderation.defs#modEventLabel",
-            comment,
+            comment: comment,
             createLabelVals: [label],
             negateLabelVals: [],
           },
           // specify the labeled post by strongRef
           subject: {
             $type: "com.atproto.repo.strongRef",
-            uri,
-            cid,
+            uri: uri,
+            cid: cid,
           },
           // put in the rest of the metadata
-          createdBy: agent.did ?? "",
+          createdBy: `${agent.did}`,
           createdAt: new Date().toISOString(),
         },
         {
           encoding: "application/json",
           headers: {
-            "atproto-proxy": `${MOD_DID}#atproto_labeler`,
+            "atproto-proxy": `${MOD_DID!}#atproto_labeler`,
             "atproto-accept-labelers":
               "did:plc:ar7c4by46qjdydhdevvrndac;redact",
           },
         },
       );
-    } catch (error) {
-      logger.error(`Error creating post label for URI ${uri}:`, error);
-      throw error;
+    } catch (e) {
+      logger.error(`Failed to create post label with error: ${e}`);
     }
   });
 };
···
         {
           event: {
             $type: "tools.ozone.moderation.defs#modEventLabel",
-            comment,
+            comment: comment,
             createLabelVals: [label],
             negateLabelVals: [],
           },
           // specify the labeled post by strongRef
           subject: {
             $type: "com.atproto.admin.defs#repoRef",
-            did,
+            did: did,
           },
           // put in the rest of the metadata
-          createdBy: agent.did ?? "",
+          createdBy: `${agent.did}`,
           createdAt: new Date().toISOString(),
         },
         {
           encoding: "application/json",
           headers: {
-            "atproto-proxy": `${MOD_DID}#atproto_labeler`,
+            "atproto-proxy": `${MOD_DID!}#atproto_labeler`,
             "atproto-accept-labelers":
               "did:plc:ar7c4by46qjdydhdevvrndac;redact",
           },
         },
       );
-    } catch (error) {
-      logger.error(`Error creating account label for DID ${did}:`, error);
-      throw error;
+    } catch (e) {
+      logger.error(`Failed to create account label with error: ${e}`);
     }
   });
 };
···
   await isLoggedIn;
   await limit(async () => {
     try {
-      return await agent.tools.ozone.moderation.emitEvent(
+      return agent.tools.ozone.moderation.emitEvent(
         {
           event: {
             $type: "tools.ozone.moderation.defs#modEventReport",
-            comment,
+            comment: comment,
             reportType: "com.atproto.moderation.defs#reasonOther",
           },
           // specify the labeled post by strongRef
           subject: {
             $type: "com.atproto.repo.strongRef",
-            uri,
-            cid,
+            uri: uri,
+            cid: cid,
           },
           // put in the rest of the metadata
-          createdBy: agent.did ?? "",
+          createdBy: `${agent.did}`,
           createdAt: new Date().toISOString(),
         },
         {
           encoding: "application/json",
           headers: {
-            "atproto-proxy": `${MOD_DID}#atproto_labeler`,
+            "atproto-proxy": `${MOD_DID!}#atproto_labeler`,
             "atproto-accept-labelers":
               "did:plc:ar7c4by46qjdydhdevvrndac;redact",
           },
         },
       );
-    } catch (error) {
-      logger.error(`Error creating post report for URI ${uri}:`, error);
-      throw error;
+    } catch (e) {
+      logger.error(`Failed to create post label with error: ${e}`);
     }
   });
 };
···
         {
           event: {
             $type: "tools.ozone.moderation.defs#modEventComment",
-            comment,
+            comment: comment,
           },
           // specify the labeled post by strongRef
           subject: {
             $type: "com.atproto.admin.defs#repoRef",
-            did,
+            did: did,
           },
           // put in the rest of the metadata
-          createdBy: agent.did ?? "",
+          createdBy: `${agent.did}`,
           createdAt: new Date().toISOString(),
         },
         {
           encoding: "application/json",
           headers: {
-            "atproto-proxy": `${MOD_DID}#atproto_labeler`,
+            "atproto-proxy": `${MOD_DID!}#atproto_labeler`,
             "atproto-accept-labelers":
               "did:plc:ar7c4by46qjdydhdevvrndac;redact",
           },
         },
       );
-    } catch (error) {
-      logger.error(`Error creating account comment for DID ${did}:`, error);
-      throw error;
+    } catch (e) {
+      console.error(e);
     }
   });
 };
···
         {
           event: {
             $type: "tools.ozone.moderation.defs#modEventReport",
-            comment,
+            comment: comment,
             reportType: "com.atproto.moderation.defs#reasonOther",
           },
           // specify the labeled post by strongRef
           subject: {
             $type: "com.atproto.admin.defs#repoRef",
-            did,
+            did: did,
           },
           // put in the rest of the metadata
-          createdBy: agent.did ?? "",
+          createdBy: `${agent.did}`,
           createdAt: new Date().toISOString(),
         },
         {
           encoding: "application/json",
           headers: {
-            "atproto-proxy": `${MOD_DID}#atproto_labeler`,
+            "atproto-proxy": `${MOD_DID!}#atproto_labeler`,
             "atproto-accept-labelers":
               "did:plc:ar7c4by46qjdydhdevvrndac;redact",
           },
         },
       );
-    } catch (error) {
-      logger.error(`Error creating account report for DID ${did}:`, error);
-      throw error;
+    } catch (e) {
+      console.error(e);
     }
   });
 };
···
   }
   logger.info(`New label added to list: ${newList.label}`);
 
-  const listUri = `at://${MOD_DID}/app.bsky.graph.list/${newList.rkey}`;
+  const listUri = `at://${MOD_DID!}/app.bsky.graph.list/${newList.rkey}`;
 
   await limit(async () => {
     try {
       await agent.com.atproto.repo.createRecord({
         collection: "app.bsky.graph.listitem",
-        repo: MOD_DID,
+        repo: `${MOD_DID!}`,
         record: {
           subject: did,
           list: listUri,
           createdAt: new Date().toISOString(),
         },
       });
-    } catch (error) {
-      logger.error(`Error adding DID ${did} to list ${label}:`, error);
-      throw error;
+    } catch (e) {
+      console.error(e);
     }
   });
 };
 
-export function checkAccountLabels(_did: string) {
+export async function checkAccountLabels(did: string) {
   /* try {
     const repo = await limit(() =>
       agent.tools.ozone.moderation.getRepo(

src/utils.ts

···
 import logger from "./logger.js";
 
-import { homoglyphMap } from "./homoglyphs";
+import { homoglyphMap } from "./homoglyphs.js";
 
 /**
  * Normalizes a string by converting it to lowercase, replacing homoglyphs,