@loggerjs/processors 0.0.1

package/dist/index.cjs

@@ -0,0 +1,1379 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _loggerjs_core = require("@loggerjs/core");
+//#region src/redact.ts
+function matchesKey(key, path, value, matchers) {
+	return matchers.some((matcher) => {
+		if (typeof matcher === "string") return matcher.toLowerCase() === key.toLowerCase();
+		if (matcher instanceof RegExp) return matcher.test(key) || matcher.test(path);
+		return matcher(key, path, value);
+	});
+}
+function pathMatches(path, paths) {
+	return paths.includes(path);
+}
+function redactValue(value, options, path = "", depth = 0, seen = /* @__PURE__ */ new WeakMap()) {
+	if (value === null || value === void 0) return value;
+	if (typeof value !== "object") return value;
+	if (depth >= options.maxDepth) return value;
+	if (seen.has(value)) return seen.get(value);
+	if (Array.isArray(value)) {
+		const out = [];
+		seen.set(value, out);
+		for (let index = 0; index < value.length; index += 1) out[index] = redactValue(value[index], options, `${path}[${index}]`, depth + 1, seen);
+		return out;
+	}
+	if (value instanceof Error) return value;
+	if (value instanceof Date) return value;
+	const input = value;
+	const out = {};
+	seen.set(value, out);
+	for (const [key, child] of Object.entries(input)) {
+		const childPath = path ? `${path}.${key}` : key;
+		if (matchesKey(key, childPath, child, options.keys ?? []) || pathMatches(childPath, options.paths ?? [])) out[key] = options.replacement;
+		else out[key] = redactValue(child, options, childPath, depth + 1, seen);
+	}
+	return out;
+}
+function redactProcessor(options = {}) {
+	const normalized = {
+		keys: options.keys ?? [
+			"password",
+			"passwd",
+			"secret",
+			"token",
+			"authorization",
+			"cookie",
+			"set-cookie",
+			"apiKey",
+			"api_key"
+		],
+		paths: options.paths ?? [],
+		replacement: options.replacement ?? "[REDACTED]",
+		maxDepth: options.maxDepth ?? 8
+	};
+	return (event) => ({
+		...event,
+		data: redactValue(event.data, normalized),
+		context: redactValue(event.context, normalized),
+		tags: redactValue(event.tags, normalized),
+		error: redactValue(event.error, normalized)
+	});
+}
+//#endregion
+//#region src/sample.ts
+function clampRate$1(rate) {
+	if (Number.isNaN(rate)) return 1;
+	return Math.max(0, Math.min(1, rate));
+}
+function sampleProcessor(options = {}) {
+	const defaultRate = clampRate$1(options.defaultRate ?? 1);
+	const random = options.random ?? Math.random;
+	const rates = options.rates ?? {};
+	return (event) => {
+		const rate = clampRate$1(rates[event.levelName] ?? defaultRate);
+		if (rate >= 1) return event;
+		if (rate <= 0) return false;
+		return random() < rate ? event : false;
+	};
+}
+//#endregion
+//#region src/tags.ts
+function tagsMiddleware(tags) {
+	return (0, _loggerjs_core.createMiddleware)("tags", (record) => {
+		record.tags = {
+			...record.tags,
+			...tags
+		};
+		return record;
+	});
+}
+function typeMiddleware(type) {
+	return (0, _loggerjs_core.createMiddleware)("type", (record) => {
+		record.type = type;
+		return record;
+	});
+}
+function contextMiddleware(context) {
+	return (0, _loggerjs_core.createMiddleware)("context", (record) => {
+		record.ctx = (0, _loggerjs_core.createBoundContext)({
+			...record.ctx,
+			...context
+		});
+		return record;
+	});
+}
+function tagsProcessor(tags) {
+	return (event) => ({
+		...event,
+		tags: {
+			...event.tags,
+			...tags
+		}
+	});
+}
+function typeProcessor(type) {
+	return (event) => ({
+		...event,
+		type
+	});
+}
+function contextProcessor(context) {
+	return (event) => ({
+		...event,
+		context: {
+			...event.context,
+			...context
+		}
+	});
+}
+//#endregion
+//#region src/dedupe.ts
+function dedupeProcessor(options = {}) {
+	const windowMs = options.windowMs ?? 1e3;
+	const maxEntries = options.maxEntries ?? 1e3;
+	const keyFor = options.key ?? ((event) => `${event.levelName}:${event.message}:${event.error?.message ?? ""}`);
+	const seen = /* @__PURE__ */ new Map();
+	return (event, context) => {
+		const now = context.now();
+		const key = keyFor(event);
+		const previous = seen.get(key);
+		if (previous !== void 0 && now - previous < windowMs) return false;
+		seen.set(key, now);
+		if (seen.size > maxEntries) {
+			const cutoff = now - windowMs;
+			for (const [entryKey, timestamp] of seen) if (timestamp < cutoff || seen.size > maxEntries) seen.delete(entryKey);
+		}
+		return event;
+	};
+}
+//#endregion
+//#region src/trace.ts
+function traceContextMiddleware(provider) {
+	return (0, _loggerjs_core.createMiddleware)("traceContext", (record) => {
+		const trace = provider();
+		if (!trace) return record;
+		record.trace = {
+			...record.trace,
+			...trace
+		};
+		return record;
+	});
+}
+function traceContextProcessor(provider) {
+	return (event) => {
+		const trace = provider();
+		if (!trace) return event;
+		return {
+			...event,
+			trace: {
+				...event.trace,
+				...trace
+			}
+		};
+	};
+}
+//#endregion
+//#region src/rate-limit.ts
+const DEFAULT_EXEMPT_LEVELS$1 = new Set(["error", "fatal"]);
+function defaultKey$2(event) {
+	return `${event.logger}:${event.levelName}:${event.source?.integration ?? event.type ?? "manual"}`;
+}
+function normalizePositive(value, fallback) {
+	if (value === void 0 || !Number.isFinite(value) || value <= 0) return fallback;
+	return value;
+}
+function normalizeNonNegative(value, fallback) {
+	if (value === void 0 || !Number.isFinite(value) || value < 0) return fallback;
+	return value;
+}
+function snapshot$3(bucket) {
+	return {
+		key: bucket.key,
+		tokens: bucket.tokens,
+		lastRefillMs: bucket.lastRefillMs
+	};
+}
+function rateLimitProcessor(options = {}) {
+	const capacity = normalizePositive(options.capacity, 100);
+	const refillPerSecond = normalizeNonNegative(options.refillPerSecond, capacity);
+	const maxBuckets = Math.max(1, Math.floor(options.maxBuckets ?? 1e4));
+	const key = options.key ?? defaultKey$2;
+	const exemptLevels = new Set(options.exemptLevels ?? DEFAULT_EXEMPT_LEVELS$1);
+	const buckets = /* @__PURE__ */ new Map();
+	const prune = () => {
+		while (buckets.size > maxBuckets) {
+			let oldest;
+			for (const bucket of buckets.values()) if (!oldest || bucket.lastSeenMs < oldest.lastSeenMs) oldest = bucket;
+			if (!oldest) return;
+			buckets.delete(oldest.key);
+		}
+	};
+	const processor = ((event, context) => {
+		if (exemptLevels.has(event.levelName)) return event;
+		const now = context.now();
+		const bucketKey = key(event);
+		let bucket = buckets.get(bucketKey);
+		if (!bucket) {
+			bucket = {
+				key: bucketKey,
+				tokens: capacity,
+				lastRefillMs: now,
+				lastSeenMs: now
+			};
+			buckets.set(bucketKey, bucket);
+			prune();
+		}
+		const elapsedSeconds = Math.max(0, (now - bucket.lastRefillMs) / 1e3);
+		bucket.tokens = Math.min(capacity, bucket.tokens + elapsedSeconds * refillPerSecond);
+		bucket.lastRefillMs = now;
+		bucket.lastSeenMs = now;
+		if (bucket.tokens >= 1) {
+			bucket.tokens -= 1;
+			return event;
+		}
+		(0, _loggerjs_core.incrementLoggerMetaCounter)("processor.rateLimit.dropped");
+		(0, _loggerjs_core.incrementLoggerMetaCounter)(`processor.rateLimit.dropped.${event.levelName}`);
+		options.onDrop?.(event, bucketKey);
+		return false;
+	});
+	processor.buckets = () => [...buckets.values()].map(snapshot$3);
+	return processor;
+}
+//#endregion
+//#region src/fingers-crossed.ts
+const DEFAULT_KEY = "default";
+function normalizeCount$1(value, fallback) {
+	if (value === void 0 || !Number.isFinite(value)) return fallback;
+	return Math.max(0, Math.floor(value));
+}
+function normalizeBucketCount$1(value) {
+	if (value === void 0 || !Number.isFinite(value)) return 1024;
+	return Math.max(1, Math.floor(value));
+}
+function incrementBy(name, count) {
+	for (let index = 0; index < count; index += 1) (0, _loggerjs_core.incrementLoggerMetaCounter)(name);
+}
+function snapshot$2(state) {
+	return {
+		key: state.key,
+		buffered: state.buffer.length,
+		activeUntilMs: state.activeUntilMs,
+		lastSeenMs: state.lastSeenMs
+	};
+}
+function isFlushFunction(target) {
+	return typeof target === "function";
+}
+function isPromiseLike(value) {
+	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+async function flushToTarget(target, events, context) {
+	if (events.length === 0) return;
+	if (isFlushFunction(target)) {
+		await target(events, context);
+		return;
+	}
+	const minLevel = target.minLevel === void 0 ? void 0 : (0, _loggerjs_core.toLevelValue)(target.minLevel);
+	const selected = minLevel === void 0 ? [...events] : events.filter((event) => event.level >= minLevel);
+	if (selected.length === 0) return;
+	const transportContext = {
+		loggerName: context.loggerName,
+		now: context.now,
+		toEvent: _loggerjs_core.recordToEvent,
+		reportInternalError: context.reportInternalError
+	};
+	if (target.logBatch) {
+		const result = target.logBatch(selected, transportContext);
+		if (isPromiseLike(result)) await result;
+		return;
+	}
+	if (target.log) {
+		for (const event of selected) {
+			const result = target.log(event, transportContext);
+			if (isPromiseLike(result)) await result;
+		}
+		return;
+	}
+	const records = selected.map(_loggerjs_core.eventToRecord);
+	if (target.writeBatch) {
+		const result = target.writeBatch(records, transportContext);
+		if (isPromiseLike(result)) await result;
+		return;
+	}
+	if (!target.write) return;
+	for (const record of records) {
+		const result = target.write(record, transportContext);
+		if (isPromiseLike(result)) await result;
+	}
+}
+function scheduleFlush(target, events, context) {
+	if (!target || events.length === 0) return;
+	const batch = [...events];
+	incrementBy("processor.fingersCrossed.flushed", batch.length);
+	flushToTarget(target, batch, context).catch((error) => {
+		context.reportInternalError(error, {
+			phase: "processor",
+			processor: "fingersCrossed"
+		});
+	});
+}
+function fingersCrossedProcessor(options = {}) {
+	const triggerLevel = (0, _loggerjs_core.toLevelValue)(options.triggerLevel ?? "error");
+	const shouldTrigger = options.shouldTrigger ?? ((event) => event.level >= triggerLevel);
+	const bufferSize = normalizeCount$1(options.bufferSize, 100);
+	const maxBuckets = normalizeBucketCount$1(options.maxBuckets);
+	const keyFor = options.key ?? (() => DEFAULT_KEY);
+	const includeTrigger = options.includeTrigger ?? true;
+	const passthroughTrigger = options.passthroughTrigger ?? !options.flushTo;
+	const passthroughAfterTrigger = options.passthroughAfterTrigger ?? true;
+	const activationMs = options.activationMs;
+	const states = /* @__PURE__ */ new Map();
+	const drop = (event, reason, key) => {
+		(0, _loggerjs_core.incrementLoggerMetaCounter)("processor.fingersCrossed.dropped");
+		(0, _loggerjs_core.incrementLoggerMetaCounter)(`processor.fingersCrossed.dropped.${reason}`);
+		options.onDrop?.(event, reason, key);
+	};
+	const getState = (key, now) => {
+		let state = states.get(key);
+		if (!state) {
+			state = {
+				key,
+				buffer: [],
+				activeUntilMs: 0,
+				lastSeenMs: now
+			};
+			states.set(key, state);
+		}
+		state.lastSeenMs = now;
+		while (states.size > maxBuckets) {
+			let oldest;
+			for (const candidate of states.values()) if (!oldest || candidate.lastSeenMs < oldest.lastSeenMs) oldest = candidate;
+			if (!oldest) break;
+			for (const buffered of oldest.buffer) drop(buffered, "bucket-pruned", oldest.key);
+			states.delete(oldest.key);
+		}
+		return state;
+	};
+	const processor = ((event, context) => {
+		const now = context.now();
+		const key = keyFor(event);
+		const state = getState(key, now);
+		if (state.activeUntilMs > 0 && state.activeUntilMs <= now) state.activeUntilMs = 0;
+		if (state.activeUntilMs > now) return passthroughAfterTrigger ? event : false;
+		if (shouldTrigger(event)) {
+			const buffered = state.buffer.splice(0);
+			state.activeUntilMs = activationMs === void 0 ? Number.POSITIVE_INFINITY : now + Math.max(0, activationMs);
+			(0, _loggerjs_core.incrementLoggerMetaCounter)("processor.fingersCrossed.triggered");
+			options.onTrigger?.(event, buffered, key);
+			scheduleFlush(options.flushTo, includeTrigger ? [...buffered, event] : buffered, context);
+			return passthroughTrigger ? event : false;
+		}
+		if (bufferSize === 0) return false;
+		if (state.buffer.length >= bufferSize) {
+			const dropped = state.buffer.shift();
+			if (dropped) drop(dropped, "buffer-full", key);
+		}
+		state.buffer.push(event);
+		(0, _loggerjs_core.incrementLoggerMetaCounter)("processor.fingersCrossed.buffered");
+		return false;
+	});
+	processor.states = () => [...states.values()].map(snapshot$2);
+	processor.reset = (key) => {
+		if (key === void 0) {
+			states.clear();
+			return;
+		}
+		states.delete(key);
+	};
+	return processor;
+}
+//#endregion
+//#region src/enrich.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeData(current, patch) {
+	if (patch === void 0) return current;
+	if (isRecord$1(current) && isRecord$1(patch)) return {
+		...current,
+		...patch
+	};
+	return patch;
+}
+function mergeRecordData(current, patch) {
+	if (patch === void 0) return current;
+	if (isRecord$1(current) && isRecord$1(patch)) return {
+		...current,
+		...patch
+	};
+	if (isRecord$1(patch)) return patch;
+	return { value: patch };
+}
+function sourceForRecord(source) {
+	if (!source) return void 0;
+	if (typeof source === "string") return source;
+	return source.integration ?? source.runtime;
+}
+function applyPatch(event, patch) {
+	return {
+		...event,
+		message: patch.message ?? event.message,
+		type: patch.type ?? event.type,
+		tags: patch.tags ? {
+			...event.tags,
+			...patch.tags
+		} : event.tags,
+		data: mergeData(event.data, patch.data),
+		context: patch.context ? {
+			...event.context,
+			...patch.context
+		} : event.context,
+		trace: patch.trace ? {
+			...event.trace,
+			...patch.trace
+		} : event.trace,
+		source: patch.source ? {
+			...event.source,
+			...patch.source
+		} : event.source
+	};
+}
+function enrichProcessor(input) {
+	return (event, context) => {
+		const patch = typeof input === "function" ? input(event, context) : input;
+		if (patch === false) return false;
+		if (!patch) return event;
+		return applyPatch(event, patch);
+	};
+}
+function applyRecordPatch(record, patch) {
+	if (patch.message !== void 0) {
+		record.msg = patch.message;
+		record.lazy = null;
+	}
+	if (patch.type !== void 0) record.type = patch.type;
+	if (patch.tags) record.tags = {
+		...record.tags,
+		...patch.tags
+	};
+	if (patch.data !== void 0) record.props = mergeRecordData(record.props, patch.data);
+	if (patch.context) record.ctx = (0, _loggerjs_core.createBoundContext)({
+		...record.ctx,
+		...patch.context
+	});
+	if (patch.trace) record.trace = {
+		...record.trace,
+		...patch.trace
+	};
+	const source = sourceForRecord(patch.source);
+	if (source) record.source = source;
+	return record;
+}
+function enrichMiddleware(input) {
+	return (0, _loggerjs_core.createMiddleware)("enrich", (record, context) => {
+		const patch = typeof input === "function" ? input(record, context) : input;
+		if (patch === false) return null;
+		if (!patch) return record;
+		return applyRecordPatch(record, patch);
+	});
+}
+//#endregion
+//#region src/level-override.ts
+function asMatchers(matcher) {
+	if (!matcher) return [];
+	return Array.isArray(matcher) ? matcher : [matcher];
+}
+function matchOne(matcher, value, event) {
+	if (typeof matcher === "function") return matcher(value, event);
+	if (matcher instanceof RegExp) return matcher.test(value ?? "");
+	return value === matcher;
+}
+function matchString(matcher, value, event) {
+	const matchers = asMatchers(matcher);
+	if (matchers.length === 0) return true;
+	return matchers.some((item) => matchOne(item, value, event));
+}
+function matchTags(expected, actual) {
+	if (!expected) return true;
+	for (const [key, value] of Object.entries(expected)) if (actual?.[key] !== value) return false;
+	return true;
+}
+function matchLevelRange(event, rule) {
+	if (rule.minLevel !== void 0 && event.level < (0, _loggerjs_core.toLevelValue)(rule.minLevel)) return false;
+	if (rule.maxLevel !== void 0 && event.level > (0, _loggerjs_core.toLevelValue)(rule.maxLevel)) return false;
+	return true;
+}
+function matchesRule(event, context, rule) {
+	return (!rule.when || rule.when(event, context)) && matchString(rule.logger, event.logger, event) && matchString(rule.type, event.type, event) && matchString(rule.integration, event.source?.integration, event) && matchString(rule.runtime, event.source?.runtime, event) && matchTags(rule.tags, event.tags) && matchLevelRange(event, rule);
+}
+function resolveLevel(value, event, context) {
+	if (typeof value === "function") {
+		const level = value(event, context);
+		return level === void 0 ? void 0 : level;
+	}
+	return value;
+}
+function applyLevel(event, level) {
+	if (level === void 0) return event;
+	if (level === false || level === "silent") return false;
+	const nextLevel = (0, _loggerjs_core.toLevelValue)(level, event.level);
+	if (!Number.isFinite(nextLevel)) return false;
+	const nextLevelName = (0, _loggerjs_core.toLevelName)(nextLevel);
+	if (nextLevel === event.level && nextLevelName === event.levelName) return event;
+	return {
+		...event,
+		level: nextLevel,
+		levelName: nextLevelName
+	};
+}
+function isOptions(input) {
+	return typeof input === "object" && input !== null && !Array.isArray(input);
+}
+function isRuleArray(input) {
+	return Array.isArray(input);
+}
+function levelOverrideProcessor(input) {
+	if (!isRuleArray(input) && !isOptions(input)) return (event, context) => applyLevel(event, resolveLevel(input, event, context));
+	const rules = isRuleArray(input) ? input : input.rules;
+	return (event, context) => {
+		for (const rule of rules) if (matchesRule(event, context, rule)) return applyLevel(event, resolveLevel(rule.level, event, context));
+		return event;
+	};
+}
+//#endregion
+//#region src/filter-route.ts
+function stringMatchers(matcher) {
+	if (!matcher) return [];
+	return Array.isArray(matcher) ? matcher : [matcher];
+}
+function matchesString(matcher, value, event) {
+	const matchers = stringMatchers(matcher);
+	if (matchers.length === 0) return true;
+	for (const item of matchers) {
+		if (typeof item === "function" && item(value, event)) return true;
+		if (item instanceof RegExp && item.test(value ?? "")) return true;
+		if (typeof item === "string" && value === item) return true;
+	}
+	return false;
+}
+function matchesLevelName(expected, actual) {
+	if (!expected) return true;
+	return Array.isArray(expected) ? expected.includes(actual) : expected === actual;
+}
+function matchesTags(expected, actual) {
+	if (!expected) return true;
+	for (const [key, value] of Object.entries(expected)) if (actual?.[key] !== value) return false;
+	return true;
+}
+function matchesLevelRange(event, match) {
+	if (match.minLevel !== void 0 && event.level < (0, _loggerjs_core.toLevelValue)(match.minLevel)) return false;
+	if (match.maxLevel !== void 0 && event.level > (0, _loggerjs_core.toLevelValue)(match.maxLevel)) return false;
+	return true;
+}
+function matchesEvent(event, context, match) {
+	return (!match.when || match.when(event, context)) && matchesString(match.logger, event.logger, event) && matchesString(match.type, event.type, event) && matchesString(match.integration, event.source?.integration, event) && matchesString(match.runtime, event.source?.runtime, event) && matchesLevelName(match.levelName, event.levelName) && matchesTags(match.tags, event.tags) && matchesLevelRange(event, match);
+}
+function isFilterRuleArray(input) {
+	return Array.isArray(input);
+}
+function normalizeFilterOptions(input) {
+	return isFilterRuleArray(input) ? { rules: input } : input;
+}
+function reportDrop(options, event, reason) {
+	options.onDrop?.(event, reason);
+	return false;
+}
+function filterProcessor(input) {
+	if (typeof input === "function") return (event, context) => input(event, context) ? event : false;
+	const options = normalizeFilterOptions(input);
+	const defaultAction = options.defaultAction ?? "keep";
+	return (event, context) => {
+		for (const rule of options.rules) {
+			if (!matchesEvent(event, context, rule)) continue;
+			return (rule.action ?? "drop") === "keep" ? event : reportDrop(options, event, rule.reason ?? "rule");
+		}
+		return defaultAction === "keep" ? event : reportDrop(options, event, "default");
+	};
+}
+function hasRoute(route) {
+	return Boolean(route?.transports || route?.excludeTransports);
+}
+function routeFromRule(rule) {
+	return {
+		transports: rule.transports,
+		excludeTransports: rule.excludeTransports
+	};
+}
+function isRouteOptions(input) {
+	return typeof input === "object" && input !== null && "rules" in input;
+}
+function isRouteRuleArray(input) {
+	return Array.isArray(input);
+}
+function routeProcessor(input) {
+	if (!isRouteRuleArray(input) && !isRouteOptions(input)) return (event) => hasRoute(input) ? (0, _loggerjs_core.withLogEventRoute)(event, input) : event;
+	const rules = isRouteRuleArray(input) ? input : input.rules;
+	const defaultRoute = isRouteRuleArray(input) ? void 0 : input.defaultRoute;
+	return (event, context) => {
+		for (const rule of rules) if (matchesEvent(event, context, rule)) {
+			const route = routeFromRule(rule);
+			return hasRoute(route) ? (0, _loggerjs_core.withLogEventRoute)(event, route) : event;
+		}
+		return hasRoute(defaultRoute) ? (0, _loggerjs_core.withLogEventRoute)(event, defaultRoute) : event;
+	};
+}
+//#endregion
+//#region src/fingerprint.ts
+const DEFAULT_PARTS = [
+	"logger",
+	"type",
+	"message",
+	"error.name",
+	"error.message",
+	"source.integration"
+];
+function fnv1a32(input) {
+	let hash = 2166136261;
+	for (let index = 0; index < input.length; index += 1) {
+		hash ^= input.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(16).padStart(8, "0");
+}
+function stackTop(stack) {
+	if (!stack) return void 0;
+	const lines = stack.split("\n");
+	return (lines[1] ?? lines[0])?.trim();
+}
+function partValue(part, event, context) {
+	if (typeof part === "function") return part(event, context);
+	if (part === "logger") return event.logger;
+	if (part === "level") return event.levelName;
+	if (part === "type") return event.type;
+	if (part === "message") return event.message;
+	if (part === "error.name") return event.error?.name;
+	if (part === "error.message") return event.error?.message;
+	if (part === "source.integration") return event.source?.integration;
+	if (part === "source.runtime") return event.source?.runtime;
+	return stackTop(event.error?.stack);
+}
+function stringifyPart(value) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") return String(value);
+	if (value instanceof Error) return `${value.name}:${value.message}`;
+	return String(value);
+}
+function writeFingerprint(event, target, key, fingerprint) {
+	if (target === "context") return {
+		...event,
+		context: {
+			...event.context,
+			[key]: fingerprint
+		}
+	};
+	return {
+		...event,
+		tags: {
+			...event.tags,
+			[key]: fingerprint
+		}
+	};
+}
+function fingerprintProcessor(options = {}) {
+	const parts = options.parts ?? DEFAULT_PARTS;
+	const hash = options.hash ?? fnv1a32;
+	const target = options.target ?? "tags";
+	const key = options.key ?? "fingerprint";
+	const separator = options.separator ?? "";
+	const prefix = options.prefix ?? "";
+	return (event, context) => {
+		return writeFingerprint(event, target, key, `${prefix}${hash(parts.map((part) => stringifyPart(partValue(part, event, context))).join(separator))}`);
+	};
+}
+//#endregion
+//#region src/normalize-error.ts
+function stackWithLimit(stack, maxStackLines) {
+	if (typeof stack !== "string" || maxStackLines <= 0) return void 0;
+	return stack.split("\n").slice(0, maxStackLines).join("\n");
+}
+function errorMessage(value) {
+	if (typeof value === "string") return value;
+	if (value && typeof value === "object" && "message" in value) {
+		const message = value.message;
+		if (typeof message === "string") return message;
+	}
+	return String(value);
+}
+function errorName(value) {
+	if (value && typeof value === "object" && "name" in value) {
+		const name = value.name;
+		if (typeof name === "string") return name;
+	}
+	return value instanceof Error ? value.name : void 0;
+}
+function objectRecord(value) {
+	return value && typeof value === "object" ? value : void 0;
+}
+function normalizeUnknownError(value, options, depth, seen) {
+	if (depth > options.maxDepth) return { message: "[Max error depth]" };
+	if (value === null || value === void 0) return { message: String(value) };
+	if (typeof value !== "object") return { message: errorMessage(value) };
+	if (seen.has(value)) return { message: "[Circular error]" };
+	seen.add(value);
+	const record = objectRecord(value);
+	const out = {
+		name: errorName(value),
+		message: errorMessage(value),
+		stack: stackWithLimit(record?.stack, options.maxStackLines)
+	};
+	const code = record?.code;
+	if (typeof code === "string" || typeof code === "number") out.code = code;
+	if (record?.cause !== void 0) out.cause = normalizeUnknownError(record.cause, options, depth + 1, seen);
+	if (options.includeAggregateErrors && Array.isArray(record?.errors)) out.errors = record.errors.map((item) => normalizeUnknownError(item, options, depth + 1, seen));
+	if (options.includeEnumerableProperties && record) for (const key of Object.keys(record)) {
+		if (key in out || key === "errors" || key === "cause") continue;
+		out[key] = record[key];
+	}
+	return out;
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeDataErrors(data, options, seen) {
+	if (!isRecord(data) || options.dataErrorKeys.length === 0) return data;
+	let next;
+	for (const key of options.dataErrorKeys) {
+		if (!(key in data) || data[key] === void 0 || data[key] === null) continue;
+		next ??= { ...data };
+		next[key] = normalizeUnknownError(data[key], options, 0, seen);
+	}
+	return next ?? data;
+}
+function normalizeErrorProcessor(options = {}) {
+	const normalized = {
+		maxDepth: Math.max(0, Math.floor(options.maxDepth ?? 5)),
+		maxStackLines: Math.max(0, Math.floor(options.maxStackLines ?? 40)),
+		includeEnumerableProperties: options.includeEnumerableProperties ?? true,
+		includeAggregateErrors: options.includeAggregateErrors ?? true,
+		dataErrorKeys: options.dataErrorKeys ?? []
+	};
+	return (event) => {
+		const seen = /* @__PURE__ */ new WeakSet();
+		const error = event.error === void 0 ? void 0 : normalizeUnknownError(event.error, normalized, 0, seen);
+		const data = normalizeDataErrors(event.data, normalized, seen);
+		if (error === void 0 && data === event.data) return event;
+		return {
+			...event,
+			error,
+			data
+		};
+	};
+}
+//#endregion
+//#region src/stack-parser.ts
+const V8_FRAME = /^\s*at\s+(?:(.*?)\s+\()?(.+?):(\d+):(\d+)\)?\s*$/;
+const FIREFOX_FRAME = /^\s*(?:(.*?)@)?(.+?):(\d+):(\d+)\s*$/;
+function toNumber(input) {
+	const value = Number(input);
+	return Number.isFinite(value) ? value : void 0;
+}
+function cleanFunctionName(input) {
+	if (!input || input === "async") return void 0;
+	return input.trim() || void 0;
+}
+function frameFromMatch(raw, match) {
+	return {
+		raw,
+		function: cleanFunctionName(match[1]),
+		file: match[2],
+		line: match[3] ? toNumber(match[3]) : void 0,
+		column: match[4] ? toNumber(match[4]) : void 0
+	};
+}
+function parseLine(raw) {
+	const v8 = raw.match(V8_FRAME);
+	if (v8) return frameFromMatch(raw, v8);
+	const firefox = raw.match(FIREFOX_FRAME);
+	if (firefox) return frameFromMatch(raw, firefox);
+	return { raw };
+}
+function isInternalFrame(frame) {
+	const file = frame.file ?? frame.raw ?? "";
+	return file.startsWith("node:internal") || file.includes("/node:internal/");
+}
+function defaultParseStack(stack) {
+	const frames = [];
+	for (const raw of stack.split("\n")) {
+		const line = raw.trim();
+		if (!line || !line.includes(":")) continue;
+		const frame = parseLine(line);
+		if (frame.file || line.startsWith("at ") || line.includes("@")) frames.push(frame);
+	}
+	return frames;
+}
+function stripRaw(frame) {
+	const { raw: _raw, ...rest } = frame;
+	return rest;
+}
+function normalizeFrames(frames, options) {
+	const out = [];
+	for (const frame of frames) {
+		if (options.dropInternal && isInternalFrame(frame)) continue;
+		out.push(options.includeRaw ? frame : stripRaw(frame));
+		if (out.length >= options.maxFrames) break;
+	}
+	return out;
+}
+function writeFrames(event, options, frames) {
+	if (options.target === "context") return {
+		...event,
+		context: {
+			...event.context,
+			[options.key]: frames
+		}
+	};
+	return {
+		...event,
+		error: {
+			message: event.error?.message ?? event.message,
+			...event.error,
+			[options.key]: frames
+		}
+	};
+}
+function parseStack(stack) {
+	return defaultParseStack(stack);
+}
+function stackParserProcessor(options = {}) {
+	const normalized = {
+		maxFrames: Math.max(0, Math.floor(options.maxFrames ?? 20)),
+		dropInternal: options.dropInternal ?? false,
+		includeRaw: options.includeRaw ?? true,
+		target: options.target ?? "error",
+		key: options.key ?? "frames",
+		parser: options.parser ?? defaultParseStack
+	};
+	return (event) => {
+		const stack = event.error?.stack;
+		if (!stack || normalized.maxFrames === 0) return event;
+		const frames = normalizeFrames(normalized.parser(stack), normalized);
+		return frames.length > 0 ? writeFrames(event, normalized, frames) : event;
+	};
+}
+//#endregion
+//#region src/privacy-guard.ts
+const DEFAULT_DENY_KEYS = [
+	"password",
+	"passwd",
+	"secret",
+	"token",
+	"authorization",
+	"cookie",
+	"set-cookie",
+	"apiKey",
+	"api_key",
+	/session/i
+];
+function digitsOnly(input) {
+	return input.replace(/\D/g, "");
+}
+function passesLuhn(input) {
+	const digits = digitsOnly(input);
+	if (digits.length < 13 || digits.length > 19) return false;
+	let sum = 0;
+	let doubleDigit = false;
+	for (let index = digits.length - 1; index >= 0; index -= 1) {
+		let value = digits.charCodeAt(index) - 48;
+		if (doubleDigit) {
+			value *= 2;
+			if (value > 9) value -= 9;
+		}
+		sum += value;
+		doubleDigit = !doubleDigit;
+	}
+	return sum % 10 === 0;
+}
+const DEFAULT_PATTERNS = [
+	{
+		name: "email",
+		pattern: /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi
+	},
+	{
+		name: "bearer-token",
+		pattern: /\bBearer\s+[A-Za-z0-9._~+/=-]+\b/g
+	},
+	{
+		name: "credit-card",
+		pattern: /\b(?:\d[ -]*?){13,19}\b/g,
+		validate: passesLuhn
+	}
+];
+function matcherMatches(matcher, key, path, value) {
+	if (typeof matcher === "string") return matcher.toLowerCase() === key.toLowerCase();
+	if (matcher instanceof RegExp) {
+		matcher.lastIndex = 0;
+		return matcher.test(key) || matcher.test(path);
+	}
+	return matcher(key, path, value);
+}
+function matchesAny(matchers, key, path, value) {
+	return matchers.some((matcher) => matcherMatches(matcher, key, path, value));
+}
+function redact(path, reason, options) {
+	options.onRedact?.(path, reason);
+	return options.replacement;
+}
+function guardString(input, path, options) {
+	let value = input;
+	for (const item of options.patterns) {
+		item.pattern.lastIndex = 0;
+		value = value.replace(item.pattern, (match) => {
+			if (item.validate && !item.validate(match)) return match;
+			options.onRedact?.(path, item.name);
+			return item.replacement ?? options.replacement;
+		});
+	}
+	if (value.length > options.maxStringLength) {
+		options.onRedact?.(path, "max-string-length");
+		value = `${value.slice(0, options.maxStringLength)}${options.truncateSuffix}`;
+	}
+	return {
+		value,
+		changed: value !== input
+	};
+}
+function guardValue(value, path, key, depth, options, seen) {
+	if (matchesAny(options.denyKeys, key, path, value) && !matchesAny(options.allowKeys, key, path, value)) return {
+		value: redact(path, "deny-key", options),
+		changed: true
+	};
+	if (typeof value === "string") return guardString(value, path, options);
+	if (value === null || value === void 0 || typeof value !== "object") return {
+		value,
+		changed: false
+	};
+	if (depth >= options.maxDepth) return {
+		value: redact(path, "max-depth", options),
+		changed: true
+	};
+	if (seen.has(value)) return {
+		value: seen.get(value),
+		changed: true
+	};
+	if (value instanceof Date || value instanceof Error) return {
+		value,
+		changed: false
+	};
+	if (Array.isArray(value)) {
+		const out = [];
+		seen.set(value, out);
+		let changed = false;
+		for (let index = 0; index < value.length; index += 1) {
+			const child = guardValue(value[index], `${path}[${index}]`, String(index), depth + 1, options, seen);
+			out[index] = child.value;
+			changed ||= child.changed;
+		}
+		return {
+			value: changed ? out : value,
+			changed
+		};
+	}
+	const input = value;
+	const out = {};
+	seen.set(value, out);
+	let changed = false;
+	for (const [childKey, childValue] of Object.entries(input)) {
+		const child = guardValue(childValue, path ? `${path}.${childKey}` : childKey, childKey, depth + 1, options, seen);
+		out[childKey] = child.value;
+		changed ||= child.changed;
+	}
+	return {
+		value: changed ? out : value,
+		changed
+	};
+}
+function guardField(value, path, options) {
+	const guarded = guardValue(value, path, path, 0, options, /* @__PURE__ */ new WeakMap());
+	return {
+		value: guarded.value,
+		changed: guarded.changed
+	};
+}
+function maybeSet(target, key, value, changed) {
+	if (!changed) return target;
+	return {
+		...target,
+		[key]: value
+	};
+}
+function privacyGuardProcessor(options = {}) {
+	const normalized = {
+		targets: new Set(options.targets ?? [
+			"message",
+			"data",
+			"context",
+			"tags",
+			"error"
+		]),
+		denyKeys: options.denyKeys ?? DEFAULT_DENY_KEYS,
+		allowKeys: options.allowKeys ?? [],
+		patterns: options.patterns ?? DEFAULT_PATTERNS,
+		replacement: options.replacement ?? "[REDACTED]",
+		maxDepth: Math.max(0, Math.floor(options.maxDepth ?? 8)),
+		maxStringLength: Math.max(1, Math.floor(options.maxStringLength ?? 8192)),
+		truncateSuffix: options.truncateSuffix ?? "...",
+		onRedact: options.onRedact
+	};
+	return (event) => {
+		let next = event;
+		if (normalized.targets.has("message")) {
+			const result = guardString(event.message, "message", normalized);
+			next = maybeSet(next, "message", result.value, result.changed);
+		}
+		if (normalized.targets.has("data")) {
+			const result = guardField(event.data, "data", normalized);
+			next = maybeSet(next, "data", result.value, result.changed);
+		}
+		if (normalized.targets.has("context")) {
+			const result = guardField(event.context, "context", normalized);
+			next = maybeSet(next, "context", result.value, result.changed);
+		}
+		if (normalized.targets.has("tags")) {
+			const result = guardField(event.tags, "tags", normalized);
+			next = maybeSet(next, "tags", result.value, result.changed);
+		}
+		if (normalized.targets.has("error")) {
+			const result = guardField(event.error, "error", normalized);
+			next = maybeSet(next, "error", result.value, result.changed);
+		}
+		return next;
+	};
+}
+//#endregion
+//#region src/schema-dev-check.ts
+function resultToErrors(result) {
+	if (result === void 0 || result === true) return [];
+	if (result === false) return ["schema validation failed"];
+	if (typeof result === "string") return [result];
+	return result;
+}
+function validatorFor(event, context, options) {
+	return options.validate ?? options.select?.(event, context) ?? (event.type ? options.validators?.[event.type] : void 0);
+}
+function tagInvalid(event, options, errors) {
+	return {
+		...event,
+		tags: {
+			...event.tags,
+			[options.tagKey ?? "schemaInvalid"]: true
+		},
+		context: {
+			...event.context,
+			[options.contextKey ?? "schemaErrors"]: [...errors]
+		}
+	};
+}
+function reportInvalid(event, context, options, errors) {
+	options.onInvalid?.(event, errors);
+	context.reportInternalError(/* @__PURE__ */ new Error(`loggerjs schema validation failed: ${errors.join("; ")}`), {
+		phase: "processor",
+		processor: "schema-dev-check",
+		eventType: event.type,
+		logger: event.logger
+	});
+}
+function schemaDevCheckProcessor(options = {}) {
+	const enabled = options.enabled ?? true;
+	const action = options.action ?? "report";
+	return (event, context) => {
+		if (!enabled) return event;
+		const validator = validatorFor(event, context, options);
+		if (!validator) return event;
+		let errors;
+		try {
+			errors = resultToErrors(validator(event.data, event, context));
+		} catch (error) {
+			context.reportInternalError(error, {
+				phase: "processor",
+				processor: "schema-dev-check",
+				eventType: event.type,
+				logger: event.logger
+			});
+			return event;
+		}
+		if (errors.length === 0) return event;
+		if (action === "drop") {
+			options.onInvalid?.(event, errors);
+			return false;
+		}
+		if (action === "tag") {
+			reportInvalid(event, context, options, errors);
+			return tagInvalid(event, options, errors);
+		}
+		reportInvalid(event, context, options, errors);
+		return event;
+	};
+}
+//#endregion
+//#region src/dynamic-sampler.ts
+const DEFAULT_EXEMPT_LEVELS = new Set(["error", "fatal"]);
+function defaultKey$1(event) {
+	return event.trace?.traceId ?? `${event.logger}:${event.levelName}:${event.type ?? "manual"}`;
+}
+function clampRate(rate) {
+	if (!Number.isFinite(rate) || Number.isNaN(rate)) return 1;
+	return Math.max(0, Math.min(1, rate));
+}
+function hashRatio(input) {
+	let hash = 2166136261;
+	for (let index = 0; index < input.length; index += 1) {
+		hash ^= input.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0) / 4294967296;
+}
+function snapshot$1(stats) {
+	return {
+		key: stats.key,
+		seen: stats.seen,
+		kept: stats.kept,
+		dropped: stats.dropped,
+		lastSeenMs: stats.lastSeenMs
+	};
+}
+function decisionContext(stats, now) {
+	return {
+		...snapshot$1(stats),
+		now
+	};
+}
+function resolveRule(event, context, options) {
+	const rule = options.rules?.find((item) => !item.when || item.when(event, context));
+	return {
+		rate: rule?.rate ?? options.defaultRate ?? 1,
+		key: rule?.key ?? options.key ?? defaultKey$1,
+		stickyBy: rule?.stickyBy ?? options.stickyBy
+	};
+}
+function prune$1(statsByKey, maxKeys) {
+	while (statsByKey.size > maxKeys) {
+		let oldest;
+		for (const item of statsByKey.values()) if (!oldest || item.lastSeenMs < oldest.lastSeenMs) oldest = item;
+		if (!oldest) return;
+		statsByKey.delete(oldest.key);
+	}
+}
+function shouldKeep(event, rule, rate, random) {
+	if (rate >= 1) return true;
+	if (rate <= 0) return false;
+	const stickyKey = rule.stickyBy?.(event);
+	return (stickyKey ? hashRatio(stickyKey) : random()) < rate;
+}
+function dynamicSamplerProcessor(options = {}) {
+	const random = options.random ?? Math.random;
+	const exemptLevels = new Set(options.exemptLevels ?? DEFAULT_EXEMPT_LEVELS);
+	const maxKeys = Math.max(1, Math.floor(options.maxKeys ?? 1e4));
+	const statsByKey = /* @__PURE__ */ new Map();
+	const processor = ((event, context) => {
+		if (exemptLevels.has(event.levelName)) return event;
+		const now = context.now();
+		const rule = resolveRule(event, context, options);
+		const key = (rule.key ?? defaultKey$1)(event);
+		let stats = statsByKey.get(key);
+		if (!stats) {
+			stats = {
+				key,
+				seen: 0,
+				kept: 0,
+				dropped: 0,
+				lastSeenMs: now
+			};
+			statsByKey.set(key, stats);
+			prune$1(statsByKey, maxKeys);
+		}
+		stats.seen += 1;
+		stats.lastSeenMs = now;
+		const rate = clampRate(typeof rule.rate === "function" ? rule.rate(event, decisionContext(stats, now)) : rule.rate);
+		if (shouldKeep(event, rule, rate, random)) {
+			stats.kept += 1;
+			return event;
+		}
+		stats.dropped += 1;
+		(0, _loggerjs_core.incrementLoggerMetaCounter)("processor.dynamicSampler.dropped");
+		(0, _loggerjs_core.incrementLoggerMetaCounter)(`processor.dynamicSampler.dropped.${event.levelName}`);
+		options.onDrop?.(event, key, rate);
+		return false;
+	});
+	processor.stats = () => [...statsByKey.values()].map(snapshot$1);
+	processor.reset = (key) => {
+		if (key) statsByKey.delete(key);
+		else statsByKey.clear();
+	};
+	return processor;
+}
+//#endregion
+//#region src/breadcrumb-buffer.ts
+function defaultKey(event) {
+	const contextKey = event.context?.sessionId ?? event.context?.userId;
+	return event.trace?.traceId ?? (contextKey === void 0 ? event.logger : String(contextKey));
+}
+function defaultBreadcrumb(event) {
+	return {
+		time: event.time,
+		levelName: event.levelName,
+		logger: event.logger,
+		message: event.message,
+		type: event.type,
+		tags: event.tags,
+		source: event.source
+	};
+}
+function normalizeCount(value, fallback) {
+	if (value === void 0 || !Number.isFinite(value)) return fallback;
+	return Math.max(0, Math.floor(value));
+}
+function normalizeBucketCount(value) {
+	if (value === void 0 || !Number.isFinite(value)) return 1024;
+	return Math.max(1, Math.floor(value));
+}
+function snapshot(state) {
+	return {
+		key: state.key,
+		buffered: state.buffer.length,
+		lastSeenMs: state.lastSeenMs
+	};
+}
+function prune(states, maxBuckets) {
+	while (states.size > maxBuckets) {
+		let oldest;
+		for (const state of states.values()) if (!oldest || state.lastSeenMs < oldest.lastSeenMs) oldest = state;
+		if (!oldest) return;
+		states.delete(oldest.key);
+	}
+}
+function attachBreadcrumbs(event, target, field, breadcrumbs) {
+	if (breadcrumbs.length === 0) return event;
+	if (target === "data" && event.data && typeof event.data === "object" && !Array.isArray(event.data)) return {
+		...event,
+		data: {
+			...event.data,
+			[field]: breadcrumbs
+		}
+	};
+	if (target === "data") return {
+		...event,
+		data: {
+			value: event.data,
+			[field]: breadcrumbs
+		}
+	};
+	return {
+		...event,
+		context: {
+			...event.context,
+			[field]: breadcrumbs
+		}
+	};
+}
+function breadcrumbBufferProcessor(options = {}) {
+	const triggerLevel = (0, _loggerjs_core.toLevelValue)(options.triggerLevel ?? "error");
+	const shouldAttach = options.shouldAttach ?? ((event) => event.level >= triggerLevel);
+	const shouldBuffer = options.shouldBuffer ?? ((event) => event.level < triggerLevel);
+	const bufferSize = normalizeCount(options.bufferSize, 50);
+	const maxBuckets = normalizeBucketCount(options.maxBuckets);
+	const keyFor = options.key ?? defaultKey;
+	const map = options.map ?? defaultBreadcrumb;
+	const target = options.target ?? "context";
+	const field = options.field ?? "breadcrumbs";
+	const includeTrigger = options.includeTrigger ?? false;
+	const clearOnTrigger = options.clearOnTrigger ?? false;
+	const states = /* @__PURE__ */ new Map();
+	const getState = (key, now) => {
+		let state = states.get(key);
+		if (!state) {
+			state = {
+				key,
+				buffer: [],
+				lastSeenMs: now
+			};
+			states.set(key, state);
+			prune(states, maxBuckets);
+		}
+		state.lastSeenMs = now;
+		return state;
+	};
+	const processor = ((event) => {
+		const state = getState(keyFor(event), event.time);
+		if (shouldAttach(event)) {
+			const next = attachBreadcrumbs(event, target, field, includeTrigger ? [...state.buffer, map(event)] : [...state.buffer]);
+			if (clearOnTrigger) state.buffer.splice(0, state.buffer.length);
+			return next;
+		}
+		if (bufferSize > 0 && shouldBuffer(event)) {
+			state.buffer.push(map(event));
+			if (state.buffer.length > bufferSize) state.buffer.splice(0, state.buffer.length - bufferSize);
+		}
+		return event;
+	});
+	processor.states = () => [...states.values()].map(snapshot);
+	processor.reset = (key) => {
+		if (key) states.delete(key);
+		else states.clear();
+	};
+	return processor;
+}
+//#endregion
+exports.breadcrumbBuffer = breadcrumbBufferProcessor;
+exports.breadcrumbBufferProcessor = breadcrumbBufferProcessor;
+exports.context = contextProcessor;
+exports.contextMiddleware = contextMiddleware;
+exports.contextMw = contextMiddleware;
+exports.contextProcessor = contextProcessor;
+exports.dedupe = dedupeProcessor;
+exports.dedupeProcessor = dedupeProcessor;
+exports.dynamicSampler = dynamicSamplerProcessor;
+exports.dynamicSamplerProcessor = dynamicSamplerProcessor;
+exports.enrich = enrichProcessor;
+exports.enrichMiddleware = enrichMiddleware;
+exports.enrichMw = enrichMiddleware;
+exports.enrichProcessor = enrichProcessor;
+exports.filter = filterProcessor;
+exports.filterProcessor = filterProcessor;
+exports.fingerprint = fingerprintProcessor;
+exports.fingerprintProcessor = fingerprintProcessor;
+exports.fingersCrossed = fingersCrossedProcessor;
+exports.fingersCrossedProcessor = fingersCrossedProcessor;
+exports.levelOverride = levelOverrideProcessor;
+exports.levelOverrideProcessor = levelOverrideProcessor;
+exports.logType = typeProcessor;
+exports.logTypeMw = typeMiddleware;
+exports.normalizeError = normalizeErrorProcessor;
+exports.normalizeErrorProcessor = normalizeErrorProcessor;
+exports.parseStack = parseStack;
+exports.privacyGuard = privacyGuardProcessor;
+exports.privacyGuardProcessor = privacyGuardProcessor;
+exports.rateLimit = rateLimitProcessor;
+exports.rateLimitProcessor = rateLimitProcessor;
+exports.redact = redactProcessor;
+exports.redactProcessor = redactProcessor;
+exports.route = routeProcessor;
+exports.routeProcessor = routeProcessor;
+exports.sample = sampleProcessor;
+exports.sampleProcessor = sampleProcessor;
+exports.schemaDevCheck = schemaDevCheckProcessor;
+exports.schemaDevCheckProcessor = schemaDevCheckProcessor;
+exports.stackParser = stackParserProcessor;
+exports.stackParserProcessor = stackParserProcessor;
+exports.tags = tagsProcessor;
+exports.tagsMiddleware = tagsMiddleware;
+exports.tagsMw = tagsMiddleware;
+exports.tagsProcessor = tagsProcessor;
+exports.traceContext = traceContextProcessor;
+exports.traceContextMiddleware = traceContextMiddleware;
+exports.traceContextMw = traceContextMiddleware;
+exports.traceContextProcessor = traceContextProcessor;
+exports.typeMiddleware = typeMiddleware;
+exports.typeProcessor = typeProcessor;
+
+//# sourceMappingURL=index.cjs.map