@klnap/next-proxy-chain 1.0.0 → 1.0.2

package/dist/index.js

@@ -1,78 +1,395 @@
-import {
-  DEFAULT_BLOCKED_REQUEST_HEADERS,
-  NEXT,
-  RuleTimeoutError,
-  applyMergedToResponse,
-  assertIncludeExcludeNoOverlap,
-  compileScopes,
-  cookieItemsFromHeaders,
-  createConsoleLogger,
-  createProxyContext,
-  decodeOverriddenRequestHeaders,
-  formatPipelineLine,
-  headersDiffer,
-  headersInitToHeaders,
-  host,
-  isNextResult,
-  isRequestHeaderAllowed,
-  listSetCookie,
-  mergeRequestHeaderOverrides,
-  mergeWrites,
-  next,
-  normalizeHost,
-  parseCookieName,
-  path,
-  pathMatches,
-  responseHeaderItems,
-  ruleLabel,
-  ruleMatches,
-  toPathRegex,
-  toRule,
-  toStatelessRegExp,
-  withPaths,
-  withRuleTimeout
-} from "./chunk-PTAOIFNB.js";
+// src/core/constants.ts
+var NEXT = /* @__PURE__ */ Symbol.for("proxy-chain.next");
+var DEFAULT_BLOCKED_REQUEST_HEADERS = Object.freeze([
+  "host",
+  "connection",
+  "keep-alive",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade",
+  "content-length",
+  "cookie",
+  "authorization",
+  "x-forwarded-host",
+  "x-forwarded-for",
+  "x-forwarded-proto",
+  "x-real-ip",
+  "x-middleware-next",
+  "x-middleware-override-headers"
+]);
 
