silgi 0.43.28 → 0.50.0

package/dist/plugins/cache.mjs

@@ -0,0 +1,212 @@
+import { RAW_INPUT } from "../compile.mjs";
+import { useStorage as useStorage$1 } from "../core/storage.mjs";
+import { defineCachedFunction, setStorage, useStorage } from "ocache";
+import { hash } from "ohash";
+//#region src/plugins/cache.ts
+/**
+* Cache plugin — production-grade response caching powered by ocache.
+*
+* All ocache features exposed:
+* - TTL + Stale-While-Revalidate (SWR)
+* - Request deduplication (concurrent calls share one in-flight promise)
+* - Automatic integrity (redeploy invalidates stale cache)
+* - shouldBypassCache / shouldInvalidateCache callbacks
+* - Entry validation and transformation
+* - Multi-tier storage (read cascade, write to all)
+* - Pluggable storage via `setCacheStorage()` (default: in-memory)
+* - unstorage adapter for Redis, Cloudflare KV, S3, etc.
+* - Mutation-triggered invalidation
+*
+* @example
+* ```ts
+* import { cacheQuery, setCacheStorage } from 'silgi/cache'
+*
+* // Basic: cache for 60 seconds with SWR
+* const listUsers = k
+*   .$use(cacheQuery({ maxAge: 60 }))
+*   .$resolve(({ ctx }) => ctx.db.users.findMany())
+*
+* // With unstorage backend (Redis)
+* import { createUnstorageAdapter } from 'silgi/cache'
+* import { createStorage } from 'silgi/unstorage'
+* import redisDriver from 'unstorage/drivers/redis'
+*
+* const storage = createStorage({ driver: redisDriver({ url: 'redis://localhost' }) })
+* setCacheStorage(createUnstorageAdapter(storage))
+* ```
+*/
+/**
+* Auto-connect ocache to silgi's storage.
+* Called lazily on first cacheQuery() use.
+*/
+let _storageConnected = false;
+function ensureStorageConnected() {
+	if (_storageConnected) return;
+	_storageConnected = true;
+	try {
+		const storage = useStorage$1("cache");
+		setStorage({
+			get: (key) => storage.getItem(key),
+			set: (key, value, opts) => {
+				if (value === null || value === void 0) {
+					storage.removeItem(key);
+					return;
+				}
+				storage.setItem(key, value, opts?.ttl ? { ttl: opts.ttl } : void 0);
+			}
+		});
+	} catch {}
+}
+/** Registry of cached function keys for invalidation */
+const cacheKeyRegistry = /* @__PURE__ */ new Map();
+/**
+* Wrap middleware that caches query results.
+*
+* Uses ocache under the hood: TTL, SWR, dedup, integrity, bypass, invalidation.
+* Default: 60s TTL, SWR enabled.
+*
+* @example
+* ```ts
+* const listUsers = k
+*   .$use(cacheQuery({ maxAge: 60 }))
+*   .$resolve(({ ctx }) => ctx.db.users.findMany())
+*
+* // Advanced: bypass cache for admin, custom validation
+* const listPosts = k
+*   .$use(cacheQuery({
+*     maxAge: 300,
+*     swr: true,
+*     staleMaxAge: 600,
+*     shouldBypassCache: (input) => (input as any)?.noCache,
+*     shouldInvalidateCache: (input) => (input as any)?.refresh,
+*     validate: (entry) => Array.isArray(entry.value),
+*     onError: (err) => console.error('[cache]', err),
+*   }))
+*   .$resolve(({ ctx }) => ctx.db.posts.findMany())
+* ```
+*/
+function cacheQuery(options = {}) {
+	const maxAge = options.maxAge ?? 60;
+	const swr = options.swr ?? true;
+	const staleMaxAge = options.staleMaxAge ?? maxAge;
+	const customGetKey = options.getKey;
+	let cacheName = options.name;
+	const pendingNextMap = /* @__PURE__ */ new Map();
+	let requestCounter = 0;
+	let cachedFn = null;
+	let keyFn;
+	return {
+		kind: "wrap",
+		fn: async (ctx, next) => {
+			ensureStorageConnected();
+			if (!cachedFn) {
+				if (!cacheName) cacheName = ctx.__procedurePath || `proc_${hash(next.toString()).slice(0, 8)}`;
+				const resolvedName = cacheName;
+				const keySet = /* @__PURE__ */ new Set();
+				cacheKeyRegistry.set(resolvedName, keySet);
+				keyFn = customGetKey ? (input) => customGetKey(input) : (input) => input !== void 0 && input !== null ? hash(input) : "";
+				const resolvedBase = options.base ?? "/cache";
+				cachedFn = defineCachedFunction(async (_input, requestId) => {
+					const mapKey = requestId ?? keyFn(_input);
+					const nextFn = pendingNextMap.get(mapKey);
+					if (nextFn) {
+						pendingNextMap.delete(mapKey);
+						return nextFn();
+					}
+					throw new Error("[silgi/cache] Missing next() for cache resolve");
+				}, {
+					name: resolvedName,
+					group: "silgi",
+					maxAge,
+					swr,
+					staleMaxAge,
+					base: resolvedBase,
+					integrity: options.integrity,
+					onError: options.onError,
+					validate: options.validate,
+					transform: options.transform,
+					shouldBypassCache: options.shouldBypassCache ? (input) => options.shouldBypassCache(input) : void 0,
+					shouldInvalidateCache: options.shouldInvalidateCache ? (input) => options.shouldInvalidateCache(input) : void 0,
+					getKey: (input) => {
+						const key = keyFn(input);
+						keySet.add(`${resolvedBase}:silgi:${resolvedName}:${key}.json`);
+						return key;
+					}
+				});
+			}
+			const input = ctx[RAW_INPUT];
+			const requestId = `__req_${++requestCounter}`;
+			pendingNextMap.set(requestId, next);
+			return cachedFn(input, requestId);
+		}
+	};
+}
+/**
+* Invalidate cached entries for a procedure by name.
+*
+* Call this after mutations to clear related query caches.
+*
+* @example
+* ```ts
+* const createUser = k.$resolve(async ({ input, ctx }) => {
+*   const user = await ctx.db.users.create(input)
+*   await invalidateQueryCache('users_list')
+*   return user
+* })
+* ```
+*/
+async function invalidateQueryCache(name) {
+	const keys = cacheKeyRegistry.get(name);
+	if (keys) {
+		const storage = useStorage();
+		await Promise.all([...keys].map((key) => storage.set(key, null)));
+		keys.clear();
+	}
+}
+/**
+* Set the cache storage backend.
+*
+* Default: in-memory Map with TTL.
+* For production, use `createUnstorageAdapter()` with Redis, Cloudflare KV, etc.
+*
+* @example
+* ```ts
+* import { setCacheStorage, createUnstorageAdapter } from 'silgi/cache'
+* import { createStorage } from 'silgi/unstorage'
+* import redisDriver from 'unstorage/drivers/redis'
+*
+* setCacheStorage(createUnstorageAdapter(
+*   createStorage({ driver: redisDriver({ url: 'redis://localhost' }) })
+* ))
+* ```
+*/
+function setCacheStorage(storage) {
+	setStorage(storage);
+}
+/**
+* Create an ocache-compatible storage adapter from an unstorage instance.
+*
+* @example
+* ```ts
+* import { createStorage } from 'silgi/unstorage'
+* import redisDriver from 'unstorage/drivers/redis'
+*
+* const storage = createStorage({ driver: redisDriver({ url: 'redis://localhost' }) })
+* const adapter = createUnstorageAdapter(storage)
+* setCacheStorage(adapter)
+* ```
+*/
+function createUnstorageAdapter(storage) {
+	return {
+		get: (key) => storage.getItem(key),
+		set: (key, value, opts) => {
+			if (value === null || value === void 0) {
+				storage.removeItem(key);
+				return;
+			}
+			storage.setItem(key, value, opts);
+		}
+	};
+}
+//#endregion
+export { cacheQuery, createUnstorageAdapter, invalidateQueryCache, setCacheStorage };

