logixia 1.13.3 → 2.0.4

package/dist/slack.transport-Dlx3xvb7.js

@@ -0,0 +1,847 @@
+const require_secret_config = require("./secret-config-CBZBs0p1.js");
+const require_internal_log = require("./internal-log-b0Vp4qrB.js");
+const require_safe_stringify = require("./safe-stringify-DLz1Kz3o.js");
+const require_transport_manager = require("./transport.manager-DkcEOlqV.js");
+const require_batch_buffer = require("./batch-buffer-DT4gdXmf.js");
+// src/transports/otlp.transport.ts
+const HEX_32 = /^[0-9a-f]{32}$/;
+/**
+* OTLP JSON wants a 32-char lowercase hex trace id. Dashed UUIDs are
+* normalised; anything else (or all zeros) returns undefined.
+*/
+function toOtlpTraceId(id) {
+	const hex = id.replace(/-/g, "").toLowerCase();
+	return HEX_32.test(hex) && hex !== "0".repeat(32) ? hex : void 0;
+}
+/**
+* Map a logixia level name to an OTel SeverityNumber (1–24) and text.
+* Per the OTel logs SDK spec: TRACE=1, DEBUG=5, INFO=9, WARN=13, ERROR=17,
+* FATAL=21. Custom/unknown levels fall back to INFO (9).
+*/
+function toOtelSeverity(level) {
+	switch (level.toLowerCase()) {
+		case "trace": return {
+			number: 1,
+			text: "TRACE"
+		};
+		case "verbose": return {
+			number: 5,
+			text: "DEBUG"
+		};
+		case "debug": return {
+			number: 5,
+			text: "DEBUG"
+		};
+		case "info": return {
+			number: 9,
+			text: "INFO"
+		};
+		case "warn":
+		case "warning": return {
+			number: 13,
+			text: "WARN"
+		};
+		case "error": return {
+			number: 17,
+			text: "ERROR"
+		};
+		case "fatal": return {
+			number: 21,
+			text: "FATAL"
+		};
+		default: return {
+			number: 9,
+			text: "INFO"
+		};
+	}
+}
+/** Coerce a JS value into an OTLP AnyValue. */
+function toAnyValue(value) {
+	if (typeof value === "string") return { stringValue: value };
+	if (typeof value === "boolean") return { boolValue: value };
+	if (typeof value === "number") return Number.isInteger(value) ? { intValue: value } : { doubleValue: value };
+	if (typeof value === "bigint") return { stringValue: value.toString() };
+	if (value === null || value === void 0) return { stringValue: "" };
+	try {
+		return { stringValue: require_safe_stringify.stringifyForLog(value) };
+	} catch {
+		return { stringValue: String(value) };
+	}
+}
+/** Build the OTLP KeyValue attribute list from a flat record. */
+function toAttributes(rec) {
+	return Object.entries(rec).map(([key, value]) => ({
+		key,
+		value: toAnyValue(value)
+	}));
+}
+var OtlpLogTransport = class {
+	constructor(config) {
+		this.name = "otlp";
+		this.flushTimer = null;
+		this.url = config.url;
+		this.headers = config.headers ?? {};
+		this.batchSize = config.batchSize ?? 100;
+		this.flushIntervalMs = config.flushIntervalMs ?? 5e3;
+		this.requestTimeoutMs = config.requestTimeoutMs ?? 1e4;
+		this.level = config.level;
+		this.buffer = new require_batch_buffer.BatchBuffer({
+			name: "OtlpLogTransport",
+			batchSize: this.batchSize,
+			maxBufferSize: config.maxBufferSize ?? 1e4,
+			send: (entries) => this.send(entries),
+			secrets: () => this.secretValues()
+		});
+		const resource = {
+			"service.name": config.serviceName ?? "logixia",
+			...config.serviceVersion ? { "service.version": config.serviceVersion } : {},
+			...config.environment ? { "deployment.environment": config.environment } : {},
+			...config.resourceAttributes ?? {}
+		};
+		this.resourceAttrs = toAttributes(resource);
+		require_secret_config.protectSecrets(this, ["headers", "url"]);
+		this.flushTimer = setInterval(() => {
+			this.flush().catch(() => {});
+		}, this.flushIntervalMs);
+		if (this.flushTimer.unref) this.flushTimer.unref();
+	}
+	write(entry) {
+		this.buffer.push(entry);
+		this.buffer.flushIfFull();
+	}
+	/** Convert one entry into an OTLP LogRecord. */
+	toLogRecord(entry) {
+		const sev = toOtelSeverity(entry.level);
+		const tsNanos = String(entry.timestamp.getTime() * 1e6);
+		const attrs = { ...entry.data ?? {} };
+		if (entry.context !== void 0) attrs["context"] = entry.context;
+		if (entry.appName !== void 0) attrs["app.name"] = entry.appName;
+		if (entry.environment !== void 0) attrs["deployment.environment"] = entry.environment;
+		const record = {
+			timeUnixNano: tsNanos,
+			observedTimeUnixNano: tsNanos,
+			severityNumber: sev.number,
+			severityText: sev.text,
+			body: { stringValue: entry.message },
+			attributes: toAttributes(attrs)
+		};
+		if (entry.traceId) {
+			const traceId = toOtlpTraceId(entry.traceId);
+			if (traceId) record["traceId"] = traceId;
+			else record["attributes"].push({
+				key: "trace_id",
+				value: { stringValue: entry.traceId }
+			});
+		}
+		return record;
+	}
+	buildPayload(entries) {
+		return require_safe_stringify.stringifyForLog({ resourceLogs: [{
+			resource: { attributes: this.resourceAttrs },
+			scopeLogs: [{
+				scope: { name: "logixia" },
+				logRecords: entries.map((e) => this.toLogRecord(e))
+			}]
+		}] });
+	}
+	flush() {
+		return this.buffer.flush();
+	}
+	secretValues() {
+		return require_secret_config.collectSecrets({
+			headers: this.headers,
+			url: this.url
+		});
+	}
+	async send(entries) {
+		if (typeof fetch !== "function") {
+			require_internal_log.internalWarn("OtlpLogTransport: global fetch unavailable — cannot export logs");
+			return;
+		}
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), this.requestTimeoutMs);
+		try {
+			const res = await fetch(this.url, {
+				method: "POST",
+				headers: {
+					"Content-Type": "application/json",
+					...this.headers
+				},
+				body: this.buildPayload(entries),
+				signal: controller.signal
+			});
+			if (!res.ok) throw new require_batch_buffer.HttpError(res.status, "", "OTLP export");
+		} catch (err) {
+			require_secret_config.scrubError(err, this.secretValues());
+			if (controller.signal.aborted) throw new Error(`OTLP export timed out after ${this.requestTimeoutMs}ms`, { cause: err });
+			throw err;
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+	async close() {
+		if (this.flushTimer) {
+			clearInterval(this.flushTimer);
+			this.flushTimer = null;
+		}
+		await this.buffer.close();
+	}
+};
+// src/transports/webhook-queue.ts
+const MAX_BACKOFF_MS = 3e4;
+const DEFAULT_QUEUE_CAP = 1e3;
+const CLOSE_TIMEOUT_MS = 3e3;
+const OVERFLOW_WARN_MS = 5e3;
+const DEFAULT_WEBHOOK_TIMEOUT_MS = 1e4;
+const ZWSP = "​";
+const LEVEL_RANK = {
+	fatal: 0,
+	error: 1,
+	warn: 2,
+	warning: 2,
+	info: 3,
+	debug: 4,
+	verbose: 5,
+	trace: 6
+};
+function resolveMinLevel(level, label) {
+	const resolved = (level ?? "error").toLowerCase();
+	if (!(resolved in LEVEL_RANK)) throw new TypeError(`${label}: unknown level "${String(level).slice(0, 40)}"`);
+	return resolved;
+}
+/** Unknown (custom) entry levels pass, like the TransportManager does. */
+function meetsLevel(entryLevel, minLevel) {
+	const entryRank = LEVEL_RANK[entryLevel.toLowerCase()];
+	return entryRank === void 0 || entryRank <= (LEVEL_RANK[minLevel] ?? 1);
+}
+/** Validates the secret URL. Error messages never contain it. */
+function parseWebhookUrl(raw, rules) {
+	const { label, allowCustomUrl, hostMatches, pathMatches, expected } = rules;
+	if (typeof raw !== "string" || raw.length === 0) throw new TypeError(`${label}: webhookUrl is required`);
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new TypeError(`${label}: webhookUrl is not a valid URL`);
+	}
+	if (url.protocol !== "https:") throw new TypeError(`${label}: webhookUrl must use https:`);
+	if (url.username || url.password) throw new TypeError(`${label}: webhookUrl must not contain credentials`);
+	if (!allowCustomUrl) {
+		if (!hostMatches(url.hostname.toLowerCase()) || !pathMatches(url.pathname) || url.port) throw new TypeError(`${label}: webhookUrl must be a ${expected} webhook (set allowCustomUrl: true to use another https endpoint)`);
+	}
+	return url;
+}
+function retryAfterHeaderMs(res) {
+	var _res$headers;
+	const raw = (_res$headers = res.headers) === null || _res$headers === void 0 ? void 0 : _res$headers.get("retry-after");
+	if (raw === null || raw === void 0 || raw === "") return void 0;
+	const seconds = Number(raw);
+	return Number.isFinite(seconds) && seconds >= 0 ? seconds * 1e3 : void 0;
+}
+function nonNegative(value, fallback) {
+	return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : fallback;
+}
+function failureCode(err) {
+	const cause = err === null || err === void 0 ? void 0 : err.cause;
+	const code = (cause === null || cause === void 0 ? void 0 : cause.code) ?? (err === null || err === void 0 ? void 0 : err.code);
+	if (typeof code === "string") return code.slice(0, 40);
+	return err instanceof Error ? err.name : "error";
+}
+function sleep(ms, signal) {
+	return new Promise((resolve) => {
+		var _timer$unref;
+		if (signal.aborted) return resolve();
+		const done = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", done);
+			resolve();
+		};
+		const timer = setTimeout(done, ms);
+		(_timer$unref = timer.unref) === null || _timer$unref === void 0 || _timer$unref.call(timer);
+		signal.addEventListener("abort", done, { once: true });
+	});
+}
+async function cancelBody(res) {
+	try {
+		var _res$body;
+		await ((_res$body = res.body) === null || _res$body === void 0 ? void 0 : _res$body.cancel());
+	} catch {}
+}
+/**
+* Throttled queue for chat webhooks. It is not built on BatchBuffer because the
+* semantics differ: sends are spaced by `minIntervalMs` (leading edge, then one
+* message per window), a window sends one summarized message and drops the
+* overflow, 429 waits are cancellable by close(), and flush() surfaces send
+* errors. HttpError / isPermanentHttpError are shared with BatchBuffer.
+*
+* Entries past `maxPerMessage` in one window are not sent: the message carries a
+* "… and N more" line and an internal warning reports the count.
+*/
+var WebhookQueue = class {
+	constructor(opts) {
+		this.opts = opts;
+		this.items = [];
+		this.timer = null;
+		this.nextAllowed = 0;
+		this.failures = 0;
+		this.closed = false;
+		this.shutdown = new AbortController();
+		this.overflowPending = 0;
+		this.lastOverflowWarn = 0;
+		this.fetchWarned = false;
+		this.host = opts.url.hostname;
+		this.httpLabel = `${opts.label} (${this.host})`;
+		this.minIntervalMs = nonNegative(opts.minIntervalMs, 1e3);
+		this.maxRetries = Math.floor(nonNegative(opts.maxRetries, 1));
+		this.timeoutMs = nonNegative(opts.requestTimeoutMs, DEFAULT_WEBHOOK_TIMEOUT_MS);
+		this.cap = new require_transport_manager.BufferCap(opts.label, opts.maxQueueSize, opts.maxPerMessage, DEFAULT_QUEUE_CAP);
+	}
+	get length() {
+		return this.items.length;
+	}
+	push(entry) {
+		if (this.closed) return;
+		this.items.push(entry);
+		this.cap.enforce(this.items);
+		this.schedule();
+	}
+	flush() {
+		this.inFlight ??= this.drain().finally(() => {
+			this.inFlight = void 0;
+		});
+		return this.inFlight;
+	}
+	/** Cancels rate-limit waits, then makes one best-effort send with a short timeout. */
+	async close() {
+		this.closed = true;
+		this.clearTimer();
+		this.shutdown.abort();
+		try {
+			await this.inFlight;
+		} catch {}
+		try {
+			await this.flush();
+		} catch (err) {
+			require_internal_log.internalError(`${this.opts.label} flush on close failed`, err);
+		}
+		this.reportOverflow(true);
+		if (this.items.length > 0) {
+			require_internal_log.internalError(`${this.opts.label} closing with ${this.items.length} undelivered entries`);
+			this.items = [];
+		}
+	}
+	clearTimer() {
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = null;
+	}
+	schedule() {
+		var _this$timer$unref, _this$timer;
+		if (this.timer || this.closed || this.items.length === 0) return;
+		const delay = Math.max(0, this.nextAllowed - Date.now());
+		this.timer = setTimeout(() => {
+			this.timer = null;
+			this.flush().catch((err) => require_internal_log.internalError(`${this.opts.label} send failed`, err));
+		}, delay);
+		(_this$timer$unref = (_this$timer = this.timer).unref) === null || _this$timer$unref === void 0 || _this$timer$unref.call(_this$timer);
+	}
+	reportOverflow(force = false) {
+		const now = Date.now();
+		if (this.overflowPending === 0 || !force && now - this.lastOverflowWarn < OVERFLOW_WARN_MS) return;
+		const n = this.overflowPending;
+		require_internal_log.internalWarn(`${this.opts.label}: ${n} entr${n === 1 ? "y" : "ies"} over the per-message limit (${this.opts.maxPerMessage}) summarized in a "... and N more" line and not sent`);
+		this.overflowPending = 0;
+		this.lastOverflowWarn = now;
+	}
+	render(batch) {
+		const rendered = [];
+		let bad = 0;
+		for (const entry of batch) try {
+			const value = this.opts.render(entry);
+			JSON.stringify(value);
+			rendered.push(value);
+		} catch (err) {
+			bad += 1;
+			if (bad === 1) require_internal_log.internalError(`${this.opts.label}: dropping an entry that cannot be rendered`, err);
+		}
+		if (bad > 1) require_internal_log.internalError(`${this.opts.label}: dropped ${bad} entries that cannot be rendered`);
+		return rendered;
+	}
+	async drain() {
+		if (this.items.length === 0) return;
+		if (typeof fetch !== "function") {
+			if (!this.fetchWarned) {
+				this.fetchWarned = true;
+				require_internal_log.internalWarn(`${this.opts.label}: global fetch is unavailable (Node 18+ required); dropping entries`);
+			}
+			this.items = [];
+			return;
+		}
+		const all = this.items;
+		this.items = [];
+		const batch = all.slice(0, this.opts.maxPerMessage);
+		const overflow = all.length - batch.length;
+		if (overflow > 0) {
+			this.overflowPending += overflow;
+			this.reportOverflow();
+		}
+		this.nextAllowed = Date.now() + this.minIntervalMs;
+		try {
+			const rendered = this.render(batch);
+			if (rendered.length === 0 && overflow === 0) return;
+			let body;
+			try {
+				body = JSON.stringify(this.opts.assemble(rendered, overflow));
+			} catch (err) {
+				require_internal_log.internalError(`${this.opts.label}: dropping a batch that cannot be serialized`, err);
+				return;
+			}
+			try {
+				await this.sendWithRetry(body);
+				this.failures = 0;
+			} catch (err) {
+				if (!require_batch_buffer.isPermanentHttpError(err)) {
+					this.items.unshift(...batch);
+					this.cap.enforce(this.items);
+					this.failures += 1;
+					const backoff = Math.min(MAX_BACKOFF_MS, Math.max(1e3, this.minIntervalMs) * 2 ** this.failures);
+					this.nextAllowed = Math.max(this.nextAllowed, Date.now() + backoff);
+				}
+				throw err;
+			}
+		} finally {
+			this.schedule();
+		}
+	}
+	async sendWithRetry(body) {
+		for (let attempt = 0;; attempt += 1) {
+			const res = await this.post(body);
+			if (res.ok) return;
+			if (res.status !== 429) throw new require_batch_buffer.HttpError(res.status, "", this.httpLabel);
+			const waitMs = Math.min(MAX_BACKOFF_MS, Math.max(0, res.retryAfterMs ?? Math.max(1e3, this.minIntervalMs)));
+			this.nextAllowed = Math.max(this.nextAllowed, Date.now() + waitMs);
+			if (attempt >= this.maxRetries || this.closed) throw new require_batch_buffer.HttpError(429, "", this.httpLabel);
+			await sleep(waitMs, this.shutdown.signal);
+			if (this.shutdown.signal.aborted) throw new Error(`${this.opts.label}: rate-limit wait cancelled by close()`);
+		}
+	}
+	async readRetryAfter(res) {
+		try {
+			return this.opts.retryAfterMs ? await this.opts.retryAfterMs(res) : retryAfterHeaderMs(res);
+		} catch {
+			return;
+		}
+	}
+	async post(body) {
+		const controller = new AbortController();
+		const timeoutMs = this.closed ? Math.min(this.timeoutMs, CLOSE_TIMEOUT_MS) : this.timeoutMs;
+		const timer = setTimeout(() => controller.abort(), timeoutMs);
+		try {
+			const res = await fetch(this.opts.url, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body,
+				redirect: "error",
+				signal: controller.signal
+			});
+			let retryAfterMs;
+			try {
+				if (res.status === 429) retryAfterMs = await this.readRetryAfter(res);
+			} finally {
+				await cancelBody(res);
+			}
+			return {
+				ok: res.ok,
+				status: res.status,
+				retryAfterMs
+			};
+		} catch (err) {
+			throw new Error(`${this.opts.label}: request to ${this.host} failed (${controller.signal.aborted ? "timeout" : failureCode(err)})`);
+		} finally {
+			clearTimeout(timer);
+		}
+	}
+};
+/** Cuts `text` to `max` chars without splitting a surrogate pair or a `&amp;`-style entity. */
+function truncateText(text, max, ellipsis = "…") {
+	if (text.length <= max) return text;
+	let cut = text.slice(0, Math.max(0, max - ellipsis.length));
+	cut = cut.replace(/&[a-z]{0,3}$/, "");
+	if (/[\uD800-\uDBFF]$/.test(cut)) cut = cut.slice(0, -1);
+	return cut + ellipsis;
+}
+/** Breaks code-fence and broadcast-mention sequences with a zero-width space. */
+function defuseText(text) {
+	return text.replace(/`{3,}/g, (m) => m.split("").join(ZWSP)).replace(/@(everyone|here|channel)/gi, `@${ZWSP}$1`);
+}
+/** Collapses control characters and newlines for single-line fields. */
+function singleLine(text) {
+	return text.replace(/[\u0000-\u001f\u007f]+/g, " ").trim();
+}
+/** ISO string, or undefined for a missing or invalid timestamp. */
+function safeIso(date) {
+	return date instanceof Date && !Number.isNaN(date.getTime()) ? date.toISOString() : void 0;
+}
+const DISCORD_DESCRIPTION_MAX = 4096;
+const DISCORD_FIELD_VALUE_MAX = 1024;
+const DISCORD_EMBED_TOTAL_MAX = 6e3;
+const DISCORD_CONTENT_MAX = 2e3;
+const FIELD_VALUE_CAP = 64;
+const DISCORD_FOOTER_MAX = 2048;
+const FENCE_OVERHEAD = 12;
+const MIN_USEFUL_BODY = 20;
+const DISCORD_LEVEL_COLORS = {
+	fatal: 10038562,
+	error: 15548997,
+	warn: 16705372,
+	warning: 16705372,
+	info: 3447003,
+	debug: 9807270,
+	verbose: 9807270,
+	trace: 9807270
+};
+const DEFAULT_COLOR = 9807270;
+/** Escapes Discord markdown and defuses @everyone / @here and code fences. */
+function escapeDiscord(text) {
+	return defuseText(text.replace(/[\\*_~`|>#[\]()]/g, "\\$&"));
+}
+function textLength(value, key) {
+	const text = value === null || value === void 0 ? void 0 : value[key];
+	return typeof text === "string" ? text.length : 0;
+}
+/** Counts every text field Discord counts toward the 6000-character limit. */
+function embedChars(embed) {
+	var _embed$title, _embed$description;
+	return (((_embed$title = embed.title) === null || _embed$title === void 0 ? void 0 : _embed$title.length) ?? 0) + (((_embed$description = embed.description) === null || _embed$description === void 0 ? void 0 : _embed$description.length) ?? 0) + (embed.fields ?? []).reduce((n, f) => n + f.name.length + f.value.length, 0) + textLength(embed["footer"], "text") + textLength(embed["author"], "name");
+}
+/** Shrinks one embed to `limit` chars: description first, then fields, footer/author, title. */
+function shrinkToFit(embed, limit) {
+	var _embed$fields;
+	const excess = () => embedChars(embed) - limit;
+	if (excess() > 0 && embed.description) {
+		const keep = embed.description.length - excess();
+		if (keep > 0) embed.description = truncateText(embed.description, keep);
+		else delete embed.description;
+	}
+	while (excess() > 0 && ((_embed$fields = embed.fields) === null || _embed$fields === void 0 ? void 0 : _embed$fields.length)) embed.fields.pop();
+	if (excess() > 0) {
+		delete embed["footer"];
+		delete embed["author"];
+	}
+	if (excess() > 0 && embed.title) embed.title = truncateText(embed.title, Math.max(1, embed.title.length - excess()));
+}
+function codeBlock(json, max) {
+	return `\`\`\`json\n${truncateText(json.replace(/`{3,}/g, (m) => m.split("").join("​")), max)}\n\`\`\``;
+}
+function clampCustomEmbed(embed) {
+	const out = { ...embed };
+	if (typeof out.title === "string") out.title = truncateText(out.title, 256);
+	if (typeof out.description === "string") out.description = truncateText(out.description, DISCORD_DESCRIPTION_MAX);
+	if (Array.isArray(out.fields)) out.fields = out.fields.slice(0, 25).map((f) => ({
+		...f,
+		name: truncateText(String(f.name), 256),
+		value: truncateText(String(f.value), DISCORD_FIELD_VALUE_MAX)
+	}));
+	const footer = out["footer"];
+	if (footer && typeof footer.text === "string") out["footer"] = {
+		...footer,
+		text: truncateText(footer.text, DISCORD_FOOTER_MAX)
+	};
+	const author = out["author"];
+	if (author && typeof author.name === "string") out["author"] = {
+		...author,
+		name: truncateText(author.name, 256)
+	};
+	return out;
+}
+var DiscordTransport = class {
+	constructor(config) {
+		this.name = "discord";
+		const url = parseWebhookUrl(config.webhookUrl, {
+			label: "DiscordTransport",
+			hostMatches: (h) => [
+				"discord.com",
+				"discordapp.com",
+				"ptb.discord.com",
+				"canary.discord.com"
+			].includes(h),
+			pathMatches: (p) => /^\/api(\/v\d+)?\/webhooks\//.test(p),
+			expected: "discord.com",
+			allowCustomUrl: config.allowCustomUrl
+		});
+		if (config.avatarUrl !== void 0 && !/^https:\/\//i.test(config.avatarUrl)) throw new TypeError("DiscordTransport: avatarUrl must use https:");
+		this.level = resolveMinLevel(config.level, "DiscordTransport");
+		if (config.filter) this.filter = config.filter;
+		this.username = config.username;
+		this.avatarUrl = config.avatarUrl;
+		this.formatter = config.formatter;
+		const queue = new WebhookQueue({
+			label: "DiscordTransport",
+			url,
+			minIntervalMs: config.minIntervalMs,
+			maxPerMessage: 10,
+			maxQueueSize: config.maxBufferSize,
+			maxRetries: config.maxRetries,
+			requestTimeoutMs: config.requestTimeoutMs ?? 1e4,
+			render: (entry) => this.draftFor(entry),
+			assemble: (drafts, overflow) => this.buildPayload(drafts, overflow),
+			retryAfterMs: readRetryAfter
+		});
+		Object.defineProperty(this, "queue", {
+			value: queue,
+			enumerable: false
+		});
+	}
+	write(entry) {
+		if (!meetsLevel(entry.level, this.level)) return;
+		this.queue.push(entry);
+	}
+	flush() {
+		return this.queue.flush();
+	}
+	close() {
+		return this.queue.close();
+	}
+	/** Never serialise the webhook URL (JSON.stringify, util.inspect). */
+	toJSON() {
+		return {
+			name: this.name,
+			level: this.level
+		};
+	}
+	/** `showHidden` would otherwise print the non-enumerable queue (and its URL). */
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		return this.toJSON();
+	}
+	buildPayload(drafts, overflow) {
+		const kept = this.fitToBudget(drafts);
+		const dropped = overflow + (drafts.length - kept.length);
+		const payload = {
+			embeds: kept.map((d) => d.embed),
+			allowed_mentions: { parse: [] }
+		};
+		if (dropped > 0) payload["content"] = truncateText(`… and ${dropped} more entr${dropped === 1 ? "y" : "ies"} not shown`, DISCORD_CONTENT_MAX);
+		if (this.username) payload["username"] = truncateText(this.username, 80);
+		if (this.avatarUrl) payload["avatar_url"] = this.avatarUrl;
+		return payload;
+	}
+	/** Enforces the 6000-char total: drops trailing embeds if needed, then shares the rest among descriptions. */
+	fitToBudget(drafts) {
+		const kept = [...drafts];
+		const base = () => kept.reduce((n, d) => n + embedChars(d.embed), 0);
+		while (kept.length > 1 && base() > 6e3) kept.pop();
+		const only = kept[0];
+		if (only && base() > 6e3) shrinkToFit(only.embed, DISCORD_EMBED_TOTAL_MAX);
+		const withData = kept.filter((d) => d.json !== void 0);
+		if (withData.length === 0) return kept;
+		const share = Math.floor((DISCORD_EMBED_TOTAL_MAX - base()) / withData.length);
+		const body = Math.min(DISCORD_DESCRIPTION_MAX, share) - FENCE_OVERHEAD;
+		for (const d of withData) if (body >= MIN_USEFUL_BODY) d.embed.description = codeBlock(d.json, body);
+		return kept;
+	}
+	draftFor(entry) {
+		if (this.formatter) try {
+			return {
+				embed: clampCustomEmbed(this.formatter(entry)),
+				json: void 0
+			};
+		} catch {
+			require_internal_log.internalWarn("DiscordTransport: formatter threw; using the default embed");
+		}
+		return defaultDraft(entry);
+	}
+};
+function defaultDraft(entry) {
+	const title = `[${singleLine(entry.level).toUpperCase()}] ${escapeDiscord(singleLine(entry.message))}`;
+	const fields = [
+		["appName", entry.appName],
+		["environment", entry.environment],
+		["context", entry.context],
+		["traceId", entry.traceId]
+	].map(([name, value]) => [name, typeof value === "string" ? singleLine(value) : ""]).filter(([, value]) => value !== "").map(([name, value]) => ({
+		name,
+		value: truncateText(escapeDiscord(value), FIELD_VALUE_CAP),
+		inline: true
+	}));
+	const embed = {
+		title: truncateText(title, 256),
+		color: DISCORD_LEVEL_COLORS[entry.level.toLowerCase()] ?? DEFAULT_COLOR,
+		fields
+	};
+	const timestamp = safeIso(entry.timestamp);
+	if (timestamp) embed.timestamp = timestamp;
+	return {
+		embed,
+		json: entry.data && Object.keys(entry.data).length > 0 ? require_safe_stringify.stringifyForLog(entry.data) : void 0
+	};
+}
+async function readRetryAfter(res) {
+	try {
+		var _res$json;
+		const body = await ((_res$json = res.json) === null || _res$json === void 0 ? void 0 : _res$json.call(res));
+		const seconds = Number(body === null || body === void 0 ? void 0 : body.retry_after);
+		if ((body === null || body === void 0 ? void 0 : body.retry_after) !== void 0 && Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+	} catch {}
+	return retryAfterHeaderMs(res);
+}
+const SLACK_DATA_MAX = 2500;
+const SLACK_FIELD_MAX = 300;
+const SLACK_TEXT_MAX = 1e3;
+const SLACK_MAX_BLOCKS = 50;
+const SLACK_MAX_PER_MESSAGE = 10;
+/** Escapes the three characters Slack treats specially and defuses broadcast mentions. */
+function escapeSlack(text) {
+	return defuseText(text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"));
+}
+const LEVEL_EMOJI = {
+	fatal: ":rotating_light:",
+	error: ":red_circle:",
+	warn: ":warning:",
+	warning: ":warning:",
+	info: ":information_source:"
+};
+var SlackTransport = class {
+	constructor(config) {
+		this.name = "slack";
+		const url = parseWebhookUrl(config.webhookUrl, {
+			label: "SlackTransport",
+			hostMatches: (h) => h === "hooks.slack.com" || h === "hooks.slack-gov.com",
+			pathMatches: (p) => p.startsWith("/services/") || p.startsWith("/triggers/"),
+			expected: "hooks.slack.com",
+			allowCustomUrl: config.allowCustomUrl
+		});
+		this.level = resolveMinLevel(config.level, "SlackTransport");
+		if (config.filter) this.filter = config.filter;
+		this.username = config.username;
+		this.iconEmoji = config.iconEmoji;
+		this.formatter = config.formatter;
+		const queue = new WebhookQueue({
+			label: "SlackTransport",
+			url,
+			minIntervalMs: config.minIntervalMs,
+			maxPerMessage: SLACK_MAX_PER_MESSAGE,
+			maxQueueSize: config.maxBufferSize,
+			maxRetries: config.maxRetries,
+			requestTimeoutMs: config.requestTimeoutMs ?? 1e4,
+			render: (entry) => this.messageFor(entry),
+			assemble: (messages, overflow) => this.buildPayload(messages, overflow)
+		});
+		Object.defineProperty(this, "queue", {
+			value: queue,
+			enumerable: false
+		});
+	}
+	write(entry) {
+		if (!meetsLevel(entry.level, this.level)) return;
+		this.queue.push(entry);
+	}
+	flush() {
+		return this.queue.flush();
+	}
+	close() {
+		return this.queue.close();
+	}
+	/** Never serialise the webhook URL (JSON.stringify, util.inspect). */
+	toJSON() {
+		return {
+			name: this.name,
+			level: this.level
+		};
+	}
+	/** `showHidden` would otherwise print the non-enumerable queue (and its URL). */
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		return this.toJSON();
+	}
+	buildPayload(messages, overflow) {
+		const blocks = messages.flatMap((m) => m.blocks ?? []);
+		const counter = overflow > 0 ? `… and ${overflow} more entr${overflow === 1 ? "y" : "ies"} not shown` : "";
+		if (counter) blocks.push({
+			type: "context",
+			elements: [{
+				type: "mrkdwn",
+				text: counter
+			}]
+		});
+		const payload = {
+			text: truncateText([...messages.map((m) => m.text ?? ""), counter].filter(Boolean).join("\n"), SLACK_TEXT_MAX),
+			blocks: blocks.slice(0, SLACK_MAX_BLOCKS)
+		};
+		if (this.username) payload["username"] = truncateText(this.username, 80);
+		if (this.iconEmoji) payload["icon_emoji"] = this.iconEmoji;
+		return payload;
+	}
+	messageFor(entry) {
+		if (this.formatter) try {
+			return this.formatter(entry);
+		} catch {
+			require_internal_log.internalWarn("SlackTransport: formatter threw; using the default message");
+		}
+		return defaultMessage(entry);
+	}
+};
+function defaultMessage(entry) {
+	const level = singleLine(entry.level).toUpperCase();
+	const emoji = LEVEL_EMOJI[entry.level.toLowerCase()] ?? ":white_circle:";
+	const headline = `[${level}] ${singleLine(entry.message)}`;
+	const blocks = [{
+		type: "header",
+		text: {
+			type: "plain_text",
+			text: truncateText(escapeSlack(headline), 150),
+			emoji: false
+		}
+	}];
+	const context = [
+		["app", entry.appName],
+		["env", entry.environment],
+		["context", entry.context],
+		["trace", entry.traceId],
+		["time", safeIso(entry.timestamp)]
+	].map(([label, value]) => [label, typeof value === "string" ? singleLine(value) : ""]).filter(([, value]) => value !== "").map(([label, value]) => ({
+		type: "mrkdwn",
+		text: `*${label}:* ${truncateText(escapeSlack(value), SLACK_FIELD_MAX)}`
+	}));
+	if (context.length > 0) blocks.push({
+		type: "context",
+		elements: context
+	});
+	if (entry.data && Object.keys(entry.data).length > 0) {
+		const json = truncateText(escapeSlack(require_safe_stringify.stringifyForLog(entry.data)), SLACK_DATA_MAX);
+		blocks.push({
+			type: "section",
+			text: {
+				type: "mrkdwn",
+				text: `\`\`\`${json}\`\`\``
+			}
+		});
+	}
+	return {
+		text: `${emoji} ${escapeSlack(truncateText(headline, 150))}`,
+		blocks
+	};
+}
+Object.defineProperty(exports, "DiscordTransport", {
+	enumerable: true,
+	get: function() {
+		return DiscordTransport;
+	}
+});
+Object.defineProperty(exports, "OtlpLogTransport", {
+	enumerable: true,
+	get: function() {
+		return OtlpLogTransport;
+	}
+});
+Object.defineProperty(exports, "SlackTransport", {
+	enumerable: true,
+	get: function() {
+		return SlackTransport;
+	}
+});
+Object.defineProperty(exports, "toOtelSeverity", {
+	enumerable: true,
+	get: function() {
+		return toOtelSeverity;
+	}
+});
+
+//# sourceMappingURL=slack.transport-Dlx3xvb7.js.map