Silent-Watcher

Dependency and Utility Evaluation

Before introducing any new dependency, package, helper, utility, or external tool, you MUST follow the Dependency Evaluation Skill.

• Evaluate whether the requirement can be implemented reliably with no more than 200 lines of production code, excluding tests.
• Identify relevant edge cases and write tests before integrating a new internal implementation.
• Prefer existing project capabilities or a small internal implementation over unnecessary dependencies.
• Evaluate security, maintenance status, compatibility, licensing, and supply-chain risks before installing any external package.
• Verify and select the latest stable release compatible with the project.
• Document every newly introduced external dependency or tool in DECISIONS.md using the established Architecture Decision Record (ADR) format.

Silent-Watcher

class Mutex {
    constructor(private locked: boolean = false, private queue: any[] = []) { }


    public async runExclusive(task: () => Promise<any>) {
        try {
            await this.lock()
            return await task()
        } finally {
            this.unlock()

Silent-Watcher

import EventEmitter from "node:events";

enum CircuitState {
    Open,
    Closed,
    HalfOpen
}

interface HealthBucket {
    successes: number;

Silent-Watcher

import EventEmitter from "node:events";

export class BulkHead extends EventEmitter {

    private queue: Array<() => void> = [];
    private concurrencyLimit: number;
    private activeCount: number = 0;
    private queueLimit: number;

    private totalAccepted = 0;

Silent-Watcher

async function fetchWithTimeout(url: string, timeout: number) {
    const controller = new AbortController();
    const signal = controller.signal;

    const requestPromise = fetch(url, { signal });

    const timeoutPromise = new Promise((_, rej) => {
        const timer = setTimeout(() => {
            rej(new Error(`Timeout: Request took longer than ${timeout}ms`));
            controller.abort();

Silent-Watcher

version: "3.8"

services:
  kafka:
    image: apache/kafka:4.0.1-rc2
    container_name: kafka
    ports:
      - "9092:9092"
    environment:
      CLUSTER_ID: mkqv8X5vRla7PzR8bKqfHk

Silent-Watcher

version: '3.8'

services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:9.0.3
    container_name: elasticsearch
    environment:
      - node.name=es-node
      - discovery.type=single-node
      - cluster.name=es-cluster

Silent-Watcher

export function setupProcessHandlers(options?: {
  exitOnError?: boolean;
  onError?: (type: 'uncaughtException' | 'unhandledRejection', error: any) => void;
}) {
  const exit = options?.exitOnError ?? true;
  const onError = options?.onError;

  process.on('uncaughtException', (err) => {
    console.error('[🔥 Uncaught Exception]:', err);
    onError?.('uncaughtException', err);

Silent-Watcher

Feature	jose	jsonwebtoken
TypeScript Support	✅ Native	☑️ Partial
ESM Support	✅ Yes	❌ No
Browser Compatibility	✅ Yes	❌ No
Algorithm Support	✅ Broad (EdDSA, ES, PS, etc.)	⚠️ Limited
Maintenance	✅ Active (Panva)	💤 Slow
Crypto Security	✅ Uses native Web Crypto API	⚠️ Custom crypto
API Style	✅ Promise-based, functional	❌ Callback/Sync

Silent-Watcher

import { safeIncrWithTTL } from "#app/common/helpers/redis";
import { unwrap } from "#app/config/db/global";
import type { MultiExecResult } from "#app/config/db/redis.config";
import { redis } from "#app/config/db/redis.config";
import { logger } from "../logger.util";

const FAILURE_PREFIX = "recaptcha:fail:ip-";
const THRESHOLD = 5; // max allowed failures
const WINDOW_SEC = 60 * 60; // rolling window for failures (1h)
const BLOCK_PREFIX = "recaptcha:block:ip-";