@ubean/server 0.1.13 → 0.2.1

package/dist/middleware.d.ts

@@ -0,0 +1,2 @@
+import { A as createFetchMemoizationMiddleware, B as RateLimitOptions, C as isDraftMode, D as FetchInitWithNext, E as FetchCacheOptions, F as after, G as defineRateLimit, H as RateLimitStoreEntry, I as createAfterMiddleware, J as defineCors, K as CorsOptions, L as flushAfterCallbacks, M as getDataCacheSize, N as revalidateDataCachePath, O as clearFetchDataCache, P as revalidateDataCacheTag, R as getAfterCallbackCount, S as enableDraftMode, T as DataCacheMiddlewareOptions, U as createMemoryRateLimitStore, V as RateLimitStore, W as createRateLimitMiddleware, _ as DraftMode, a as RevalidationResult, b as defineDraftMode, c as createSingleFlightMiddleware, d as getInvalidatedKeys, f as getRevalidationEntries, g as unregisterRevalidation, h as runRevalidation, i as RevalidationKey, j as createMemoizedFetch, k as createDataCacheMiddleware, l as defineRevalidation, m as invalidateKey, n as RevalidationEntry, o as SingleFlightOptions, p as invalidate, q as createCorsMiddleware, r as RevalidationFetcher, s as clearRevalidationRegistry, t as RevalidationContext, u as defineSingleFlight, v as DraftModeOptions, w as useDraftMode, x as disableDraftMode, y as createDraftModeMiddleware, z as RateLimitInfo } from "./single-flight-BJyhDLdU.js";
+export { CorsOptions, DataCacheMiddlewareOptions, DraftMode, DraftModeOptions, FetchCacheOptions, FetchInitWithNext, RateLimitInfo, RateLimitOptions, RateLimitStore, RateLimitStoreEntry, RevalidationContext, RevalidationEntry, RevalidationFetcher, RevalidationKey, RevalidationResult, SingleFlightOptions, after, clearFetchDataCache, clearRevalidationRegistry, createAfterMiddleware, createCorsMiddleware, createDataCacheMiddleware, createDraftModeMiddleware, createFetchMemoizationMiddleware, createMemoizedFetch, createMemoryRateLimitStore, createRateLimitMiddleware, createSingleFlightMiddleware, defineCors, defineDraftMode, defineRateLimit, defineRevalidation, defineSingleFlight, disableDraftMode, enableDraftMode, flushAfterCallbacks, getAfterCallbackCount, getDataCacheSize, getInvalidatedKeys, getRevalidationEntries, invalidate, invalidateKey, isDraftMode, revalidateDataCachePath, revalidateDataCacheTag, runRevalidation, unregisterRevalidation, useDraftMode };

package/dist/middleware.js

@@ -0,0 +1,3 @@
+import { C as defineRateLimit, S as createRateLimitMiddleware, T as defineCors, _ as after, a as getInvalidatedKeys, b as getAfterCallbackCount, c as invalidateKey, d as createDraftModeMiddleware, f as defineDraftMode, g as useDraftMode, h as isDraftMode, i as defineSingleFlight, l as runRevalidation, m as enableDraftMode, n as createSingleFlightMiddleware, o as getRevalidationEntries, p as disableDraftMode, r as defineRevalidation, s as invalidate, t as clearRevalidationRegistry, u as unregisterRevalidation, v as createAfterMiddleware, w as createCorsMiddleware, x as createMemoryRateLimitStore, y as flushAfterCallbacks } from "./single-flight-mJ4ZKbx1.js";
+import { a as getDataCacheSize, i as createMemoizedFetch, n as createDataCacheMiddleware, o as revalidateDataCachePath, r as createFetchMemoizationMiddleware, s as revalidateDataCacheTag, t as clearFetchDataCache } from "./fetch-memo-rbkxxnW4.js";
+export { after, clearFetchDataCache, clearRevalidationRegistry, createAfterMiddleware, createCorsMiddleware, createDataCacheMiddleware, createDraftModeMiddleware, createFetchMemoizationMiddleware, createMemoizedFetch, createMemoryRateLimitStore, createRateLimitMiddleware, createSingleFlightMiddleware, defineCors, defineDraftMode, defineRateLimit, defineRevalidation, defineSingleFlight, disableDraftMode, enableDraftMode, flushAfterCallbacks, getAfterCallbackCount, getDataCacheSize, getInvalidatedKeys, getRevalidationEntries, invalidate, invalidateKey, isDraftMode, revalidateDataCachePath, revalidateDataCacheTag, runRevalidation, unregisterRevalidation, useDraftMode };