package/dist/plugins/coerce.d.mts

@@ -0,0 +1,24 @@
+import { WrapDef } from "../types.mjs";
+
+//#region src/plugins/coerce.d.ts
+/**
+ * Coerce string values in the input to their proper JavaScript types.
+ * Only processes top-level and one-level-deep object values.
+ *
+ * Rules:
+ * - "123", "-42", "3.14" → number
+ * - "true", "false" → boolean
+ * - "null" → null
+ * - "undefined" → undefined
+ * - "" → undefined (empty strings become undefined)
+ * - Everything else → kept as-is
+ *
+ * Implemented as a wrap (not a guard) so it runs after __rawInput is populated
+ * by the pipeline compiler.
+ */
+declare const coerceGuard: WrapDef<Record<string, unknown>>;
+declare function coerceValue(value: unknown): unknown;
+declare function coerceObject(obj: Record<string, unknown>): void;
+/** Standalone coercion function — use outside of guards */
+//#endregion
+export { coerceGuard, coerceObject, coerceValue };

package/dist/plugins/coerce.mjs

@@ -0,0 +1,70 @@
+import { RAW_INPUT } from "../compile.mjs";
+//#region src/plugins/coerce.ts
+/**
+* Smart coercion — convert string query parameters to proper types.
+*
+* When procedures receive GET requests, input arrives as strings via
+* query parameters. This wrap coerces common types automatically:
+* "123" → 123, "true" → true, "null" → null, etc.
+*
+* @example
+* ```ts
+* import { coerceGuard } from "silgi/plugins"
+*
+* const getUser = k
+*   .$use(coerceGuard)
+*   .$input(z.object({ id: z.number(), active: z.boolean().optional() }))
+*   .$resolve(({ input }) => db.users.find(input.id))
+*
+* // GET /users/get?data={"id":"42","active":"true"}
+* // → input is coerced to { id: 42, active: true }
+* ```
+*/
+/**
+* Coerce string values in the input to their proper JavaScript types.
+* Only processes top-level and one-level-deep object values.
+*
+* Rules:
+* - "123", "-42", "3.14" → number
+* - "true", "false" → boolean
+* - "null" → null
+* - "undefined" → undefined
+* - "" → undefined (empty strings become undefined)
+* - Everything else → kept as-is
+*
+* Implemented as a wrap (not a guard) so it runs after __rawInput is populated
+* by the pipeline compiler.
+*/
+const coerceGuard = {
+	kind: "wrap",
+	fn: async (ctx, next) => {
+		const input = ctx[RAW_INPUT];
+		if (typeof input === "object" && input !== null) coerceObject(input);
+		return next();
+	}
+};
+function coerceValue(value) {
+	if (typeof value !== "string") return value;
+	if (value === "") return void 0;
+	if (value === "null") return null;
+	if (value === "undefined") return void 0;
+	if (value === "true") return true;
+	if (value === "false") return false;
+	if (value.length > 0 && value.length <= 20) {
+		const num = Number(value);
+		if (!Number.isNaN(num) && String(num) === value) return num;
+	}
+	return value;
+}
+function coerceObject(obj) {
+	const keys = Object.keys(obj);
+	for (let i = 0; i < keys.length; i++) {
+		const key = keys[i];
+		const val = obj[key];
+		if (typeof val === "string") obj[key] = coerceValue(val);
+		else if (typeof val === "object" && val !== null && !Array.isArray(val)) coerceObject(val);
+		else if (Array.isArray(val)) for (let j = 0; j < val.length; j++) val[j] = coerceValue(val[j]);
+	}
+}
+//#endregion
+export { coerceGuard, coerceObject, coerceValue };

