@julr/tenace 1.0.0-next.0

package/build/src/main.js

@@ -0,0 +1,1125 @@
+import { a as CircuitOpenError, i as CircuitIsolatedError, l as TimeoutError$1, n as BulkheadFullError, o as LockNotAcquiredError, r as CancelledError, s as RateLimitError, u as WaitForTimeoutError } from "./errors-BODHnryv.js";
+import { t as MemoryRateLimiterAdapter } from "./memory-DXkg8s6y.js";
+import { t as MemoryCacheAdapter } from "./memory-DWyezb1O.js";
+import pWaitFor, { TimeoutError } from "p-wait-for";
+import { ms } from "@julr/utils/string/ms";
+import { BrokenCircuitError, BulkheadRejectedError, CircuitState, ConsecutiveBreaker, CountBreaker, DelegateBackoff, IsolatedCircuitError, SamplingBreaker, TaskCancelledError, TimeoutStrategy, bulkhead, circuitBreaker, fallback, handleAll, handleWhen, retry, timeout, wrap } from "cockatiel";
+function parseDuration(duration) {
+	return ms.parse(duration);
+}
+async function waitFor(condition, options = {}) {
+	const intervalMs = options.interval ? parseDuration(options.interval) : 100;
+	const timeoutMs = options.timeout ? parseDuration(options.timeout) : 1e4;
+	try {
+		await pWaitFor(condition, {
+			interval: intervalMs,
+			timeout: timeoutMs,
+			...options.before !== void 0 && { before: options.before },
+			...options.signal !== void 0 && { signal: options.signal }
+		});
+	} catch (error) {
+		if (error instanceof TimeoutError) throw new WaitForTimeoutError(options.message);
+		throw error;
+	}
+}
+let otelApi;
+async function loadOtelApi() {
+	if (otelApi) return otelApi;
+	try {
+		otelApi = await import("@opentelemetry/api");
+		return otelApi;
+	} catch {
+		return;
+	}
+}
+function getActiveSpan() {
+	return otelApi?.trace.getActiveSpan();
+}
+function emitEvent(name, attributes) {
+	const span = getActiveSpan();
+	if (!span) return;
+	span.addEvent(name, attributes);
+}
+function recordSpan(name, fn, attributes) {
+	if (!otelApi) return fn();
+	return otelApi.trace.getTracer("tenace").startActiveSpan(name, attributes ? { attributes } : {}, (span) => {
+		try {
+			const result = fn();
+			if (result instanceof Promise) return result.then((value) => {
+				span.setStatus({ code: otelApi.SpanStatusCode.OK });
+				span.end();
+				return value;
+			}).catch((error) => {
+				span.setStatus({
+					code: otelApi.SpanStatusCode.ERROR,
+					message: error instanceof Error ? error.message : String(error)
+				});
+				span.recordException(error instanceof Error ? error : new Error(String(error)));
+				span.end();
+				throw error;
+			});
+			span.setStatus({ code: otelApi.SpanStatusCode.OK });
+			span.end();
+			return result;
+		} catch (error) {
+			span.setStatus({
+				code: otelApi.SpanStatusCode.ERROR,
+				message: error instanceof Error ? error.message : String(error)
+			});
+			span.recordException(error instanceof Error ? error : new Error(String(error)));
+			span.end();
+			throw error;
+		}
+	});
+}
+const TelemetryEvents = {
+	RETRY_ATTEMPT: "tenace.retry",
+	RETRY_SUCCESS: "tenace.retry.success",
+	RETRY_EXHAUSTED: "tenace.retry.exhausted",
+	TIMEOUT: "tenace.timeout",
+	CIRCUIT_OPEN: "tenace.circuit_breaker.open",
+	CIRCUIT_CLOSE: "tenace.circuit_breaker.close",
+	CIRCUIT_HALF_OPEN: "tenace.circuit_breaker.half_open",
+	BULKHEAD_REJECTED: "tenace.bulkhead.rejected",
+	CACHE_HIT: "tenace.cache.hit",
+	CACHE_MISS: "tenace.cache.miss",
+	RATE_LIMIT_REJECTED: "tenace.rate_limit.rejected",
+	LOCK_ACQUIRED: "tenace.lock.acquired",
+	LOCK_NOT_ACQUIRED: "tenace.lock.not_acquired",
+	LOCK_RELEASED: "tenace.lock.released",
+	FALLBACK_TRIGGERED: "tenace.fallback"
+};
+const plugins = [];
+function use(plugin) {
+	plugins.push(plugin);
+}
+function getPlugins() {
+	return plugins;
+}
+function clearPlugins() {
+	plugins.length = 0;
+}
+function registerHook(hook, fn) {
+	const plugin = { [hook]: fn };
+	use(plugin);
+	return () => {
+		const index = plugins.indexOf(plugin);
+		if (index !== -1) plugins.splice(index, 1);
+	};
+}
+function notifyPlugins(hook, event) {
+	for (const plugin of plugins) {
+		const handler = plugin[hook];
+		if (typeof handler === "function") handler(event);
+	}
+}
+function wrapError(error) {
+	if (error instanceof IsolatedCircuitError) return new CircuitIsolatedError(error.message);
+	if (error instanceof BrokenCircuitError) return new CircuitOpenError(error.message);
+	if (error instanceof TaskCancelledError) {
+		if (error.message.includes("timed out")) return new TimeoutError$1(error.message);
+		return new CancelledError(error.message);
+	}
+	if (error instanceof BulkheadRejectedError) return new BulkheadFullError(error.message);
+	if (error instanceof Error) return error;
+	return new Error(String(error));
+}
+function createBreaker(config) {
+	switch (config.kind) {
+		case "consecutive": return new ConsecutiveBreaker(config.threshold);
+		case "count": {
+			const opts = {
+				threshold: config.threshold,
+				size: config.size
+			};
+			if (config.minimumNumberOfCalls !== void 0) opts.minimumNumberOfCalls = config.minimumNumberOfCalls;
+			return new CountBreaker(opts);
+		}
+		case "sampling": {
+			const opts = {
+				threshold: config.threshold,
+				duration: config.durationMs
+			};
+			if (config.minimumRps !== void 0) opts.minimumRps = config.minimumRps;
+			return new SamplingBreaker(opts);
+		}
+	}
+}
+function createCircuitBreakerPolicy(config) {
+	const cb = circuitBreaker(handleAll, {
+		halfOpenAfter: config.halfOpenAfterMs,
+		breaker: createBreaker(config.breaker)
+	});
+	if (config.hooks) {
+		cb.onBreak(() => {
+			config.hooks.onOpen?.();
+			config.hooks.onStateChange?.("open");
+		});
+		cb.onReset(() => {
+			config.hooks.onClose?.();
+			config.hooks.onStateChange?.("closed");
+		});
+		cb.onHalfOpen(() => {
+			config.hooks.onHalfOpen?.();
+			config.hooks.onStateChange?.("half-open");
+		});
+	}
+	cb.onBreak(() => {
+		emitEvent(TelemetryEvents.CIRCUIT_OPEN);
+		notifyPlugins("onCircuitOpened", {});
+	});
+	cb.onReset(() => {
+		emitEvent(TelemetryEvents.CIRCUIT_CLOSE);
+		notifyPlugins("onCircuitClosed", {});
+	});
+	cb.onHalfOpen(() => {
+		emitEvent(TelemetryEvents.CIRCUIT_HALF_OPEN);
+		notifyPlugins("onCircuitHalfOpened", {});
+	});
+	return cb;
+}
+function createRetryPolicy(config) {
+	const times = config.times ?? 3;
+	const delay = config.delay;
+	const retryOpts = { maxAttempts: times };
+	if (delay !== void 0) {
+		const delayFn = typeof delay === "function" ? delay : () => parseDuration(delay);
+		retryOpts.backoff = new DelegateBackoff((context) => delayFn(context.attempt, context.result.error));
+	}
+	const retryIf = config.retryIf;
+	const abortIf = config.abortIf;
+	const policy = retry(handleWhen((error) => {
+		if (error instanceof BrokenCircuitError) return false;
+		if (error instanceof BulkheadRejectedError) return false;
+		if (!(error instanceof Error)) return true;
+		if (abortIf?.(error)) return false;
+		if (retryIf) return retryIf(error);
+		return true;
+	}), retryOpts);
+	policy.onRetry((event) => {
+		const error = "error" in event ? event.error : /* @__PURE__ */ new Error("Unknown error");
+		emitEvent(TelemetryEvents.RETRY_ATTEMPT, {
+			attempt: event.attempt,
+			delay_ms: event.delay,
+			error: error.message
+		});
+		notifyPlugins("onRetry", {
+			attempt: event.attempt,
+			delay: event.delay,
+			error
+		});
+		config.onRetry?.({
+			attempt: event.attempt,
+			delay: event.delay,
+			error
+		});
+	});
+	policy.onGiveUp((event) => {
+		const error = "error" in event ? event.error : /* @__PURE__ */ new Error("Unknown error");
+		emitEvent(TelemetryEvents.RETRY_EXHAUSTED, { error: error.message });
+		notifyPlugins("onRetryExhausted", { error });
+		config.onRetryExhausted?.({ error });
+	});
+	return policy;
+}
+var PolicyConfigurator = class {
+	layers = [];
+	#addLayer(layer) {
+		return this.createInstance([...this.layers, layer]);
+	}
+	withTimeout(duration, strategyOrOptions) {
+		const isOptions = typeof strategyOrOptions === "object";
+		const strategy = isOptions ? strategyOrOptions.strategy ?? "cooperative" : strategyOrOptions ?? "cooperative";
+		const onTimeout = isOptions ? strategyOrOptions.onTimeout : void 0;
+		const config = {
+			durationMs: parseDuration(duration),
+			strategy
+		};
+		if (onTimeout) config.onTimeout = onTimeout;
+		return this.#addLayer({
+			type: "timeout",
+			config
+		});
+	}
+	withRetry(options) {
+		return this.#addLayer({
+			type: "retry",
+			config: options ?? {}
+		});
+	}
+	withCircuitBreaker(options) {
+		const config = {
+			halfOpenAfterMs: parseDuration(options.halfOpenAfter),
+			breaker: {
+				kind: "consecutive",
+				threshold: options.failureThreshold
+			}
+		};
+		if (options.hooks) config.hooks = options.hooks;
+		const instance = createCircuitBreakerPolicy(config);
+		return this.#addLayer({
+			type: "circuitBreaker",
+			config,
+			instance
+		});
+	}
+	withSamplingCircuitBreaker(options) {
+		const durationMs = parseDuration(options.duration);
+		const halfOpenAfterMs = parseDuration(options.halfOpenAfter);
+		const breaker = {
+			kind: "sampling",
+			threshold: options.threshold,
+			durationMs
+		};
+		if (options.minimumRps !== void 0) breaker.minimumRps = options.minimumRps;
+		const config = {
+			halfOpenAfterMs,
+			breaker
+		};
+		if (options.hooks) config.hooks = options.hooks;
+		const instance = createCircuitBreakerPolicy(config);
+		return this.#addLayer({
+			type: "circuitBreaker",
+			config,
+			instance
+		});
+	}
+	withFallback(fn, options) {
+		const config = { fn };
+		if (options?.onFallback) config.onFallback = options.onFallback;
+		return this.#addLayer({
+			type: "fallback",
+			config
+		});
+	}
+	withSpan(name, attributes) {
+		const config = { name };
+		if (attributes) config.attributes = attributes;
+		return this.#addLayer({
+			type: "span",
+			config
+		});
+	}
+	withBulkhead(limit, queueOrOptions) {
+		const isOptions = typeof queueOrOptions === "object";
+		const queue = isOptions ? queueOrOptions.queue : queueOrOptions;
+		const onRejected = isOptions ? queueOrOptions.onRejected : void 0;
+		const config = { limit };
+		if (queue !== void 0) config.queue = queue;
+		if (onRejected) config.onRejected = onRejected;
+		const instance = bulkhead(config.limit, config.queue);
+		return this.#addLayer({
+			type: "bulkhead",
+			config,
+			instance
+		});
+	}
+	withCache(options) {
+		return this.#addLayer({
+			type: "cache",
+			config: options
+		});
+	}
+	withRateLimit(options) {
+		return this.#addLayer({
+			type: "rateLimit",
+			config: options
+		});
+	}
+	withDistributedLock(options) {
+		return this.#addLayer({
+			type: "distributedLock",
+			config: options
+		});
+	}
+	withChaosFault(options) {
+		const config = {
+			rate: options.rate,
+			error: options.error,
+			errors: options.errors
+		};
+		return this.#addLayer({
+			type: "chaosFault",
+			config
+		});
+	}
+	withChaosLatency(options) {
+		const delay = typeof options.delay === "number" ? {
+			min: options.delay,
+			max: options.delay
+		} : options.delay;
+		const config = {
+			rate: options.rate,
+			delay
+		};
+		return this.#addLayer({
+			type: "chaosLatency",
+			config
+		});
+	}
+};
+var ConfigStore = class {
+	#cache;
+	#rateLimiter;
+	#lock;
+	#defaultCache;
+	#defaultRateLimiter;
+	configure(config) {
+		if (config.cache) this.#cache = config.cache;
+		if (config.rateLimiter) this.#rateLimiter = config.rateLimiter;
+		if (config.lock) this.#lock = config.lock;
+	}
+	getCache() {
+		if (this.#cache) return this.#cache;
+		if (!this.#defaultCache) this.#defaultCache = new MemoryCacheAdapter();
+		return this.#defaultCache;
+	}
+	getRateLimiter() {
+		if (this.#rateLimiter) return this.#rateLimiter;
+		if (!this.#defaultRateLimiter) this.#defaultRateLimiter = new MemoryRateLimiterAdapter();
+		return this.#defaultRateLimiter;
+	}
+	getLock() {
+		return this.#lock;
+	}
+	reset() {
+		this.#cache = void 0;
+		this.#rateLimiter = void 0;
+		this.#lock = void 0;
+		this.#defaultCache = void 0;
+		this.#defaultRateLimiter = void 0;
+	}
+};
+const configStore = new ConfigStore();
+function createCachePolicy(options) {
+	const adapter = options.adapter ?? configStore.getCache();
+	return { execute: async (fn, signal) => {
+		try {
+			const cached = await adapter.get(options.key);
+			if (cached !== void 0) {
+				emitEvent(TelemetryEvents.CACHE_HIT, { key: options.key });
+				notifyPlugins("onCacheHit", { key: options.key });
+				options.onHit?.({ key: options.key });
+				return cached;
+			}
+			emitEvent(TelemetryEvents.CACHE_MISS, { key: options.key });
+			notifyPlugins("onCacheMiss", { key: options.key });
+			options.onMiss?.({ key: options.key });
+		} catch (error) {
+			if (!options.optional) throw error;
+		}
+		const result = await fn({
+			signal: signal ?? new AbortController().signal,
+			attempt: 0
+		});
+		try {
+			await adapter.set(options.key, result, options.ttl);
+		} catch {}
+		return result;
+	} };
+}
+function createRateLimitPolicy(options) {
+	const adapter = options.adapter ?? configStore.getRateLimiter();
+	return { execute: async (fn, signal) => {
+		try {
+			const result = await adapter.acquire(options.key, {
+				maxCalls: options.maxCalls,
+				windowMs: options.windowMs,
+				...options.strategy !== void 0 && { strategy: options.strategy }
+			});
+			if (!result.allowed) {
+				emitEvent(TelemetryEvents.RATE_LIMIT_REJECTED, {
+					key: options.key,
+					retry_after_ms: result.retryAfterMs ?? 0
+				});
+				notifyPlugins("onRateLimitRejected", {
+					key: options.key,
+					retryAfterMs: result.retryAfterMs
+				});
+				if (result.retryAfterMs !== void 0) options.onRejected?.({
+					key: options.key,
+					retryAfterMs: result.retryAfterMs
+				});
+				else options.onRejected?.({ key: options.key });
+				throw new RateLimitError({
+					message: `Rate limit exceeded for key "${options.key}". Retry after ${result.retryAfterMs}ms`,
+					retryAfterMs: result.retryAfterMs ?? 0,
+					remaining: result.remaining
+				});
+			}
+		} catch (error) {
+			if (error instanceof RateLimitError) throw error;
+			if (!options.optional) throw error;
+		}
+		return fn({
+			signal: signal ?? new AbortController().signal,
+			attempt: 0
+		});
+	} };
+}
+function createLockPolicy(options) {
+	const adapter = options.adapter ?? configStore.getLock();
+	if (!adapter) throw new Error("No lock adapter configured. Set one globally with configStore.configure({ lock }) or pass it in options.");
+	return { execute: async (fn, signal) => {
+		const context = {
+			signal: signal ?? new AbortController().signal,
+			attempt: 0
+		};
+		const [acquired, result] = await adapter.run(options.key, options.ttl, () => fn(context), options.retry ? { retry: options.retry } : {});
+		if (!acquired) {
+			emitEvent(TelemetryEvents.LOCK_NOT_ACQUIRED, { key: options.key });
+			notifyPlugins("onLockRejected", { key: options.key });
+			options.onRejected?.({ key: options.key });
+			throw new LockNotAcquiredError({ key: options.key });
+		}
+		emitEvent(TelemetryEvents.LOCK_ACQUIRED, { key: options.key });
+		notifyPlugins("onLockAcquired", { key: options.key });
+		options.onAcquired?.({ key: options.key });
+		return result;
+	} };
+}
+function createChaosFaultPolicy(config) {
+	return { execute: async (fn, signal) => {
+		if (Math.random() < config.rate) throw config.errors ? config.errors[Math.floor(Math.random() * config.errors.length)] : config.error ?? /* @__PURE__ */ new Error("Chaos fault");
+		return fn({ signal: signal ?? new AbortController().signal });
+	} };
+}
+function createChaosLatencyPolicy(config) {
+	return { execute: async (fn, signal) => {
+		if (Math.random() < config.rate) await sleep(config.delay.min === config.delay.max ? config.delay.min : Math.floor(Math.random() * (config.delay.max - config.delay.min) + config.delay.min));
+		return fn({ signal: signal ?? new AbortController().signal });
+	} };
+}
+function sleep(ms$1) {
+	return new Promise((resolve) => setTimeout(resolve, ms$1));
+}
+const DEFAULT_CHAOS_ERROR = /* @__PURE__ */ new Error("Chaos fault");
+var ChaosManager = class {
+	#config = null;
+	enable(config) {
+		this.#config = this.#normalizeConfig(config);
+	}
+	disable() {
+		this.#config = null;
+	}
+	isEnabled() {
+		return this.#config !== null;
+	}
+	getConfig() {
+		return this.#config;
+	}
+	#normalizeConfig(config) {
+		const result = {};
+		if (config.fault !== void 0) result.fault = this.#normalizeFaultConfig(config.fault);
+		if (config.latency !== void 0) result.latency = this.#normalizeLatencyConfig(config.latency);
+		return result;
+	}
+	#normalizeFaultConfig(config) {
+		if (typeof config === "number") return {
+			rate: config,
+			error: DEFAULT_CHAOS_ERROR
+		};
+		return {
+			rate: config.rate,
+			error: config.error,
+			errors: config.errors
+		};
+	}
+	#normalizeLatencyConfig(config) {
+		if (typeof config === "number") return {
+			rate: 1,
+			delay: {
+				min: config,
+				max: config
+			}
+		};
+		const delay = config.delay;
+		if (typeof delay === "number") return {
+			rate: config.rate,
+			delay: {
+				min: delay,
+				max: delay
+			}
+		};
+		return {
+			rate: config.rate,
+			delay
+		};
+	}
+};
+const chaosManager = new ChaosManager();
+var TenaceBuilder = class TenaceBuilder extends PolicyConfigurator {
+	#fn;
+	constructor(options = {}) {
+		super();
+		this.#fn = options.fn;
+		this.layers = options.layers ?? [];
+	}
+	createInstance(layers) {
+		return new TenaceBuilder({
+			fn: this.#fn,
+			layers
+		});
+	}
+	async execute(fn) {
+		const targetFn = fn ?? this.#fn;
+		if (!targetFn) throw new Error("No function provided to execute");
+		const policy = this.#buildOrderedPolicy();
+		const wrappedFn = this.#wrapFn(targetFn);
+		try {
+			const spanLayer = this.layers.find((l) => l.type === "span");
+			if (spanLayer) return await this.#executeWithSpan(policy, wrappedFn, spanLayer.config);
+			return await policy.execute(wrappedFn);
+		} catch (error) {
+			const wrappedError = wrapError(error);
+			this.#emitErrorHooks(wrappedError);
+			throw wrappedError;
+		}
+	}
+	#buildOrderedPolicy() {
+		const pipelineLayers = this.#mergeWithGlobalChaos(this.layers).filter((l) => [
+			"timeout",
+			"retry",
+			"circuitBreaker",
+			"bulkhead",
+			"fallback",
+			"chaosFault",
+			"chaosLatency",
+			"cache",
+			"rateLimit",
+			"distributedLock"
+		].includes(l.type));
+		if (pipelineLayers.length === 0) return this.#createNoopPolicy();
+		const policies = pipelineLayers.map((layer) => this.#createCockatielPolicy(layer));
+		if (policies.length === 1) return policies[0];
+		return wrap(...[...policies].reverse());
+	}
+	#mergeWithGlobalChaos(layers) {
+		const globalConfig = chaosManager.getConfig();
+		if (!globalConfig) return layers;
+		const result = [...layers];
+		if (globalConfig.latency && !layers.some((l) => l.type === "chaosLatency")) result.unshift({
+			type: "chaosLatency",
+			config: globalConfig.latency
+		});
+		if (globalConfig.fault && !layers.some((l) => l.type === "chaosFault")) result.unshift({
+			type: "chaosFault",
+			config: globalConfig.fault
+		});
+		return result;
+	}
+	#createNoopPolicy() {
+		return { execute: (fn) => Promise.resolve(fn({
+			signal: new AbortController().signal,
+			attempt: 0
+		})) };
+	}
+	#createCockatielPolicy(layer) {
+		if (layer.instance) return layer.instance;
+		switch (layer.type) {
+			case "timeout": {
+				const config = layer.config;
+				const strategy = config.strategy === "aggressive" ? TimeoutStrategy.Aggressive : TimeoutStrategy.Cooperative;
+				return timeout(config.durationMs, strategy);
+			}
+			case "retry": return createRetryPolicy(layer.config);
+			case "circuitBreaker": return createCircuitBreakerPolicy(layer.config);
+			case "bulkhead": {
+				const config = layer.config;
+				return bulkhead(config.limit, config.queue);
+			}
+			case "fallback": {
+				const config = layer.config;
+				const fallbackFn = () => {
+					emitEvent(TelemetryEvents.FALLBACK_TRIGGERED);
+					notifyPlugins("onFallback", {});
+					config.onFallback?.();
+					return config.fn();
+				};
+				return fallback(handleAll, fallbackFn);
+			}
+			case "chaosFault": return createChaosFaultPolicy(layer.config);
+			case "chaosLatency": return createChaosLatencyPolicy(layer.config);
+			case "cache": return createCachePolicy(layer.config);
+			case "rateLimit": return createRateLimitPolicy(layer.config);
+			case "distributedLock": return createLockPolicy(layer.config);
+			default: throw new Error(`Unknown policy type: ${layer.type}`);
+		}
+	}
+	#wrapFn(fn) {
+		return (ctx) => fn({
+			signal: ctx.signal,
+			attempt: ctx.attempt ?? 0
+		});
+	}
+	#emitErrorHooks(error) {
+		if (error instanceof TimeoutError$1) {
+			emitEvent(TelemetryEvents.TIMEOUT);
+			notifyPlugins("onTimeout", {});
+			const timeoutLayer = this.layers.find((l) => l.type === "timeout");
+			if (timeoutLayer) timeoutLayer.config.onTimeout?.();
+		} else if (error instanceof BulkheadFullError) {
+			emitEvent(TelemetryEvents.BULKHEAD_REJECTED);
+			notifyPlugins("onBulkheadRejected", {});
+			const bulkheadLayer = this.layers.find((l) => l.type === "bulkhead");
+			if (bulkheadLayer) bulkheadLayer.config.onRejected?.();
+		}
+	}
+	async #executeWithSpan(policy, fn, spanConfig) {
+		const otelApi$1 = await loadOtelApi();
+		if (!otelApi$1) return policy.execute(fn);
+		return otelApi$1.trace.getTracer("tenace").startActiveSpan(spanConfig.name, async (span) => {
+			try {
+				if (spanConfig.attributes) for (const [key, value] of Object.entries(spanConfig.attributes)) span.setAttribute(key, value);
+				this.#addPolicyAttributes(span);
+				const wrappedFn = this.layers.some((l) => l.type === "retry") ? this.#wrapWithAttemptSpans(fn) : fn;
+				const result = await policy.execute(wrappedFn);
+				span.setStatus({ code: otelApi$1.SpanStatusCode.OK });
+				return result;
+			} catch (error) {
+				const wrappedError = wrapError(error);
+				this.#emitErrorHooks(wrappedError);
+				span.setStatus({
+					code: otelApi$1.SpanStatusCode.ERROR,
+					message: wrappedError instanceof Error ? wrappedError.message : "Unknown error"
+				});
+				span.recordException(wrappedError instanceof Error ? wrappedError : new Error(String(wrappedError)));
+				throw wrappedError;
+			} finally {
+				span.end();
+			}
+		});
+	}
+	#wrapWithAttemptSpans(fn) {
+		return (ctx) => recordSpan("tenace.retry.attempt", () => fn(ctx), { "tenace.attempt": ctx.attempt ?? 0 });
+	}
+	#addPolicyAttributes(span) {
+		const policies = this.layers.filter((l) => l.type !== "span").map((l) => l.type);
+		if (policies.length > 0) span.setAttribute("tenace.policies", policies.join(","));
+		for (const layer of this.layers) switch (layer.type) {
+			case "retry": {
+				const config = layer.config;
+				span.setAttribute("tenace.retry.max_attempts", config.times ?? 3);
+				break;
+			}
+			case "timeout": {
+				const config = layer.config;
+				span.setAttribute("tenace.timeout.duration_ms", config.durationMs);
+				break;
+			}
+			case "bulkhead": {
+				const config = layer.config;
+				span.setAttribute("tenace.bulkhead.limit", config.limit);
+				break;
+			}
+		}
+	}
+	wrap(fn) {
+		return () => this.execute(fn);
+	}
+};
+var TenacePolicy = class TenacePolicy extends PolicyConfigurator {
+	#resolvedLayers = null;
+	constructor(layers = []) {
+		super();
+		this.layers = layers;
+	}
+	createInstance(layers) {
+		return new TenacePolicy(layers);
+	}
+	#resolveSharedLayers() {
+		if (this.#resolvedLayers) return this.#resolvedLayers;
+		this.#resolvedLayers = this.layers.map((layer) => {
+			if (layer.type === "circuitBreaker" && !layer.instance) return {
+				...layer,
+				instance: createCircuitBreakerPolicy(layer.config)
+			};
+			if (layer.type === "bulkhead" && !layer.instance) {
+				const config = layer.config;
+				return {
+					...layer,
+					instance: bulkhead(config.limit, config.queue)
+				};
+			}
+			return layer;
+		});
+		return this.#resolvedLayers;
+	}
+	get circuitBreaker() {
+		const cbLayer = this.#resolveSharedLayers().find((l) => l.type === "circuitBreaker");
+		if (!cbLayer?.instance) return null;
+		const cb = cbLayer.instance;
+		return {
+			get state() {
+				if (cb.state === CircuitState.Open) return "open";
+				if (cb.state === CircuitState.HalfOpen) return "half-open";
+				return "closed";
+			},
+			get isOpen() {
+				return cb.state === CircuitState.Open;
+			},
+			get isClosed() {
+				return cb.state === CircuitState.Closed;
+			},
+			get isHalfOpen() {
+				return cb.state === CircuitState.HalfOpen;
+			},
+			isolate() {
+				return cb.isolate();
+			}
+		};
+	}
+	wrap(fn) {
+		return () => this.call(fn).execute();
+	}
+	call(fn) {
+		return new TenaceBuilder({
+			fn,
+			layers: this.#resolveSharedLayers()
+		});
+	}
+};
+var Semaphore = class {
+	#permits;
+	#queue = [];
+	#activeCount = 0;
+	constructor(permits) {
+		if (permits < 1) throw new Error("Semaphore permits must be at least 1");
+		this.#permits = permits;
+	}
+	get availablePermits() {
+		return this.#permits - this.#activeCount;
+	}
+	get activeCount() {
+		return this.#activeCount;
+	}
+	get pendingCount() {
+		return this.#queue.length;
+	}
+	get permits() {
+		return this.#permits;
+	}
+	async acquire() {
+		return new Promise((resolve) => {
+			const tryAcquire = () => {
+				if (this.#activeCount < this.#permits) {
+					this.#activeCount++;
+					resolve(() => this.#release());
+				} else this.#queue.push(tryAcquire);
+			};
+			tryAcquire();
+		});
+	}
+	#release() {
+		this.#activeCount--;
+		const next = this.#queue.shift();
+		if (next) next();
+	}
+	async run(fn) {
+		const release = await this.acquire();
+		try {
+			return await fn();
+		} finally {
+			release();
+		}
+	}
+	wrap(fn) {
+		return async (...args) => {
+			return this.run(() => fn(...args));
+		};
+	}
+	async map(items, fn) {
+		const itemsArray = Array.from(items);
+		return Promise.all(itemsArray.map((item, index) => this.run(() => fn(item, index))));
+	}
+	clearQueue() {
+		this.#queue = [];
+	}
+};
+function semaphore(permits) {
+	return new Semaphore(permits);
+}
+var CollectionBuilder = class {
+	#tasks;
+	#concurrency = Infinity;
+	#retryAttempts = 0;
+	#retryOptions;
+	#timeoutMs;
+	#timeoutStrategy = "cooperative";
+	#stopOnFirstError = true;
+	#signal;
+	#onTaskComplete;
+	#onTaskError;
+	#onProgress;
+	constructor(tasks) {
+		this.#tasks = tasks;
+	}
+	withConcurrency(limit) {
+		this.#concurrency = limit;
+		return this;
+	}
+	withRetryPerTask(attempts, options) {
+		this.#retryAttempts = attempts;
+		if (options) this.#retryOptions = options;
+		return this;
+	}
+	withTimeoutPerTask(duration, strategy = "cooperative") {
+		this.#timeoutMs = parseDuration(duration);
+		this.#timeoutStrategy = strategy;
+		return this;
+	}
+	stopOnError(stop) {
+		this.#stopOnFirstError = stop;
+		return this;
+	}
+	withSignal(signal) {
+		this.#signal = signal;
+		return this;
+	}
+	onTaskComplete(callback) {
+		this.#onTaskComplete = callback;
+		return this;
+	}
+	onTaskError(callback) {
+		this.#onTaskError = callback;
+		return this;
+	}
+	onProgress(callback) {
+		this.#onProgress = callback;
+		return this;
+	}
+	async execute() {
+		const results = await this.#run();
+		const firstError = results.find((r) => r.status === "rejected");
+		if (firstError && firstError.status === "rejected") throw firstError.reason;
+		return results.map((r) => {
+			if (r.status === "fulfilled") return r.value;
+			throw r.reason;
+		});
+	}
+	async settle() {
+		const originalStopOnError = this.#stopOnFirstError;
+		this.#stopOnFirstError = false;
+		const results = await this.#run();
+		this.#stopOnFirstError = originalStopOnError;
+		return results;
+	}
+	async #run() {
+		const total = this.#tasks.length;
+		if (total === 0) return [];
+		const results = Array.from({ length: total });
+		let completed = 0;
+		let failed = 0;
+		let aborted = false;
+		const semaphore$1 = new Semaphore(this.#concurrency === Infinity ? total : this.#concurrency);
+		if (this.#signal?.aborted) {
+			const error = /* @__PURE__ */ new Error("Operation aborted");
+			error.name = "AbortError";
+			throw error;
+		}
+		const abortHandler = () => {
+			aborted = true;
+		};
+		this.#signal?.addEventListener("abort", abortHandler);
+		const executeTask = async (task, index) => {
+			if (aborted) {
+				const error = /* @__PURE__ */ new Error("Operation aborted");
+				error.name = "AbortError";
+				results[index] = {
+					status: "rejected",
+					reason: error,
+					index
+				};
+				return;
+			}
+			try {
+				const value = await semaphore$1.run(() => this.#executeWithPolicies(task, index));
+				completed++;
+				results[index] = {
+					status: "fulfilled",
+					value,
+					index
+				};
+				const progress = {
+					completed,
+					failed,
+					total,
+					index
+				};
+				this.#onTaskComplete?.(value, progress);
+				this.#onProgress?.(progress);
+			} catch (error) {
+				failed++;
+				const err = error instanceof Error ? error : new Error(String(error));
+				results[index] = {
+					status: "rejected",
+					reason: err,
+					index
+				};
+				const progress = {
+					completed,
+					failed,
+					total,
+					index
+				};
+				this.#onTaskError?.(err, progress);
+				this.#onProgress?.(progress);
+				if (this.#stopOnFirstError) aborted = true;
+			}
+		};
+		await Promise.all(this.#tasks.map((task, index) => executeTask(task, index)));
+		this.#signal?.removeEventListener("abort", abortHandler);
+		return results;
+	}
+	async #executeWithPolicies(task, _index) {
+		let fn = task;
+		if (this.#timeoutMs) {
+			const timeoutMs = this.#timeoutMs;
+			const strategy = this.#timeoutStrategy;
+			fn = () => this.#withTimeout({
+				task,
+				ms: timeoutMs,
+				strategy
+			});
+		}
+		if (this.#retryAttempts > 0) return this.#withRetry(fn);
+		return fn();
+	}
+	async #withTimeout(options) {
+		if (options.strategy === "cooperative") return Promise.race([options.task(), new Promise((_, reject) => {
+			setTimeout(() => {
+				const error = /* @__PURE__ */ new Error(`Operation timed out after ${options.ms}ms`);
+				error.name = "TimeoutError";
+				reject(error);
+			}, options.ms);
+		})]);
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => controller.abort(), options.ms);
+		try {
+			const result = await Promise.race([options.task(), new Promise((_, reject) => {
+				controller.signal.addEventListener("abort", () => {
+					const error = /* @__PURE__ */ new Error(`Operation timed out after ${options.ms}ms`);
+					error.name = "TimeoutError";
+					reject(error);
+				});
+			})]);
+			clearTimeout(timeoutId);
+			return result;
+		} catch (error) {
+			clearTimeout(timeoutId);
+			throw error;
+		}
+	}
+	async #withRetry(task) {
+		let lastError;
+		const maxAttempts = this.#retryAttempts + 1;
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) try {
+			return await task();
+		} catch (error) {
+			lastError = error instanceof Error ? error : new Error(String(error));
+			if (this.#retryOptions?.abortIf?.(lastError)) throw lastError;
+			if (attempt < maxAttempts) {
+				if (this.#retryOptions?.retryIf && !this.#retryOptions.retryIf(lastError)) throw lastError;
+				if (this.#retryOptions?.delay !== void 0) {
+					const delay = this.#calculateDelay(attempt, lastError);
+					await this.#sleep(delay);
+				}
+			}
+		}
+		throw lastError;
+	}
+	#calculateDelay(attempt, error) {
+		const delay = this.#retryOptions?.delay;
+		if (delay === void 0) return 0;
+		if (typeof delay === "function") return delay(attempt, error);
+		return parseDuration(delay);
+	}
+	#sleep(ms$1) {
+		return new Promise((resolve) => setTimeout(resolve, ms$1));
+	}
+};
+const backoff = {
+	constant(delay) {
+		const ms$1 = parseDuration(delay);
+		return () => ms$1;
+	},
+	exponential(options = {}) {
+		const initial = parseDuration(options.initial ?? 100);
+		const max = parseDuration(options.max ?? 3e4);
+		const exponent = options.exponent ?? 2;
+		return (attempt) => {
+			const delay = initial * Math.pow(exponent, attempt - 1);
+			return Math.min(delay, max);
+		};
+	},
+	exponentialWithJitter(options = {}) {
+		const initial = parseDuration(options.initial ?? 100);
+		const max = parseDuration(options.max ?? 3e4);
+		const exponent = options.exponent ?? 2;
+		const jitter = options.jitter ?? "full";
+		let previousDelay = initial;
+		return (attempt) => {
+			if (jitter === "decorrelated") {
+				const delay = Math.min(max, randomBetween(initial, previousDelay * 3));
+				previousDelay = delay;
+				return delay;
+			}
+			const exponentialDelay = initial * Math.pow(exponent, attempt - 1);
+			const cappedDelay = Math.min(exponentialDelay, max);
+			return Math.floor(Math.random() * cappedDelay);
+		};
+	},
+	linear(options = {}) {
+		const initial = parseDuration(options.initial ?? 100);
+		const step = parseDuration(options.step ?? 100);
+		const max = parseDuration(options.max ?? 3e4);
+		return (attempt) => {
+			const delay = initial + step * (attempt - 1);
+			return Math.min(delay, max);
+		};
+	}
+};
+function randomBetween(min, max) {
+	return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+const Tenace = {
+	call(fn) {
+		return new TenaceBuilder({ fn });
+	},
+	policy() {
+		return new TenacePolicy();
+	},
+	wrap(fn, policy) {
+		return policy.wrap(fn);
+	},
+	all(tasks) {
+		return new CollectionBuilder(tasks);
+	},
+	map(items, mapper) {
+		return new CollectionBuilder(Array.from(items).map((item, index) => () => mapper(item, index)));
+	},
+	waitFor(condition, options) {
+		return waitFor(condition, options);
+	},
+	chaos: {
+		enable: (config) => chaosManager.enable(config),
+		disable: () => chaosManager.disable(),
+		isEnabled: () => chaosManager.isEnabled()
+	},
+	hooks: {
+		onRetry: (fn) => registerHook("onRetry", fn),
+		onRetryExhausted: (fn) => registerHook("onRetryExhausted", fn),
+		onTimeout: (fn) => registerHook("onTimeout", fn),
+		onCircuitOpened: (fn) => registerHook("onCircuitOpened", fn),
+		onCircuitClosed: (fn) => registerHook("onCircuitClosed", fn),
+		onCircuitHalfOpened: (fn) => registerHook("onCircuitHalfOpened", fn),
+		onBulkheadRejected: (fn) => registerHook("onBulkheadRejected", fn),
+		onCacheHit: (fn) => registerHook("onCacheHit", fn),
+		onCacheMiss: (fn) => registerHook("onCacheMiss", fn),
+		onRateLimitRejected: (fn) => registerHook("onRateLimitRejected", fn),
+		onFallback: (fn) => registerHook("onFallback", fn),
+		onLockAcquired: (fn) => registerHook("onLockAcquired", fn),
+		onLockRejected: (fn) => registerHook("onLockRejected", fn)
+	}
+};
+export { CollectionBuilder, Semaphore, Tenace, backoff, clearPlugins, configStore, getPlugins, registerHook, semaphore, use };