@workkit/hono 0.0.1

package/README.md

@@ -0,0 +1,87 @@
+# @workkit/hono
+
+> Hono middleware for env validation, error handling, rate limiting, and caching
+
+[![npm](https://img.shields.io/npm/v/@workkit/hono)](https://www.npmjs.com/package/@workkit/hono)
+[![bundle size](https://img.shields.io/bundlephobia/minzip/@workkit/hono)](https://bundlephobia.com/package/@workkit/hono)
+
+## Install
+
+```bash
+bun add @workkit/hono hono
+```
+
+## Usage
+
+### Before (manual Hono setup)
+
+```ts
+import { Hono } from "hono"
+
+const app = new Hono()
+
+app.use("*", async (c, next) => {
+  // Manual env validation on every request
+  if (!c.env.API_KEY) return c.text("Missing API_KEY", 500)
+  await next()
+})
+
+app.onError((err, c) => {
+  // Generic error handling — lose structured error info
+  return c.json({ error: err.message }, 500)
+})
+```
+
+### After (workkit hono)
+
+```ts
+import { Hono } from "hono"
+import { workkit, workkitErrorHandler, rateLimit, cacheResponse } from "@workkit/hono"
+import { z } from "zod"
+
+const app = new Hono()
+
+// Validate env on first request — typed and cached
+app.use(workkit({ env: { API_KEY: z.string().min(1), DB: z.any() } }))
+
+// Structured error handling — WorkkitErrors become proper JSON responses
+app.onError(workkitErrorHandler())
+
+// KV-backed rate limiting
+app.use("/api/*", rateLimit({ limit: 100, window: "1m" }))
+
+// Response caching
+app.use("/api/public/*", cacheResponse({ ttl: 300 }))
+
+app.get("/", (c) => {
+  const env = c.get("workkit:env") // fully typed
+  return c.json({ key: env.API_KEY })
+})
+```
+
+## API
+
+### Middleware
+
+- **`workkit(options)`** — Validate environment bindings. Stores typed env in `c.get("workkit:env")`.
+
+### Error Handling
+
+- **`workkitErrorHandler(options?)`** — Convert `WorkkitError` instances to structured JSON responses with proper status codes.
+
+### Rate Limiting
+
+- **`rateLimit(options)`** — KV-backed rate limiting middleware. Options: `limit`, `window`, `keyFn?`
+- **`fixedWindow(options)`** — Fixed window rate limiter (lower-level)
+
+### Caching
+
+- **`cacheResponse(options)`** — Cache responses using the Cache API. Options: `ttl`, `vary?`
+
+### Helpers
+
+- **`getEnv(c)`** — Get validated env from Hono context (shorthand for `c.get("workkit:env")`)
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,209 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  workkitErrorHandler: () => workkitErrorHandler,
+  workkit: () => workkit,
+  rateLimit: () => rateLimit,
+  parseDuration: () => parseDuration,
+  getEnv: () => getEnv,
+  fixedWindow: () => fixedWindow,
+  cacheResponse: () => cacheResponse
+});
+module.exports = __toCommonJS(exports_src);
+
+// src/middleware.ts
+var import_env = require("@workkit/env");
+function workkit(options) {
+  let cachedEnv = null;
+  return async (c, next) => {
+    if (!cachedEnv) {
+      const rawEnv = c.env;
+      cachedEnv = await import_env.parseEnv(rawEnv, options.env);
+    }
+    c.set("workkit:env", cachedEnv);
+    c.set("workkit:envValidated", true);
+    await next();
+  };
+}
+// src/error-handler.ts
+var import_errors = require("@workkit/errors");
+function workkitErrorHandler(options = {}) {
+  const { includeStack = false, onError } = options;
+  return async (err, c) => {
+    if (onError) {
+      try {
+        await onError(err, c);
+      } catch {}
+    }
+    if (import_errors.isWorkkitError(err)) {
+      return workkitErrorToResponse(err, includeStack);
+    }
+    const wrapped = new import_errors.InternalError(err instanceof Error ? err.message : "An unexpected error occurred", { cause: err });
+    return workkitErrorToResponse(wrapped, includeStack);
+  };
+}
+function workkitErrorToResponse(error, includeStack) {
+  const body = {
+    error: {
+      code: error.code,
+      message: error.message,
+      statusCode: error.statusCode
+    }
+  };
+  if ("issues" in error && Array.isArray(error.issues)) {
+    body.error.issues = error.issues;
+  }
+  if (includeStack && error.stack) {
+    body.error.stack = error.stack;
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (error instanceof import_errors.RateLimitError && error.retryAfterMs) {
+    headers["Retry-After"] = String(Math.ceil(error.retryAfterMs / 1000));
+  }
+  return new Response(JSON.stringify(body), {
+    status: error.statusCode,
+    headers
+  });
+}
+// src/rate-limit.ts
+var import_errors2 = require("@workkit/errors");
+function rateLimit(options) {
+  const { limiter, keyFn, onRateLimited } = options;
+  return async (c, next) => {
+    const key = await keyFn(c);
+    const result = await limiter.check(key);
+    c.header("X-RateLimit-Limit", String(result.remaining + (result.allowed ? 0 : 1)));
+    c.header("X-RateLimit-Remaining", String(result.remaining));
+    c.header("X-RateLimit-Reset", String(Math.ceil(result.resetAt / 1000)));
+    if (!result.allowed) {
+      if (onRateLimited) {
+        return onRateLimited(c, result);
+      }
+      const retryAfterMs = result.resetAt - Date.now();
+      throw new import_errors2.RateLimitError("Rate limit exceeded", retryAfterMs > 0 ? retryAfterMs : undefined);
+    }
+    await next();
+  };
+}
+function parseDuration(duration) {
+  const match = duration.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) {
+    throw new Error(`Invalid duration format: "${duration}". Use e.g. '1m', '5m', '1h', '1d'.`);
+  }
+  const value = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  switch (unit) {
+    case "s":
+      return value * 1000;
+    case "m":
+      return value * 60 * 1000;
+    case "h":
+      return value * 60 * 60 * 1000;
+    case "d":
+      return value * 24 * 60 * 60 * 1000;
+    default:
+      throw new Error(`Unknown duration unit: "${unit}"`);
+  }
+}
+function fixedWindow(options) {
+  const { namespace, limit, window: windowStr, prefix = "rl:" } = options;
+  const windowMs = parseDuration(windowStr);
+  return {
+    async check(key) {
+      const now = Date.now();
+      const windowStart = Math.floor(now / windowMs) * windowMs;
+      const resetAt = windowStart + windowMs;
+      const kvKey = `${prefix}${key}:${windowStart}`;
+      const current = await namespace.get(kvKey);
+      const count = current ? Number.parseInt(current, 10) : 0;
+      if (count >= limit) {
+        return { allowed: false, remaining: 0, resetAt };
+      }
+      const ttlSeconds = Math.ceil(windowMs / 1000);
+      await namespace.put(kvKey, String(count + 1), {
+        expirationTtl: ttlSeconds
+      });
+      return { allowed: true, remaining: limit - count - 1, resetAt };
+    }
+  };
+}
+// src/cache.ts
+function cacheResponse(options) {
+  const { ttl, keyFn, methods = ["GET"] } = options;
+  return async (c, next) => {
+    if (!methods.includes(c.req.method)) {
+      await next();
+      return;
+    }
+    const cacheKey = keyFn ? keyFn(c) : c.req.url;
+    const cacheRequest = new Request(cacheKey);
+    const cache = options.cache ?? (typeof caches !== "undefined" ? caches.default : null);
+    if (!cache) {
+      await next();
+      return;
+    }
+    const cached = await cache.match(cacheRequest);
+    if (cached) {
+      return cached;
+    }
+    await next();
+    const response = c.res;
+    if (response.status >= 200 && response.status < 300) {
+      const cloned = response.clone();
+      const cachedResponse = new Response(cloned.body, {
+        status: cloned.status,
+        statusText: cloned.statusText,
+        headers: new Headers(cloned.headers)
+      });
+      cachedResponse.headers.set("Cache-Control", `s-maxage=${ttl}`);
+      const putPromise = cache.put(cacheRequest, cachedResponse);
+      try {
+        c.executionCtx.waitUntil(putPromise);
+      } catch {
+        await putPromise;
+      }
+    }
+  };
+}
+// src/helpers.ts
+function getEnv(c) {
+  const validated = c.get("workkit:envValidated");
+  if (!validated) {
+    throw new Error("workkit:env is not available. Did you forget to add the workkit() middleware?");
+  }
+  return c.get("workkit:env");
+}
+
+//# debugId=4C2D147FF9900DA464756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.d.cts

@@ -0,0 +1,186 @@
+import { EnvSchema as EnvSchema2 } from "@workkit/env";
+import { MiddlewareHandler } from "hono";
+import { EnvSchema, InferEnv } from "@workkit/env";
+import { Context, Env } from "hono";
+/**
+* Options for the workkit() middleware.
+*/
+interface WorkkitOptions<T extends EnvSchema> {
+	/** Environment schema to validate against on first request */
+	env: T;
+}
+/**
+* Options for the workkitErrorHandler.
+*/
+interface ErrorHandlerOptions {
+	/** Include stack trace in error response (never in production) */
+	includeStack?: boolean;
+	/** Custom error callback for logging/reporting */
+	onError?: (err: Error, c: Context) => void | Promise<void>;
+}
+/**
+* A rate limiter instance that checks whether a key is allowed.
+*/
+interface RateLimiter {
+	/** Check if the key is allowed. Returns { allowed, remaining, resetAt } */
+	check(key: string): Promise<RateLimitResult>;
+}
+/**
+* Result of a rate limit check.
+*/
+interface RateLimitResult {
+	/** Whether the request is allowed */
+	allowed: boolean;
+	/** Remaining requests in the current window */
+	remaining: number;
+	/** When the window resets (ms since epoch) */
+	resetAt: number;
+}
+/**
+* Options for the rateLimit middleware.
+*/
+interface RateLimitOptions {
+	/** The rate limiter implementation */
+	limiter: RateLimiter;
+	/** Function to extract the rate limit key from context (e.g., IP address) */
+	keyFn: (c: Context) => string | Promise<string>;
+	/** Custom response when rate limited (optional) */
+	onRateLimited?: (c: Context, result: RateLimitResult) => Response | Promise<Response>;
+}
+/**
+* Options for fixed-window rate limiter.
+*/
+interface FixedWindowOptions {
+	/** KV namespace for storing counters */
+	namespace: KVNamespace;
+	/** Maximum requests per window */
+	limit: number;
+	/** Window duration — e.g. '1m', '5m', '1h', '1d' */
+	window: string;
+	/** Optional prefix for KV keys */
+	prefix?: string;
+}
+/**
+* Options for the cacheResponse middleware.
+*/
+interface CacheOptions {
+	/** Cache TTL in seconds */
+	ttl: number;
+	/** Function to generate the cache key (defaults to request URL) */
+	keyFn?: (c: Context) => string;
+	/** Cache API instance (defaults to caches.default) */
+	cache?: Cache;
+	/** HTTP methods to cache (defaults to ['GET']) */
+	methods?: string[];
+}
+/**
+* Hono environment type with workkit context variables.
+*/
+interface WorkkitEnv<T extends EnvSchema = EnvSchema> extends Env {
+	Variables: {
+		"workkit:env": InferEnv<T>;
+		"workkit:envValidated": boolean;
+	};
+}
+/**
+* Main workkit middleware — validates environment bindings on first request
+* and stores the parsed, typed env in Hono's context.
+*
+* Validation runs once (on the first request) and the result is cached
+* for subsequent requests within the same Worker invocation.
+*
+* @example
+* ```ts
+* const app = new Hono()
+* app.use(workkit({ env: { API_KEY: z.string().min(1) } }))
+* app.get('/', (c) => {
+*   const env = c.get('workkit:env') // typed
+* })
+* ```
+*/
+declare function workkit<T extends EnvSchema2>(options: WorkkitOptions<T>): MiddlewareHandler<WorkkitEnv<T>>;
+import { ErrorHandler } from "hono";
+/**
+* Hono error handler that converts WorkkitErrors to proper HTTP responses.
+*
+* - WorkkitError instances → structured JSON with their status code
+* - RateLimitError → includes Retry-After header
+* - ValidationError → includes issues array
+* - Unknown errors → 500 Internal Server Error
+*
+* @example
+* ```ts
+* app.onError(workkitErrorHandler({
+*   includeStack: false,
+*   onError: (err, c) => console.error(err),
+* }))
+* ```
+*/
+declare function workkitErrorHandler(options?: ErrorHandlerOptions): ErrorHandler;
+import { MiddlewareHandler as MiddlewareHandler2 } from "hono";
+/**
+* Rate limit middleware for Hono.
+*
+* @example
+* ```ts
+* app.use('/api/*', rateLimit({
+*   limiter: fixedWindow({ namespace: env.KV, limit: 100, window: '1m' }),
+*   keyFn: (c) => c.req.header('CF-Connecting-IP') ?? 'unknown',
+* }))
+* ```
+*/
+declare function rateLimit(options: RateLimitOptions): MiddlewareHandler2;
+/**
+* Parse a duration string like '1m', '5m', '1h', '1d' into milliseconds.
+*/
+declare function parseDuration(duration: string): number;
+/**
+* Creates a fixed-window rate limiter backed by KV.
+*
+* Each window is stored as a KV key with an expiration TTL.
+* Uses KV's eventual consistency — suitable for soft rate limiting,
+* not cryptographic precision.
+*
+* @example
+* ```ts
+* const limiter = fixedWindow({
+*   namespace: env.RATE_LIMIT_KV,
+*   limit: 100,
+*   window: '1m',
+* })
+* ```
+*/
+declare function fixedWindow(options: FixedWindowOptions): RateLimiter;
+import { MiddlewareHandler as MiddlewareHandler3 } from "hono";
+/**
+* Cache middleware for Hono — caches responses using the Cache API.
+*
+* Only caches successful (2xx) responses. Serves cached responses on cache hit.
+* Uses Cloudflare's Cache API by default.
+*
+* @example
+* ```ts
+* app.get('/api/data', cacheResponse({ ttl: 300 }), async (c) => {
+*   return c.json(await fetchData())
+* })
+* ```
+*/
+declare function cacheResponse(options: CacheOptions): MiddlewareHandler3;
+import { EnvSchema as EnvSchema3, InferEnv as InferEnv2 } from "@workkit/env";
+import { Context as Context2 } from "hono";
+/**
+* Get the validated, typed environment from Hono context.
+*
+* Requires the workkit() middleware to have run first.
+* Throws if env has not been validated yet.
+*
+* @example
+* ```ts
+* app.get('/test', (c) => {
+*   const env = getEnv(c)
+*   return c.json({ key: env.API_KEY })
+* })
+* ```
+*/
+declare function getEnv<T extends EnvSchema3>(c: Context2<WorkkitEnv<T>>): InferEnv2<T>;
+export { workkitErrorHandler, workkit, rateLimit, parseDuration, getEnv, fixedWindow, cacheResponse, WorkkitOptions, WorkkitEnv, RateLimiter, RateLimitResult, RateLimitOptions, FixedWindowOptions, ErrorHandlerOptions, CacheOptions };

package/dist/index.d.ts

@@ -0,0 +1,186 @@
+import { EnvSchema as EnvSchema2 } from "@workkit/env";
+import { MiddlewareHandler } from "hono";
+import { EnvSchema, InferEnv } from "@workkit/env";
+import { Context, Env } from "hono";
+/**
+* Options for the workkit() middleware.
+*/
+interface WorkkitOptions<T extends EnvSchema> {
+	/** Environment schema to validate against on first request */
+	env: T;
+}
+/**
+* Options for the workkitErrorHandler.
+*/
+interface ErrorHandlerOptions {
+	/** Include stack trace in error response (never in production) */
+	includeStack?: boolean;
+	/** Custom error callback for logging/reporting */
+	onError?: (err: Error, c: Context) => void | Promise<void>;
+}
+/**
+* A rate limiter instance that checks whether a key is allowed.
+*/
+interface RateLimiter {
+	/** Check if the key is allowed. Returns { allowed, remaining, resetAt } */
+	check(key: string): Promise<RateLimitResult>;
+}
+/**
+* Result of a rate limit check.
+*/
+interface RateLimitResult {
+	/** Whether the request is allowed */
+	allowed: boolean;
+	/** Remaining requests in the current window */
+	remaining: number;
+	/** When the window resets (ms since epoch) */
+	resetAt: number;
+}
+/**
+* Options for the rateLimit middleware.
+*/
+interface RateLimitOptions {
+	/** The rate limiter implementation */
+	limiter: RateLimiter;
+	/** Function to extract the rate limit key from context (e.g., IP address) */
+	keyFn: (c: Context) => string | Promise<string>;
+	/** Custom response when rate limited (optional) */
+	onRateLimited?: (c: Context, result: RateLimitResult) => Response | Promise<Response>;
+}
+/**
+* Options for fixed-window rate limiter.
+*/
+interface FixedWindowOptions {
+	/** KV namespace for storing counters */
+	namespace: KVNamespace;
+	/** Maximum requests per window */
+	limit: number;
+	/** Window duration — e.g. '1m', '5m', '1h', '1d' */
+	window: string;
+	/** Optional prefix for KV keys */
+	prefix?: string;
+}
+/**
+* Options for the cacheResponse middleware.
+*/
+interface CacheOptions {
+	/** Cache TTL in seconds */
+	ttl: number;
+	/** Function to generate the cache key (defaults to request URL) */
+	keyFn?: (c: Context) => string;
+	/** Cache API instance (defaults to caches.default) */
+	cache?: Cache;
+	/** HTTP methods to cache (defaults to ['GET']) */
+	methods?: string[];
+}
+/**
+* Hono environment type with workkit context variables.
+*/
+interface WorkkitEnv<T extends EnvSchema = EnvSchema> extends Env {
+	Variables: {
+		"workkit:env": InferEnv<T>;
+		"workkit:envValidated": boolean;
+	};
+}
+/**
+* Main workkit middleware — validates environment bindings on first request
+* and stores the parsed, typed env in Hono's context.
+*
+* Validation runs once (on the first request) and the result is cached
+* for subsequent requests within the same Worker invocation.
+*
+* @example
+* ```ts
+* const app = new Hono()
+* app.use(workkit({ env: { API_KEY: z.string().min(1) } }))
+* app.get('/', (c) => {
+*   const env = c.get('workkit:env') // typed
+* })
+* ```
+*/
+declare function workkit<T extends EnvSchema2>(options: WorkkitOptions<T>): MiddlewareHandler<WorkkitEnv<T>>;
+import { ErrorHandler } from "hono";
+/**
+* Hono error handler that converts WorkkitErrors to proper HTTP responses.
+*
+* - WorkkitError instances → structured JSON with their status code
+* - RateLimitError → includes Retry-After header
+* - ValidationError → includes issues array
+* - Unknown errors → 500 Internal Server Error
+*
+* @example
+* ```ts
+* app.onError(workkitErrorHandler({
+*   includeStack: false,
+*   onError: (err, c) => console.error(err),
+* }))
+* ```
+*/
+declare function workkitErrorHandler(options?: ErrorHandlerOptions): ErrorHandler;
+import { MiddlewareHandler as MiddlewareHandler2 } from "hono";
+/**
+* Rate limit middleware for Hono.
+*
+* @example
+* ```ts
+* app.use('/api/*', rateLimit({
+*   limiter: fixedWindow({ namespace: env.KV, limit: 100, window: '1m' }),
+*   keyFn: (c) => c.req.header('CF-Connecting-IP') ?? 'unknown',
+* }))
+* ```
+*/
+declare function rateLimit(options: RateLimitOptions): MiddlewareHandler2;
+/**
+* Parse a duration string like '1m', '5m', '1h', '1d' into milliseconds.
+*/
+declare function parseDuration(duration: string): number;
+/**
+* Creates a fixed-window rate limiter backed by KV.
+*
+* Each window is stored as a KV key with an expiration TTL.
+* Uses KV's eventual consistency — suitable for soft rate limiting,
+* not cryptographic precision.
+*
+* @example
+* ```ts
+* const limiter = fixedWindow({
+*   namespace: env.RATE_LIMIT_KV,
+*   limit: 100,
+*   window: '1m',
+* })
+* ```
+*/
+declare function fixedWindow(options: FixedWindowOptions): RateLimiter;
+import { MiddlewareHandler as MiddlewareHandler3 } from "hono";
+/**
+* Cache middleware for Hono — caches responses using the Cache API.
+*
+* Only caches successful (2xx) responses. Serves cached responses on cache hit.
+* Uses Cloudflare's Cache API by default.
+*
+* @example
+* ```ts
+* app.get('/api/data', cacheResponse({ ttl: 300 }), async (c) => {
+*   return c.json(await fetchData())
+* })
+* ```
+*/
+declare function cacheResponse(options: CacheOptions): MiddlewareHandler3;
+import { EnvSchema as EnvSchema3, InferEnv as InferEnv2 } from "@workkit/env";
+import { Context as Context2 } from "hono";
+/**
+* Get the validated, typed environment from Hono context.
+*
+* Requires the workkit() middleware to have run first.
+* Throws if env has not been validated yet.
+*
+* @example
+* ```ts
+* app.get('/test', (c) => {
+*   const env = getEnv(c)
+*   return c.json({ key: env.API_KEY })
+* })
+* ```
+*/
+declare function getEnv<T extends EnvSchema3>(c: Context2<WorkkitEnv<T>>): InferEnv2<T>;
+export { workkitErrorHandler, workkit, rateLimit, parseDuration, getEnv, fixedWindow, cacheResponse, WorkkitOptions, WorkkitEnv, RateLimiter, RateLimitResult, RateLimitOptions, FixedWindowOptions, ErrorHandlerOptions, CacheOptions };

package/dist/index.js

@@ -0,0 +1,176 @@
+// src/middleware.ts
+import { parseEnv } from "@workkit/env";
+function workkit(options) {
+  let cachedEnv = null;
+  return async (c, next) => {
+    if (!cachedEnv) {
+      const rawEnv = c.env;
+      cachedEnv = await parseEnv(rawEnv, options.env);
+    }
+    c.set("workkit:env", cachedEnv);
+    c.set("workkit:envValidated", true);
+    await next();
+  };
+}
+// src/error-handler.ts
+import { InternalError, RateLimitError, isWorkkitError } from "@workkit/errors";
+function workkitErrorHandler(options = {}) {
+  const { includeStack = false, onError } = options;
+  return async (err, c) => {
+    if (onError) {
+      try {
+        await onError(err, c);
+      } catch {}
+    }
+    if (isWorkkitError(err)) {
+      return workkitErrorToResponse(err, includeStack);
+    }
+    const wrapped = new InternalError(err instanceof Error ? err.message : "An unexpected error occurred", { cause: err });
+    return workkitErrorToResponse(wrapped, includeStack);
+  };
+}
+function workkitErrorToResponse(error, includeStack) {
+  const body = {
+    error: {
+      code: error.code,
+      message: error.message,
+      statusCode: error.statusCode
+    }
+  };
+  if ("issues" in error && Array.isArray(error.issues)) {
+    body.error.issues = error.issues;
+  }
+  if (includeStack && error.stack) {
+    body.error.stack = error.stack;
+  }
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (error instanceof RateLimitError && error.retryAfterMs) {
+    headers["Retry-After"] = String(Math.ceil(error.retryAfterMs / 1000));
+  }
+  return new Response(JSON.stringify(body), {
+    status: error.statusCode,
+    headers
+  });
+}
+// src/rate-limit.ts
+import { RateLimitError as RateLimitError2 } from "@workkit/errors";
+function rateLimit(options) {
+  const { limiter, keyFn, onRateLimited } = options;
+  return async (c, next) => {
+    const key = await keyFn(c);
+    const result = await limiter.check(key);
+    c.header("X-RateLimit-Limit", String(result.remaining + (result.allowed ? 0 : 1)));
+    c.header("X-RateLimit-Remaining", String(result.remaining));
+    c.header("X-RateLimit-Reset", String(Math.ceil(result.resetAt / 1000)));
+    if (!result.allowed) {
+      if (onRateLimited) {
+        return onRateLimited(c, result);
+      }
+      const retryAfterMs = result.resetAt - Date.now();
+      throw new RateLimitError2("Rate limit exceeded", retryAfterMs > 0 ? retryAfterMs : undefined);
+    }
+    await next();
+  };
+}
+function parseDuration(duration) {
+  const match = duration.match(/^(\d+)(s|m|h|d)$/);
+  if (!match) {
+    throw new Error(`Invalid duration format: "${duration}". Use e.g. '1m', '5m', '1h', '1d'.`);
+  }
+  const value = Number.parseInt(match[1], 10);
+  const unit = match[2];
+  switch (unit) {
+    case "s":
+      return value * 1000;
+    case "m":
+      return value * 60 * 1000;
+    case "h":
+      return value * 60 * 60 * 1000;
+    case "d":
+      return value * 24 * 60 * 60 * 1000;
+    default:
+      throw new Error(`Unknown duration unit: "${unit}"`);
+  }
+}
+function fixedWindow(options) {
+  const { namespace, limit, window: windowStr, prefix = "rl:" } = options;
+  const windowMs = parseDuration(windowStr);
+  return {
+    async check(key) {
+      const now = Date.now();
+      const windowStart = Math.floor(now / windowMs) * windowMs;
+      const resetAt = windowStart + windowMs;
+      const kvKey = `${prefix}${key}:${windowStart}`;
+      const current = await namespace.get(kvKey);
+      const count = current ? Number.parseInt(current, 10) : 0;
+      if (count >= limit) {
+        return { allowed: false, remaining: 0, resetAt };
+      }
+      const ttlSeconds = Math.ceil(windowMs / 1000);
+      await namespace.put(kvKey, String(count + 1), {
+        expirationTtl: ttlSeconds
+      });
+      return { allowed: true, remaining: limit - count - 1, resetAt };
+    }
+  };
+}
+// src/cache.ts
+function cacheResponse(options) {
+  const { ttl, keyFn, methods = ["GET"] } = options;
+  return async (c, next) => {
+    if (!methods.includes(c.req.method)) {
+      await next();
+      return;
+    }
+    const cacheKey = keyFn ? keyFn(c) : c.req.url;
+    const cacheRequest = new Request(cacheKey);
+    const cache = options.cache ?? (typeof caches !== "undefined" ? caches.default : null);
+    if (!cache) {
+      await next();
+      return;
+    }
+    const cached = await cache.match(cacheRequest);
+    if (cached) {
+      return cached;
+    }
+    await next();
+    const response = c.res;
+    if (response.status >= 200 && response.status < 300) {
+      const cloned = response.clone();
+      const cachedResponse = new Response(cloned.body, {
+        status: cloned.status,
+        statusText: cloned.statusText,
+        headers: new Headers(cloned.headers)
+      });
+      cachedResponse.headers.set("Cache-Control", `s-maxage=${ttl}`);
+      const putPromise = cache.put(cacheRequest, cachedResponse);
+      try {
+        c.executionCtx.waitUntil(putPromise);
+      } catch {
+        await putPromise;
+      }
+    }
+  };
+}
+// src/helpers.ts
+function getEnv(c) {
+  const validated = c.get("workkit:envValidated");
+  if (!validated) {
+    throw new Error("workkit:env is not available. Did you forget to add the workkit() middleware?");
+  }
+  return c.get("workkit:env");
+}
+export {
+  workkitErrorHandler,
+  workkit,
+  rateLimit,
+  parseDuration,
+  getEnv,
+  fixedWindow,
+  cacheResponse
+};
+
+//# debugId=0CE4411E8BEEF18964756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,14 @@
+{
+  "version": 3,
+  "sources": ["src/middleware.ts", "src/error-handler.ts", "src/rate-limit.ts", "src/cache.ts", "src/helpers.ts"],
+  "sourcesContent": [
+    "import { parseEnv } from \"@workkit/env\";\nimport type { EnvSchema, InferEnv } from \"@workkit/env\";\nimport type { MiddlewareHandler } from \"hono\";\nimport type { WorkkitEnv, WorkkitOptions } from \"./types\";\n\n/**\n * Main workkit middleware — validates environment bindings on first request\n * and stores the parsed, typed env in Hono's context.\n *\n * Validation runs once (on the first request) and the result is cached\n * for subsequent requests within the same Worker invocation.\n *\n * @example\n * ```ts\n * const app = new Hono()\n * app.use(workkit({ env: { API_KEY: z.string().min(1) } }))\n * app.get('/', (c) => {\n *   const env = c.get('workkit:env') // typed\n * })\n * ```\n */\nexport function workkit<T extends EnvSchema>(\n\toptions: WorkkitOptions<T>,\n): MiddlewareHandler<WorkkitEnv<T>> {\n\tlet cachedEnv: InferEnv<T> | null = null;\n\n\treturn async (c, next) => {\n\t\tif (!cachedEnv) {\n\t\t\tconst rawEnv = c.env as Record<string, unknown>;\n\t\t\tcachedEnv = await parseEnv(rawEnv, options.env);\n\t\t}\n\n\t\tc.set(\"workkit:env\", cachedEnv);\n\t\tc.set(\"workkit:envValidated\", true);\n\n\t\tawait next();\n\t};\n}\n",
+    "import { InternalError, RateLimitError, type WorkkitError, isWorkkitError } from \"@workkit/errors\";\nimport type { ErrorHandler } from \"hono\";\nimport type { ErrorHandlerOptions } from \"./types\";\n\n/**\n * Hono error handler that converts WorkkitErrors to proper HTTP responses.\n *\n * - WorkkitError instances → structured JSON with their status code\n * - RateLimitError → includes Retry-After header\n * - ValidationError → includes issues array\n * - Unknown errors → 500 Internal Server Error\n *\n * @example\n * ```ts\n * app.onError(workkitErrorHandler({\n *   includeStack: false,\n *   onError: (err, c) => console.error(err),\n * }))\n * ```\n */\nexport function workkitErrorHandler(options: ErrorHandlerOptions = {}): ErrorHandler {\n\tconst { includeStack = false, onError } = options;\n\n\treturn async (err, c) => {\n\t\tif (onError) {\n\t\t\ttry {\n\t\t\t\tawait onError(err, c);\n\t\t\t} catch {\n\t\t\t\t// Don't let error callback failures break the response\n\t\t\t}\n\t\t}\n\n\t\tif (isWorkkitError(err)) {\n\t\t\treturn workkitErrorToResponse(err, includeStack);\n\t\t}\n\n\t\t// Wrap unknown errors as InternalError\n\t\tconst wrapped = new InternalError(\n\t\t\terr instanceof Error ? err.message : \"An unexpected error occurred\",\n\t\t\t{ cause: err },\n\t\t);\n\n\t\treturn workkitErrorToResponse(wrapped, includeStack);\n\t};\n}\n\nfunction workkitErrorToResponse(error: WorkkitError, includeStack: boolean): Response {\n\tconst body: Record<string, unknown> = {\n\t\terror: {\n\t\t\tcode: error.code,\n\t\t\tmessage: error.message,\n\t\t\tstatusCode: error.statusCode,\n\t\t},\n\t};\n\n\t// Include validation issues if present\n\tif (\"issues\" in error && Array.isArray((error as any).issues)) {\n\t\t(body.error as any).issues = (error as any).issues;\n\t}\n\n\tif (includeStack && error.stack) {\n\t\t(body.error as any).stack = error.stack;\n\t}\n\n\tconst headers: Record<string, string> = {\n\t\t\"Content-Type\": \"application/json\",\n\t};\n\n\t// Set Retry-After header for rate limit errors\n\tif (error instanceof RateLimitError && error.retryAfterMs) {\n\t\theaders[\"Retry-After\"] = String(Math.ceil(error.retryAfterMs / 1000));\n\t}\n\n\treturn new Response(JSON.stringify(body), {\n\t\tstatus: error.statusCode,\n\t\theaders,\n\t});\n}\n",
+    "import { RateLimitError } from \"@workkit/errors\";\nimport type { MiddlewareHandler } from \"hono\";\nimport type { FixedWindowOptions, RateLimitOptions, RateLimitResult, RateLimiter } from \"./types\";\n\n/**\n * Rate limit middleware for Hono.\n *\n * @example\n * ```ts\n * app.use('/api/*', rateLimit({\n *   limiter: fixedWindow({ namespace: env.KV, limit: 100, window: '1m' }),\n *   keyFn: (c) => c.req.header('CF-Connecting-IP') ?? 'unknown',\n * }))\n * ```\n */\nexport function rateLimit(options: RateLimitOptions): MiddlewareHandler {\n\tconst { limiter, keyFn, onRateLimited } = options;\n\n\treturn async (c, next) => {\n\t\tconst key = await keyFn(c);\n\t\tconst result = await limiter.check(key);\n\n\t\t// Set rate limit headers regardless of outcome\n\t\tc.header(\"X-RateLimit-Limit\", String(result.remaining + (result.allowed ? 0 : 1)));\n\t\tc.header(\"X-RateLimit-Remaining\", String(result.remaining));\n\t\tc.header(\"X-RateLimit-Reset\", String(Math.ceil(result.resetAt / 1000)));\n\n\t\tif (!result.allowed) {\n\t\t\tif (onRateLimited) {\n\t\t\t\treturn onRateLimited(c, result);\n\t\t\t}\n\n\t\t\tconst retryAfterMs = result.resetAt - Date.now();\n\t\t\tthrow new RateLimitError(\"Rate limit exceeded\", retryAfterMs > 0 ? retryAfterMs : undefined);\n\t\t}\n\n\t\tawait next();\n\t};\n}\n\n/**\n * Parse a duration string like '1m', '5m', '1h', '1d' into milliseconds.\n */\nexport function parseDuration(duration: string): number {\n\tconst match = duration.match(/^(\\d+)(s|m|h|d)$/);\n\tif (!match) {\n\t\tthrow new Error(`Invalid duration format: \"${duration}\". Use e.g. '1m', '5m', '1h', '1d'.`);\n\t}\n\n\tconst value = Number.parseInt(match[1]!, 10);\n\tconst unit = match[2]!;\n\n\tswitch (unit) {\n\t\tcase \"s\":\n\t\t\treturn value * 1000;\n\t\tcase \"m\":\n\t\t\treturn value * 60 * 1000;\n\t\tcase \"h\":\n\t\t\treturn value * 60 * 60 * 1000;\n\t\tcase \"d\":\n\t\t\treturn value * 24 * 60 * 60 * 1000;\n\t\tdefault:\n\t\t\tthrow new Error(`Unknown duration unit: \"${unit}\"`);\n\t}\n}\n\n/**\n * Creates a fixed-window rate limiter backed by KV.\n *\n * Each window is stored as a KV key with an expiration TTL.\n * Uses KV's eventual consistency — suitable for soft rate limiting,\n * not cryptographic precision.\n *\n * @example\n * ```ts\n * const limiter = fixedWindow({\n *   namespace: env.RATE_LIMIT_KV,\n *   limit: 100,\n *   window: '1m',\n * })\n * ```\n */\nexport function fixedWindow(options: FixedWindowOptions): RateLimiter {\n\tconst { namespace, limit, window: windowStr, prefix = \"rl:\" } = options;\n\tconst windowMs = parseDuration(windowStr);\n\n\treturn {\n\t\tasync check(key: string): Promise<RateLimitResult> {\n\t\t\tconst now = Date.now();\n\t\t\tconst windowStart = Math.floor(now / windowMs) * windowMs;\n\t\t\tconst resetAt = windowStart + windowMs;\n\t\t\tconst kvKey = `${prefix}${key}:${windowStart}`;\n\n\t\t\tconst current = await namespace.get(kvKey);\n\t\t\tconst count = current ? Number.parseInt(current, 10) : 0;\n\n\t\t\tif (count >= limit) {\n\t\t\t\treturn { allowed: false, remaining: 0, resetAt };\n\t\t\t}\n\n\t\t\t// Increment counter with TTL equal to window duration (in seconds, rounded up)\n\t\t\tconst ttlSeconds = Math.ceil(windowMs / 1000);\n\t\t\tawait namespace.put(kvKey, String(count + 1), {\n\t\t\t\texpirationTtl: ttlSeconds,\n\t\t\t});\n\n\t\t\treturn { allowed: true, remaining: limit - count - 1, resetAt };\n\t\t},\n\t};\n}\n",
+    "import type { MiddlewareHandler } from \"hono\";\nimport type { CacheOptions } from \"./types\";\n\n/**\n * Cache middleware for Hono — caches responses using the Cache API.\n *\n * Only caches successful (2xx) responses. Serves cached responses on cache hit.\n * Uses Cloudflare's Cache API by default.\n *\n * @example\n * ```ts\n * app.get('/api/data', cacheResponse({ ttl: 300 }), async (c) => {\n *   return c.json(await fetchData())\n * })\n * ```\n */\nexport function cacheResponse(options: CacheOptions): MiddlewareHandler {\n\tconst { ttl, keyFn, methods = [\"GET\"] } = options;\n\n\treturn async (c, next) => {\n\t\t// Only cache specified methods\n\t\tif (!methods.includes(c.req.method)) {\n\t\t\tawait next();\n\t\t\treturn;\n\t\t}\n\n\t\tconst cacheKey = keyFn ? keyFn(c) : c.req.url;\n\t\tconst cacheRequest = new Request(cacheKey);\n\n\t\t// Try to get the cache instance\n\t\tconst cache = options.cache ?? (typeof caches !== \"undefined\" ? caches.default : null);\n\t\tif (!cache) {\n\t\t\t// No cache available, skip caching\n\t\t\tawait next();\n\t\t\treturn;\n\t\t}\n\n\t\t// Check for cached response\n\t\tconst cached = await cache.match(cacheRequest);\n\t\tif (cached) {\n\t\t\treturn cached;\n\t\t}\n\n\t\t// Execute handler\n\t\tawait next();\n\n\t\t// Only cache successful responses\n\t\tconst response = c.res;\n\t\tif (response.status >= 200 && response.status < 300) {\n\t\t\t// Clone the response and add cache headers\n\t\t\tconst cloned = response.clone();\n\t\t\tconst cachedResponse = new Response(cloned.body, {\n\t\t\t\tstatus: cloned.status,\n\t\t\t\tstatusText: cloned.statusText,\n\t\t\t\theaders: new Headers(cloned.headers),\n\t\t\t});\n\t\t\tcachedResponse.headers.set(\"Cache-Control\", `s-maxage=${ttl}`);\n\n\t\t\t// Store in cache — use waitUntil if available, otherwise await directly\n\t\t\tconst putPromise = cache.put(cacheRequest, cachedResponse);\n\t\t\ttry {\n\t\t\t\tc.executionCtx.waitUntil(putPromise);\n\t\t\t} catch {\n\t\t\t\t// executionCtx not available (e.g., in tests), await directly\n\t\t\t\tawait putPromise;\n\t\t\t}\n\t\t}\n\t};\n}\n",
+    "import type { EnvSchema, InferEnv } from \"@workkit/env\";\nimport type { Context } from \"hono\";\nimport type { WorkkitEnv } from \"./types\";\n\n/**\n * Get the validated, typed environment from Hono context.\n *\n * Requires the workkit() middleware to have run first.\n * Throws if env has not been validated yet.\n *\n * @example\n * ```ts\n * app.get('/test', (c) => {\n *   const env = getEnv(c)\n *   return c.json({ key: env.API_KEY })\n * })\n * ```\n */\nexport function getEnv<T extends EnvSchema>(c: Context<WorkkitEnv<T>>): InferEnv<T> {\n\tconst validated = c.get(\"workkit:envValidated\");\n\tif (!validated) {\n\t\tthrow new Error(\n\t\t\t\"workkit:env is not available. Did you forget to add the workkit() middleware?\",\n\t\t);\n\t}\n\treturn c.get(\"workkit:env\");\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAyB,IAAzB;AAqBO,SAAS,OAA4B,CAC3C,SACmC;AAAA,EACnC,IAAI,YAAgC;AAAA,EAEpC,OAAO,OAAO,GAAG,SAAS;AAAA,IACzB,IAAI,CAAC,WAAW;AAAA,MACf,MAAM,SAAS,EAAE;AAAA,MACjB,YAAY,MAAM,oBAAS,QAAQ,QAAQ,GAAG;AAAA,IAC/C;AAAA,IAEA,EAAE,IAAI,eAAe,SAAS;AAAA,IAC9B,EAAE,IAAI,wBAAwB,IAAI;AAAA,IAElC,MAAM,KAAK;AAAA;AAAA;;ACnCoE,IAAjF;AAoBO,SAAS,mBAAmB,CAAC,UAA+B,CAAC,GAAiB;AAAA,EACpF,QAAQ,eAAe,OAAO,YAAY;AAAA,EAE1C,OAAO,OAAO,KAAK,MAAM;AAAA,IACxB,IAAI,SAAS;AAAA,MACZ,IAAI;AAAA,QACH,MAAM,QAAQ,KAAK,CAAC;AAAA,QACnB,MAAM;AAAA,IAGT;AAAA,IAEA,IAAI,6BAAe,GAAG,GAAG;AAAA,MACxB,OAAO,uBAAuB,KAAK,YAAY;AAAA,IAChD;AAAA,IAGA,MAAM,UAAU,IAAI,4BACnB,eAAe,QAAQ,IAAI,UAAU,gCACrC,EAAE,OAAO,IAAI,CACd;AAAA,IAEA,OAAO,uBAAuB,SAAS,YAAY;AAAA;AAAA;AAIrD,SAAS,sBAAsB,CAAC,OAAqB,cAAiC;AAAA,EACrF,MAAM,OAAgC;AAAA,IACrC,OAAO;AAAA,MACN,MAAM,MAAM;AAAA,MACZ,SAAS,MAAM;AAAA,MACf,YAAY,MAAM;AAAA,IACnB;AAAA,EACD;AAAA,EAGA,IAAI,YAAY,SAAS,MAAM,QAAS,MAAc,MAAM,GAAG;AAAA,IAC7D,KAAK,MAAc,SAAU,MAAc;AAAA,EAC7C;AAAA,EAEA,IAAI,gBAAgB,MAAM,OAAO;AAAA,IAC/B,KAAK,MAAc,QAAQ,MAAM;AAAA,EACnC;AAAA,EAEA,MAAM,UAAkC;AAAA,IACvC,gBAAgB;AAAA,EACjB;AAAA,EAGA,IAAI,iBAAiB,gCAAkB,MAAM,cAAc;AAAA,IAC1D,QAAQ,iBAAiB,OAAO,KAAK,KAAK,MAAM,eAAe,IAAI,CAAC;AAAA,EACrE;AAAA,EAEA,OAAO,IAAI,SAAS,KAAK,UAAU,IAAI,GAAG;AAAA,IACzC,QAAQ,MAAM;AAAA,IACd;AAAA,EACD,CAAC;AAAA;;AC5E6B,IAA/B;AAeO,SAAS,SAAS,CAAC,SAA8C;AAAA,EACvE,QAAQ,SAAS,OAAO,kBAAkB;AAAA,EAE1C,OAAO,OAAO,GAAG,SAAS;AAAA,IACzB,MAAM,MAAM,MAAM,MAAM,CAAC;AAAA,IACzB,MAAM,SAAS,MAAM,QAAQ,MAAM,GAAG;AAAA,IAGtC,EAAE,OAAO,qBAAqB,OAAO,OAAO,aAAa,OAAO,UAAU,IAAI,EAAE,CAAC;AAAA,IACjF,EAAE,OAAO,yBAAyB,OAAO,OAAO,SAAS,CAAC;AAAA,IAC1D,EAAE,OAAO,qBAAqB,OAAO,KAAK,KAAK,OAAO,UAAU,IAAI,CAAC,CAAC;AAAA,IAEtE,IAAI,CAAC,OAAO,SAAS;AAAA,MACpB,IAAI,eAAe;AAAA,QAClB,OAAO,cAAc,GAAG,MAAM;AAAA,MAC/B;AAAA,MAEA,MAAM,eAAe,OAAO,UAAU,KAAK,IAAI;AAAA,MAC/C,MAAM,IAAI,8BAAe,uBAAuB,eAAe,IAAI,eAAe,SAAS;AAAA,IAC5F;AAAA,IAEA,MAAM,KAAK;AAAA;AAAA;AAON,SAAS,aAAa,CAAC,UAA0B;AAAA,EACvD,MAAM,QAAQ,SAAS,MAAM,kBAAkB;AAAA,EAC/C,IAAI,CAAC,OAAO;AAAA,IACX,MAAM,IAAI,MAAM,6BAA6B,6CAA6C;AAAA,EAC3F;AAAA,EAEA,MAAM,QAAQ,OAAO,SAAS,MAAM,IAAK,EAAE;AAAA,EAC3C,MAAM,OAAO,MAAM;AAAA,EAEnB,QAAQ;AAAA,SACF;AAAA,MACJ,OAAO,QAAQ;AAAA,SACX;AAAA,MACJ,OAAO,QAAQ,KAAK;AAAA,SAChB;AAAA,MACJ,OAAO,QAAQ,KAAK,KAAK;AAAA,SACrB;AAAA,MACJ,OAAO,QAAQ,KAAK,KAAK,KAAK;AAAA;AAAA,MAE9B,MAAM,IAAI,MAAM,2BAA2B,OAAO;AAAA;AAAA;AAoB9C,SAAS,WAAW,CAAC,SAA0C;AAAA,EACrE,QAAQ,WAAW,OAAO,QAAQ,WAAW,SAAS,UAAU;AAAA,EAChE,MAAM,WAAW,cAAc,SAAS;AAAA,EAExC,OAAO;AAAA,SACA,MAAK,CAAC,KAAuC;AAAA,MAClD,MAAM,MAAM,KAAK,IAAI;AAAA,MACrB,MAAM,cAAc,KAAK,MAAM,MAAM,QAAQ,IAAI;AAAA,MACjD,MAAM,UAAU,cAAc;AAAA,MAC9B,MAAM,QAAQ,GAAG,SAAS,OAAO;AAAA,MAEjC,MAAM,UAAU,MAAM,UAAU,IAAI,KAAK;AAAA,MACzC,MAAM,QAAQ,UAAU,OAAO,SAAS,SAAS,EAAE,IAAI;AAAA,MAEvD,IAAI,SAAS,OAAO;AAAA,QACnB,OAAO,EAAE,SAAS,OAAO,WAAW,GAAG,QAAQ;AAAA,MAChD;AAAA,MAGA,MAAM,aAAa,KAAK,KAAK,WAAW,IAAI;AAAA,MAC5C,MAAM,UAAU,IAAI,OAAO,OAAO,QAAQ,CAAC,GAAG;AAAA,QAC7C,eAAe;AAAA,MAChB,CAAC;AAAA,MAED,OAAO,EAAE,SAAS,MAAM,WAAW,QAAQ,QAAQ,GAAG,QAAQ;AAAA;AAAA,EAEhE;AAAA;;AC5FM,SAAS,aAAa,CAAC,SAA0C;AAAA,EACvE,QAAQ,KAAK,OAAO,UAAU,CAAC,KAAK,MAAM;AAAA,EAE1C,OAAO,OAAO,GAAG,SAAS;AAAA,IAEzB,IAAI,CAAC,QAAQ,SAAS,EAAE,IAAI,MAAM,GAAG;AAAA,MACpC,MAAM,KAAK;AAAA,MACX;AAAA,IACD;AAAA,IAEA,MAAM,WAAW,QAAQ,MAAM,CAAC,IAAI,EAAE,IAAI;AAAA,IAC1C,MAAM,eAAe,IAAI,QAAQ,QAAQ;AAAA,IAGzC,MAAM,QAAQ,QAAQ,UAAU,OAAO,WAAW,cAAc,OAAO,UAAU;AAAA,IACjF,IAAI,CAAC,OAAO;AAAA,MAEX,MAAM,KAAK;AAAA,MACX;AAAA,IACD;AAAA,IAGA,MAAM,SAAS,MAAM,MAAM,MAAM,YAAY;AAAA,IAC7C,IAAI,QAAQ;AAAA,MACX,OAAO;AAAA,IACR;AAAA,IAGA,MAAM,KAAK;AAAA,IAGX,MAAM,WAAW,EAAE;AAAA,IACnB,IAAI,SAAS,UAAU,OAAO,SAAS,SAAS,KAAK;AAAA,MAEpD,MAAM,SAAS,SAAS,MAAM;AAAA,MAC9B,MAAM,iBAAiB,IAAI,SAAS,OAAO,MAAM;AAAA,QAChD,QAAQ,OAAO;AAAA,QACf,YAAY,OAAO;AAAA,QACnB,SAAS,IAAI,QAAQ,OAAO,OAAO;AAAA,MACpC,CAAC;AAAA,MACD,eAAe,QAAQ,IAAI,iBAAiB,YAAY,KAAK;AAAA,MAG7D,MAAM,aAAa,MAAM,IAAI,cAAc,cAAc;AAAA,MACzD,IAAI;AAAA,QACH,EAAE,aAAa,UAAU,UAAU;AAAA,QAClC,MAAM;AAAA,QAEP,MAAM;AAAA;AAAA,IAER;AAAA;AAAA;;AChDK,SAAS,MAA2B,CAAC,GAAwC;AAAA,EACnF,MAAM,YAAY,EAAE,IAAI,sBAAsB;AAAA,EAC9C,IAAI,CAAC,WAAW;AAAA,IACf,MAAM,IAAI,MACT,+EACD;AAAA,EACD;AAAA,EACA,OAAO,EAAE,IAAI,aAAa;AAAA;",
+  "debugId": "4C2D147FF9900DA464756E2164756E21",
+  "names": []
+}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@workkit/hono",
+  "version": "0.0.1",
+  "description": "Hono middleware that integrates workkit utilities — env validation, error handling, rate limiting, caching",
+  "license": "MIT",
+  "author": "Bikash Dash <beeeku>",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/beeeku/workkit",
+    "directory": "integrations/hono"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "sideEffects": false,
+  "scripts": {
+    "build": "bunup",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@workkit/types": "workspace:*",
+    "@workkit/errors": "workspace:*",
+    "@workkit/env": "workspace:*"
+  },
+  "peerDependencies": {
+    "hono": ">=4.0.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20250310.0",
+    "bunup": "0.16.31",
+    "expect-type": "^1.1.0",
+    "hono": "^4.7.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "keywords": [
+    "cloudflare",
+    "workers",
+    "hono",
+    "middleware",
+    "env",
+    "validation",
+    "error-handler",
+    "rate-limit",
+    "cache",
+    "workkit"
+  ]
+}