package/dist/plugins/cookies.d.mts

@@ -0,0 +1,14 @@
+import { CookieSerializeOptions, parseSetCookie, splitSetCookieString } from "cookie-es";
+
+//#region src/plugins/cookies.d.ts
+type CookieOptions = CookieSerializeOptions;
+/** Parse a specific cookie value by name. */
+declare function getCookie(headers: Record<string, string> | string, name: string): string | undefined;
+/** Parse all cookies into a key-value object. */
+declare function parseCookies(headers: Record<string, string> | string): Record<string, string>;
+/** Serialize a Set-Cookie header. Defaults: path="/", httpOnly, sameSite=lax. */
+declare function setCookie(name: string, value: string, options?: CookieOptions): string;
+/** Delete a cookie by setting maxAge=0. */
+declare function deleteCookie(name: string, options?: Pick<CookieOptions, 'path' | 'domain'>): string;
+//#endregion
+export { CookieOptions, deleteCookie, getCookie, parseCookies, parseSetCookie, setCookie, splitSetCookieString };

package/dist/plugins/cookies.mjs

@@ -0,0 +1,48 @@
+import { parse, parseSetCookie, serialize, splitSetCookieString } from "cookie-es";
+//#region src/plugins/cookies.ts
+/**
+* Cookie helpers — thin wrapper over cookie-es (unjs).
+*
+* @example
+* ```ts
+* import { getCookie, setCookie, deleteCookie } from "silgi/cookies"
+*
+* const auth = k.guard((ctx) => {
+*   const token = getCookie(ctx.headers, "session")
+*   if (!token) throw new SilgiError("UNAUTHORIZED")
+*   return { sessionToken: token }
+* })
+* ```
+*/
+/** Parse a specific cookie value by name. */
+function getCookie(headers, name) {
+	const str = typeof headers === "string" ? headers : headers.cookie ?? headers.Cookie ?? "";
+	if (!str) return void 0;
+	return parse(str)[name];
+}
+/** Parse all cookies into a key-value object. */
+function parseCookies(headers) {
+	const str = typeof headers === "string" ? headers : headers.cookie ?? headers.Cookie ?? "";
+	if (!str) return {};
+	return parse(str);
+}
+/** Serialize a Set-Cookie header. Defaults: path="/", httpOnly, sameSite=lax. */
+function setCookie(name, value, options = {}) {
+	const merged = {
+		path: "/",
+		httpOnly: true,
+		sameSite: "lax",
+		...options
+	};
+	if (merged.sameSite === "none") merged.secure = true;
+	return serialize(name, value, merged);
+}
+/** Delete a cookie by setting maxAge=0. */
+function deleteCookie(name, options = {}) {
+	return setCookie(name, "", {
+		...options,
+		maxAge: 0
+	});
+}
+//#endregion
+export { deleteCookie, getCookie, parseCookies, parseSetCookie, setCookie, splitSetCookieString };

