hono-universal-cache 0.1.2

package/README.md

@@ -0,0 +1,400 @@
+# hono-universal-cache
+
+Universal cache middleware for [Hono](https://hono.dev) powered by [unstorage](https://unstorage.unjs.io).
+
+Cache **API responses** across **any runtime** - Cloudflare Workers, Vercel Edge, Node.js, Bun, Deno, and more.
+
+> **Note:** Optimized for API responses (JSON, text, HTML). For static assets (images, videos, files), use CDN/edge caching instead.
+
+## Features
+
+✨ **Universal Runtime Support** - Works everywhere Hono works  
+🗄️ **Multiple Storage Drivers** - Memory, Redis, Cloudflare KV, Vercel KV, filesystem, and [more](https://unstorage.unjs.io/drivers)  
+⚡ **TTL Support** - Automatic expiration with configurable time-to-live  
+🎯 **Selective Caching** - Control what gets cached by status code  
+🔑 **Custom Key Generation** - Flexible cache key strategies  
+🪶 **Lightweight** - Minimal overhead, focused on storage operations  
+🎨 **HTTP Header Agnostic** - You control your own Cache-Control headers  
+📦 **Efficient Storage** - Optimized for text-based API responses
+
+## Installation
+
+```bash
+npm install hono-universal-cache
+# or
+pnpm add hono-universal-cache
+# or
+yarn add hono-universal-cache
+```
+
+> **Note:** `unstorage` is included as a dependency - no need to install it separately!
+
+## Quick Start
+
+### Basic Usage (In-Memory)
+
+```typescript
+import { Hono } from 'hono'
+import { universalCache } from 'hono-universal-cache'
+
+const app = new Hono()
+
+app.use('*', universalCache({
+  cacheName: 'my-app-cache',
+  ttl: 3600 // 1 hour
+}))
+
+app.get('/api/data', (c) => {
+  // Set your own Cache-Control headers
+  c.header('Cache-Control', 'public, max-age=3600')
+  return c.json({ timestamp: Date.now() })
+})
+
+export default app
+```
+
+### With Custom Storage Driver
+
+```typescript
+import { createStorage } from 'unstorage'
+import redisDriver from 'unstorage/drivers/redis'
+
+const storage = createStorage({
+  driver: redisDriver({
+    host: 'localhost',
+    port: 6379
+  })
+})
+
+app.use('*', universalCache({
+  cacheName: 'api-cache',
+  storage,
+  ttl: 3600
+}))
+```
+
+## Runtime-Specific Examples
+
+### Cloudflare Workers
+
+```typescript
+import { Hono } from 'hono'
+import { universalCache } from 'hono-universal-cache'
+import { createStorage } from 'unstorage'
+import cloudflareKVBindingDriver from 'unstorage/drivers/cloudflare-kv-binding'
+
+type Env = {
+  MY_KV: KVNamespace
+}
+
+const app = new Hono<{ Bindings: Env }>()
+
+app.use('*', async (c, next) => {
+  const storage = createStorage({
+    driver: cloudflareKVBindingDriver({ 
+      binding: c.env.MY_KV 
+    })
+  })
+
+  return universalCache({
+    cacheName: 'worker-cache',
+    storage,
+    ttl: 3600
+  })(c, next)
+})
+
+export default app
+```
+
+### Vercel Edge
+
+```typescript
+import { createStorage } from 'unstorage'
+import vercelKVDriver from 'unstorage/drivers/vercel-kv'
+
+const storage = createStorage({
+  driver: vercelKVDriver({
+    // Auto-detects from environment:
+    // KV_REST_API_URL and KV_REST_API_TOKEN
+  })
+})
+
+app.use('*', universalCache({
+  cacheName: 'edge-cache',
+  storage,
+  ttl: 3600
+}))
+```
+
+### Node.js / Bun (Filesystem)
+
+```typescript
+import { createStorage } from 'unstorage'
+import fsDriver from 'unstorage/drivers/fs'
+
+const storage = createStorage({
+  driver: fsDriver({
+    base: './cache'
+  })
+})
+
+app.use('*', universalCache({
+  cacheName: 'fs-cache',
+  storage,
+  ttl: 3600
+}))
+```
+
+### Redis
+
+```typescript
+import { createStorage } from 'unstorage'
+import redisDriver from 'unstorage/drivers/redis'
+
+const storage = createStorage({
+  driver: redisDriver({
+    host: 'localhost',
+    port: 6379,
+    // password: 'your-password'
+  })
+})
+
+app.use('*', universalCache({
+  cacheName: 'redis-cache',
+  storage,
+  ttl: 3600
+}))
+```
+
+## API Reference
+
+### `universalCache(options)`
+
+Creates a Hono middleware for response caching.
+
+#### Options
+
+```typescript
+type CacheOptions = {
+  // Required: Cache namespace
+  cacheName: string | ((c: Context) => Promise<string> | string)
+  
+  // Optional: Unstorage instance (defaults to in-memory)
+  storage?: Storage
+  
+  // Optional: Time-to-live in seconds
+  ttl?: number
+  
+  // Optional: Status codes to cache (default: [200])
+  cacheableStatusCodes?: number[]
+  
+  // Optional: Custom cache key generator
+  keyGenerator?: (c: Context) => Promise<string> | string
+}
+```
+
+## Common Use Cases
+
+### Dynamic Cache Names
+
+Cache different tenants or users separately:
+
+```typescript
+app.use('*', universalCache({
+  cacheName: (c) => {
+    const tenant = c.req.header('X-Tenant-ID') || 'default'
+    return `cache:${tenant}`
+  },
+  storage,
+  ttl: 3600
+}))
+```
+
+### Custom Key Generation
+
+Cache based on custom logic (e.g., ignore specific query params):
+
+```typescript
+app.use('*', universalCache({
+  cacheName: 'api-cache',
+  keyGenerator: (c) => {
+    const url = new URL(c.req.url)
+    // Ignore tracking parameters
+    url.searchParams.delete('utm_source')
+    url.searchParams.delete('utm_campaign')
+    return url.toString()
+  },
+  storage
+}))
+```
+
+### Selective Caching by Status Code
+
+Cache successful and redirect responses:
+
+```typescript
+app.use('*', universalCache({
+  cacheName: 'selective-cache',
+  cacheableStatusCodes: [200, 201, 301, 302],
+  storage
+}))
+```
+
+### Managing HTTP Headers
+
+The middleware focuses on storage-level caching. You control HTTP headers in your route handlers:
+
+```typescript
+app.get('/api/public', (c) => {
+  // Set headers for browser/CDN caching
+  c.header('Cache-Control', 'public, max-age=3600')
+  c.header('Vary', 'Accept-Encoding')
+  
+  return c.json({ data: 'public data' })
+})
+
+app.get('/api/private', (c) => {
+  // Private data - browser should not cache
+  c.header('Cache-Control', 'private, no-cache')
+  
+  // But server-side cache can still store it
+  return c.json({ data: 'user-specific data' })
+})
+```
+
+## Storage Drivers
+
+Use any [unstorage driver](https://unstorage.unjs.io/drivers):
+
+### Popular Drivers
+
+- **Memory** - `unstorage/drivers/memory` (default, ephemeral)
+- **Filesystem** - `unstorage/drivers/fs` (Node.js/Bun)
+- **Redis** - `unstorage/drivers/redis` (persistent, distributed)
+- **Cloudflare KV** - `unstorage/drivers/cloudflare-kv-binding`
+- **Vercel KV** - `unstorage/drivers/vercel-kv`
+- **MongoDB** - `unstorage/drivers/mongodb`
+- **Upstash Redis** - `unstorage/drivers/upstash`
+- **LRU Cache** - `unstorage/drivers/lru-cache` (in-memory with eviction)
+
+### Cloud Storage
+
+- **AWS S3** - `unstorage/drivers/s3`
+- **Azure Blob** - `unstorage/drivers/azure-storage-blob`
+- **Cloudflare R2** - `unstorage/drivers/cloudflare-r2-binding`
+- **Vercel Blob** - `unstorage/drivers/vercel-blob`
+
+See [all 50+ drivers](https://unstorage.unjs.io/drivers) in the unstorage documentation.
+
+## How It Works
+
+1. **Request arrives** → Middleware generates cache key
+2. **Check cache** → Retrieve from storage if exists and not expired
+3. **Cache hit** → Return cached response immediately
+4. **Cache miss** → Execute route handler
+5. **Check cacheability** → Verify status code and Vary header
+6. **Store response** → Save text body to storage with TTL metadata (non-blocking)
+7. **Return response** → Send to client
+
+## Important Notes
+
+### Optimized for API Responses
+
+This middleware is designed for **text-based API responses**:
+
+- ✅ **JSON APIs** - Perfect use case
+- ✅ **Text responses** - Works great
+- ✅ **HTML pages** - Fully supported
+- ✅ **XML/RSS feeds** - No problem
+- ❌ **Binary assets** (images, PDFs, videos) - Use CDN/edge caching instead
+
+**Why not binary?** The middleware uses `response.text()` for optimal storage efficiency. For static assets, use:
+- CDN caching (Cloudflare, CloudFront)
+- Object storage (S3, R2, Blob Storage)
+- Hono's built-in static file serving with CDN
+
+### Vary: * Behavior
+
+Responses with `Vary: *` header are **never cached**, per RFC 9111:
+
+```typescript
+app.get('/api/uncacheable', (c) => {
+  c.header('Vary', '*') // This response will not be cached
+  return c.json({ random: Math.random() })
+})
+```
+
+### HTTP Headers vs Storage Caching
+
+This middleware handles **server-side storage caching only**:
+
+- ✅ Stores responses in Redis, KV, filesystem, etc.
+- ❌ Does NOT modify Cache-Control or other HTTP headers
+- 💡 You control browser/CDN caching via headers in your routes
+
+### Non-blocking Cache Writes
+
+Cache writes happen asynchronously and don't block responses:
+
+- **Cloudflare Workers/Vercel Edge**: Uses `waitUntil()` for background writes
+- **Other runtimes**: Uses promises with error handling
+
+## Advanced Usage
+
+### CacheManager API
+
+Access the low-level cache manager for manual operations:
+
+```typescript
+import { CacheManager } from 'hono-universal-cache'
+import { createStorage } from 'unstorage'
+
+const storage = createStorage()
+const cache = new CacheManager(storage, 3600) // 1 hour TTL
+
+// Manual cache operations
+await cache.set('key', response)
+const cached = await cache.get('key')
+const exists = await cache.has('key')
+await cache.delete('key')
+await cache.clear()
+const keys = await cache.keys()
+```
+
+### Per-Route Caching
+
+Apply caching to specific routes only:
+
+```typescript
+const app = new Hono()
+
+// Global middleware without cache
+app.use('*', logger())
+
+// Cache only API routes
+app.use('/api/*', universalCache({
+  cacheName: 'api-cache',
+  storage,
+  ttl: 300 // 5 minutes
+}))
+
+// Cache product pages longer
+app.use('/products/*', universalCache({
+  cacheName: 'products-cache',
+  storage,
+  ttl: 3600 // 1 hour
+}))
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions welcome! Please open an issue or PR.
+
+## Credits
+
+- [Hono](https://hono.dev) - Ultrafast web framework
+- [unstorage](https://unstorage.unjs.io) - Universal storage layer

package/dist/index.d.mts

@@ -0,0 +1,181 @@
+import { Storage } from "unstorage";
+import { Context, MiddlewareHandler } from "hono";
+
+//#region src/types.d.ts
+
+/**
+ * Options for configuring the universal cache middleware.
+ */
+type CacheOptions = {
+  /**
+   * Name or function to generate cache namespace.
+   * Used to organize cached entries.
+   */
+  cacheName: string | ((c: Context) => Promise<string> | string);
+  /**
+   * HTTP status codes that should be cached.
+   * @default [200]
+   */
+  cacheableStatusCodes?: number[];
+  /**
+   * Custom function to generate cache keys.
+   * @default Uses request URL
+   */
+  keyGenerator?: (c: Context) => Promise<string> | string;
+  /**
+   * Unstorage instance for cache persistence.
+   * If not provided, defaults to in-memory storage.
+   */
+  storage?: Storage;
+  /**
+   * Time-to-live for cached entries in seconds.
+   * After this duration, cached entries are considered stale.
+   */
+  ttl?: number;
+};
+/**
+ * Serialized representation of a cached Response.
+ * Stored in unstorage with metadata.
+ * Optimized for text-based API responses (JSON, text, HTML).
+ */
+type CachedResponse = {
+  /**
+   * Response body as text string.
+   * Works for JSON, text, HTML, and other text-based responses.
+   */
+  body: string;
+  /**
+   * Response headers as key-value pairs.
+   */
+  headers: Record<string, string>;
+  /**
+   * HTTP status code.
+   */
+  status: number;
+  /**
+   * HTTP status text.
+   */
+  statusText: string;
+  /**
+   * Timestamp when the response was cached (Unix epoch ms).
+   */
+  cachedAt: number;
+};
+/**
+ * Metadata stored alongside cached entries.
+ */
+type CacheMetadata = {
+  /**
+   * Timestamp when entry was created (Date object for unstorage compatibility).
+   */
+  mtime: Date;
+  /**
+   * Expiration timestamp (Unix epoch ms).
+   * Calculated as cachedAt + ttl.
+   */
+  expires?: number;
+};
+//#endregion
+//#region src/cache.d.ts
+/**
+ * CacheManager handles Response serialization, storage, and retrieval.
+ *
+ * Wraps unstorage to provide Response-specific caching with TTL support.
+ * Designed for API responses (JSON, text, HTML) - not binary assets.
+ */
+declare class CacheManager {
+  private storage;
+  private ttl?;
+  /**
+   * Creates a new CacheManager instance.
+   *
+   * @param storage - Unstorage instance
+   * @param ttl - Optional time-to-live in seconds
+   */
+  constructor(storage: Storage, ttl?: number);
+  /**
+   * Serializes a Response object for storage.
+   *
+   * Converts Response to a plain object with text body.
+   * Optimized for API responses (JSON, text, HTML).
+   *
+   * @param response - Response to serialize
+   * @returns Serialized response object
+   */
+  private serializeResponse;
+  /**
+   * Deserializes a cached response back to Response object.
+   *
+   * @param cached - Serialized response
+   * @returns Reconstructed Response object
+   */
+  private deserializeResponse;
+  /**
+   * Retrieves a cached response by key.
+   *
+   * Returns null if:
+   * - Entry doesn't exist
+   * - Entry has expired (based on TTL)
+   *
+   * @param key - Cache key
+   * @returns Cached Response or null
+   */
+  get(key: string): Promise<Response | null>;
+  /**
+   * Stores a Response in cache.
+   *
+   * @param key - Cache key
+   * @param response - Response to cache
+   */
+  set(key: string, response: Response): Promise<void>;
+  /**
+   * Checks if a key exists in cache and is not expired.
+   *
+   * @param key - Cache key
+   * @returns True if key exists and is valid
+   */
+  has(key: string): Promise<boolean>;
+  /**
+   * Deletes a cached entry.
+   *
+   * @param key - Cache key
+   */
+  delete(key: string): Promise<void>;
+  /**
+   * Clears all cached entries.
+   */
+  clear(): Promise<void>;
+  /**
+   * Gets all cache keys.
+   *
+   * @returns Array of cache keys
+   */
+  keys(): Promise<string[]>;
+}
+//#endregion
+//#region src/index.d.ts
+/**
+ * Universal cache middleware for Hono.
+ *
+ * Caches responses using unstorage for cross-runtime compatibility.
+ * Works with Cloudflare Workers, Vercel Edge, Node.js, Bun, Deno, and more.
+ *
+ * @param options - Cache configuration options
+ * @returns Hono middleware handler
+ *
+ * @example
+ * ```ts
+ * import { Hono } from 'hono'
+ * import { universalCache } from 'hono-universal-cache'
+ *
+ * const app = new Hono()
+ *
+ * app.use('*', universalCache({
+ *   cacheName: 'my-app-cache',
+ *   ttl: 3600
+ * }))
+ * ```
+ */
+declare const universalCache: (options: CacheOptions) => MiddlewareHandler;
+//#endregion
+export { CacheManager, type CacheMetadata, type CacheOptions, type CachedResponse, universalCache };

package/dist/index.mjs

@@ -0,0 +1,248 @@
+import { createStorage } from "unstorage";
+import { getRuntimeKey } from "hono/adapter";
+
+//#region src/utils.ts
+/**
+* Generates a cache key for the given context.
+* 
+* @param c - Hono context
+* @param keyGenerator - Optional custom key generator function
+* @returns Cache key string
+*/
+async function generateCacheKey(c, keyGenerator) {
+	if (keyGenerator) return await keyGenerator(c);
+	return c.req.url;
+}
+/**
+* Checks if a status code is cacheable.
+* 
+* @param status - HTTP status code
+* @param cacheableStatusCodes - Set of allowed status codes
+* @returns True if status code is cacheable
+*/
+function isCacheableStatus(status, cacheableStatusCodes) {
+	return cacheableStatusCodes.has(status);
+}
+/**
+* Checks if a cached entry has expired based on TTL.
+* 
+* @param cachedAt - Timestamp when entry was cached (Unix epoch ms)
+* @param ttl - Time-to-live in seconds
+* @returns True if entry has expired
+*/
+function isExpired(cachedAt, ttl) {
+	if (!ttl) return false;
+	return Date.now() > cachedAt + ttl * 1e3;
+}
+
+//#endregion
+//#region src/cache.ts
+/**
+* CacheManager handles Response serialization, storage, and retrieval.
+* 
+* Wraps unstorage to provide Response-specific caching with TTL support.
+* Designed for API responses (JSON, text, HTML) - not binary assets.
+*/
+var CacheManager = class {
+	storage;
+	ttl;
+	/**
+	* Creates a new CacheManager instance.
+	* 
+	* @param storage - Unstorage instance
+	* @param ttl - Optional time-to-live in seconds
+	*/
+	constructor(storage, ttl) {
+		this.storage = storage;
+		this.ttl = ttl;
+	}
+	/**
+	* Serializes a Response object for storage.
+	* 
+	* Converts Response to a plain object with text body.
+	* Optimized for API responses (JSON, text, HTML).
+	* 
+	* @param response - Response to serialize
+	* @returns Serialized response object
+	*/
+	async serializeResponse(response) {
+		const body = await response.text();
+		const headers = {};
+		response.headers.forEach((value, key) => {
+			headers[key] = value;
+		});
+		return {
+			body,
+			headers,
+			status: response.status,
+			statusText: response.statusText,
+			cachedAt: Date.now()
+		};
+	}
+	/**
+	* Deserializes a cached response back to Response object.
+	* 
+	* @param cached - Serialized response
+	* @returns Reconstructed Response object
+	*/
+	deserializeResponse(cached) {
+		const headers = new Headers(cached.headers);
+		const body = cached.status === 204 || cached.status === 205 ? null : cached.body;
+		return new Response(body, {
+			status: cached.status,
+			statusText: cached.statusText,
+			headers
+		});
+	}
+	/**
+	* Retrieves a cached response by key.
+	* 
+	* Returns null if:
+	* - Entry doesn't exist
+	* - Entry has expired (based on TTL)
+	* 
+	* @param key - Cache key
+	* @returns Cached Response or null
+	*/
+	async get(key) {
+		try {
+			const cached = await this.storage.getItem(key);
+			if (!cached) return null;
+			if (isExpired(cached.cachedAt, this.ttl)) {
+				await this.delete(key);
+				return null;
+			}
+			return this.deserializeResponse(cached);
+		} catch (error) {
+			console.error("Cache retrieval error:", error);
+			return null;
+		}
+	}
+	/**
+	* Stores a Response in cache.
+	* 
+	* @param key - Cache key
+	* @param response - Response to cache
+	*/
+	async set(key, response) {
+		try {
+			const serialized = await this.serializeResponse(response);
+			await this.storage.setItem(key, serialized);
+			if (this.ttl) {
+				const metadata = {
+					mtime: new Date(serialized.cachedAt),
+					expires: serialized.cachedAt + this.ttl * 1e3
+				};
+				await this.storage.setMeta(key, metadata);
+			}
+		} catch (error) {
+			console.error("Cache storage error:", error);
+		}
+	}
+	/**
+	* Checks if a key exists in cache and is not expired.
+	* 
+	* @param key - Cache key
+	* @returns True if key exists and is valid
+	*/
+	async has(key) {
+		try {
+			const cached = await this.storage.getItem(key);
+			if (!cached) return false;
+			return !isExpired(cached.cachedAt, this.ttl);
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Deletes a cached entry.
+	* 
+	* @param key - Cache key
+	*/
+	async delete(key) {
+		try {
+			await this.storage.removeItem(key);
+		} catch (error) {
+			console.error("Cache deletion error:", error);
+		}
+	}
+	/**
+	* Clears all cached entries.
+	*/
+	async clear() {
+		try {
+			await this.storage.clear();
+		} catch (error) {
+			console.error("Cache clear error:", error);
+		}
+	}
+	/**
+	* Gets all cache keys.
+	* 
+	* @returns Array of cache keys
+	*/
+	async keys() {
+		try {
+			return await this.storage.getKeys();
+		} catch (error) {
+			console.error("Cache keys retrieval error:", error);
+			return [];
+		}
+	}
+};
+
+//#endregion
+//#region src/types.ts
+/**
+* Status codes that can be cached by default.
+*/
+const DEFAULT_CACHEABLE_STATUS_CODES = [200];
+
+//#endregion
+//#region src/index.ts
+/**
+* Universal cache middleware for Hono.
+* 
+* Caches responses using unstorage for cross-runtime compatibility.
+* Works with Cloudflare Workers, Vercel Edge, Node.js, Bun, Deno, and more.
+* 
+* @param options - Cache configuration options
+* @returns Hono middleware handler
+* 
+* @example
+* ```ts
+* import { Hono } from 'hono'
+* import { universalCache } from 'hono-universal-cache'
+* 
+* const app = new Hono()
+* 
+* app.use('*', universalCache({
+*   cacheName: 'my-app-cache',
+*   ttl: 3600
+* }))
+* ```
+*/
+const universalCache = (options) => {
+	let storage = options.storage;
+	if (!storage) {
+		console.warn("No storage provided, using default in-memory storage");
+		storage = createStorage();
+	}
+	const cacheManager = new CacheManager(storage, options.ttl);
+	const cacheableStatusCodes = new Set(options.cacheableStatusCodes ?? DEFAULT_CACHEABLE_STATUS_CODES);
+	return async (c, next) => {
+		const baseKey = await generateCacheKey(c, options.keyGenerator);
+		const key = `${typeof options.cacheName === "function" ? await options.cacheName(c) : options.cacheName}:${baseKey}`;
+		const cachedResponse = await cacheManager.get(key);
+		if (cachedResponse) return new Response(cachedResponse.body, cachedResponse);
+		await next();
+		if (!isCacheableStatus(c.res.status, cacheableStatusCodes)) return;
+		const res = c.res.clone();
+		const cachePromise = cacheManager.set(key, res);
+		if (getRuntimeKey() === "workerd") c?.executionCtx?.waitUntil?.(cachePromise);
+		else await cachePromise;
+	};
+};
+
+//#endregion
+export { CacheManager, universalCache };

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "hono-universal-cache",
+  "type": "module",
+  "version": "0.1.2",
+  "description": "Universal cache middleware for Hono powered by unstorage - works across Cloudflare Workers, Vercel Edge, Node.js, Bun, Deno, and more.",
+  "author": "Anas Mohammed",
+  "license": "MIT",
+  "homepage": "https://github.com/anasmohammed361/hono-universal-cache#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/anasmohammed361/hono-universal-cache.git"
+  },
+  "bugs": {
+    "url": "https://github.com/anasmohammed361/hono-universal-cache/issues"
+  },
+  "keywords": [
+    "hono",
+    "cache",
+    "middleware",
+    "universal",
+    "unstorage",
+    "cloudflare",
+    "vercel",
+    "edge",
+    "workers",
+    "redis",
+    "kv"
+  ],
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "bumpp": "^10.3.2",
+    "hono": "^4.11.3",
+    "tsdown": "^0.18.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  },
+  "dependencies": {
+    "unstorage": "^1.17.3"
+  },
+  "peerDependencies": {
+    "hono": ">=4.0.0"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "release": "pnpm build && pnpm typecheck && bumpp && pnpm run release:publish",
+    "release:publish": "gh release create v$(node -p \"require('./package.json').version\") --generate-notes"
+  }
+}