@joint-ops/hitlimit-bun 1.0.6 → 1.1.1

package/README.md

@@ -6,36 +6,36 @@
 [![TypeScript](https://img.shields.io/badge/TypeScript-Ready-blue.svg)](https://www.typescriptlang.org/)
 [![Bun](https://img.shields.io/badge/Bun-Native-black.svg)](https://bun.sh)
 
-> The fastest rate limiter for Bun - Native bun:sqlite performance | Elysia rate limit plugin
+> The fastest rate limiter for Bun - 7M+ ops/sec with memory-first design | Elysia, Hono & Bun.serve
 
-**hitlimit-bun** is a high-performance, Bun-native rate limiting library for Bun.serve and Elysia applications. Built specifically for Bun's runtime with native bun:sqlite for maximum performance. The only rate limiter designed from the ground up for Bun.
+**hitlimit-bun** is a blazing-fast, Bun-native rate limiting library for Bun.serve, Elysia, and Hono applications. **Memory-first by default** with 7.29M ops/sec performance (14.6x faster than SQLite). Optional persistence with native bun:sqlite or Redis when you need it.
 
 **[Documentation](https://hitlimit.jointops.dev/docs/bun)** | **[GitHub](https://github.com/JointOps/hitlimit-monorepo)** | **[npm](https://www.npmjs.com/package/@joint-ops/hitlimit-bun)**
 
 ## ⚡ Why hitlimit-bun?
 
-**hitlimit-bun uses Bun's native SQLite** - no FFI overhead, no Node.js polyfills.
+**Memory-first for maximum performance.** 14.6x faster than SQLite.
 
 ```
 ┌─────────────────────────────────────────────────────────────────┐
 │                                                                 │
-│  bun:sqlite         ████████████████████████░░░  386,000 ops/s  │
-│  better-sqlite3     ████████████████████████░░░  400,000 ops/s* │
+│  Memory (v1.1+)     ██████████████████████████████  7.29M ops/s │
+│  SQLite (v1.0)      █░░░░░░░░░░░░░░░░░░░░░░░░░░░░  500K ops/s  │
 │                                                                 │
-│  *estimated - bun:sqlite has zero FFI overhead                  │
+│  14.6x performance improvement with memory default             │
 │                                                                 │
 └─────────────────────────────────────────────────────────────────┘
 ```
 
+- **🚀 Memory-First** - 7.29M ops/sec by default (v1.1.0+), 14.6x faster than SQLite
 - **Bun Native** - Built specifically for Bun's runtime, not a Node.js port
-- **6.1M ops/sec** - Memory store (multi-IP scenarios)
-- **386K ops/sec** - With bun:sqlite (multi-IP scenarios)
 - **Zero Config** - Works out of the box with sensible defaults
-- **Elysia Plugin** - First-class Elysia framework integration
+- **Framework Support** - First-class Elysia and Hono integration
+- **Optional Persistence** - SQLite (500K ops/sec) or Redis (6.6K ops/sec) when needed
 - **TypeScript First** - Full type safety and IntelliSense support
 - **Auto-Ban** - Automatically ban repeat offenders after threshold violations
 - **Shared Limits** - Group rate limits via groupId for teams/tenants
-- **Tiny Footprint** - ~23KB total, zero runtime dependencies
+- **Tiny Footprint** - ~18KB core bundle, zero runtime dependencies
 
 ## Installation
 
@@ -67,6 +67,20 @@ new Elysia()
   .listen(3000)
 ```
 
+### Hono Rate Limiting
+
+```typescript
+import { Hono } from 'hono'
+import { hitlimit } from '@joint-ops/hitlimit-bun/hono'
+
+const app = new Hono()
+
+app.use(hitlimit({ limit: 100, window: '1m' }))
+app.get('/', (c) => c.text('Hello Bun!'))
+
+Bun.serve({ port: 3000, fetch: app.fetch })
+```
+
 ### Using createHitLimit
 
 ```typescript
@@ -235,7 +249,7 @@ hitlimit({
     retryAfter: true  // Retry-After header on 429
   },
 
-  // Store (default: bun:sqlite)
+  // Store (default: memory)
   store: sqliteStore({ path: './ratelimit.db' }),
 
   // Skip rate limiting
@@ -260,39 +274,30 @@ hitlimit({
 
 ## Storage Backends
 
-### SQLite Store (Default)
+### Memory Store (Default)
 
-Uses Bun's native bun:sqlite for maximum performance. Default store.
+Fastest option, used by default. No persistence.
 
 ```typescript
 import { hitlimit } from '@joint-ops/hitlimit-bun'
 
-// Default - uses bun:sqlite with in-memory database
+// Default - uses memory store (no config needed)
 Bun.serve({
   fetch: hitlimit({}, handler)
 })
-
-// Custom path for persistence
-import { sqliteStore } from '@joint-ops/hitlimit-bun'
-
-Bun.serve({
-  fetch: hitlimit({
-    store: sqliteStore({ path: './ratelimit.db' })
-  }, handler)
-})
 ```
 
-### Memory Store
+### SQLite Store
 
-For simple use cases without persistence.
+Uses Bun's native bun:sqlite for persistent rate limiting.
 
 ```typescript
 import { hitlimit } from '@joint-ops/hitlimit-bun'
-import { memoryStore } from '@joint-ops/hitlimit-bun/stores/memory'
+import { sqliteStore } from '@joint-ops/hitlimit-bun'
 
 Bun.serve({
   fetch: hitlimit({
-    store: memoryStore()
+    store: sqliteStore({ path: './ratelimit.db' })
   }, handler)
 })
 ```
@@ -351,9 +356,9 @@ hitlimit-bun is optimized for Bun's runtime with native performance:
 
 | Store | Operations/sec | vs Node.js |
 |-------|----------------|------------|
-| **Memory** | 7,210,000+ | +130% faster |
-| **bun:sqlite** | 520,000+ | **+10% faster** 🔥 |
-| **Redis** | 6,900+ | +3% faster |
+| **Memory** | 7,290,000+ | +52% faster |
+| **bun:sqlite** | 500,000+ | ~same |
+| **Redis** | 6,600+ | ~same |
 
 ### HTTP Throughput
 
@@ -423,7 +428,7 @@ new Elysia()
 Node.js rate limiters like express-rate-limit use better-sqlite3 which relies on N-API bindings. In Bun, this adds overhead and loses the performance benefits of Bun's native runtime.
 
 **hitlimit-bun** is built specifically for Bun:
-- Uses native `bun:sqlite` (2.7x faster than better-sqlite3)
+- Uses native `bun:sqlite` (no N-API overhead)
 - No FFI overhead or Node.js polyfills
 - First-class Elysia framework support
 - Optimized for Bun.serve's request handling

package/dist/elysia.d.ts

@@ -3,6 +3,17 @@ import type { HitLimitOptions } from '@joint-ops/hitlimit-types';
 export interface ElysiaHitLimitOptions extends HitLimitOptions<{
     request: Request;
 }> {
+    /**
+     * @deprecated Use `store: sqliteStore({ path })` instead.
+     *
+     * Starting with v1.1.0, the default store is Memory for 15.7x better performance.
+     * If you need SQLite persistence:
+     *
+     * ```typescript
+     * import { sqliteStore } from '@joint-ops/hitlimit-bun/stores/sqlite'
+     * hitlimit({ store: sqliteStore({ path: './db.sqlite' }) })
+     * ```
+     */
     sqlitePath?: string;
     name?: string;
 }

package/dist/elysia.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elysia.d.ts","sourceRoot":"","sources":["../src/elysia.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAKhE,MAAM,WAAW,qBAAsB,SAAQ,eAAe,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;IAClF,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAQD,wBAAgB,QAAQ,CAAC,OAAO,GAAE,qBAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4C3D"}
+{"version":3,"file":"elysia.d.ts","sourceRoot":"","sources":["../src/elysia.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAA;AAC/B,OAAO,KAAK,EAAE,eAAe,EAAgE,MAAM,2BAA2B,CAAA;AAK9H,MAAM,WAAW,qBAAsB,SAAQ,eAAe,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC;IAClF;;;;;;;;;;OAUG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAkBD,wBAAgB,QAAQ,CAAC,OAAO,GAAE,qBAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyG3D"}

package/dist/elysia.js

@@ -1,99 +1,103 @@
 // @bun
-// src/stores/sqlite.ts
-import { Database } from "bun:sqlite";
-
-class BunSqliteStore {
-  db;
-  hitStmt;
-  getStmt;
-  resetStmt;
-  isBannedStmt;
-  banStmt;
-  recordViolationStmt;
-  getViolationStmt;
-  resetBanStmt;
-  resetViolationStmt;
-  cleanupTimer;
-  constructor(options = {}) {
-    this.db = new Database(options.path ?? ":memory:");
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS hitlimit (
-        key TEXT PRIMARY KEY,
-        count INTEGER NOT NULL,
-        reset_at INTEGER NOT NULL
-      )
-    `);
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS hitlimit_bans (
-        key TEXT PRIMARY KEY,
-        expires_at INTEGER NOT NULL
-      )
-    `);
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS hitlimit_violations (
-        key TEXT PRIMARY KEY,
-        count INTEGER NOT NULL DEFAULT 1,
-        reset_at INTEGER NOT NULL
-      )
-    `);
-    this.hitStmt = this.db.prepare(`
-      INSERT INTO hitlimit (key, count, reset_at) VALUES (?1, 1, ?2)
-      ON CONFLICT(key) DO UPDATE SET
-        count = CASE WHEN reset_at <= ?3 THEN 1 ELSE count + 1 END,
-        reset_at = CASE WHEN reset_at <= ?3 THEN ?2 ELSE reset_at END
-    `);
-    this.getStmt = this.db.prepare("SELECT count, reset_at FROM hitlimit WHERE key = ?");
-    this.resetStmt = this.db.prepare("DELETE FROM hitlimit WHERE key = ?");
-    this.isBannedStmt = this.db.prepare("SELECT 1 FROM hitlimit_bans WHERE key = ?1 AND expires_at > ?2");
-    this.banStmt = this.db.prepare("INSERT OR REPLACE INTO hitlimit_bans (key, expires_at) VALUES (?1, ?2)");
-    this.recordViolationStmt = this.db.prepare(`
-      INSERT INTO hitlimit_violations (key, count, reset_at) VALUES (?1, 1, ?2)
-      ON CONFLICT(key) DO UPDATE SET
-        count = CASE WHEN reset_at <= ?3 THEN 1 ELSE count + 1 END,
-        reset_at = CASE WHEN reset_at <= ?3 THEN ?2 ELSE reset_at END
-    `);
-    this.getViolationStmt = this.db.prepare("SELECT count FROM hitlimit_violations WHERE key = ?");
-    this.resetBanStmt = this.db.prepare("DELETE FROM hitlimit_bans WHERE key = ?");
-    this.resetViolationStmt = this.db.prepare("DELETE FROM hitlimit_violations WHERE key = ?");
-    this.cleanupTimer = setInterval(() => {
-      const now = Date.now();
-      this.db.prepare("DELETE FROM hitlimit WHERE reset_at <= ?").run(now);
-      this.db.prepare("DELETE FROM hitlimit_bans WHERE expires_at <= ?").run(now);
-      this.db.prepare("DELETE FROM hitlimit_violations WHERE reset_at <= ?").run(now);
-    }, 60000);
-  }
+// src/stores/memory.ts
+class MemoryStore {
+  isSync = true;
+  hits = new Map;
+  bans = new Map;
+  violations = new Map;
   hit(key, windowMs, _limit) {
+    const entry = this.hits.get(key);
+    if (entry !== undefined) {
+      entry.count++;
+      return { count: entry.count, resetAt: entry.resetAt };
+    }
     const now = Date.now();
     const resetAt = now + windowMs;
-    this.hitStmt.run(key, resetAt, now);
-    const row = this.getStmt.get(key);
-    return { count: row.count, resetAt: row.reset_at };
+    const timeoutId = setTimeout(() => {
+      this.hits.delete(key);
+    }, windowMs);
+    if (typeof timeoutId.unref === "function") {
+      timeoutId.unref();
+    }
+    this.hits.set(key, { count: 1, resetAt, timeoutId });
+    return { count: 1, resetAt };
   }
   isBanned(key) {
-    return this.isBannedStmt.get(key, Date.now()) !== null;
+    const ban = this.bans.get(key);
+    if (!ban)
+      return false;
+    if (Date.now() >= ban.expiresAt) {
+      clearTimeout(ban.timeoutId);
+      this.bans.delete(key);
+      return false;
+    }
+    return true;
   }
   ban(key, durationMs) {
-    this.banStmt.run(key, Date.now() + durationMs);
+    const existing = this.bans.get(key);
+    if (existing)
+      clearTimeout(existing.timeoutId);
+    const expiresAt = Date.now() + durationMs;
+    const timeoutId = setTimeout(() => {
+      this.bans.delete(key);
+    }, durationMs);
+    if (typeof timeoutId.unref === "function") {
+      timeoutId.unref();
+    }
+    this.bans.set(key, { expiresAt, timeoutId });
   }
   recordViolation(key, windowMs) {
-    const now = Date.now();
-    const resetAt = now + windowMs;
-    this.recordViolationStmt.run(key, resetAt, now);
-    const row = this.getViolationStmt.get(key);
-    return row?.count ?? 1;
+    const entry = this.violations.get(key);
+    if (entry && Date.now() < entry.resetAt) {
+      entry.count++;
+      return entry.count;
+    }
+    if (entry)
+      clearTimeout(entry.timeoutId);
+    const resetAt = Date.now() + windowMs;
+    const timeoutId = setTimeout(() => {
+      this.violations.delete(key);
+    }, windowMs);
+    if (typeof timeoutId.unref === "function") {
+      timeoutId.unref();
+    }
+    this.violations.set(key, { count: 1, resetAt, timeoutId });
+    return 1;
   }
   reset(key) {
-    this.resetStmt.run(key);
-    this.resetBanStmt.run(key);
-    this.resetViolationStmt.run(key);
+    const entry = this.hits.get(key);
+    if (entry) {
+      clearTimeout(entry.timeoutId);
+      this.hits.delete(key);
+    }
+    const ban = this.bans.get(key);
+    if (ban) {
+      clearTimeout(ban.timeoutId);
+      this.bans.delete(key);
+    }
+    const violation = this.violations.get(key);
+    if (violation) {
+      clearTimeout(violation.timeoutId);
+      this.violations.delete(key);
+    }
   }
   shutdown() {
-    clearInterval(this.cleanupTimer);
-    this.db.close();
+    for (const [, entry] of this.hits) {
+      clearTimeout(entry.timeoutId);
+    }
+    this.hits.clear();
+    for (const [, entry] of this.bans) {
+      clearTimeout(entry.timeoutId);
+    }
+    this.bans.clear();
+    for (const [, entry] of this.violations) {
+      clearTimeout(entry.timeoutId);
+    }
+    this.violations.clear();
   }
 }
-function sqliteStore(options) {
-  return new BunSqliteStore(options);
+function memoryStore() {
+  return new MemoryStore;
 }
 
 // src/elysia.ts
@@ -277,10 +281,69 @@ var instanceCounter = 0;
 function getDefaultKey(_ctx) {
   return "unknown";
 }
+function buildResponseBody(response, info) {
+  if (typeof response === "function") {
+    return response(info);
+  }
+  return { ...response, limit: info.limit, remaining: info.remaining, resetIn: info.resetIn };
+}
 function hitlimit(options = {}) {
   const pluginName = options.name ?? `hitlimit-${instanceCounter++}`;
-  const store = options.store ?? sqliteStore({ path: options.sqlitePath });
+  if (options.sqlitePath && !options.store) {
+    console.warn("[hitlimit-bun] DEPRECATION WARNING: " + "sqlitePath is deprecated and will be ignored. " + "Use store: sqliteStore({ path }) instead. " + "See migration guide: https://hitlimit.jointops.dev/docs/migration/v1.1.0");
+  }
+  const store = options.store ?? memoryStore();
   const config = resolveConfig(options, store, getDefaultKey);
+  const hasSkip = !!config.skip;
+  const hasTiers = !!(config.tier && config.tiers);
+  const hasBan = !!config.ban;
+  const hasGroup = !!config.group;
+  const standardHeaders = config.headers.standard;
+  const legacyHeaders = config.headers.legacy;
+  const retryAfterHeader = config.headers.retryAfter;
+  const limit = config.limit;
+  const windowMs = config.windowMs;
+  const responseConfig = config.response;
+  const isSyncStore = store.isSync === true;
+  const isSyncKey = !options.key;
+  if (!hasSkip && !hasTiers && !hasBan && !hasGroup && isSyncStore && isSyncKey) {
+    return new Elysia({ name: pluginName }).onBeforeHandle({ as: "scoped" }, ({ set }) => {
+      const key = "unknown";
+      const result = store.hit(key, windowMs, limit);
+      const allowed = result.count <= limit;
+      const remaining = Math.max(0, limit - result.count);
+      const resetIn = Math.ceil((result.resetAt - Date.now()) / 1000);
+      if (standardHeaders) {
+        set.headers["RateLimit-Limit"] = String(limit);
+        set.headers["RateLimit-Remaining"] = String(remaining);
+        set.headers["RateLimit-Reset"] = String(resetIn);
+      }
+      if (legacyHeaders) {
+        set.headers["X-RateLimit-Limit"] = String(limit);
+        set.headers["X-RateLimit-Remaining"] = String(remaining);
+        set.headers["X-RateLimit-Reset"] = String(Math.ceil(result.resetAt / 1000));
+      }
+      if (!allowed) {
+        if (retryAfterHeader) {
+          set.headers["Retry-After"] = String(resetIn);
+        }
+        const body = buildResponseBody(responseConfig, {
+          limit,
+          remaining: 0,
+          resetIn,
+          resetAt: result.resetAt,
+          key
+        });
+        set.status = 429;
+        const headers = { "Content-Type": "application/json" };
+        for (const [k, v] of Object.entries(set.headers)) {
+          if (v != null)
+            headers[k] = String(v);
+        }
+        return new Response(JSON.stringify(body), { status: 429, headers });
+      }
+    });
+  }
   return new Elysia({ name: pluginName }).onBeforeHandle({ as: "scoped" }, async ({ request, set }) => {
     const ctx = { request };
     if (config.skip) {
@@ -296,13 +359,12 @@ function hitlimit(options = {}) {
       });
       if (!result.allowed) {
         set.status = 429;
-        return new Response(JSON.stringify(result.body), {
-          status: 429,
-          headers: {
-            "Content-Type": "application/json",
-            ...result.headers
-          }
-        });
+        const headers = { "Content-Type": "application/json" };
+        for (const [k, v] of Object.entries(result.headers)) {
+          if (v != null)
+            headers[k] = String(v);
+        }
+        return new Response(JSON.stringify(result.body), { status: 429, headers });
       }
     } catch (error) {
       const action = await config.onStoreError(error, ctx);

package/dist/hono.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from 'hono';
+import type { HitLimitOptions } from '@joint-ops/hitlimit-types';
+export declare function hitlimit(options?: HitLimitOptions<Context>): import("hono").MiddlewareHandler<any, string, {}, Response | (Response & import("hono").TypedResponse<{
+    [x: string]: any;
+}, 429, "json">)>;
+//# sourceMappingURL=hono.d.ts.map

package/dist/hono.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hono.d.ts","sourceRoot":"","sources":["../src/hono.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAO,KAAK,EAAE,eAAe,EAAgE,MAAM,2BAA2B,CAAA;AAqB9H,wBAAgB,QAAQ,CAAC,OAAO,GAAE,eAAe,CAAC,OAAO,CAAM;;kBAkF9D"}

package/dist/hono.js

@@ -0,0 +1,364 @@
+// @bun
+// src/stores/memory.ts
+class MemoryStore {
+  isSync = true;
+  hits = new Map;
+  bans = new Map;
+  violations = new Map;
+  hit(key, windowMs, _limit) {
+    const entry = this.hits.get(key);
+    if (entry !== undefined) {
+      entry.count++;
+      return { count: entry.count, resetAt: entry.resetAt };
+    }
+    const now = Date.now();
+    const resetAt = now + windowMs;
+    const timeoutId = setTimeout(() => {
+      this.hits.delete(key);
+    }, windowMs);
+    if (typeof timeoutId.unref === "function") {
+      timeoutId.unref();
+    }
+    this.hits.set(key, { count: 1, resetAt, timeoutId });
+    return { count: 1, resetAt };
+  }
+  isBanned(key) {
+    const ban = this.bans.get(key);
+    if (!ban)
+      return false;
+    if (Date.now() >= ban.expiresAt) {
+      clearTimeout(ban.timeoutId);
+      this.bans.delete(key);
+      return false;
+    }
+    return true;
+  }
+  ban(key, durationMs) {
+    const existing = this.bans.get(key);
+    if (existing)
+      clearTimeout(existing.timeoutId);
+    const expiresAt = Date.now() + durationMs;
+    const timeoutId = setTimeout(() => {
+      this.bans.delete(key);
+    }, durationMs);
+    if (typeof timeoutId.unref === "function") {
+      timeoutId.unref();
+    }
+    this.bans.set(key, { expiresAt, timeoutId });
+  }
+  recordViolation(key, windowMs) {
+    const entry = this.violations.get(key);
+    if (entry && Date.now() < entry.resetAt) {
+      entry.count++;
+      return entry.count;
+    }
+    if (entry)
+      clearTimeout(entry.timeoutId);
+    const resetAt = Date.now() + windowMs;
+    const timeoutId = setTimeout(() => {
+      this.violations.delete(key);
+    }, windowMs);
+    if (typeof timeoutId.unref === "function") {
+      timeoutId.unref();
+    }
+    this.violations.set(key, { count: 1, resetAt, timeoutId });
+    return 1;
+  }
+  reset(key) {
+    const entry = this.hits.get(key);
+    if (entry) {
+      clearTimeout(entry.timeoutId);
+      this.hits.delete(key);
+    }
+    const ban = this.bans.get(key);
+    if (ban) {
+      clearTimeout(ban.timeoutId);
+      this.bans.delete(key);
+    }
+    const violation = this.violations.get(key);
+    if (violation) {
+      clearTimeout(violation.timeoutId);
+      this.violations.delete(key);
+    }
+  }
+  shutdown() {
+    for (const [, entry] of this.hits) {
+      clearTimeout(entry.timeoutId);
+    }
+    this.hits.clear();
+    for (const [, entry] of this.bans) {
+      clearTimeout(entry.timeoutId);
+    }
+    this.bans.clear();
+    for (const [, entry] of this.violations) {
+      clearTimeout(entry.timeoutId);
+    }
+    this.violations.clear();
+  }
+}
+function memoryStore() {
+  return new MemoryStore;
+}
+
+// src/hono.ts
+import { createMiddleware } from "hono/factory";
+
+// src/core/utils.ts
+var UNITS = {
+  s: 1000,
+  m: 60 * 1000,
+  h: 60 * 60 * 1000,
+  d: 24 * 60 * 60 * 1000
+};
+function parseWindow(window) {
+  if (typeof window === "number")
+    return window;
+  const match = window.match(/^(\d+)(s|m|h|d)$/);
+  if (!match)
+    throw new Error(`Invalid window format: ${window}`);
+  return parseInt(match[1]) * UNITS[match[2]];
+}
+
+// src/core/config.ts
+function resolveConfig(options, defaultStore, defaultKey) {
+  return {
+    limit: options.limit ?? 100,
+    windowMs: parseWindow(options.window ?? "1m"),
+    key: options.key ?? defaultKey,
+    tiers: options.tiers,
+    tier: options.tier,
+    response: options.response ?? { hitlimit: true, message: "Whoa there! Rate limit exceeded." },
+    headers: {
+      standard: options.headers?.standard ?? true,
+      legacy: options.headers?.legacy ?? true,
+      retryAfter: options.headers?.retryAfter ?? true
+    },
+    store: options.store ?? defaultStore,
+    onStoreError: options.onStoreError ?? (() => "allow"),
+    skip: options.skip,
+    ban: options.ban ? { threshold: options.ban.threshold, durationMs: parseWindow(options.ban.duration) } : null,
+    group: options.group ?? null
+  };
+}
+
+// src/core/headers.ts
+function buildHeaders(info, config, allowed) {
+  const headers = {};
+  if (config.standard) {
+    headers["RateLimit-Limit"] = String(info.limit);
+    headers["RateLimit-Remaining"] = String(info.remaining);
+    headers["RateLimit-Reset"] = String(Math.ceil(info.resetAt / 1000));
+  }
+  if (config.legacy) {
+    headers["X-RateLimit-Limit"] = String(info.limit);
+    headers["X-RateLimit-Remaining"] = String(info.remaining);
+    headers["X-RateLimit-Reset"] = String(Math.ceil(info.resetAt / 1000));
+  }
+  if (!allowed && config.retryAfter) {
+    headers["Retry-After"] = String(info.resetIn);
+  }
+  if (info.banned) {
+    headers["X-RateLimit-Ban"] = "true";
+    if (info.banExpiresAt) {
+      headers["X-RateLimit-Ban-Expires"] = String(Math.ceil(info.banExpiresAt / 1000));
+    }
+  }
+  return headers;
+}
+
+// src/core/response.ts
+function buildBody(response, info) {
+  if (typeof response === "function") {
+    return response(info);
+  }
+  const body = {
+    ...response,
+    limit: info.limit,
+    remaining: info.remaining,
+    resetIn: info.resetIn
+  };
+  if (info.banned) {
+    body.banned = true;
+    body.banExpiresAt = info.banExpiresAt;
+    body.message = "You have been temporarily banned due to repeated rate limit violations";
+  }
+  return body;
+}
+
+// src/core/limiter.ts
+async function resolveKey(config, req) {
+  let key = await config.key(req);
+  let groupId;
+  if (config.group) {
+    groupId = typeof config.group === "function" ? await config.group(req) : config.group;
+    key = `group:${groupId}:${key}`;
+  }
+  return { key, groupId };
+}
+function resolveTier(config, tierName) {
+  if (tierName && config.tiers) {
+    const tierConfig = config.tiers[tierName];
+    if (tierConfig) {
+      return {
+        limit: tierConfig.limit,
+        windowMs: tierConfig.window ? parseWindow(tierConfig.window) : config.windowMs
+      };
+    }
+  }
+  return { limit: config.limit, windowMs: config.windowMs };
+}
+async function checkLimit(config, req) {
+  const { key, groupId } = await resolveKey(config, req);
+  let tierName;
+  if (config.tier && config.tiers) {
+    tierName = await config.tier(req);
+  }
+  const { limit, windowMs } = resolveTier(config, tierName);
+  if (config.ban && config.store.isBanned) {
+    const banned = await config.store.isBanned(key);
+    if (banned) {
+      const banResetIn = Math.ceil(config.ban.durationMs / 1000);
+      const info2 = {
+        limit,
+        remaining: 0,
+        resetIn: banResetIn,
+        resetAt: Date.now() + config.ban.durationMs,
+        key,
+        tier: tierName,
+        banned: true,
+        banExpiresAt: Date.now() + config.ban.durationMs,
+        group: groupId
+      };
+      return {
+        allowed: false,
+        info: info2,
+        headers: buildHeaders(info2, config.headers, false),
+        body: buildBody(config.response, info2)
+      };
+    }
+  }
+  if (limit === Infinity) {
+    return {
+      allowed: true,
+      info: { limit, remaining: Infinity, resetIn: 0, resetAt: 0, key, tier: tierName, group: groupId },
+      headers: {},
+      body: {}
+    };
+  }
+  const result = await config.store.hit(key, windowMs, limit);
+  const now = Date.now();
+  const resetIn = Math.max(0, Math.ceil((result.resetAt - now) / 1000));
+  const remaining = Math.max(0, limit - result.count);
+  const allowed = result.count <= limit;
+  const info = {
+    limit,
+    remaining,
+    resetIn,
+    resetAt: result.resetAt,
+    key,
+    tier: tierName,
+    group: groupId
+  };
+  if (!allowed && config.ban && config.store.recordViolation) {
+    const violations = await config.store.recordViolation(key, config.ban.durationMs);
+    info.violations = violations;
+    if (violations >= config.ban.threshold && config.store.ban) {
+      await config.store.ban(key, config.ban.durationMs);
+      info.banned = true;
+      info.banExpiresAt = now + config.ban.durationMs;
+    }
+  }
+  return {
+    allowed,
+    info,
+    headers: buildHeaders(info, config.headers, allowed),
+    body: allowed ? {} : buildBody(config.response, info)
+  };
+}
+
+// src/hono.ts
+function getDefaultKey(c) {
+  return c.req.header("x-forwarded-for")?.split(",")[0]?.trim() || c.req.header("x-real-ip") || "unknown";
+}
+function buildResponseBody(response, info) {
+  if (typeof response === "function") {
+    return response(info);
+  }
+  return { ...response, limit: info.limit, remaining: info.remaining, resetIn: info.resetIn };
+}
+function hitlimit(options = {}) {
+  const store = options.store ?? memoryStore();
+  const config = resolveConfig(options, store, getDefaultKey);
+  const hasSkip = !!config.skip;
+  const hasTiers = !!(config.tier && config.tiers);
+  const hasBan = !!config.ban;
+  const hasGroup = !!config.group;
+  const standardHeaders = config.headers.standard;
+  const legacyHeaders = config.headers.legacy;
+  const retryAfterHeader = config.headers.retryAfter;
+  const limit = config.limit;
+  const windowMs = config.windowMs;
+  const responseConfig = config.response;
+  const isSyncStore = store.isSync === true;
+  const isSyncKey = !options.key;
+  if (!hasSkip && !hasTiers && !hasBan && !hasGroup && isSyncStore && isSyncKey) {
+    return createMiddleware(async (c, next) => {
+      const key = c.req.header("x-forwarded-for")?.split(",")[0]?.trim() || c.req.header("x-real-ip") || "unknown";
+      const result = store.hit(key, windowMs, limit);
+      const allowed = result.count <= limit;
+      const remaining = Math.max(0, limit - result.count);
+      const resetIn = Math.ceil((result.resetAt - Date.now()) / 1000);
+      if (standardHeaders) {
+        c.header("RateLimit-Limit", String(limit));
+        c.header("RateLimit-Remaining", String(remaining));
+        c.header("RateLimit-Reset", String(resetIn));
+      }
+      if (legacyHeaders) {
+        c.header("X-RateLimit-Limit", String(limit));
+        c.header("X-RateLimit-Remaining", String(remaining));
+        c.header("X-RateLimit-Reset", String(Math.ceil(result.resetAt / 1000)));
+      }
+      if (!allowed) {
+        if (retryAfterHeader) {
+          c.header("Retry-After", String(resetIn));
+        }
+        const body = buildResponseBody(responseConfig, {
+          limit,
+          remaining: 0,
+          resetIn,
+          resetAt: result.resetAt,
+          key
+        });
+        return c.json(body, 429);
+      }
+      await next();
+    });
+  }
+  return createMiddleware(async (c, next) => {
+    if (config.skip) {
+      const shouldSkip = await config.skip(c);
+      if (shouldSkip) {
+        await next();
+        return;
+      }
+    }
+    try {
+      const result = await checkLimit(config, c);
+      for (const [key, value] of Object.entries(result.headers)) {
+        c.header(key, value);
+      }
+      if (!result.allowed) {
+        return c.json(result.body, 429);
+      }
+    } catch (error) {
+      const action = await config.onStoreError(error, c);
+      if (action === "deny") {
+        return c.json({ hitlimit: true, message: "Rate limit error" }, 429);
+      }
+    }
+    await next();
+  });
+}
+export {
+  hitlimit
+};

package/dist/index.d.ts

@@ -2,9 +2,20 @@ import type { HitLimitOptions } from '@joint-ops/hitlimit-types';
 import { checkLimit } from './core/limiter.js';
 export type { HitLimitOptions, HitLimitInfo, HitLimitResult, HitLimitStore, StoreResult, TierConfig, HeadersConfig, ResolvedConfig, KeyGenerator, TierResolver, SkipFunction, StoreErrorHandler, ResponseFormatter, ResponseConfig, BanConfig, GroupIdResolver } from '@joint-ops/hitlimit-types';
 export { DEFAULT_LIMIT, DEFAULT_WINDOW, DEFAULT_WINDOW_MS, DEFAULT_MESSAGE } from '@joint-ops/hitlimit-types';
-export { sqliteStore } from './stores/sqlite.js';
+export { memoryStore } from './stores/memory.js';
 export { checkLimit };
 export interface BunHitLimitOptions extends HitLimitOptions<Request> {
+    /**
+     * @deprecated Use `store: sqliteStore({ path })` instead.
+     *
+     * Starting with v1.1.0, the default store is Memory for 15.7x better performance.
+     * If you need SQLite persistence:
+     *
+     * ```typescript
+     * import { sqliteStore } from '@joint-ops/hitlimit-bun/stores/sqlite'
+     * hitlimit({ store: sqliteStore({ path: './db.sqlite' }) }, handler)
+     * ```
+     */
     sqlitePath?: string;
 }
 type BunServer = {

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAEhE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAG9C,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,cAAc,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AACjS,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAC7G,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,CAAA;AAErB,MAAM,WAAW,kBAAmB,SAAQ,eAAe,CAAC,OAAO,CAAC;IAClE,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,KAAK,SAAS,GAAG;IAAE,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAAE,CAAA;AAExE,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;AAMrF,wBAAgB,QAAQ,CACtB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,YAAY,GACpB,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAiJnE;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAA;IAClF,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CACzC;AAED,wBAAgB,cAAc,CAAC,OAAO,GAAE,kBAAuB,GAAG,UAAU,CAgD3E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAEhE,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAG9C,YAAY,EAAE,eAAe,EAAE,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,cAAc,EAAE,YAAY,EAAE,YAAY,EAAE,YAAY,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,cAAc,EAAE,SAAS,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AACjS,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAC7G,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,CAAA;AAErB,MAAM,WAAW,kBAAmB,SAAQ,eAAe,CAAC,OAAO,CAAC;IAClE;;;;;;;;;;OAUG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB;AAED,KAAK,SAAS,GAAG;IAAE,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG;QAAE,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAA;CAAE,CAAA;AAExE,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;AAMrF,wBAAgB,QAAQ,CACtB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,YAAY,GACpB,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAsPnE;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,GAAG,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,GAAG,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAA;IAClF,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAA;CACzC;AAED,wBAAgB,cAAc,CAAC,OAAO,GAAE,kBAAuB,GAAG,UAAU,CA0D3E"}

package/dist/index.js

@@ -1,99 +1,103 @@
 // @bun
-// src/stores/sqlite.ts
-import { Database } from "bun:sqlite";
-
-class BunSqliteStore {
-  db;
-  hitStmt;
-  getStmt;
-  resetStmt;
-  isBannedStmt;
-  banStmt;
-  recordViolationStmt;
-  getViolationStmt;
-  resetBanStmt;
-  resetViolationStmt;
-  cleanupTimer;
-  constructor(options = {}) {
-    this.db = new Database(options.path ?? ":memory:");
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS hitlimit (
-        key TEXT PRIMARY KEY,
-        count INTEGER NOT NULL,
-        reset_at INTEGER NOT NULL
-      )
-    `);
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS hitlimit_bans (
-        key TEXT PRIMARY KEY,
-        expires_at INTEGER NOT NULL
-      )
-    `);
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS hitlimit_violations (
-        key TEXT PRIMARY KEY,
-        count INTEGER NOT NULL DEFAULT 1,
-        reset_at INTEGER NOT NULL
-      )
-    `);
-    this.hitStmt = this.db.prepare(`
-      INSERT INTO hitlimit (key, count, reset_at) VALUES (?1, 1, ?2)
-      ON CONFLICT(key) DO UPDATE SET
-        count = CASE WHEN reset_at <= ?3 THEN 1 ELSE count + 1 END,
-        reset_at = CASE WHEN reset_at <= ?3 THEN ?2 ELSE reset_at END
-    `);
-    this.getStmt = this.db.prepare("SELECT count, reset_at FROM hitlimit WHERE key = ?");
-    this.resetStmt = this.db.prepare("DELETE FROM hitlimit WHERE key = ?");
-    this.isBannedStmt = this.db.prepare("SELECT 1 FROM hitlimit_bans WHERE key = ?1 AND expires_at > ?2");
-    this.banStmt = this.db.prepare("INSERT OR REPLACE INTO hitlimit_bans (key, expires_at) VALUES (?1, ?2)");
-    this.recordViolationStmt = this.db.prepare(`
-      INSERT INTO hitlimit_violations (key, count, reset_at) VALUES (?1, 1, ?2)
-      ON CONFLICT(key) DO UPDATE SET
-        count = CASE WHEN reset_at <= ?3 THEN 1 ELSE count + 1 END,
-        reset_at = CASE WHEN reset_at <= ?3 THEN ?2 ELSE reset_at END
-    `);
-    this.getViolationStmt = this.db.prepare("SELECT count FROM hitlimit_violations WHERE key = ?");
-    this.resetBanStmt = this.db.prepare("DELETE FROM hitlimit_bans WHERE key = ?");
-    this.resetViolationStmt = this.db.prepare("DELETE FROM hitlimit_violations WHERE key = ?");
-    this.cleanupTimer = setInterval(() => {
-      const now = Date.now();
-      this.db.prepare("DELETE FROM hitlimit WHERE reset_at <= ?").run(now);
-      this.db.prepare("DELETE FROM hitlimit_bans WHERE expires_at <= ?").run(now);
-      this.db.prepare("DELETE FROM hitlimit_violations WHERE reset_at <= ?").run(now);
-    }, 60000);
-  }
+// src/stores/memory.ts
+class MemoryStore {
+  isSync = true;
+  hits = new Map;
+  bans = new Map;
+  violations = new Map;
   hit(key, windowMs, _limit) {
+    const entry = this.hits.get(key);
+    if (entry !== undefined) {
+      entry.count++;
+      return { count: entry.count, resetAt: entry.resetAt };
+    }
     const now = Date.now();
     const resetAt = now + windowMs;
-    this.hitStmt.run(key, resetAt, now);
-    const row = this.getStmt.get(key);
-    return { count: row.count, resetAt: row.reset_at };
+    const timeoutId = setTimeout(() => {
+      this.hits.delete(key);
+    }, windowMs);
+    if (typeof timeoutId.unref === "function") {
+      timeoutId.unref();
+    }
+    this.hits.set(key, { count: 1, resetAt, timeoutId });
+    return { count: 1, resetAt };
   }
   isBanned(key) {
-    return this.isBannedStmt.get(key, Date.now()) !== null;
+    const ban = this.bans.get(key);
+    if (!ban)
+      return false;
+    if (Date.now() >= ban.expiresAt) {
+      clearTimeout(ban.timeoutId);
+      this.bans.delete(key);
+      return false;
+    }
+    return true;
   }
   ban(key, durationMs) {
-    this.banStmt.run(key, Date.now() + durationMs);
+    const existing = this.bans.get(key);
+    if (existing)
+      clearTimeout(existing.timeoutId);
+    const expiresAt = Date.now() + durationMs;
+    const timeoutId = setTimeout(() => {
+      this.bans.delete(key);
+    }, durationMs);
+    if (typeof timeoutId.unref === "function") {
+      timeoutId.unref();
+    }
+    this.bans.set(key, { expiresAt, timeoutId });
   }
   recordViolation(key, windowMs) {
-    const now = Date.now();
-    const resetAt = now + windowMs;
-    this.recordViolationStmt.run(key, resetAt, now);
-    const row = this.getViolationStmt.get(key);
-    return row?.count ?? 1;
+    const entry = this.violations.get(key);
+    if (entry && Date.now() < entry.resetAt) {
+      entry.count++;
+      return entry.count;
+    }
+    if (entry)
+      clearTimeout(entry.timeoutId);
+    const resetAt = Date.now() + windowMs;
+    const timeoutId = setTimeout(() => {
+      this.violations.delete(key);
+    }, windowMs);
+    if (typeof timeoutId.unref === "function") {
+      timeoutId.unref();
+    }
+    this.violations.set(key, { count: 1, resetAt, timeoutId });
+    return 1;
   }
   reset(key) {
-    this.resetStmt.run(key);
-    this.resetBanStmt.run(key);
-    this.resetViolationStmt.run(key);
+    const entry = this.hits.get(key);
+    if (entry) {
+      clearTimeout(entry.timeoutId);
+      this.hits.delete(key);
+    }
+    const ban = this.bans.get(key);
+    if (ban) {
+      clearTimeout(ban.timeoutId);
+      this.bans.delete(key);
+    }
+    const violation = this.violations.get(key);
+    if (violation) {
+      clearTimeout(violation.timeoutId);
+      this.violations.delete(key);
+    }
   }
   shutdown() {
-    clearInterval(this.cleanupTimer);
-    this.db.close();
+    for (const [, entry] of this.hits) {
+      clearTimeout(entry.timeoutId);
+    }
+    this.hits.clear();
+    for (const [, entry] of this.bans) {
+      clearTimeout(entry.timeoutId);
+    }
+    this.bans.clear();
+    for (const [, entry] of this.violations) {
+      clearTimeout(entry.timeoutId);
+    }
+    this.violations.clear();
   }
 }
-function sqliteStore(options) {
-  return new BunSqliteStore(options);
+function memoryStore() {
+  return new MemoryStore;
 }
 
 // src/core/utils.ts
@@ -283,7 +287,10 @@ function hitlimit(options, handler) {
   const defaultKey = (req) => {
     return activeServer?.requestIP(req)?.address || "unknown";
   };
-  const store = options.store ?? sqliteStore({ path: options.sqlitePath });
+  if (options.sqlitePath && !options.store) {
+    console.warn("[hitlimit-bun] DEPRECATION WARNING: " + "sqlitePath is deprecated and will be ignored. " + "Use store: sqliteStore({ path }) instead. " + "See migration guide: https://hitlimit.jointops.dev/docs/migration/v1.1.0");
+  }
+  const store = options.store ?? memoryStore();
   const config = resolveConfig(options, store, options.key ?? defaultKey);
   const hasSkip = !!config.skip;
   const hasTiers = !!(config.tier && config.tiers);
@@ -297,6 +304,80 @@ function hitlimit(options, handler) {
   const response = config.response;
   const customKey = options.key;
   const blockedBody = JSON.stringify(response);
+  const isSyncStore = store.isSync === true;
+  const isSyncKey = !customKey;
+  if (!hasSkip && !hasTiers && !hasBan && !hasGroup && isSyncStore && isSyncKey) {
+    return (req, server) => {
+      const ip = server.requestIP(req)?.address || "unknown";
+      const result = store.hit(ip, windowMs, limit);
+      const allowed = result.count <= limit;
+      if (!allowed) {
+        const headers = { "Content-Type": "application/json" };
+        const resetIn = Math.ceil((result.resetAt - Date.now()) / 1000);
+        if (standardHeaders) {
+          headers["RateLimit-Limit"] = String(limit);
+          headers["RateLimit-Remaining"] = "0";
+          headers["RateLimit-Reset"] = String(resetIn);
+        }
+        if (legacyHeaders) {
+          headers["X-RateLimit-Limit"] = String(limit);
+          headers["X-RateLimit-Remaining"] = "0";
+          headers["X-RateLimit-Reset"] = String(Math.ceil(result.resetAt / 1000));
+        }
+        if (retryAfterHeader) {
+          headers["Retry-After"] = String(resetIn);
+        }
+        return new Response(blockedBody, { status: 429, headers });
+      }
+      const res = handler(req, server);
+      if (res instanceof Promise) {
+        return res.then((response2) => {
+          if (standardHeaders || legacyHeaders) {
+            const resetIn = Math.ceil((result.resetAt - Date.now()) / 1000);
+            const remaining = Math.max(0, limit - result.count);
+            const newHeaders = new Headers(response2.headers);
+            if (standardHeaders) {
+              newHeaders.set("RateLimit-Limit", String(limit));
+              newHeaders.set("RateLimit-Remaining", String(remaining));
+              newHeaders.set("RateLimit-Reset", String(resetIn));
+            }
+            if (legacyHeaders) {
+              newHeaders.set("X-RateLimit-Limit", String(limit));
+              newHeaders.set("X-RateLimit-Remaining", String(remaining));
+              newHeaders.set("X-RateLimit-Reset", String(Math.ceil(result.resetAt / 1000)));
+            }
+            return new Response(response2.body, {
+              status: response2.status,
+              statusText: response2.statusText,
+              headers: newHeaders
+            });
+          }
+          return response2;
+        });
+      }
+      if (standardHeaders || legacyHeaders) {
+        const resetIn = Math.ceil((result.resetAt - Date.now()) / 1000);
+        const remaining = Math.max(0, limit - result.count);
+        const newHeaders = new Headers(res.headers);
+        if (standardHeaders) {
+          newHeaders.set("RateLimit-Limit", String(limit));
+          newHeaders.set("RateLimit-Remaining", String(remaining));
+          newHeaders.set("RateLimit-Reset", String(resetIn));
+        }
+        if (legacyHeaders) {
+          newHeaders.set("X-RateLimit-Limit", String(limit));
+          newHeaders.set("X-RateLimit-Remaining", String(remaining));
+          newHeaders.set("X-RateLimit-Reset", String(Math.ceil(result.resetAt / 1000)));
+        }
+        return new Response(res.body, {
+          status: res.status,
+          statusText: res.statusText,
+          headers: newHeaders
+        });
+      }
+      return res;
+    };
+  }
   if (!hasSkip && !hasTiers && !hasBan && !hasGroup) {
     return async (req, server) => {
       try {
@@ -402,7 +483,10 @@ function createHitLimit(options = {}) {
   const defaultKey = (req) => {
     return activeServer?.requestIP(req)?.address || "unknown";
   };
-  const store = options.store ?? sqliteStore({ path: options.sqlitePath });
+  if (options.sqlitePath && !options.store) {
+    console.warn("[hitlimit-bun] DEPRECATION WARNING: " + "sqlitePath is deprecated and will be ignored. " + "Use store: sqliteStore({ path }) instead. " + "See migration guide: https://hitlimit.jointops.dev/docs/migration/v1.1.0");
+  }
+  const store = options.store ?? memoryStore();
   const config = resolveConfig(options, store, options.key ?? defaultKey);
   return {
     async check(req, server) {
@@ -439,7 +523,7 @@ function createHitLimit(options = {}) {
   };
 }
 export {
-  sqliteStore,
+  memoryStore,
   hitlimit,
   createHitLimit,
   checkLimit,

package/dist/stores/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/stores/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,2BAA2B,CAAA;AAgJ3E,wBAAgB,WAAW,IAAI,aAAa,CAE3C"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/stores/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,2BAA2B,CAAA;AAiJ3E,wBAAgB,WAAW,IAAI,aAAa,CAE3C"}

package/dist/stores/memory.js

@@ -1,6 +1,7 @@
 // @bun
 // src/stores/memory.ts
 class MemoryStore {
+  isSync = true;
   hits = new Map;
   bans = new Map;
   violations = new Map;

package/dist/stores/sqlite.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/stores/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,2BAA2B,CAAA;AAE3E,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AA+GD,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,aAAa,CAEvE"}
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../src/stores/sqlite.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAe,MAAM,2BAA2B,CAAA;AAE3E,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAgHD,wBAAgB,WAAW,CAAC,OAAO,CAAC,EAAE,kBAAkB,GAAG,aAAa,CAEvE"}

package/dist/stores/sqlite.js

@@ -3,6 +3,7 @@
 import { Database } from "bun:sqlite";
 
 class BunSqliteStore {
+  isSync = true;
   db;
   hitStmt;
   getStmt;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@joint-ops/hitlimit-bun",
-  "version": "1.0.6",
-  "description": "Fast Bun-native rate limiting for Bun.serve & Elysia - API throttling with bun:sqlite, high performance request limiting",
+  "version": "1.1.1",
+  "description": "Ultra-fast Bun-native rate limiting - Memory-first with 6M+ ops/sec for Bun.serve, Elysia & Hono",
   "author": {
     "name": "Shayan M Hussain",
     "email": "shayanhussain48@gmail.com",
@@ -19,10 +19,16 @@
   },
   "keywords": [
     "rate-limit",
-    "rate-limiter",
-    "rate-limiting",
-    "ratelimit",
     "bun",
+    "rate-limiter",
+    "memory",
+    "fast",
+    "elysia",
+    "bun.serve",
+    "middleware",
+    "sqlite",
+    "redis",
+    "hono",
     "bun-rate-limit",
     "bun-sqlite",
     "bun-middleware",
@@ -30,15 +36,12 @@
     "bun-server",
     "bun-native",
     "bun-http",
-    "elysia",
     "elysia-plugin",
     "elysia-rate-limit",
     "elysia-middleware",
     "elysia-throttle",
-    "hono",
     "hono-rate-limit",
     "hono-bun",
-    "middleware",
     "throttle",
     "throttling",
     "api",
@@ -50,7 +53,6 @@
     "brute-force",
     "brute-force-protection",
     "login-protection",
-    "redis",
     "redis-rate-limit",
     "typescript",
     "high-performance",
@@ -64,7 +66,6 @@
     "http-rate-limit",
     "bun-api",
     "bun-framework",
-    "fast",
     "lightweight",
     "zero-dependency",
     "esm"
@@ -84,6 +85,11 @@
       "bun": "./dist/elysia.js",
       "import": "./dist/elysia.js"
     },
+    "./hono": {
+      "types": "./dist/hono.d.ts",
+      "bun": "./dist/hono.js",
+      "import": "./dist/hono.js"
+    },
     "./stores/memory": {
       "types": "./dist/stores/memory.d.ts",
       "bun": "./dist/stores/memory.js",
@@ -105,22 +111,26 @@
   ],
   "sideEffects": false,
   "scripts": {
-    "build": "bun build ./src/index.ts ./src/elysia.ts ./src/stores/memory.ts ./src/stores/redis.ts ./src/stores/sqlite.ts --outdir=./dist --target=bun --external=elysia --external=ioredis --external=@sinclair/typebox && tsc --emitDeclarationOnly",
+    "build": "bun build ./src/index.ts ./src/elysia.ts ./src/hono.ts ./src/stores/memory.ts ./src/stores/redis.ts ./src/stores/sqlite.ts --outdir=./dist --target=bun --external=elysia --external=hono --external=ioredis --external=@sinclair/typebox && tsc --emitDeclarationOnly",
     "clean": "rm -rf dist",
     "test": "bun test",
     "test:watch": "bun test --watch"
   },
   "dependencies": {
-    "@joint-ops/hitlimit-types": "1.0.6"
+    "@joint-ops/hitlimit-types": "1.1.1"
   },
   "peerDependencies": {
     "elysia": ">=1.0.0",
+    "hono": ">=4.0.0",
     "ioredis": ">=5.0.0"
   },
   "peerDependenciesMeta": {
     "elysia": {
       "optional": true
     },
+    "hono": {
+      "optional": true
+    },
     "ioredis": {
       "optional": true
     }
@@ -129,6 +139,7 @@
     "@sinclair/typebox": "^0.34.48",
     "@types/bun": "latest",
     "elysia": "^1.0.0",
+    "hono": "^4.11.9",
     "ioredis": "^5.3.0",
     "typescript": "^5.3.0"
   }