package/dist/plugins/cors.d.mts

@@ -0,0 +1,43 @@
+//#region src/plugins/cors.d.ts
+/**
+ * CORS plugin — response header helper.
+ *
+ * Returns CORS headers to merge into responses.
+ * Handles preflight OPTIONS requests automatically via the handler.
+ */
+interface CORSOptions {
+  origin?: string | string[] | ((origin: string) => boolean);
+  methods?: string[];
+  allowedHeaders?: string[];
+  exposedHeaders?: string[];
+  credentials?: boolean;
+  maxAge?: number;
+}
+/**
+ * Create CORS headers config for silgi().
+ *
+ * @example
+ * ```ts
+ * import { cors } from "silgi/cors"
+ *
+ * const k = silgi({
+ *   context: (req) => ({}),
+ *   hooks: cors({ origin: "https://app.example.com", credentials: true }),
+ * })
+ * ```
+ */
+declare function cors(options?: CORSOptions): {
+  headers: Record<string, string>;
+  options: CORSOptions;
+};
+/**
+ * CORS header map — use in custom serve() or middleware.
+ * Returns headers object to merge into responses.
+ *
+ * For dynamic origins (array/function), omits Access-Control-Allow-Origin
+ * entirely when the request origin is not allowed — this is the correct
+ * behavior per the CORS spec (browsers reject missing header).
+ */
+declare function corsHeaders(options?: CORSOptions, requestOrigin?: string): Record<string, string>;
+//#endregion
+export { CORSOptions, cors, corsHeaders };

