@ubean/server 0.1.12 → 0.2.0

package/dist/single-flight-mJ4ZKbx1.js

@@ -0,0 +1,715 @@
+import { createHmac, timingSafeEqual } from "node:crypto";
+//#region src/cors.ts
+const DEFAULT_METHODS = [
+	"GET",
+	"HEAD",
+	"PUT",
+	"POST",
+	"DELETE",
+	"PATCH",
+	"OPTIONS"
+];
+const DEFAULT_HEADERS = [
+	"Content-Type",
+	"Authorization",
+	"X-Requested-With",
+	"Accept",
+	"Origin"
+];
+function isPreflight(c) {
+	return c.req.method === "OPTIONS" && !!c.req.header("origin") && !!c.req.header("access-control-request-method");
+}
+function configureOrigin(c, option, requestOrigin) {
+	if (option === true || option === void 0 || option === "*") return "*";
+	if (option === false) return null;
+	if (typeof option === "string") return option;
+	if (Array.isArray(option)) {
+		if (option.includes(requestOrigin) || option.includes("*")) return requestOrigin;
+		return null;
+	}
+	if (typeof option === "function") return null;
+	return null;
+}
+function createCorsMiddleware(options = {}) {
+	const { origin = "*", allowMethods = DEFAULT_METHODS, allowHeaders, exposeHeaders = [], credentials = false, maxAge, preflightContinue = false } = options;
+	const resolvedAllowHeaders = allowHeaders?.length ? allowHeaders : DEFAULT_HEADERS;
+	return async function corsMiddleware(c, next) {
+		const requestOrigin = c.req.header("origin") || "";
+		let originValue = null;
+		if (typeof origin === "function") {
+			const result = await origin(requestOrigin, c);
+			if (result === true || result === void 0) originValue = requestOrigin;
+			else if (result === false) originValue = null;
+			else if (typeof result === "string") originValue = result;
+		} else originValue = configureOrigin(c, origin, requestOrigin);
+		if (originValue) {
+			c.header("Access-Control-Allow-Origin", originValue);
+			if (originValue !== "*" || credentials) c.header("Vary", "Origin");
+		}
+		if (credentials) c.header("Access-Control-Allow-Credentials", "true");
+		if (exposeHeaders.length > 0) c.header("Access-Control-Expose-Headers", exposeHeaders.join(", "));
+		if (isPreflight(c)) {
+			const preflightHeaders = {};
+			if (originValue) preflightHeaders["Access-Control-Allow-Origin"] = originValue;
+			if (credentials) preflightHeaders["Access-Control-Allow-Credentials"] = "true";
+			preflightHeaders["Access-Control-Allow-Methods"] = allowMethods.join(", ");
+			preflightHeaders["Access-Control-Allow-Headers"] = resolvedAllowHeaders.join(", ");
+			if (maxAge != null) preflightHeaders["Access-Control-Max-Age"] = String(maxAge);
+			if (originValue && originValue !== "*") preflightHeaders["Vary"] = "Origin";
+			if (!preflightContinue) return new Response(null, {
+				status: 204,
+				headers: preflightHeaders
+			});
+		}
+		await next();
+	};
+}
+function defineCors(options) {
+	return createCorsMiddleware(options);
+}
+//#endregion
+//#region src/rate-limit.ts
+var MemoryRateLimitStore = class {
+	store = /* @__PURE__ */ new Map();
+	timer = null;
+	constructor() {
+		this.timer = setInterval(() => this._cleanup(), 6e4);
+	}
+	_cleanup() {
+		const now = Date.now();
+		for (const [key, entry] of this.store.entries()) if (entry.expireAt <= now) this.store.delete(key);
+	}
+	async get(key) {
+		const entry = this.store.get(key);
+		if (!entry || entry.expireAt <= Date.now()) {
+			if (entry) this.store.delete(key);
+			return;
+		}
+		return {
+			count: entry.count,
+			resetAt: entry.resetAt
+		};
+	}
+	async set(key, entry, ttlMs) {
+		this.store.set(key, {
+			...entry,
+			expireAt: Date.now() + ttlMs
+		});
+	}
+	async increment(key, windowMs) {
+		const now = Date.now();
+		const existing = this.store.get(key);
+		if (!existing || existing.resetAt <= now) {
+			const entry = {
+				count: 1,
+				resetAt: now + windowMs,
+				expireAt: now + windowMs
+			};
+			this.store.set(key, entry);
+			return {
+				count: 1,
+				resetAt: entry.resetAt
+			};
+		}
+		existing.count++;
+		return {
+			count: existing.count,
+			resetAt: existing.resetAt
+		};
+	}
+	async reset(key) {
+		this.store.delete(key);
+	}
+	destroy() {
+		if (this.timer) {
+			clearInterval(this.timer);
+			this.timer = null;
+		}
+		this.store.clear();
+	}
+};
+function defaultKeyGenerator(c) {
+	const forwarded = c.req.header("x-forwarded-for");
+	if (forwarded) return forwarded.split(",")[0].trim();
+	const realIp = c.req.header("x-real-ip");
+	if (realIp) return realIp;
+	return c.req.raw.headers.get("cf-connecting-ip") || "unknown";
+}
+function defaultHandler(c, info) {
+	c.header("Retry-After", String(Math.ceil(info.retryAfter / 1e3)));
+	return c.json({
+		error: "Too Many Requests",
+		message: `Rate limit exceeded. Try again in ${Math.ceil(info.retryAfter / 1e3)} seconds.`,
+		limit: info.limit,
+		remaining: info.remaining,
+		reset: info.reset
+	}, 429);
+}
+function createRateLimitMiddleware(options = {}) {
+	const { maxRequests = 100, windowMs = 6e4, keyGenerator = defaultKeyGenerator, handler = defaultHandler, skip, standardHeaders = true, legacyHeaders = false, store: customStore } = options;
+	const store = customStore || new MemoryRateLimitStore();
+	return async function rateLimitMiddleware(c, next) {
+		if (skip && await skip(c)) {
+			await next();
+			return;
+		}
+		const key = keyGenerator(c);
+		const result = await store.increment(key, windowMs);
+		const now = Date.now();
+		const remaining = Math.max(0, maxRequests - result.count);
+		const reset = Math.ceil(result.resetAt / 1e3);
+		const retryAfter = Math.max(0, result.resetAt - now);
+		if (standardHeaders) {
+			c.header("RateLimit-Limit", String(maxRequests));
+			c.header("RateLimit-Remaining", String(remaining));
+			c.header("RateLimit-Reset", String(reset));
+		}
+		if (legacyHeaders) {
+			c.header("X-RateLimit-Limit", String(maxRequests));
+			c.header("X-RateLimit-Remaining", String(remaining));
+			c.header("X-RateLimit-Reset", String(reset));
+		}
+		if (result.count > maxRequests) return handler(c, {
+			limit: maxRequests,
+			remaining: 0,
+			reset,
+			retryAfter
+		});
+		await next();
+	};
+}
+function defineRateLimit(options) {
+	return createRateLimitMiddleware(options);
+}
+function createMemoryRateLimitStore() {
+	return new MemoryRateLimitStore();
+}
+//#endregion
+//#region src/after.ts
+/**
+* 使用 AsyncLocalStorage 实现请求作用域
+* 在非 Node.js 环境中降级为基于 requestId 的 Map
+*/
+let asyncLocalStorage$1 = null;
+try {
+	const { AsyncLocalStorage } = await import("node:async_hooks");
+	asyncLocalStorage$1 = new AsyncLocalStorage();
+} catch {}
+/**
+* Fallback: 使用全局 Map(基于请求 ID,不如 AsyncLocalStorage 精确)
+*/
+const fallbackStore$1 = /* @__PURE__ */ new Map();
+function getRequestId$1(c) {
+	return c.get("requestId") || "default";
+}
+/**
+* 注册一个在响应发送后执行的回调
+*
+* @example
+* ```typescript
+* import { after } from 'ubean';
+*
+* export const POST = defineHandler(async (c) => {
+*   const result = doWork();
+*   after(() => {
+*     // 这些不会阻塞响应
+*     analytics.track('post_created', result);
+*     invalidateCache('/posts');
+*   });
+*   return c.json(result);
+* });
+* ```
+*/
+function after(callback) {
+	if (asyncLocalStorage$1) {
+		const ctx = asyncLocalStorage$1.getStore?.();
+		if (ctx && ctx.registered) {
+			ctx.callbacks.push(callback);
+			return;
+		}
+	}
+	if (typeof process !== "undefined" && process.env?.NODE_ENV !== "production") console.warn("[ubean] after() called outside of after middleware context, callback will not be executed");
+}
+/**
+* 创建 after() 中间件
+*
+* 在响应发送后执行所有通过 `after()` 注册的回调
+*/
+function createAfterMiddleware() {
+	return async function afterMiddleware(c, next) {
+		const ctx = {
+			callbacks: [],
+			registered: true
+		};
+		const reqId = getRequestId$1(c);
+		fallbackStore$1.set(reqId, ctx);
+		if (asyncLocalStorage$1) await asyncLocalStorage$1.run(ctx, async () => {
+			await next();
+		});
+		else await next();
+		const callbacks = ctx.callbacks;
+		fallbackStore$1.delete(reqId);
+		if (callbacks.length > 0) {
+			const executeCallbacks = async () => {
+				for (const cb of callbacks) try {
+					await cb();
+				} catch (err) {
+					console.error("[ubean] after() callback error:", err);
+				}
+			};
+			const waitUntil = c.executionContext?.waitUntil;
+			if (typeof waitUntil === "function") waitUntil(executeCallbacks());
+			else if (typeof globalThis.queueMicrotask === "function") globalThis.queueMicrotask(() => {
+				executeCallbacks().catch((err) => console.error("[ubean] after() error:", err));
+			});
+			else setTimeout(() => {
+				executeCallbacks().catch((err) => console.error("[ubean] after() error:", err));
+			}, 0);
+		}
+	};
+}
+/**
+* 手动执行 after 回调(用于自定义中间件或测试)
+*/
+async function flushAfterCallbacks(c) {
+	const reqId = getRequestId$1(c);
+	const ctx = fallbackStore$1.get(reqId);
+	if (!ctx) return;
+	for (const cb of ctx.callbacks) try {
+		await cb();
+	} catch (err) {
+		console.error("[ubean] after() callback error:", err);
+	}
+	ctx.callbacks = [];
+	fallbackStore$1.delete(reqId);
+}
+/**
+* 获取当前请求中注册的 after 回调数量(主要用于测试)
+*/
+function getAfterCallbackCount(c) {
+	if (asyncLocalStorage$1) {
+		const store = asyncLocalStorage$1.getStore?.();
+		if (store) return store.callbacks.length;
+	}
+	if (c) {
+		const ctx = fallbackStore$1.get(getRequestId$1(c));
+		if (ctx) return ctx.callbacks.length;
+	}
+	return 0;
+}
+//#endregion
+//#region src/draft-mode.ts
+function sign(value, secret) {
+	return `${value}.${createHmac("sha256", secret).update(value).digest("base64url")}`;
+}
+function verify(signed, secret) {
+	const idx = signed.lastIndexOf(".");
+	if (idx === -1) return null;
+	const value = signed.slice(0, idx);
+	const signature = signed.slice(idx + 1);
+	const expected = createHmac("sha256", secret).update(value).digest("base64url");
+	if (signature.length !== expected.length) return null;
+	try {
+		if (timingSafeEqual(Buffer.from(signature), Buffer.from(expected))) return value;
+	} catch {
+		return null;
+	}
+	return null;
+}
+function parseCookie(cookieHeader, name) {
+	if (!cookieHeader) return void 0;
+	const match = cookieHeader.match(new RegExp(`(?:^|;\\s*)${name}=([^;]+)`));
+	return match ? match[1] : void 0;
+}
+function serializeCookie(name, value, opts, maxAge) {
+	const parts = [`${name}=${value}`];
+	if (opts.path) parts.push(`Path=${opts.path}`);
+	if (opts.domain) parts.push(`Domain=${opts.domain}`);
+	if (opts.secure) parts.push("Secure");
+	if (opts.httpOnly) parts.push("HttpOnly");
+	if (opts.sameSite) parts.push(`SameSite=${opts.sameSite}`);
+	if (maxAge !== void 0) parts.push(`Max-Age=${maxAge}`);
+	return parts.join("; ");
+}
+function isExcluded(path, exclude) {
+	if (!exclude || exclude.length === 0) return false;
+	return exclude.some((p) => path.startsWith(p));
+}
+const DRAFT_MODE_CONTEXT_KEY = "__ubean_draft_mode__";
+var DraftModeController = class {
+	_enabled;
+	_pendingAction = "none";
+	constructor(initialEnabled) {
+		this._enabled = initialEnabled;
+	}
+	get isEnabled() {
+		return this._enabled;
+	}
+	get pendingAction() {
+		return this._pendingAction;
+	}
+	enable() {
+		this._enabled = true;
+		this._pendingAction = "enable";
+	}
+	disable() {
+		this._enabled = false;
+		this._pendingAction = "disable";
+	}
+};
+function getController(c) {
+	return c[DRAFT_MODE_CONTEXT_KEY] || null;
+}
+/**
+* 创建 draft mode 中间件
+*
+* 中间件读取请求中的签名 cookie,验证签名与过期时间后在 context 上
+* 标记 draft mode 状态。响应阶段根据 controller 的 pendingAction
+* 设置或清除 cookie。
+*
+* @example
+* ```typescript
+* // 启用 draft mode(默认 1 小时有效)
+* app.use('*', createDraftModeMiddleware({ secret: 'my-secret' }));
+*
+* // 自定义 cookie 名称与 TTL
+* app.use('*', createDraftModeMiddleware({
+*   secret: 'my-secret',
+*   cookieName: 'preview',
+*   ttl: 86400
+* }));
+* ```
+*/
+function createDraftModeMiddleware(options) {
+	if (!options.secret) throw new Error("[ubean] createDraftModeMiddleware requires a `secret` option");
+	const { cookieName = "ubean_draft", ttl = 3600, cookie: cookieOpts = {}, exclude = [] } = options;
+	const cookieDefaults = {
+		path: "/",
+		secure: false,
+		httpOnly: true,
+		sameSite: "lax",
+		...cookieOpts
+	};
+	return async function draftModeMiddleware(c, next) {
+		if (isExcluded(c.req.path, exclude)) {
+			await next();
+			return;
+		}
+		const cookieValue = parseCookie(c.req.header("cookie"), cookieName);
+		let enabled = false;
+		if (cookieValue) {
+			const verified = verify(cookieValue, options.secret);
+			if (verified !== null) {
+				const expiry = Number(verified);
+				if (!Number.isNaN(expiry) && expiry > Date.now()) enabled = true;
+			}
+		}
+		const controller = new DraftModeController(enabled);
+		c[DRAFT_MODE_CONTEXT_KEY] = controller;
+		await next();
+		if (controller.pendingAction === "enable") {
+			const expiry = Date.now() + ttl * 1e3;
+			const token = sign(String(expiry), options.secret);
+			c.header("Set-Cookie", serializeCookie(cookieName, token, cookieDefaults, ttl));
+		} else if (controller.pendingAction === "disable") c.header("Set-Cookie", serializeCookie(cookieName, "", cookieDefaults, 0));
+	};
+}
+/**
+* 启用 draft mode(设置签名 cookie)
+*
+* 在路由处理函数中调用,中间件会在响应阶段设置 cookie。
+*
+* @example
+* ```typescript
+* app.get('/api/preview/enable', c => {
+*   enableDraftMode(c);
+*   return c.json({ ok: true });
+* });
+* ```
+*/
+function enableDraftMode(c) {
+	const controller = getController(c);
+	if (!controller) throw new Error("[ubean] enableDraftMode() requires createDraftModeMiddleware to be registered on this app");
+	controller.enable();
+}
+/**
+* 禁用 draft mode(清除 cookie)
+*
+* @example
+* ```typescript
+* app.get('/api/preview/disable', c => {
+*   disableDraftMode(c);
+*   return c.json({ ok: true });
+* });
+* ```
+*/
+function disableDraftMode(c) {
+	const controller = getController(c);
+	if (!controller) throw new Error("[ubean] disableDraftMode() requires createDraftModeMiddleware to be registered on this app");
+	controller.disable();
+}
+/**
+* 检查 draft mode 是否已启用(从 context 读取)
+*
+* 未注册中间件时返回 false。
+*/
+function isDraftMode(c) {
+	return getController(c)?.isEnabled ?? false;
+}
+/**
+* 获取 draft mode 组合式 API
+*
+* 返回 `{ isEnabled, enable, disable }`,在路由处理函数中使用。
+*
+* @example
+* ```typescript
+* app.get('*', c => {
+*   const draft = useDraftMode(c);
+*   if (draft.isEnabled) {
+*     // 返回草稿内容
+*   }
+*   return c.json({ draft: draft.isEnabled });
+* });
+* ```
+*/
+function useDraftMode(c) {
+	const controller = getController(c);
+	if (controller) return controller;
+	return {
+		isEnabled: false,
+		enable: () => {
+			throw new Error("[ubean] useDraftMode().enable() requires createDraftModeMiddleware to be registered on this app");
+		},
+		disable: () => {
+			throw new Error("[ubean] useDraftMode().disable() requires createDraftModeMiddleware to be registered on this app");
+		}
+	};
+}
+/**
+* 定义 draft mode 中间件(别名,与 defineCsrf / defineCors 风格一致)
+*/
+function defineDraftMode(options) {
+	return createDraftModeMiddleware(options);
+}
+//#endregion
+//#region src/single-flight.ts
+let asyncLocalStorage = null;
+try {
+	const { AsyncLocalStorage } = await import("node:async_hooks");
+	asyncLocalStorage = new AsyncLocalStorage();
+} catch {}
+/**
+* Fallback: 使用全局 Map(基于 requestId,不如 AsyncLocalStorage 精确)
+*/
+const fallbackStore = /* @__PURE__ */ new Map();
+function getRequestId(c) {
+	return c.get("requestId") || "default";
+}
+function getCurrentContext(c) {
+	if (asyncLocalStorage) return asyncLocalStorage.getStore?.();
+	if (c) return fallbackStore.get(getRequestId(c));
+}
+/**
+* 全局 revalidation 处理器注册表(进程内内存)。
+*
+* 每个 entry 声明它负责哪些 revalidation 键。当 `invalidate(keys)` 被调用时,
+* 中间件查找所有键与 invalidated 键有交集的 entry 并执行其 fetcher。
+*/
+const revalidationRegistry = [];
+/**
+* 注册一个 revalidation 依赖。
+*
+* @param keys 该 fetcher 负责的重新获取键列表
+* @param fetcher 重新获取处理器,返回需要打包进响应的数据
+* @param name 可选名称(用于调试)
+*
+* @example
+* ```typescript
+* defineRevalidation(['users', 'user-count'], async (ctx) => {
+*   const [users, count] = await Promise.all([
+*     db.query.users.findMany(),
+*     db.select({ count: count() }).from(users)
+*   ]);
+*   return { users, 'user-count': count };
+* });
+* ```
+*/
+function defineRevalidation(keys, fetcher, name) {
+	const entry = {
+		keys: [...keys],
+		fetcher,
+		name
+	};
+	revalidationRegistry.push(entry);
+	return entry;
+}
+/**
+* 取消注册一个 revalidation 条目。
+*/
+function unregisterRevalidation(entry) {
+	const idx = revalidationRegistry.indexOf(entry);
+	if (idx === -1) return false;
+	revalidationRegistry.splice(idx, 1);
+	return true;
+}
+/**
+* 获取所有已注册的 revalidation 条目(只读副本,用于测试/调试)。
+*/
+function getRevalidationEntries() {
+	return [...revalidationRegistry];
+}
+/**
+* 清空所有 revalidation 注册(主要用于测试)。
+*/
+function clearRevalidationRegistry() {
+	revalidationRegistry.length = 0;
+}
+/**
+* 标记需要重新获取的依赖键。
+*
+* 必须在 single-flight 中间件作用域内(action 处理器中)调用,
+* 否则给出开发警告。
+*
+* @example
+* ```typescript
+* export const deleteUser = defineAction(async (input) => {
+*   await db.delete(users).where(eq(users.id, input.id));
+*   invalidate(['users', `user:${input.id}`]);
+*   return { ok: true };
+* });
+* ```
+*/
+function invalidate(keys) {
+	const ctx = asyncLocalStorage?.getStore?.();
+	if (ctx && ctx.registered) {
+		for (const key of keys) ctx.invalidatedKeys.add(key);
+		return;
+	}
+	if (typeof process !== "undefined" && process.env?.NODE_ENV !== "production") console.warn("[ubean] invalidate() called outside of single-flight middleware context, revalidation will not be executed");
+}
+/**
+* 标记单个键需要重新获取(`invalidate([key])` 的简写)。
+*/
+function invalidateKey(key) {
+	invalidate([key]);
+}
+/**
+* 获取当前请求中被 invalidate 的键(主要用于测试/调试)。
+*/
+function getInvalidatedKeys(c) {
+	const ctx = getCurrentContext(c);
+	if (!ctx) return [];
+	return Array.from(ctx.invalidatedKeys);
+}
+/**
+* 查找所有键与 invalidated 键有交集的 entry。
+*/
+function findMatchingEntries(invalidatedKeys) {
+	if (invalidatedKeys.length === 0) return [];
+	const keySet = new Set(invalidatedKeys);
+	return revalidationRegistry.filter((entry) => entry.keys.some((k) => keySet.has(k)));
+}
+/**
+* 执行所有匹配的 revalidation fetcher 并收集结果。
+*/
+async function executeRevalidation(invalidatedKeys, c, parallel) {
+	const entries = findMatchingEntries(invalidatedKeys);
+	const data = {};
+	const errors = [];
+	const touchedKeys = /* @__PURE__ */ new Set();
+	const runFetcher = async (entry) => {
+		const matchedKeys = entry.keys.filter((k) => invalidatedKeys.includes(k));
+		for (const k of matchedKeys) touchedKeys.add(k);
+		try {
+			const result = await entry.fetcher({
+				keys: matchedKeys,
+				context: c
+			});
+			if (result && typeof result === "object") Object.assign(data, result);
+		} catch (err) {
+			errors.push({
+				keys: entry.keys,
+				message: err instanceof Error ? err.message : String(err)
+			});
+		}
+	};
+	if (parallel) await Promise.all(entries.map(runFetcher));
+	else for (const entry of entries) await runFetcher(entry);
+	return {
+		data,
+		keys: Array.from(touchedKeys),
+		timestamp: Date.now(),
+		errors
+	};
+}
+/**
+* 创建 single-flight mutations 中间件。
+*
+* 拦截 Server Action 响应,执行由 `invalidate()` 标记的 revalidation,
+* 将结果打包进响应体,使客户端在单个 round-trip 内获得更新后的数据。
+*
+* @example
+* ```typescript
+* app.use('*', createSingleFlightMiddleware());
+* ```
+*/
+function createSingleFlightMiddleware(options = {}) {
+	const { revalidationHeader = "X-Ubean-Revalidated", revalidationField = "__ubean_revalidation__", contentTypes = ["application/json"], skip, parallel = true } = options;
+	return async function singleFlightMiddleware(c, next) {
+		if (skip && await skip(c)) {
+			await next();
+			return;
+		}
+		const ctx = {
+			invalidatedKeys: /* @__PURE__ */ new Set(),
+			registered: true
+		};
+		const reqId = getRequestId(c);
+		fallbackStore.set(reqId, ctx);
+		if (asyncLocalStorage) await asyncLocalStorage.run(ctx, async () => {
+			await next();
+		});
+		else await next();
+		fallbackStore.delete(reqId);
+		const invalidatedKeys = Array.from(ctx.invalidatedKeys);
+		if (invalidatedKeys.length === 0) return;
+		const result = await executeRevalidation(invalidatedKeys, c, parallel);
+		const response = c.res;
+		const contentType = response.headers.get("content-type") || "";
+		if (!contentTypes.some((ct) => contentType.includes(ct))) {
+			c.header(revalidationHeader, invalidatedKeys.join(","));
+			return;
+		}
+		try {
+			const originalBody = await response.json();
+			const newBody = {
+				...originalBody && typeof originalBody === "object" ? originalBody : { value: originalBody },
+				[revalidationField]: result
+			};
+			const newResponse = c.json(newBody, response.status);
+			response.headers.forEach((value, key) => {
+				if (key.toLowerCase() !== "content-type" && key.toLowerCase() !== "content-length") newResponse.headers.set(key, value);
+			});
+			newResponse.headers.set(revalidationHeader, result.keys.join(","));
+			c.res = newResponse;
+		} catch {
+			c.header(revalidationHeader, invalidatedKeys.join(","));
+		}
+	};
+}
+/**
+* 手动执行 revalidation(用于自定义中间件或测试)。
+*
+* 在中间件作用域外也可调用 —— 直接传入 invalidated 键与上下文。
+*/
+async function runRevalidation(invalidatedKeys, c, parallel = true) {
+	return executeRevalidation(invalidatedKeys, c, parallel);
+}
+/**
+* Single-flight 中间件别名(与 cors/rate-limit 的 define* 风格一致)。
+*/
+function defineSingleFlight(options = {}) {
+	return createSingleFlightMiddleware(options);
+}
+//#endregion
+export { defineRateLimit as C, createRateLimitMiddleware as S, defineCors as T, after as _, getInvalidatedKeys as a, getAfterCallbackCount as b, invalidateKey as c, createDraftModeMiddleware as d, defineDraftMode as f, useDraftMode as g, isDraftMode as h, defineSingleFlight as i, runRevalidation as l, enableDraftMode as m, createSingleFlightMiddleware as n, getRevalidationEntries as o, disableDraftMode as p, defineRevalidation as r, invalidate as s, clearRevalidationRegistry as t, unregisterRevalidation as u, createAfterMiddleware as v, createCorsMiddleware as w, createMemoryRateLimitStore as x, flushAfterCallbacks as y };