-// src/index.ts
-import { NextRequest, NextResponse } from "next/server";
-function isPathFilter(value) {
-  if (value === null || typeof value !== "object") return false;
-  if ("nextUrl" in value) return false;
-  return "include" in value || "exclude" in value || "name" in value || "pathOptions" in value;
+// src/core/context.ts
+function createProxyContext() {
+  return /* @__PURE__ */ new Map();
 }
-function defineProxy(nameOrRun, maybeRun) {
-  const defaultName = typeof nameOrRun === "string" ? nameOrRun : void 0;
-  const run = typeof nameOrRun === "function" ? nameOrRun : maybeRun;
-  const proxy = ((reqOrFilter, eventOrCtx, maybeEvent) => {
-    if (isPathFilter(reqOrFilter)) {
-      return withPaths(run, {
-        ...reqOrFilter,
-        name: reqOrFilter.name ?? defaultName
+
+// src/core/matching.ts
+var RESERVED_FN_NAMES = /* @__PURE__ */ new Set(["", "proxy", "anonymous", "run", "next"]);
+function extractMeaningfulName(value) {
+  if (!value || RESERVED_FN_NAMES.has(value)) return void 0;
+  return value;
+}
+function toStatelessRegExp(re) {
+  const flags = re.flags.replace(/[gy]/g, "");
+  return flags === re.flags ? re : new RegExp(re.source, flags);
+}
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function host(matcher) {
+  const list = Array.isArray(matcher) ? matcher : [matcher];
+  const parts = list.map((m) => {
+    if (m instanceof RegExp) return `(?:${toStatelessRegExp(m).source})`;
+    return `(?:${escapeRegex(m.toLowerCase())})`;
+  });
+  return toStatelessRegExp(new RegExp(`^(?:${parts.join("|")})$`, "i"));
+}
+function isScopeObject(value) {
+  return "host" in value || "path" in value;
+}
+function segmentToRegex(segment) {
+  if (segment === "**") return "(?:.*)";
+  if (segment === "*") return "[^/]+";
+  if (segment.startsWith(":")) return "[^/]+";
+  return escapeRegex(segment);
+}
+function path(pattern, options = {}) {
+  const { locales = [] } = options;
+  const localePrefix = locales.length > 0 ? `(?:(?:${locales.map(escapeRegex).join("|")})\\/)?` : "";
+  if (pattern instanceof RegExp) {
+    const body2 = pattern.source.replace(/^\^/, "").replace(/\$$/, "");
+    const needsStart = !pattern.source.startsWith("^");
+    const needsEnd = !pattern.source.endsWith("$");
+    return toStatelessRegExp(
+      new RegExp(
+        `${needsStart ? "^" : ""}${localePrefix ? `/${localePrefix}` : ""}${body2}${needsEnd ? "$" : ""}`,
+        pattern.flags
+      )
+    );
+  }
+  const normalized = (pattern.startsWith("/") ? pattern : `/${pattern}`).replace(/\/$/, "") || "/";
+  const segments = normalized.slice(1).split("/");
+  const trailingStar = segments.length > 0 && segments[segments.length - 1] === "*";
+  const suffix = trailingStar ? "(?:\\/.*)?$" : "$";
+  const body = trailingStar ? segments.slice(0, -1).map(segmentToRegex).concat("[^/]+").join("\\/") : segments.map(segmentToRegex).join("\\/");
+  return new RegExp(`^/${localePrefix}${body}${suffix}`);
+}
+function toPathRegex(matcher, options) {
+  const list = Array.isArray(matcher) ? matcher : [matcher];
+  const regexes = list.map((m) => path(m, options));
+  if (regexes.length === 1) return toStatelessRegExp(regexes[0]);
+  return toStatelessRegExp(new RegExp(`(?:${regexes.map((r) => `(?:${r.source})`).join("|")})`));
+}
+function compileScopes(input, pathOptions) {
+  if (input == null) return void 0;
+  const list = Array.isArray(input) ? input : [input];
+  const compilePath = (matcher) => {
+    if (Array.isArray(matcher)) {
+      const parts = matcher.map(
+        (m) => typeof m === "string" ? path(m, pathOptions) : toStatelessRegExp(m)
+      );
+      if (parts.length === 1) return parts[0];
+      return toStatelessRegExp(new RegExp(`(?:${parts.map((r) => `(?:${r.source})`).join("|")})`));
+    }
+    return typeof matcher === "string" ? path(matcher, pathOptions) : toStatelessRegExp(matcher);
+  };
+  const compiled = [];
+  for (const item of list) {
+    if (typeof item === "string" || item instanceof RegExp) {
+      compiled.push({ path: compilePath(item) });
+      continue;
+    }
+    if (item && typeof item === "object" && isScopeObject(item)) {
+      if (item.host == null && item.path == null) {
+        throw new Error("[proxy-chain] scope needs at least `host` or `path`");
+      }
+      compiled.push({
+        host: item.host != null ? host(item.host) : void 0,
+        path: item.path != null ? compilePath(item.path) : void 0
       });
+      continue;
     }
-    return run(reqOrFilter, eventOrCtx, maybeEvent);
+    throw new Error("[proxy-chain] invalid include/exclude scope");
+  }
+  return compiled;
+}
+function scopeMatches(pathname, hostname, scope) {
+  if (scope.host) {
+    if (!hostname || !scope.host.test(hostname)) return false;
+  }
+  if (scope.path) {
+    if (!scope.path.test(pathname)) return false;
+  }
+  return true;
+}
+function toRule(entry) {
+  if (typeof entry === "function") {
+    const name2 = extractMeaningfulName(entry.name);
+    return name2 ? { run: entry, name: name2 } : { run: entry };
+  }
+  const rule = entry;
+  const runName = typeof rule.run === "function" ? extractMeaningfulName(rule.run.name) : void 0;
+  const name = extractMeaningfulName(rule.name) ?? runName;
+  const harden = (scopes) => scopes?.map((s) => ({
+    host: s.host ? toStatelessRegExp(s.host) : void 0,
+    path: s.path ? toStatelessRegExp(s.path) : void 0
+  }));
+  return {
+    ...rule,
+    name: name ?? void 0,
+    include: harden(rule.include),
+    exclude: harden(rule.exclude)
+  };
+}
+function ruleLabel(rule, index) {
+  const runName = typeof rule.run === "function" ? extractMeaningfulName(rule.run.name) : void 0;
+  return extractMeaningfulName(rule.name) ?? runName ?? `rule#${index}`;
+}
+function withPaths(entry, filter) {
+  const base = toRule(entry);
+  const opts = filter.pathOptions;
+  const include = compileScopes(filter.include, opts);
+  const exclude = compileScopes(filter.exclude, opts);
+  const name = filter.name ?? base.name;
+  assertIncludeExcludeNoOverlap(include, exclude, name ?? "proxy");
+  return { run: base.run, include, exclude, name };
+}
+function ruleMatches(pathname, hostname, rule) {
+  if (rule.exclude?.some((scope) => scopeMatches(pathname, hostname, scope))) return false;
+  if (rule.include && !rule.include.some((scope) => scopeMatches(pathname, hostname, scope))) {
+    return false;
+  }
+  return true;
+}
+function pathMatches(pathname, rule) {
+  return ruleMatches(pathname, null, rule);
+}
+function normalizeHost(raw) {
+  if (!raw) return null;
+  const first = raw.split(",")[0]?.trim().toLowerCase();
+  if (!first) return null;
+  if (first.startsWith("[")) {
+    const end = first.indexOf("]");
+    return end === -1 ? first : first.slice(1, end);
+  }
+  const withoutPort = first.replace(/:\d+$/, "");
+  return withoutPort || null;
+}
+function scopeKey(scope) {
+  return `${scope.host?.source ?? "*"}::${scope.host?.flags ?? ""}|${scope.path?.source ?? "*"}::${scope.path?.flags ?? ""}`;
+}
+function assertIncludeExcludeNoOverlap(include, exclude, label) {
+  if (!include?.length || !exclude?.length) return;
+  const excluded = new Set(exclude.map(scopeKey));
+  for (const scope of include) {
+    if (excluded.has(scopeKey(scope))) {
+      throw new Error(
+        `[proxy-chain] ${label}: include and exclude share an identical scope. Remove one.`
+      );
+    }
+  }
+}
+
+// src/core/headers.ts
+function normalizeHeaderName(name) {
+  return name.toLowerCase();
+}
+function headersInitToHeaders(init) {
+  return new Headers(init);
+}
+function headersDiffer(base, overrides) {
+  for (const [key, value] of overrides.entries()) {
+    if (base.get(key) !== value) return true;
+  }
+  return false;
+}
+function isRequestHeaderAllowed(name, policy = {}) {
+  const key = normalizeHeaderName(name);
+  const allowed = new Set((policy.allowed ?? []).map(normalizeHeaderName));
+  if (allowed.has(key)) return true;
+  if (key.startsWith("x-middleware-")) return false;
+  const blocked = /* @__PURE__ */ new Set([
+    ...DEFAULT_BLOCKED_REQUEST_HEADERS.map(normalizeHeaderName),
+    ...(policy.blocked ?? []).map(normalizeHeaderName)
+  ]);
+  return !blocked.has(key);
+}
+function mergeRequestHeaderOverrides(target, overrides, policy = {}) {
+  const dropped = [];
+  let applied = 0;
+  overrides.forEach((value, key) => {
+    if (!isRequestHeaderAllowed(key, policy)) {
+      dropped.push(key);
+      return;
+    }
+    target.set(key, value);
+    applied++;
   });
-  Object.defineProperty(proxy, "name", {
-    value: defaultName ?? "",
-    configurable: true
+  return { applied, dropped };
+}
+function parseCookieName(setCookie) {
+  const eq = setCookie.indexOf("=");
+  return (eq === -1 ? setCookie : setCookie.slice(0, eq)).trim();
+}
+function listSetCookie(headers) {
+  const extended = headers;
+  if (typeof extended.getSetCookie === "function") return extended.getSetCookie();
+  const single = headers.get("set-cookie");
+  return single ? [single] : [];
+}
+function cookieItemsFromHeaders(headers) {
+  const map = /* @__PURE__ */ new Map();
+  for (const value of listSetCookie(headers)) {
+    map.set(parseCookieName(value), value);
+  }
+  return map;
+}
+function responseHeaderItems(headers) {
+  const map = /* @__PURE__ */ new Map();
+  headers.forEach((value, key) => {
+    const lower = key.toLowerCase();
+    if (lower === "set-cookie") return;
+    if (lower.startsWith("x-middleware-next") || lower.startsWith("x-middleware-rewrite") || lower.startsWith("x-middleware-override-headers") || lower.startsWith("x-middleware-request-")) {
+      return;
+    }
+    map.set(key, value);
   });
-  return proxy;
+  return map;
 }
-function resolveConfig(overrides = {}) {
-  const { logger, debug, ...rest } = overrides;
+function decodeOverriddenRequestHeaders(headers) {
+  const result = new Headers();
+  const overrideHeaderNames = headers.get("x-middleware-override-headers");
+  if (overrideHeaderNames) {
+    for (const name of overrideHeaderNames.split(",")) {
+      const trimmed = name.trim();
+      const val = headers.get(`x-middleware-request-${trimmed}`);
+      if (val !== null) {
+        result.set(trimmed, val);
+      }
+    }
+  }
+  return result;
+}
+function mergeWrites(writes, strategy, onConflict) {
+  const resolved = /* @__PURE__ */ new Map();
+  const setBy = /* @__PURE__ */ new Map();
+  for (const write of writes) {
+    for (const [key, value] of write.items) {
+      const existing = resolved.get(key);
+      if (existing === void 0) {
+        resolved.set(key, value);
+        setBy.set(key, write.ruleName);
+        continue;
+      }
+      const previousRule = setBy.get(key);
+      if (typeof strategy === "function") {
+        const result = strategy(key, existing, value);
+        if (result === null || result === void 0) resolved.delete(key);
+        else resolved.set(key, result);
+        setBy.set(key, write.ruleName);
+        continue;
+      }
+      if (strategy === "first-write-wins") {
+        onConflict?.(key, previousRule, write.ruleName);
+        continue;
+      }
+      onConflict?.(key, write.ruleName, previousRule);
+      resolved.set(key, value);
+      setBy.set(key, write.ruleName);
+    }
+  }
+  return resolved;
+}
+function applyMergedToResponse(res, headers, cookies) {
+  for (const [key, value] of headers) {
+    res.headers.set(key, value);
+  }
+  res.headers.delete("set-cookie");
+  for (const cookie of cookies.values()) {
+    res.headers.append("set-cookie", cookie);
+  }
+}
+
+// src/core/actions.ts
+function next(options = {}) {
+  return { [NEXT]: true, ...options };
+}
+function isNextResult(value) {
+  return typeof value === "object" && value !== null && NEXT in value;
+}
+
+// src/core/logger.ts
+var LEVEL_RANK = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40
+};
+function createConsoleLogger(minLevel = "info") {
+  const min = LEVEL_RANK[minLevel];
+  const write = (level) => (obj, msg) => {
+    if (LEVEL_RANK[level] < min) return;
+    if (typeof obj === "string") {
+      console[level](obj);
+      return;
+    }
+    const message = msg ?? "";
+    if (message) console[level](`[proxy-chain] ${message}`, obj);
+    else console[level]("[proxy-chain]", obj);
+  };
   return {
-    createContext: () => createProxyContext(),
-    cookieMergeStrategy: "last-write-wins",
-    headerMergeStrategy: "last-write-wins",
-    debug: false,
-    ruleTimeoutMs: 0,
-    requestHeaderPolicy: {},
-    strictOverrideCheck: false,
-    ...rest,
-    ...debug !== void 0 ? { debug } : {},
-    logger: logger ?? createConsoleLogger(debug ? "debug" : "info")
+    debug: write("debug"),
+    info: write("info"),
+    warn: write("warn"),
+    error: write("error")
   };
 }
+function formatDuration(ms) {
+  return `${ms.toFixed(2)}ms`;
+}
+function formatPipelineLine(input) {
+  const trace = input.traceId ? ` [${input.traceId.slice(0, 8)}]` : "";
+  const req = `${input.method} ${input.path}${trace}`;
+  const { name, outcome } = input;
+  switch (outcome.kind) {
+    case "passed":
+      return `[proxy-chain] \xB7 ${req} | ${name} (${formatDuration(outcome.duration)}) -> passed`;
+    case "next":
+      return `[proxy-chain] ~ ${req} | ${name} (${formatDuration(outcome.duration)}) -> headers mutated (${outcome.headers})`;
+    case "stop":
+      return `[proxy-chain] \xD7 ${req} | ${name} (${formatDuration(outcome.duration)}) -> stop ${outcome.status}`;
+  }
+}
+
+// src/core/timeout.ts
+var RuleTimeoutError = class extends Error {
+  ruleName;
+  timeoutMs;
+  constructor(ruleName, timeoutMs) {
+    super(`[proxy-chain] ${ruleName} timed out after ${timeoutMs}ms`);
+    this.name = "RuleTimeoutError";
+    this.ruleName = ruleName;
+    this.timeoutMs = timeoutMs;
+  }
+};
+async function withRuleTimeout(promise, timeoutMs, ruleName) {
+  if (!timeoutMs || timeoutMs <= 0) return promise;
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new RuleTimeoutError(ruleName, timeoutMs)), timeoutMs);
+  });
+  try {
+    return await Promise.race([promise, timeout]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+
+// src/core/pipeline.ts
+import { NextResponse } from "next/server";
 function safeInternalError() {
   return new NextResponse("Internal Server Error", {
     status: 500,
@@ -161,6 +478,57 @@ function resolveRuleResult(res, requestHeaderPolicy, logger, debug) {
   }
   return { kind: "stop", response: res };
 }
+function finalizeResponse(res, headerWrites, cookieWrites, headerStrategy, cookieStrategy, logger, debug) {
+  const headers = mergeWrites(headerWrites, headerStrategy, (key, winner, loser) => {
+    if (debug) logger.debug({ header: key, winner, loser }, "header conflict resolved");
+  });
+  const cookies = mergeWrites(cookieWrites, cookieStrategy, (key, winner, loser) => {
+    if (debug) logger.debug({ cookie: key, winner, loser }, "cookie conflict resolved");
+  });
+  applyMergedToResponse(res, headers, cookies);
+  return res;
+}
+
+// src/core/engine.ts
+import { NextRequest, NextResponse as NextResponse2 } from "next/server";
+function isPathFilter(value) {
+  if (value === null || typeof value !== "object") return false;
+  if ("nextUrl" in value) return false;
+  return "include" in value || "exclude" in value || "name" in value || "pathOptions" in value;
+}
+function defineProxy(nameOrRun, maybeRun) {
+  const defaultName = typeof nameOrRun === "string" ? nameOrRun : void 0;
+  const run = typeof nameOrRun === "function" ? nameOrRun : maybeRun;
+  const proxy = ((reqOrFilter, eventOrCtx, maybeEvent) => {
+    if (isPathFilter(reqOrFilter)) {
+      return withPaths(run, {
+        ...reqOrFilter,
+        name: reqOrFilter.name ?? defaultName
+      });
+    }
+    return run(reqOrFilter, eventOrCtx, maybeEvent);
+  });
+  Object.defineProperty(proxy, "name", {
+    value: defaultName ?? "",
+    configurable: true
+  });
+  return proxy;
+}
+function resolveConfig(overrides = {}) {
+  const { logger, debug, ...rest } = overrides;
+  return {
+    createContext: () => createProxyContext(),
+    cookieMergeStrategy: "last-write-wins",
+    headerMergeStrategy: "last-write-wins",
+    debug: false,
+    ruleTimeoutMs: 0,
+    requestHeaderPolicy: {},
+    strictOverrideCheck: false,
+    ...rest,
+    ...debug !== void 0 ? { debug } : {},
+    logger: logger ?? createConsoleLogger(debug ? "debug" : "info")
+  };
+}
 function proxyChain(optionsOrEntries, maybeEntries) {
   const options = Array.isArray(optionsOrEntries) ? {} : optionsOrEntries;
   const entries = Array.isArray(optionsOrEntries) ? optionsOrEntries : maybeEntries;
@@ -212,8 +580,9 @@ function proxyChain(optionsOrEntries, maybeEntries) {
     const appliedRequestOverrides = new Headers();
     const queueRequestOverrides = (overrides) => {
       if (!pendingRequestOverrides) pendingRequestOverrides = new Headers();
-      mergeRequestHeaderOverrides(pendingRequestOverrides, overrides, requestHeaderPolicy);
+      const target = pendingRequestOverrides;
       overrides.forEach((v, k) => {
+        target.set(k, v);
         appliedRequestOverrides.set(k, v);
       });
     };
@@ -267,7 +636,7 @@ function proxyChain(optionsOrEntries, maybeEntries) {
                     })
                   );
                 }
-                return finalize(
+                return finalizeResponse(
                   recovered,
                   headerWrites,
                   cookieWrites,
@@ -364,7 +733,7 @@ function proxyChain(optionsOrEntries, maybeEntries) {
             }
           }
         }
-        return finalize(
+        return finalizeResponse(
           outcome.response,
           headerWrites,
           cookieWrites,
@@ -403,11 +772,11 @@ function proxyChain(optionsOrEntries, maybeEntries) {
       let final;
       if (finalRewriteUrl) {
         const rewriteTarget = new URL(finalRewriteUrl, finalReq.url);
-        final = NextResponse.rewrite(rewriteTarget, { request: { headers: finalReq.headers } });
+        final = NextResponse2.rewrite(rewriteTarget, { request: { headers: finalReq.headers } });
       } else {
-        final = NextResponse.next({ request: { headers: finalReq.headers } });
+        final = NextResponse2.next({ request: { headers: finalReq.headers } });
       }
-      return finalize(
+      return finalizeResponse(
         final,
         headerWrites,
         cookieWrites,
@@ -429,16 +798,6 @@ function proxyChain(optionsOrEntries, maybeEntries) {
     }
   };
 }
-function finalize(res, headerWrites, cookieWrites, headerStrategy, cookieStrategy, logger, debug) {
-  const headers = mergeWrites(headerWrites, headerStrategy, (key, winner, loser) => {
-    if (debug) logger.debug({ header: key, winner, loser }, "header conflict resolved");
-  });
-  const cookies = mergeWrites(cookieWrites, cookieStrategy, (key, winner, loser) => {
-    if (debug) logger.debug({ cookie: key, winner, loser }, "cookie conflict resolved");
-  });
-  applyMergedToResponse(res, headers, cookies);
-  return res;
-}
 export {
   DEFAULT_BLOCKED_REQUEST_HEADERS,
   NEXT,
@@ -452,8 +811,10 @@ export {
   createProxyContext,
   decodeOverriddenRequestHeaders,
   defineProxy,
+  finalizeResponse,
   formatPipelineLine,
   headersDiffer,
+  headersInitToHeaders,
   host,
   isNextResult,
   isRequestHeaderAllowed,
@@ -466,6 +827,7 @@ export {
   path,
   pathMatches,
   proxyChain,
+  resolveRuleResult,
   responseHeaderItems,
   ruleLabel,
   ruleMatches,

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@klnap/next-proxy-chain",
-  "version": "1.0.0",
-  "description": "Composable Next.js 16+ proxy rule chain with Edge-safe logging and a pure core (zero Next imports).",
+  "version": "1.0.2",
+  "description": "Composable request-chaining and proxy engine for Next.js 15 (middleware.ts) and Next.js 16 (proxy.ts) with deterministic header mutation, isolated per-request context, and pure Web API core.",
   "license": "MIT",
   "author": "klnap",
   "type": "module",
   "sideEffects": false,
   "keywords": [
     "nextjs",
+    "nextjs15",
     "nextjs16",
     "proxy",
     "middleware",
@@ -26,10 +27,10 @@
       "default": "./dist/index.js"
     },
     "./core": {
-      "types": "./dist/core.d.ts",
-      "import": "./dist/core.js",
-      "require": "./dist/core.cjs",
-      "default": "./dist/core.js"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
     }
   },
   "main": "./dist/index.cjs",
@@ -39,23 +40,26 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/core.ts --format cjs,esm --dts",
+    "build": "tsup src/index.ts --format cjs,esm --dts",
     "typecheck": "tsc -p tsconfig.json",
     "test": "bun test",
     "test:watch": "bun test --watch",
-    "clean": "rm -rf dist .turbo coverage node_modules"
+    "clean": "rm -rf dist .turbo coverage",
+    "prepublishOnly": "bun run clean && bun run typecheck && bun test && bun run build"
   },
   "peerDependencies": {
-    "next": ">=15.0.0 || >=16.0.0"
+    "next": ">=15.0.0"
   },
   "devDependencies": {
+    "@types/bun": "^1.4.0",
     "@types/node": "^20",
     "next": "16.3.2",
     "tsup": "^8.4.0",
-    "typescript": "^5"
+    "typescript": "^5",
+    "vitest": "^4.1.11"
   },
   "engines": {
-    "node": ">=22.0.0",
-    "bun": ">=1.4.0"
+    "node": ">=20.0.0",
+    "bun": ">=1.0.0"
   }
 }