package/dist/plugins/cors.mjs

@@ -0,0 +1,62 @@
+//#region src/plugins/cors.ts
+/**
+* Create CORS headers config for silgi().
+*
+* @example
+* ```ts
+* import { cors } from "silgi/cors"
+*
+* const k = silgi({
+*   context: (req) => ({}),
+*   hooks: cors({ origin: "https://app.example.com", credentials: true }),
+* })
+* ```
+*/
+function cors(options = {}) {
+	const origin = options.origin ?? "*";
+	if (options.credentials && typeof origin === "string" && origin === "*") throw new Error("[silgi/cors] Cannot use credentials: true with origin: \"*\". Set an explicit origin.");
+	return {
+		headers: corsHeaders(options),
+		options
+	};
+}
+/**
+* CORS header map — use in custom serve() or middleware.
+* Returns headers object to merge into responses.
+*
+* For dynamic origins (array/function), omits Access-Control-Allow-Origin
+* entirely when the request origin is not allowed — this is the correct
+* behavior per the CORS spec (browsers reject missing header).
+*/
+function corsHeaders(options = {}, requestOrigin) {
+	const origin = options.origin ?? "*";
+	const methods = options.methods ?? [
+		"GET",
+		"POST",
+		"PUT",
+		"PATCH",
+		"DELETE",
+		"OPTIONS"
+	];
+	const allowedHeaders = options.allowedHeaders ?? ["Content-Type", "Authorization"];
+	const headers = {
+		"access-control-allow-methods": methods.join(", "),
+		"access-control-allow-headers": allowedHeaders.join(", ")
+	};
+	if (typeof origin === "string") {
+		headers["access-control-allow-origin"] = origin;
+		if (origin !== "*") headers["vary"] = "Origin";
+	} else if (Array.isArray(origin)) {
+		if (requestOrigin && origin.includes(requestOrigin)) headers["access-control-allow-origin"] = requestOrigin;
+		headers["vary"] = "Origin";
+	} else if (typeof origin === "function") {
+		if (requestOrigin && origin(requestOrigin)) headers["access-control-allow-origin"] = requestOrigin;
+		headers["vary"] = "Origin";
+	}
+	if (options.credentials) headers["access-control-allow-credentials"] = "true";
+	if (options.maxAge !== void 0) headers["access-control-max-age"] = String(options.maxAge);
+	if (options.exposedHeaders) headers["access-control-expose-headers"] = options.exposedHeaders.join(", ");
+	return headers;
+}
+//#endregion
+export { cors, corsHeaders };

package/dist/plugins/file-upload.d.mts

@@ -0,0 +1,38 @@
+import { GuardDef } from "../types.mjs";
+
+//#region src/plugins/file-upload.d.ts
+interface FileGuardOptions {
+  /** Maximum file size in bytes. Default: 10MB */
+  maxFileSize?: number;
+  /** Allowed MIME types (supports wildcards like "image/*"). Default: all */
+  allowedTypes?: string[];
+  /** Maximum number of files. Default: 1 */
+  maxFiles?: number;
+  /** Form field name for the file. Default: "file" */
+  fieldName?: string;
+}
+interface UploadedFile {
+  name: string;
+  size: number;
+  type: string;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+  stream(): ReadableStream<Uint8Array>;
+}
+/**
+ * Guard that parses multipart file uploads from the request.
+ *
+ * Adds `ctx.file` (single) or `ctx.files` (multiple) to the context.
+ * Validates file size and MIME type before the procedure runs.
+ */
+declare function fileGuard(options?: FileGuardOptions): GuardDef<Record<string, unknown>>;
+/**
+ * Parse multipart form data from a Request.
+ * Returns files and fields separately.
+ */
+declare function parseMultipart(request: Request): Promise<{
+  files: UploadedFile[];
+  fields: Record<string, string>;
+}>;
+//#endregion
+export { FileGuardOptions, UploadedFile, fileGuard, parseMultipart };