package/dist/observability-Cio6Qq1H.js

@@ -0,0 +1,339 @@
+import { createHooks } from "hookable";
+//#region src/observability.ts
+const REQUEST_ID_HEADER = "x-request-id";
+function generateRequestId() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+	return `req_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+function getRequestId(c) {
+	return c.get("requestId");
+}
+function generateSpanId() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+	return Array.from({ length: 16 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+}
+function generateTraceId() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID().replace(/-/g, "") + crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+	return Array.from({ length: 32 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+}
+function createSpan(options) {
+	let ended = false;
+	const ctx = {
+		traceId: generateTraceId(),
+		spanId: generateSpanId()
+	};
+	if (options.parent) {
+		if ("context" in options.parent) {
+			ctx.traceId = options.parent.context.traceId;
+			ctx.parentSpanId = options.parent.context.spanId;
+		} else {
+			ctx.traceId = options.parent.traceId;
+			ctx.parentSpanId = options.parent.spanId;
+		}
+	}
+	const span = {
+		name: options.name,
+		context: ctx,
+		startTime: Date.now(),
+		status: "ok",
+		attributes: { ...options.attributes },
+		events: [],
+		parent: options.parent && "context" in options.parent ? options.parent : void 0,
+		end(opts) {
+			if (ended) return;
+			ended = true;
+			span.endTime = Date.now();
+			if (opts?.status) span.status = opts.status;
+			if (opts?.attributes) Object.assign(span.attributes, opts.attributes);
+			if (opts?.error) {
+				span.error = opts.error;
+				span.status = "error";
+			}
+		},
+		setAttribute(key, value) {
+			if (!ended) span.attributes[key] = value;
+		},
+		setAttributes(attrs) {
+			if (!ended) Object.assign(span.attributes, attrs);
+		},
+		addEvent(name, attributes) {
+			if (!ended) span.events.push({
+				name,
+				timestamp: Date.now(),
+				attributes
+			});
+		},
+		isRecording() {
+			return !ended;
+		},
+		duration() {
+			if (span.endTime === void 0) return void 0;
+			return span.endTime - span.startTime;
+		}
+	};
+	return span;
+}
+function createObservabilityTracer(config = {}) {
+	const hooks = createHooks();
+	const exporters = [...config.exporters || []];
+	const sensitiveKeys = new Set((config.sensitiveKeys || [
+		"password",
+		"passwd",
+		"secret",
+		"token",
+		"authorization",
+		"api_key",
+		"apikey",
+		"access_token",
+		"refresh_token",
+		"private_key",
+		"credit_card",
+		"ssn",
+		"auth"
+	]).map((k) => k.toLowerCase()));
+	const enabled = config.enabled !== false;
+	function addExporter(exporter) {
+		exporters.push(exporter);
+	}
+	function removeExporter(name) {
+		const idx = exporters.findIndex((e) => e.name === name);
+		if (idx >= 0) exporters.splice(idx, 1);
+	}
+	function redactAttributes(attrs) {
+		const result = {};
+		for (const [key, value] of Object.entries(attrs)) if (sensitiveKeys.has(key.toLowerCase())) result[key] = "[REDACTED]";
+		else if (typeof value === "string" && value.length > 2048) result[key] = `${value.slice(0, 2048)}...[truncated]`;
+		else result[key] = value;
+		return result;
+	}
+	function startTracedSpan(options) {
+		if (!enabled) return createSpan(options);
+		const span = createSpan({
+			...options,
+			attributes: {
+				...config.defaultAttributes,
+				...options.attributes
+			}
+		});
+		hooks.callHook("span:start", span);
+		const originalEnd = span.end.bind(span);
+		span.end = function(opts) {
+			if (opts?.attributes) opts.attributes = redactAttributes(opts.attributes);
+			span.attributes = redactAttributes(span.attributes);
+			originalEnd(opts);
+			hooks.callHook("span:end", span);
+			if (span.error) hooks.callHook("span:error", span, span.error);
+			for (const exporter of exporters) try {
+				exporter.exportSpan(span);
+			} catch {}
+		};
+		return span;
+	}
+	async function tracedWithSpan(options, fn) {
+		const span = startTracedSpan(typeof options === "string" ? { name: options } : options);
+		try {
+			const result = await fn(span);
+			span.end();
+			return result;
+		} catch (err) {
+			span.end({
+				error: err instanceof Error ? err : new Error(String(err)),
+				status: "error"
+			});
+			throw err;
+		}
+	}
+	function getActiveSpan() {}
+	async function flush() {
+		await Promise.all(exporters.map((e) => e.flush?.()));
+	}
+	async function shutdown() {
+		await flush();
+		await Promise.all(exporters.map((e) => e.shutdown?.()));
+	}
+	return {
+		hooks,
+		startSpan: startTracedSpan,
+		withSpan: tracedWithSpan,
+		getActiveSpan,
+		addExporter,
+		removeExporter,
+		redactAttributes,
+		flush,
+		shutdown,
+		createSpan
+	};
+}
+let globalTracer = null;
+function setGlobalTracer(tracer) {
+	globalTracer = tracer;
+}
+function getGlobalTracer() {
+	if (!globalTracer) globalTracer = createObservabilityTracer();
+	return globalTracer;
+}
+function startSpan(options) {
+	return getGlobalTracer().startSpan(typeof options === "string" ? { name: options } : options);
+}
+function withSpan(options, fn) {
+	return getGlobalTracer().withSpan(options, fn);
+}
+function createOpenTelemetryExporter(options = {}) {
+	const url = options.url || "http://localhost:4318/v1/traces";
+	const headers = options.headers || {};
+	const serviceName = options.serviceName || "ubean-app";
+	const serviceVersion = options.serviceVersion || "0.0.0";
+	const fetchImpl = options.fetchImpl || (typeof fetch !== "undefined" ? fetch : void 0);
+	const batch = [];
+	let batchTimer = null;
+	const BATCH_SIZE = 512;
+	const FLUSH_INTERVAL = 5e3;
+	function spanToOTLP(span) {
+		const attributes = [];
+		for (const [k, v] of Object.entries(span.attributes)) {
+			if (v === void 0 || v === null) continue;
+			attributes.push({
+				key: k,
+				value: typeof v === "string" ? { stringValue: v } : typeof v === "number" ? { intValue: String(Math.floor(v)) } : typeof v === "boolean" ? { boolValue: v } : { stringValue: String(v) }
+			});
+		}
+		const events = span.events.map((e) => ({
+			timeUnixNano: e.timestamp * 1e6,
+			name: e.name,
+			attributes: e.attributes ? Object.entries(e.attributes).filter(([, v]) => v !== void 0 && v !== null).map(([k, v]) => ({
+				key: k,
+				value: typeof v === "string" ? { stringValue: v } : typeof v === "number" ? { intValue: String(Math.floor(v)) } : { stringValue: String(v) }
+			})) : []
+		}));
+		return {
+			traceId: span.context.traceId,
+			spanId: span.context.spanId,
+			parentSpanId: span.context.parentSpanId || "",
+			name: span.name,
+			kind: "SPAN_KIND_INTERNAL",
+			startTimeUnixNano: span.startTime * 1e6,
+			endTimeUnixNano: (span.endTime || Date.now()) * 1e6,
+			attributes,
+			events,
+			status: span.status === "error" ? {
+				code: "STATUS_CODE_ERROR",
+				message: span.error?.message || ""
+			} : { code: "STATUS_CODE_OK" },
+			droppedAttributesCount: 0,
+			droppedEventsCount: 0
+		};
+	}
+	async function exportBatch() {
+		if (batch.length === 0 || !fetchImpl) return;
+		const spans = batch.splice(0, BATCH_SIZE);
+		try {
+			await fetchImpl(url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...headers
+				},
+				body: JSON.stringify({ resourceSpans: [{
+					resource: { attributes: [{
+						key: "service.name",
+						value: { stringValue: serviceName }
+					}, {
+						key: "service.version",
+						value: { stringValue: serviceVersion }
+					}] },
+					scopeSpans: [{
+						scope: { name: "ubean" },
+						spans
+					}]
+				}] })
+			});
+		} catch {}
+	}
+	function scheduleFlush() {
+		if (batchTimer) return;
+		batchTimer = setTimeout(() => {
+			batchTimer = null;
+			exportBatch();
+		}, FLUSH_INTERVAL);
+	}
+	return {
+		name: "opentelemetry",
+		exportSpan(span) {
+			batch.push(spanToOTLP(span));
+			if (batch.length >= BATCH_SIZE) exportBatch();
+			else scheduleFlush();
+		},
+		async flush() {
+			while (batch.length > 0) await exportBatch();
+		},
+		async shutdown() {
+			if (batchTimer) {
+				clearTimeout(batchTimer);
+				batchTimer = null;
+			}
+			await this.flush?.();
+		}
+	};
+}
+function createConsoleExporter(options = {}) {
+	const slowThreshold = options.slowThreshold ?? 1e3;
+	return {
+		name: "console",
+		exportSpan(span) {
+			const duration = span.duration() ?? 0;
+			const status = span.status === "error" ? "✗" : span.status === "cancelled" ? "○" : "✓";
+			const slow = duration >= slowThreshold ? " (slow)" : "";
+			const errMsg = span.error ? ` — ${span.error.message}` : "";
+			if (!(typeof globalThis.console !== "undefined")) return;
+			const msg = `${status} [${duration}ms] ${span.name}${slow}${errMsg}`;
+			if (span.status === "error") console.error(msg);
+			else if (slow) console.warn(msg);
+			else console.debug(msg);
+		}
+	};
+}
+function createTracingMiddleware(options = {}) {
+	const tracer = options.tracer || getGlobalTracer();
+	const headerFilter = options.headerFilter || (() => false);
+	const includeHeaders = options.includeHeaders ?? false;
+	return async function tracingMiddleware(c, next) {
+		const method = c.req.method || "GET";
+		const path = c.req.path || "/";
+		const requestId = getRequestId(c);
+		const span = tracer.startSpan({
+			name: `${method} ${path}`,
+			attributes: {
+				"http.method": method,
+				"http.url": path,
+				"http.request_id": requestId
+			}
+		});
+		c.set("span", span);
+		if (includeHeaders) {
+			const headers = {};
+			for (const [k, v] of Object.entries(c.req.header?.() || {})) if (!headerFilter(k)) headers[k] = v;
+			span.setAttributes(tracer.redactAttributes(headers));
+		}
+		const start = Date.now();
+		try {
+			await next();
+			const statusCode = c.res?.status || 200;
+			span.setAttribute("http.status_code", statusCode);
+			if (statusCode >= 500) span.end({ status: "error" });
+			else span.end({ status: statusCode >= 400 ? "error" : "ok" });
+		} catch (err) {
+			const duration = Date.now() - start;
+			span.setAttribute("error.duration_ms", duration);
+			span.end({
+				error: err instanceof Error ? err : new Error(String(err)),
+				status: "error"
+			});
+			throw err;
+		}
+	};
+}
+function getSpan(c) {
+	return c.get("span");
+}
+//#endregion
+export { createSpan as a, getGlobalTracer as c, setGlobalTracer as d, startSpan as f, createOpenTelemetryExporter as i, getRequestId as l, createConsoleExporter as n, createTracingMiddleware as o, withSpan as p, createObservabilityTracer as r, generateRequestId as s, REQUEST_ID_HEADER as t, getSpan as u };

package/dist/observability-DUNUEjj3.d.ts

@@ -0,0 +1,70 @@
+import { Hookable } from "hookable";
+import { Span, Span as Span$1, SpanAttributes, SpanAttributes as SpanAttributes$1, SpanContext, SpanEndOptions, SpanEvent, SpanOptions, SpanOptions as SpanOptions$1, SpanStatus } from "@ubean/shared";
+//#region src/observability.d.ts
+declare const REQUEST_ID_HEADER = "x-request-id";
+interface RequestIdOptions {
+  headerName?: string;
+  limitLength?: number;
+  generator?: (c: any) => string;
+}
+declare function generateRequestId(): string;
+declare function getRequestId(c: {
+  get: (key: 'requestId') => string;
+}): string;
+interface ObservabilityHooks {
+  'span:start': (span: Span) => void | Promise<void>;
+  'span:end': (span: Span) => void | Promise<void>;
+  'span:error': (span: Span, error: Error) => void | Promise<void>;
+}
+interface ObservabilityExporter {
+  name: string;
+  exportSpan(span: Readonly<Span>): void | Promise<void>;
+  flush?(): Promise<void>;
+  shutdown?(): Promise<void>;
+}
+interface ObservabilityConfig {
+  defaultAttributes?: SpanAttributes;
+  sensitiveKeys?: string[];
+  exporters?: ObservabilityExporter[];
+  enabled?: boolean;
+}
+declare function createSpan(options: SpanOptions): Span;
+declare function createObservabilityTracer(config?: ObservabilityConfig): {
+  hooks: Hookable<ObservabilityHooks, import("hookable").HookKeys<ObservabilityHooks>>;
+  startSpan: (options: SpanOptions) => Span;
+  withSpan: <T>(options: SpanOptions | string, fn: (span: Span) => T | Promise<T>) => Promise<T>;
+  getActiveSpan: () => Span | undefined;
+  addExporter: (exporter: ObservabilityExporter) => void;
+  removeExporter: (name: string) => void;
+  redactAttributes: (attrs: SpanAttributes) => SpanAttributes;
+  flush: () => Promise<void>;
+  shutdown: () => Promise<void>;
+  createSpan: typeof createSpan;
+};
+type ObservabilityTracer = ReturnType<typeof createObservabilityTracer>;
+declare function setGlobalTracer(tracer: ObservabilityTracer | null): void;
+declare function getGlobalTracer(): ObservabilityTracer;
+declare function startSpan(options: SpanOptions | string): Span;
+declare function withSpan<T>(options: SpanOptions | string, fn: (span: Span) => T | Promise<T>): Promise<T>;
+declare function createOpenTelemetryExporter(options?: {
+  url?: string;
+  headers?: Record<string, string>;
+  serviceName?: string;
+  serviceVersion?: string;
+  fetchImpl?: typeof fetch;
+}): ObservabilityExporter;
+declare function createConsoleExporter(options?: {
+  colors?: boolean;
+  slowThreshold?: number;
+}): ObservabilityExporter;
+interface TracingMiddlewareOptions {
+  tracer?: ObservabilityTracer;
+  includeHeaders?: boolean;
+  headerFilter?: (name: string) => boolean;
+}
+declare function createTracingMiddleware(options?: TracingMiddlewareOptions): (c: any, next: any) => Promise<void>;
+declare function getSpan(c: {
+  get: (key: string) => unknown;
+}): Span | undefined;
+//#endregion
+export { getSpan as C, withSpan as E, getRequestId as S, startSpan as T, createOpenTelemetryExporter as _, REQUEST_ID_HEADER as a, generateRequestId as b, SpanAttributes$1 as c, SpanEvent as d, SpanOptions$1 as f, createObservabilityTracer as g, createConsoleExporter as h, ObservabilityTracer as i, SpanContext as l, TracingMiddlewareOptions as m, ObservabilityExporter as n, RequestIdOptions as o, SpanStatus as p, ObservabilityHooks as r, Span$1 as s, ObservabilityConfig as t, SpanEndOptions as u, createSpan as v, setGlobalTracer as w, getGlobalTracer as x, createTracingMiddleware as y };

package/dist/observability.d.ts

@@ -0,0 +1,2 @@
+import { C as getSpan, E as withSpan, S as getRequestId, T as startSpan, _ as createOpenTelemetryExporter, a as REQUEST_ID_HEADER, b as generateRequestId, c as SpanAttributes, d as SpanEvent, f as SpanOptions, g as createObservabilityTracer, h as createConsoleExporter, i as ObservabilityTracer, l as SpanContext, m as TracingMiddlewareOptions, n as ObservabilityExporter, o as RequestIdOptions, p as SpanStatus, r as ObservabilityHooks, s as Span, t as ObservabilityConfig, u as SpanEndOptions, v as createSpan, w as setGlobalTracer, x as getGlobalTracer, y as createTracingMiddleware } from "./observability-DUNUEjj3.js";
+export { ObservabilityConfig, ObservabilityExporter, ObservabilityHooks, ObservabilityTracer, REQUEST_ID_HEADER, RequestIdOptions, type Span, type SpanAttributes, type SpanContext, type SpanEndOptions, type SpanEvent, type SpanOptions, type SpanStatus, TracingMiddlewareOptions, createConsoleExporter, createObservabilityTracer, createOpenTelemetryExporter, createSpan, createTracingMiddleware, generateRequestId, getGlobalTracer, getRequestId, getSpan, setGlobalTracer, startSpan, withSpan };

package/dist/observability.js

@@ -0,0 +1,2 @@
+import { a as createSpan, c as getGlobalTracer, d as setGlobalTracer, f as startSpan, i as createOpenTelemetryExporter, l as getRequestId, n as createConsoleExporter, o as createTracingMiddleware, p as withSpan, r as createObservabilityTracer, s as generateRequestId, t as REQUEST_ID_HEADER, u as getSpan } from "./observability-Cio6Qq1H.js";
+export { REQUEST_ID_HEADER, createConsoleExporter, createObservabilityTracer, createOpenTelemetryExporter, createSpan, createTracingMiddleware, generateRequestId, getGlobalTracer, getRequestId, getSpan, setGlobalTracer, startSpan, withSpan };

package/dist/queue-Bwzi3mhK.js

@@ -0,0 +1,210 @@
+//#region src/queue.ts
+const queueDefinitions = /* @__PURE__ */ new Map();
+let globalDriver = null;
+const inMemoryQueues = /* @__PURE__ */ new Map();
+function generateId() {
+	if (typeof crypto !== "undefined" && crypto.randomUUID) return crypto.randomUUID();
+	return `msg_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+function defineQueue(options, handler) {
+	if (!options.name) throw new Error("[ubean] Queue must have a name");
+	const finalHandler = handler || options.handler;
+	if (!finalHandler) throw new Error(`[ubean] Queue "${options.name}" must have a handler`);
+	const def = {
+		name: options.name,
+		handler: finalHandler,
+		concurrency: options.concurrency ?? 5,
+		retries: options.retries ?? 3,
+		retryDelay: options.retryDelay ?? 1e3,
+		deadLetterQueue: options.deadLetterQueue
+	};
+	queueDefinitions.set(options.name, def);
+	const untypedDef = def;
+	if (globalDriver?.registerHandler) globalDriver.registerHandler(options.name, finalHandler, untypedDef);
+	ensureInMemoryQueue(options.name, untypedDef);
+	return def;
+}
+function ensureInMemoryQueue(name, options) {
+	if (!inMemoryQueues.has(name)) inMemoryQueues.set(name, {
+		messages: [],
+		processing: /* @__PURE__ */ new Set(),
+		stats: {
+			pending: 0,
+			processing: 0,
+			completed: 0,
+			failed: 0
+		},
+		options: {
+			name,
+			...options
+		}
+	});
+	return inMemoryQueues.get(name);
+}
+function createMemoryQueueDriver() {
+	let running = false;
+	let processTimer = null;
+	async function processQueue(name) {
+		const queue = inMemoryQueues.get(name);
+		if (!queue) return;
+		const def = queueDefinitions.get(name);
+		const concurrency = def?.concurrency ?? 5;
+		const retries = def?.retries ?? 3;
+		const retryDelay = def?.retryDelay ?? 1e3;
+		while (queue.processing.size < concurrency && queue.messages.length > 0) {
+			const msg = queue.messages.shift();
+			if (!msg) break;
+			queue.processing.add(msg.id);
+			queue.stats.processing++;
+			queue.stats.pending--;
+			processMessage(name, msg).catch(() => {});
+		}
+		async function processMessage(queueName, message) {
+			const q = inMemoryQueues.get(queueName);
+			if (!q) return;
+			const handler = queueDefinitions.get(queueName)?.handler;
+			if (!handler) {
+				q.processing.delete(message.id);
+				q.stats.processing--;
+				return;
+			}
+			try {
+				await handler(message);
+				q.processing.delete(message.id);
+				q.stats.processing--;
+				q.stats.completed++;
+			} catch (err) {
+				q.processing.delete(message.id);
+				q.stats.processing--;
+				message.attempts++;
+				if (message.attempts >= retries) {
+					q.stats.failed++;
+					const dlq = def?.deadLetterQueue;
+					if (dlq) await driver.send(dlq, message.body, { headers: { "x-error": err instanceof Error ? err.message : String(err) } });
+				} else {
+					await new Promise((resolve) => setTimeout(resolve, retryDelay * message.attempts));
+					q.messages.unshift(message);
+					q.stats.pending++;
+				}
+			}
+		}
+	}
+	const driver = {
+		async send(queueName, body, options = {}) {
+			const queue = ensureInMemoryQueue(queueName);
+			const id = generateId();
+			const message = {
+				id,
+				body,
+				timestamp: Date.now(),
+				attempts: 0,
+				headers: options.headers
+			};
+			if (options.delay && options.delay > 0) setTimeout(() => {
+				queue.messages.push(message);
+				queue.stats.pending++;
+				if (running) processQueue(queueName);
+			}, options.delay);
+			else {
+				queue.messages.push(message);
+				queue.stats.pending++;
+				if (running) processQueue(queueName);
+			}
+			return id;
+		},
+		async sendBatch(queueName, bodies, options = {}) {
+			const ids = [];
+			for (const body of bodies) {
+				const id = await this.send(queueName, body, options);
+				ids.push(id);
+			}
+			return ids;
+		},
+		registerHandler(queueName, handler, options) {
+			const queue = ensureInMemoryQueue(queueName, options);
+			queue.handler = handler;
+		},
+		async start() {
+			if (running) return;
+			running = true;
+			for (const [name, def] of queueDefinitions) {
+				const queue = ensureInMemoryQueue(name, def);
+				queue.handler = def.handler;
+			}
+			processTimer = setInterval(() => {
+				for (const name of inMemoryQueues.keys()) processQueue(name);
+			}, 100);
+			for (const name of inMemoryQueues.keys()) processQueue(name);
+		},
+		async stop() {
+			running = false;
+			if (processTimer) {
+				clearInterval(processTimer);
+				processTimer = null;
+			}
+		},
+		async getQueueDepth(queueName) {
+			const queue = inMemoryQueues.get(queueName);
+			if (!queue) return 0;
+			return queue.messages.length;
+		},
+		async deleteMessage(queueName, messageId) {
+			const queue = inMemoryQueues.get(queueName);
+			if (!queue) return false;
+			const idx = queue.messages.findIndex((m) => m.id === messageId);
+			if (idx >= 0) {
+				queue.messages.splice(idx, 1);
+				queue.stats.pending--;
+				return true;
+			}
+			if (queue.processing.has(messageId)) {
+				queue.processing.delete(messageId);
+				queue.stats.processing--;
+				return true;
+			}
+			return false;
+		}
+	};
+	return driver;
+}
+function useQueueDriver() {
+	if (!globalDriver) globalDriver = createMemoryQueueDriver();
+	return globalDriver;
+}
+function setQueueDriver(driver) {
+	globalDriver = driver;
+	for (const [name, def] of queueDefinitions) if (driver.registerHandler) driver.registerHandler(name, def.handler, def);
+}
+async function sendMessage(queueName, body, options) {
+	return useQueueDriver().send(queueName, body, options);
+}
+async function sendMessages(queueName, bodies, options) {
+	return useQueueDriver().sendBatch(queueName, bodies, options);
+}
+function getQueueDefinitions() {
+	return Array.from(queueDefinitions.values());
+}
+function clearQueueDefinitions() {
+	queueDefinitions.clear();
+	inMemoryQueues.clear();
+}
+async function startQueueWorkers() {
+	const driver = useQueueDriver();
+	if (driver.start) await driver.start();
+}
+async function stopQueueWorkers() {
+	const driver = useQueueDriver();
+	if (driver.stop) await driver.stop();
+}
+function getQueueStats(queueName) {
+	const queue = inMemoryQueues.get(queueName);
+	if (!queue) return void 0;
+	return { ...queue.stats };
+}
+function getAllQueueStats() {
+	const result = {};
+	for (const [name, queue] of inMemoryQueues) result[name] = { ...queue.stats };
+	return result;
+}
+//#endregion
+export { getQueueDefinitions as a, sendMessages as c, stopQueueWorkers as d, useQueueDriver as f, getAllQueueStats as i, setQueueDriver as l, createMemoryQueueDriver as n, getQueueStats as o, defineQueue as r, sendMessage as s, clearQueueDefinitions as t, startQueueWorkers as u };