A self-hostable bookmark-everything app (links, notes and images) with AI-based automatic tagging and full text search
feat: redis based ratelimiting plugin (#2535)
Mohamed Bassemb68ac513f651
diff --git a/apps/workers/workers/crawlerWorker.ts b/apps/workers/workers/crawlerWorker.tsindex df23196e..f6f2af83 100644--- a/apps/workers/workers/crawlerWorker.ts+++ b/apps/workers/workers/crawlerWorker.ts@@ -2001,7 +2001,7 @@ async function checkDomainRateLimit(url: string, jobId: string): Promise<void> {}const hostname = new URL(url).hostname;- const rateLimitResult = rateLimitClient.checkRateLimit(+ const rateLimitResult = await rateLimitClient.checkRateLimit({name: "domain-ratelimit",maxRequests: crawlerDomainRateLimitConfig.maxRequests,diff --git a/packages/plugins/package.json b/packages/plugins/package.jsonindex 06aafbfa..15a183a9 100644--- a/packages/plugins/package.json+++ b/packages/plugins/package.json@@ -8,6 +8,7 @@"./queue-liteque": "./queue-liteque/index.ts","./queue-restate": "./queue-restate/index.ts","./ratelimit-memory": "./ratelimit-memory/index.ts",+ "./ratelimit-redis": "./ratelimit-redis/index.ts","./search-meilisearch": "./search-meilisearch/index.ts"},"scripts": {@@ -23,6 +24,7 @@"@restatedev/restate-sdk": "^1.10.3","@restatedev/restate-sdk-clients": "^1.10.3","async-mutex": "^0.4.1",+ "ioredis": "^5.4.2","liteque": "^0.7.0","meilisearch": "^0.45.0"},diff --git a/packages/plugins/ratelimit-redis/index.ts b/packages/plugins/ratelimit-redis/index.tsnew file mode 100644index 00000000..86a55c83--- /dev/null+++ b/packages/plugins/ratelimit-redis/index.ts@@ -0,0 +1,19 @@+// Auto-register the RateLimit plugin when this package is imported+import serverConfig from "@karakeep/shared/config";+import { PluginManager, PluginType } from "@karakeep/shared/plugins";++import { RedisRateLimitProvider } from "./src";++// Only register if Redis configuration is provided+if (serverConfig.redis?.url) {+ PluginManager.register({+ type: PluginType.RateLimit,+ name: "Redis Rate Limiter",+ provider: new RedisRateLimitProvider({+ url: serverConfig.redis.url,+ }),+ });+}++// Export the provider and rate limiter class for advanced usage+export { RedisRateLimiter, RedisRateLimitProvider } from "./src";diff --git a/packages/plugins/ratelimit-redis/src/index.ts b/packages/plugins/ratelimit-redis/src/index.tsnew file mode 100644index 00000000..5a1bdd63--- /dev/null+++ b/packages/plugins/ratelimit-redis/src/index.ts@@ -0,0 +1,200 @@+import Redis from "ioredis";++import type {+ RateLimitClient,+ RateLimitConfig,+ RateLimitResult,+} from "@karakeep/shared/ratelimiting";+import { PluginProvider } from "@karakeep/shared/plugins";++const KEY_PREFIX = "ratelimit:v1";++export class RedisRateLimiter implements RateLimitClient {+ private redis: Redis;++ constructor(redis: Redis) {+ this.redis = redis;+ }++ async checkRateLimit(+ config: RateLimitConfig,+ key: string,+ ): Promise<RateLimitResult> {+ if (!key) {+ return { allowed: true };+ }++ const rateLimitKey = `${KEY_PREFIX}:${config.name}:${key}`;+ const rateLimitSequenceKey = `${rateLimitKey}:seq`;+ const now = Date.now();++ try {+ // Use a Lua script to ensure atomicity+ // This script:+ // 1. Removes old entries outside the time window+ // 2. Counts current entries+ // 3. Adds new entry if under limit+ // 4. Sets expiration on the key+ const luaScript = `+ local key = KEYS[1]+ local sequenceKey = KEYS[2]+ local now = tonumber(ARGV[1])+ local window = tonumber(ARGV[2])+ local maxRequests = tonumber(ARGV[3])+ local windowStart = now - window++ -- Remove old entries+ redis.call('ZREMRANGEBYSCORE', key, '-inf', windowStart)++ -- Count current requests+ local current = redis.call('ZCARD', key)++ if current < maxRequests then+ -- Add new request+ local seq = redis.call('INCR', sequenceKey)+ redis.call('ZADD', key, now, now .. ':' .. seq)+ -- Set expiration (window in milliseconds converted to seconds, plus 1 for safety)+ redis.call('EXPIRE', key, math.ceil(window / 1000) + 1)+ redis.call('EXPIRE', sequenceKey, math.ceil(window / 1000) + 1)+ return {1, 0} -- allowed, resetInSeconds+ else+ -- Get the oldest entry to calculate reset time+ local oldest = redis.call('ZRANGE', key, 0, 0, 'WITHSCORES')+ local resetTime = tonumber(oldest[2]) + window+ local resetInSeconds = math.ceil((resetTime - now) / 1000)+ return {0, resetInSeconds} -- not allowed, resetInSeconds+ end+ `;++ const result = (await this.redis.eval(+ luaScript,+ 2,+ rateLimitKey,+ rateLimitSequenceKey,+ now.toString(),+ config.windowMs.toString(),+ config.maxRequests.toString(),+ )) as [number, number];++ const [allowed, resetInSeconds] = result;++ if (allowed === 1) {+ return { allowed: true };+ } else {+ return {+ allowed: false,+ resetInSeconds: resetInSeconds,+ };+ }+ } catch (error) {+ // On Redis error, fail open (allow the request)+ console.error("Redis rate limit error:", error);+ return { allowed: true };+ }+ }++ async reset(config: RateLimitConfig, key: string) {+ const rateLimitKey = `${KEY_PREFIX}:${config.name}:${key}`;+ const rateLimitSequenceKey = `${rateLimitKey}:seq`;+ try {+ await this.redis.del(rateLimitKey, rateLimitSequenceKey);+ } catch (error) {+ console.error("Redis rate limit reset error:", error);+ }+ }++ async clear() {+ try {+ let cursor = "0";+ do {+ const [nextCursor, keys] = await this.redis.scan(+ cursor,+ "MATCH",+ `${KEY_PREFIX}:*`,+ "COUNT",+ 100,+ );+ cursor = nextCursor;+ if (keys.length > 0) {+ await this.redis.del(...keys);+ }+ } while (cursor !== "0");+ } catch (error) {+ console.error("Redis rate limit clear error:", error);+ }+ }++ async disconnect() {+ await this.redis.quit();+ }+}++export interface RedisRateLimiterOptions {+ url: string;+}++export class RedisRateLimitProvider implements PluginProvider<RateLimitClient> {+ private client: RedisRateLimiter | null = null;+ private clientInitPromise: Promise<RedisRateLimiter | null> | null = null;+ private nextRetryAt = 0;+ private options: RedisRateLimiterOptions;+ private static readonly RETRY_BACKOFF_MS = 5_000;++ constructor(options: RedisRateLimiterOptions) {+ this.options = options;+ }++ private createRedisClient(): Redis {+ return new Redis(this.options.url, {+ lazyConnect: true,+ maxRetriesPerRequest: 0,+ retryStrategy: () => 3_000,+ });+ }++ private async initializeClient(): Promise<RedisRateLimiter | null> {+ const redis = this.createRedisClient();++ try {+ // Test connection+ await redis.connect();+ await redis.ping();++ this.nextRetryAt = 0;+ console.log("Redis rate limiter connected successfully");+ return new RedisRateLimiter(redis);+ } catch (error) {+ this.nextRetryAt = Date.now() + RedisRateLimitProvider.RETRY_BACKOFF_MS;+ redis.disconnect();+ console.error("Failed to connect to Redis for rate limiting:", error);+ return null;+ }+ }++ async getClient(): Promise<RateLimitClient | null> {+ if (this.client) {+ return this.client;+ }++ if (this.clientInitPromise) {+ return await this.clientInitPromise;+ }++ if (this.nextRetryAt > Date.now()) {+ return null;+ }++ const initPromise = this.initializeClient();+ this.clientInitPromise = initPromise;++ try {+ const client = await initPromise;+ this.client = client;+ return client;+ } finally {+ if (this.clientInitPromise === initPromise) {+ this.clientInitPromise = null;+ }+ }+ }+}diff --git a/packages/plugins/ratelimit-redis/src/tests/docker-compose.yml b/packages/plugins/ratelimit-redis/src/tests/docker-compose.ymlnew file mode 100644index 00000000..27f8d250--- /dev/null+++ b/packages/plugins/ratelimit-redis/src/tests/docker-compose.yml@@ -0,0 +1,5 @@+services:+ redis:+ image: redis:7-alpine+ ports:+ - "${REDIS_PORT:-6379}:6379"diff --git a/packages/plugins/ratelimit-redis/src/tests/ratelimit-redis.test.ts b/packages/plugins/ratelimit-redis/src/tests/ratelimit-redis.test.tsnew file mode 100644index 00000000..ba7f360f--- /dev/null+++ b/packages/plugins/ratelimit-redis/src/tests/ratelimit-redis.test.ts@@ -0,0 +1,213 @@+import assert from "assert";+import {+ afterAll,+ beforeAll,+ beforeEach,+ describe,+ expect,+ inject,+ it,+} from "vitest";++import { RedisRateLimiter, RedisRateLimitProvider } from "../index";++describe("RedisRateLimiter", () => {+ let rateLimiter: RedisRateLimiter;++ beforeAll(async () => {+ const redisPort = inject("redisPort");+ const provider = new RedisRateLimitProvider({+ url: `redis://localhost:${redisPort}`,+ });+ const client = await provider.getClient();+ assert(client, "Failed to connect to Redis");+ rateLimiter = client as RedisRateLimiter;+ });++ beforeEach(async () => {+ await rateLimiter.clear();+ });++ afterAll(async () => {+ if (rateLimiter) {+ await rateLimiter.disconnect();+ }+ });++ describe("checkRateLimit", () => {+ it("should allow requests within rate limit", async () => {+ const config = {+ name: "test-allow",+ windowMs: 60000,+ maxRequests: 3,+ };++ const result1 = await rateLimiter.checkRateLimit(config, "user1");+ const result2 = await rateLimiter.checkRateLimit(config, "user1");+ const result3 = await rateLimiter.checkRateLimit(config, "user1");++ expect(result1.allowed).toBe(true);+ expect(result2.allowed).toBe(true);+ expect(result3.allowed).toBe(true);+ });++ it("should block requests exceeding rate limit", async () => {+ const config = {+ name: "test-block",+ windowMs: 60000,+ maxRequests: 2,+ };++ const result1 = await rateLimiter.checkRateLimit(config, "user1");+ const result2 = await rateLimiter.checkRateLimit(config, "user1");+ const result3 = await rateLimiter.checkRateLimit(config, "user1");++ expect(result1.allowed).toBe(true);+ expect(result2.allowed).toBe(true);+ expect(result3.allowed).toBe(false);+ assert(!result3.allowed);+ expect(result3.resetInSeconds).toBeGreaterThan(0);+ });++ it("should reset after window expires", async () => {+ const config = {+ name: "test-window",+ windowMs: 2000, // 2 second window for faster test+ maxRequests: 1,+ };++ const result1 = await rateLimiter.checkRateLimit(config, "user1");+ expect(result1.allowed).toBe(true);++ const result2 = await rateLimiter.checkRateLimit(config, "user1");+ expect(result2.allowed).toBe(false);++ // Wait for the window to expire+ await new Promise((resolve) => setTimeout(resolve, 2500));++ const result3 = await rateLimiter.checkRateLimit(config, "user1");+ expect(result3.allowed).toBe(true);+ });++ it("should isolate rate limits by key", async () => {+ const config = {+ name: "test-isolate-key",+ windowMs: 60000,+ maxRequests: 1,+ };++ const result1 = await rateLimiter.checkRateLimit(config, "user1:/api/v1");+ const result2 = await rateLimiter.checkRateLimit(config, "user1:/api/v2");++ expect(result1.allowed).toBe(true);+ expect(result2.allowed).toBe(true);+ });++ it("should isolate rate limits by config name", async () => {+ const config1 = {+ name: "api-isolate",+ windowMs: 60000,+ maxRequests: 1,+ };+ const config2 = {+ name: "auth-isolate",+ windowMs: 60000,+ maxRequests: 1,+ };++ const result1 = await rateLimiter.checkRateLimit(config1, "user1");+ const result2 = await rateLimiter.checkRateLimit(config2, "user1");++ expect(result1.allowed).toBe(true);+ expect(result2.allowed).toBe(true);+ });++ it("should calculate correct resetInSeconds", async () => {+ const config = {+ name: "test-reset-calc",+ windowMs: 60000,+ maxRequests: 1,+ };++ await rateLimiter.checkRateLimit(config, "user1");+ const result = await rateLimiter.checkRateLimit(config, "user1");++ expect(result.allowed).toBe(false);+ assert(!result.allowed);+ expect(result.resetInSeconds).toBeGreaterThan(0);+ expect(result.resetInSeconds).toBeLessThanOrEqual(60);+ });++ it("should allow empty key", async () => {+ const config = {+ name: "test-empty-key",+ windowMs: 60000,+ maxRequests: 1,+ };++ const result = await rateLimiter.checkRateLimit(config, "");+ expect(result.allowed).toBe(true);+ });+ });++ describe("reset", () => {+ it("should reset rate limit for specific identifier", async () => {+ const config = {+ name: "test-reset",+ windowMs: 60000,+ maxRequests: 1,+ };++ await rateLimiter.checkRateLimit(config, "user1");+ const result1 = await rateLimiter.checkRateLimit(config, "user1");+ expect(result1.allowed).toBe(false);++ await rateLimiter.reset(config, "user1");++ const result2 = await rateLimiter.checkRateLimit(config, "user1");+ expect(result2.allowed).toBe(true);+ });++ it("should not affect other identifiers", async () => {+ const config = {+ name: "test-reset-isolation",+ windowMs: 60000,+ maxRequests: 1,+ };++ await rateLimiter.checkRateLimit(config, "user1");+ await rateLimiter.checkRateLimit(config, "user2");++ await rateLimiter.reset(config, "user1");++ const result1 = await rateLimiter.checkRateLimit(config, "user1");+ const result2 = await rateLimiter.checkRateLimit(config, "user2");++ expect(result1.allowed).toBe(true);+ expect(result2.allowed).toBe(false);+ });+ });++ describe("concurrent access", () => {+ it("should handle concurrent requests atomically", async () => {+ const config = {+ name: "test-concurrent",+ windowMs: 60000,+ maxRequests: 5,+ };++ // Fire 10 requests concurrently+ const results = await Promise.all(+ Array.from({ length: 10 }, () =>+ rateLimiter.checkRateLimit(config, "user1"),+ ),+ );++ const allowed = results.filter((r) => r.allowed).length;+ const blocked = results.filter((r) => !r.allowed).length;++ expect(allowed).toBe(5);+ expect(blocked).toBe(5);+ });+ });+});diff --git a/packages/plugins/ratelimit-redis/src/tests/setup/startContainers.ts b/packages/plugins/ratelimit-redis/src/tests/setup/startContainers.tsnew file mode 100644index 00000000..691bc923--- /dev/null+++ b/packages/plugins/ratelimit-redis/src/tests/setup/startContainers.ts@@ -0,0 +1,90 @@+import { execSync } from "child_process";+import net from "net";+import path from "path";+import { fileURLToPath } from "url";+import type { GlobalSetupContext } from "vitest/node";++import { waitUntil } from "../utils.js";++async function getRandomPort(): Promise<number> {+ const server = net.createServer();+ return new Promise<number>((resolve, reject) => {+ server.unref();+ server.on("error", reject);+ server.listen(0, () => {+ const port = (server.address() as net.AddressInfo).port;+ server.close(() => resolve(port));+ });+ });+}++async function waitForHealthy(port: number, timeout = 30000): Promise<void> {+ await waitUntil(+ async () => {+ const socket = net.createConnection({ port, host: "localhost" });+ return new Promise<boolean>((resolve) => {+ socket.on("connect", () => {+ socket.destroy();+ resolve(true);+ });+ socket.on("error", () => {+ socket.destroy();+ resolve(false);+ });+ });+ },+ "Redis is healthy",+ timeout,+ );+}++export default async function ({ provide }: GlobalSetupContext) {+ const __dirname = path.dirname(fileURLToPath(import.meta.url));+ const redisPort = await getRandomPort();++ console.log(`Starting Redis on port ${redisPort}...`);+ try {+ execSync(`docker compose up -d`, {+ cwd: path.join(__dirname, ".."),+ stdio: ["ignore", "pipe", "pipe"],+ env: {+ ...process.env,+ REDIS_PORT: redisPort.toString(),+ },+ });+ } catch (error) {+ const execError = error as {+ stdout?: Buffer;+ stderr?: Buffer;+ message?: string;+ };+ console.error("Failed to start Redis container");+ if (execError.stdout) {+ console.error(execError.stdout.toString());+ }+ if (execError.stderr) {+ console.error(execError.stderr.toString());+ }+ console.error(execError.message ?? error);+ throw error;+ }++ console.log("Waiting for Redis to become healthy...");+ await waitForHealthy(redisPort);++ provide("redisPort", redisPort);++ return async () => {+ console.log("Stopping Redis...");+ execSync("docker compose down", {+ cwd: path.join(__dirname, ".."),+ stdio: "ignore",+ });+ };+}++declare module "vitest" {+ export interface ProvidedContext {+ redisPort: number;+ }+}diff --git a/packages/plugins/ratelimit-redis/src/tests/utils.ts b/packages/plugins/ratelimit-redis/src/tests/utils.tsnew file mode 100644index 00000000..e02d2dee--- /dev/null+++ b/packages/plugins/ratelimit-redis/src/tests/utils.ts@@ -0,0 +1,23 @@+export async function waitUntil(+ f: () => Promise<boolean>,+ description: string,+ timeoutMs = 60000,+): Promise<void> {+ const startTime = Date.now();++ while (Date.now() - startTime < timeoutMs) {+ console.log(`Waiting for ${description}...`);+ try {+ const res = await f();+ if (res) {+ console.log(`${description}: success`);+ return;+ }+ } catch (error) {+ console.log(`${description}: error, retrying...: ${error}`);+ }+ await new Promise((resolve) => setTimeout(resolve, 1000));+ }++ throw new Error(`${description}: timeout after ${timeoutMs}ms`);+}diff --git a/packages/plugins/vitest.config.ts b/packages/plugins/vitest.config.tsindex 3d5f33f7..df18bfa8 100644--- a/packages/plugins/vitest.config.ts+++ b/packages/plugins/vitest.config.ts@@ -6,7 +6,10 @@ import { defineConfig } from "vitest/config";export default defineConfig({plugins: [tsconfigPaths()],test: {- globalSetup: ["./queue-restate/src/tests/setup/startContainers.ts"],+ globalSetup: [+ "./queue-restate/src/tests/setup/startContainers.ts",+ "./ratelimit-redis/src/tests/setup/startContainers.ts",+ ],teardownTimeout: 30000,include: ["**/src/tests/**/*.test.ts"],testTimeout: 60000,diff --git a/packages/shared-server/src/plugins.ts b/packages/shared-server/src/plugins.tsindex 9e78bedb..e5231a7b 100644--- a/packages/shared-server/src/plugins.ts+++ b/packages/shared-server/src/plugins.ts@@ -10,7 +10,9 @@ export async function loadAllPlugins() {await import("@karakeep/plugins/queue-liteque");await import("@karakeep/plugins/queue-restate");await import("@karakeep/plugins/search-meilisearch");+ // Rate limiters (order matters - last one wins)await import("@karakeep/plugins/ratelimit-memory");+ await import("@karakeep/plugins/ratelimit-redis");PluginManager.logAllPlugins();pluginsLoaded = true;}diff --git a/packages/shared/config.ts b/packages/shared/config.tsindex d4333af6..173b87fd 100644--- a/packages/shared/config.ts+++ b/packages/shared/config.ts@@ -167,6 +167,9 @@ const allEnv = z.object({// Rate limiting configurationRATE_LIMITING_ENABLED: stringBool("false"),+ // Redis configuration+ REDIS_URL: z.string().url().optional(),+// Stripe configurationSTRIPE_SECRET_KEY: z.string().optional(),STRIPE_PUBLISHABLE_KEY: z.string().optional(),@@ -415,6 +418,9 @@ const serverConfigSchema = allEnv.transform((val, ctx) => {rateLimiting: {enabled: val.RATE_LIMITING_ENABLED,},+ redis: {+ url: val.REDIS_URL,+ },stripe: {secretKey: val.STRIPE_SECRET_KEY,publishableKey: val.STRIPE_PUBLISHABLE_KEY,diff --git a/packages/shared/ratelimiting.ts b/packages/shared/ratelimiting.tsindex ee5988b4..183720ac 100644--- a/packages/shared/ratelimiting.ts+++ b/packages/shared/ratelimiting.ts@@ -17,19 +17,22 @@ export interface RateLimitClient {* @param key Unique rate limiting key (e.g., "ip:127.0.0.1:path:/api/v1")* @returns Result indicating if the request is allowed and reset time if not*/- checkRateLimit(config: RateLimitConfig, key: string): RateLimitResult;+ checkRateLimit(+ config: RateLimitConfig,+ key: string,+ ): RateLimitResult | Promise<RateLimitResult>;/*** Reset rate limit for a specific key* @param config Rate limit configuration* @param key Unique rate limiting key*/- reset(config: RateLimitConfig, key: string): void;+ reset(config: RateLimitConfig, key: string): void | Promise<void>;/*** Clear all rate limit entries*/- clear(): void;+ clear(): void | Promise<void>;}export async function getRateLimitClient(): Promise<RateLimitClient | null> {diff --git a/packages/trpc/lib/rateLimit.ts b/packages/trpc/lib/rateLimit.tsindex bf8a8e8b..90576789 100644--- a/packages/trpc/lib/rateLimit.ts+++ b/packages/trpc/lib/rateLimit.ts@@ -34,7 +34,7 @@ export function createRateLimitMiddleware<T>(config: RateLimitConfig) {// Build the rate limiting key from IP and pathconst key = `${ip}:${opts.path}`;- const result = client.checkRateLimit(config, key);+ const result = await client.checkRateLimit(config, key);if (!result.allowed) {throw new TRPCError({diff --git a/pnpm-lock.yaml b/pnpm-lock.yamlindex 7dbb40b2..1cfcd846 100644--- a/pnpm-lock.yaml+++ b/pnpm-lock.yaml@@ -1283,6 +1283,9 @@ importers:async-mutex:specifier: ^0.4.1version: 0.4.1+ ioredis:+ specifier: ^5.4.2+ version: 5.10.0liteque:specifier: ^0.7.0version: 0.7.0(@opentelemetry/[email protected])(@types/[email protected])(@types/[email protected])([email protected])([email protected])([email protected])@@ -4052,6 +4055,9 @@ packages:cpu: [x64]os: [win32]+ '@ioredis/[email protected]':+ resolution: {integrity: sha512-JH8ZL/ywcJyR9MmJ5BNqZllXNZQqQbnVZOqpPQqE1vHiFgAw4NHbvE0FOduNU8IX9babitBT46571OnPTT0Zcw==}+'@isaacs/[email protected]':resolution: {integrity: sha512-yzMTt9lEb8Gv7zRioUilSglI0c0smZ9k5D65677DLWLtWJaXIS3CqcGyUFByYKlnUj6TkjLVs54fBl6+TiGQDQ==}engines: {node: 20 || >=22}@@ -7542,6 +7548,10 @@ packages:resolution: {integrity: sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==}engines: {node: '>=6'}+ resolution: {integrity: sha512-RMr0FhtfXemyinomL4hrWcYJxmX6deFdCxpJzhDttxgO1+bcCnkk+9drydLVDmAMG7NE6aN/fl4F7ucU/90gAA==}+ engines: {node: '>=0.10.0'}+resolution: {integrity: sha512-Vsv7kFaXm+ptHDMZ7izaRsP70GgrW9NBNGswt9OZaVBLlE0SNpDq8eu/VGXyF9r7M0azK3Wy7OlYXsuyYLFzHg==}peerDependencies:@@ -8124,6 +8134,10 @@ packages:resolution: {integrity: sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==}engines: {node: '>=0.4.0'}+ resolution: {integrity: sha512-HVQE3AAb/pxF8fQAoiqpvg9i3evqug3hoiwakOyZAwJm+6vZehbkYXZ0l4JxS+I3QxM97v5aaRNhj8v5oBhekw==}+ engines: {node: '>=0.10'}+resolution: {integrity: sha512-7emPTl6Dpo6JRXOXjLRxck+FlLRX5847cLKEn00PLAgc3g2hTZZgr+e4c2v6QpSmLeFP3n5yUo7ft6avBK/5jQ==}engines: {node: '>= 0.6'}@@ -9876,6 +9890,10 @@ packages:resolution: {integrity: sha512-phJfQVBuaJM5raOpJjSfkiD6BpbCE4Ns//LaXl6wGYtUBY83nWS6Rf9tXm2e8VaK60JEjYldbPif/A2B1C2gNA==}+ resolution: {integrity: sha512-HVBe9OFuqs+Z6n64q09PQvP1/R4Bm+30PAyyD4wIEqssh3v9L21QjCVk4kRLucMBcDokJTcLjsGeVRlq/nH6DA==}+ engines: {node: '>=12.22.0'}+resolution: {integrity: sha512-zHtQzGojZXTwZTHQqra+ETKd4Sn3vgi7uBmlPoXVWZqYvuKmtI0l/VZTjqGmJY9x88GGOaZ9+G9ES8hC4T4X8g==}engines: {node: '>= 12'}@@ -10663,6 +10681,12 @@ packages:resolution: {integrity: sha512-FT1yDzDYEoYWhnSGnpE/4Kj1fLZkDFyqRb7fNt6FdYOSxlUWAtp42Eh6Wb0rGIv/m9Bgo7x4GhQbm5Ys4SG5ow==}+ resolution: {integrity: sha512-qjxPLHd3r5DnsdGacqOMU6pb/avJzdh9tFX2ymgoZE27BmjXrNy/y4LoaiTeAb+O3gL8AfpJGtqfX/ae2leYYQ==}++ resolution: {integrity: sha512-chi4NHZlZqZD18a0imDHnZPrDeBbTtVN7GXMwuGdRH9qotxAjYs3aVLKc7zNOG9eddR5Ksd8rvFEBc9SsggPpg==}+resolution: {integrity: sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==}@@ -13475,6 +13499,14 @@ packages:resolution: {integrity: sha512-cjwII1MdIIVloKvC9ErQ+OgAtwHBmcZ0Bg4ciz78FtbT8In39aAYbaA7zvxQ61xVMSPE8WxhLwLbhif4Js2C+g==}+ resolution: {integrity: sha512-1qny3OExCf0UvUV/5wpYKf2YwPcOqXzkwKKSmKHiE6ZMQs5heeE/c8eXK+PNllPvmjgAbfnsbpkGZWy8cBpn9w==}+ engines: {node: '>=4'}++ resolution: {integrity: sha512-DJnGAeenTdpMEH6uAJRK/uiyEIH9WVsUmoLwzudwGJUwZPp80PDBWPHXSAGNPwNvIXAbe7MSUB1zQFugFml66A==}+ engines: {node: '>=4'}+resolution: {integrity: sha512-+P3TjtnP0k/FEjcBL5FZpoovtvrTNT/UXd4/sluaSyrURlSlhLSzEdfsTBW7WsKB6yPvgd7q/iZPICFjW4o57Q==}peerDependencies:@@ -14277,6 +14309,9 @@ packages:resolution: {integrity: sha512-WjlahMgHmCJpqzU8bIBy4qtsZdU9lRlcZE3Lvyej6t4tuOuv1vk57OW3MBrj6hXBFx/nNoC9MPMTcr5YA7NQbg==}engines: {node: '>=6'}+ resolution: {integrity: sha512-qoRRSyROncaz1z0mvYqIE4lCd9p2R90i6GxW3uZv5ucSu8tU7B5HXUP1gG8pVZsYNVaXjk8ClXHPttLyxAL48A==}+resolution: {integrity: sha512-OpZ3zP+jT1PI7I8nemJX4AKmAX070ZkYPVWV/AaKTJl+tXCTGyVdC1a4SL8RUQYEwk/f34ZX8UTykN68FwrqAA==}engines: {node: '>= 0.6'}@@ -19720,6 +19755,8 @@ snapshots:'@img/[email protected]':optional: true+ '@ioredis/[email protected]': {}+'@isaacs/[email protected]': {}'@isaacs/[email protected]':@@ -23256,7 +23293,7 @@ snapshots:dependencies:- '@babel/runtime': 7.28.4+ '@babel/runtime': 7.28.6cosmiconfig: 7.1.0resolve: 1.22.10@@ -23858,6 +23895,8 @@ snapshots:+ [email protected]: {}+[email protected](@types/[email protected](@types/[email protected]))(@types/[email protected])([email protected]([email protected]))([email protected]):dependencies:'@radix-ui/react-compose-refs': 1.1.2(@types/[email protected])([email protected])@@ -24486,6 +24525,8 @@ snapshots:+ [email protected]: {}+@@ -26486,6 +26527,20 @@ snapshots:dependencies:loose-envify: 1.4.0+ dependencies:+ '@ioredis/commands': 1.5.1+ cluster-key-slot: 1.1.2+ debug: 4.4.3+ denque: 2.1.0+ lodash.defaults: 4.2.0+ lodash.isarguments: 3.1.0+ redis-errors: 1.2.0+ redis-parser: 3.0.0+ standard-as-callback: 2.1.0+ transitivePeerDependencies:+ - supports-color+dependencies:jsbn: 1.1.0@@ -27304,6 +27359,10 @@ snapshots:+ [email protected]: {}++ [email protected]: {}+@@ -31200,6 +31259,12 @@ snapshots:unified: 11.0.5vfile: 6.0.3+ [email protected]: {}++ dependencies:+ redis-errors: 1.2.0+dependencies:redux: 4.2.1@@ -32211,6 +32276,8 @@ snapshots:dependencies:type-fest: 0.7.1+ [email protected]: {}+