package/dist/plugins/file-upload.mjs

@@ -0,0 +1,102 @@
+import { SilgiError } from "../core/error.mjs";
+//#region src/plugins/file-upload.ts
+/**
+* File upload/download — type-safe File/Blob handling.
+*
+* Parse multipart/form-data requests and pass File objects
+* to procedure handlers. Works with serve() and handler().
+*
+* @example
+* ```ts
+* import { fileInput, fileGuard } from "silgi/plugins"
+*
+* const uploadAvatar = k
+*   .$use(fileGuard({ maxFileSize: 5 * 1024 * 1024, allowedTypes: ["image/*"] }))
+*   .$resolve(async ({ ctx }) => {
+*     const file = ctx.file
+*     const buffer = await file.arrayBuffer()
+*     return { name: file.name, size: file.size, type: file.type }
+*   })
+* ```
+*/
+/**
+* Guard that parses multipart file uploads from the request.
+*
+* Adds `ctx.file` (single) or `ctx.files` (multiple) to the context.
+* Validates file size and MIME type before the procedure runs.
+*/
+function fileGuard(options = {}) {
+	const { maxFileSize = 10 * 1024 * 1024, allowedTypes, maxFiles = 1, fieldName: _fieldName = "file" } = options;
+	return {
+		kind: "guard",
+		fn: (ctx) => {
+			const files = ctx.__files;
+			if (!files || files.length === 0) throw new SilgiError("BAD_REQUEST", {
+				status: 400,
+				message: "No file uploaded"
+			});
+			if (files.length > maxFiles) throw new SilgiError("BAD_REQUEST", {
+				status: 400,
+				message: `Too many files: ${files.length} (max ${maxFiles})`
+			});
+			for (const file of files) {
+				if (file.size > maxFileSize) throw new SilgiError("PAYLOAD_TOO_LARGE", {
+					status: 413,
+					message: `File too large: ${file.size} bytes (max ${maxFileSize})`,
+					data: {
+						maxFileSize,
+						actualSize: file.size,
+						fileName: file.name
+					}
+				});
+				if (allowedTypes && !matchesMimeType(file.type, allowedTypes)) throw new SilgiError("BAD_REQUEST", {
+					status: 400,
+					message: `File type not allowed: ${file.type}`,
+					data: {
+						allowedTypes,
+						actualType: file.type,
+						fileName: file.name
+					}
+				});
+			}
+			return maxFiles === 1 ? { file: files[0] } : { files };
+		}
+	};
+}
+/**
+* Parse multipart form data from a Request.
+* Returns files and fields separately.
+*/
+async function parseMultipart(request) {
+	const formData = await request.formData();
+	const files = [];
+	const fields = {};
+	for (const [key, value] of formData.entries()) if (typeof value !== "string") {
+		const file = value;
+		files.push({
+			name: file.name,
+			size: file.size,
+			type: file.type,
+			arrayBuffer: () => file.arrayBuffer(),
+			text: () => file.text(),
+			stream: () => file.stream()
+		});
+	} else fields[key] = value;
+	return {
+		files,
+		fields
+	};
+}
+function matchesMimeType(actual, patterns) {
+	for (const pattern of patterns) {
+		if (pattern === "*" || pattern === "*/*") return true;
+		if (pattern === actual) return true;
+		if (pattern.endsWith("/*")) {
+			const prefix = pattern.slice(0, -2);
+			if (actual.startsWith(prefix + "/")) return true;
+		}
+	}
+	return false;
+}
+//#endregion
+export { fileGuard, parseMultipart };

package/dist/plugins/index.d.mts

@@ -0,0 +1,18 @@
+import { AnalyticsOptions, AnalyticsSnapshot, ErrorEntry, ProcedureSnapshot, TraceSpan } from "./analytics/types.mjs";
+import { AnalyticsCollector } from "./analytics/collector.mjs";
+import { RequestTrace, trace } from "./analytics/trace.mjs";
+import { analyticsHTML } from "./analytics/routes.mjs";
+import { errorToMarkdown } from "./analytics/export.mjs";
+import { Span, Tracer, otelWrap } from "./otel.mjs";
+import { CookieOptions, deleteCookie, getCookie, parseCookies, setCookie } from "./cookies.mjs";
+import { CORSOptions, cors, corsHeaders } from "./cors.mjs";
+import { Logger, LoggingOptions, loggingHooks } from "./pino.mjs";
+import { MemoryRateLimiter, MemoryRateLimiterOptions, RateLimitGuardOptions, RateLimitResult, RateLimiter, rateLimitGuard } from "./ratelimit.mjs";
+import { BodyLimitOptions, bodyLimitGuard } from "./body-limit.mjs";
+import { strictGetGuard } from "./strict-get.mjs";
+import { decrypt, encrypt, sign, unsign } from "./signing.mjs";
+import { coerceGuard, coerceObject, coerceValue } from "./coerce.mjs";
+import { BatchHandlerOptions, createBatchHandler } from "./batch-server.mjs";
+import { MemoryPubSub, PubSubBackend, Publisher, createPublisher } from "./pubsub.mjs";
+import { FileGuardOptions, UploadedFile, fileGuard, parseMultipart } from "./file-upload.mjs";
+export { AnalyticsCollector, type AnalyticsOptions, type AnalyticsSnapshot, type BatchHandlerOptions, type BodyLimitOptions, type CORSOptions, type CookieOptions, type ErrorEntry, type FileGuardOptions, type Logger, type LoggingOptions, MemoryPubSub, MemoryRateLimiter, type MemoryRateLimiterOptions, type ProcedureSnapshot, type PubSubBackend, type Publisher, type RateLimitGuardOptions, type RateLimitResult, type RateLimiter, RequestTrace, type Span, type TraceSpan, type Tracer, type UploadedFile, analyticsHTML, bodyLimitGuard, coerceGuard, coerceObject, coerceValue, cors, corsHeaders, createBatchHandler, createPublisher, decrypt, deleteCookie, encrypt, errorToMarkdown, fileGuard, getCookie, loggingHooks, otelWrap, parseCookies, parseMultipart, rateLimitGuard, setCookie, sign, strictGetGuard, trace, unsign };

package/dist/plugins/index.mjs

@@ -0,0 +1,17 @@
+import { cors, corsHeaders } from "./cors.mjs";
+import { otelWrap } from "./otel.mjs";
+import { loggingHooks } from "./pino.mjs";
+import { MemoryRateLimiter, rateLimitGuard } from "./ratelimit.mjs";
+import { bodyLimitGuard } from "./body-limit.mjs";
+import { strictGetGuard } from "./strict-get.mjs";
+import { deleteCookie, getCookie, parseCookies, setCookie } from "./cookies.mjs";
+import { decrypt, encrypt, sign, unsign } from "./signing.mjs";
+import { coerceGuard, coerceObject, coerceValue } from "./coerce.mjs";
+import { createBatchHandler } from "./batch-server.mjs";
+import { MemoryPubSub, createPublisher } from "./pubsub.mjs";
+import { fileGuard, parseMultipart } from "./file-upload.mjs";
+import { AnalyticsCollector } from "./analytics/collector.mjs";
+import { errorToMarkdown } from "./analytics/export.mjs";
+import { analyticsHTML } from "./analytics/routes.mjs";
+import { RequestTrace, trace } from "./analytics/trace.mjs";
+export { AnalyticsCollector, MemoryPubSub, MemoryRateLimiter, RequestTrace, analyticsHTML, bodyLimitGuard, coerceGuard, coerceObject, coerceValue, cors, corsHeaders, createBatchHandler, createPublisher, decrypt, deleteCookie, encrypt, errorToMarkdown, fileGuard, getCookie, loggingHooks, otelWrap, parseCookies, parseMultipart, rateLimitGuard, setCookie, sign, strictGetGuard, trace, unsign };