@interactive-inc/flume 0.3.0 → 0.6.0

package/dist/slack.js

@@ -1,12 +1,12 @@
-import { n as createFlumeDefaultDeps, t as FlumeLogger } from "./logger-CpGB9WO_.js";
-import { i as FlumeConnectionError, n as resolveFlumeReconnectConfig, r as FlumeParseError, t as FlumeReconnector } from "./reconnector-BDoJ1xNX.js";
-import { t as FlumeHttpError } from "./http-error-BtXonO-W.js";
-import { t as FlumeSerialQueue } from "./serial-queue-ExmlnpzQ.js";
-import { n as isRecord, r as scheduleFlumeReconnect, t as safeJsonParse } from "./safe-json-parse-BWlzGOLl.js";
-import { t as safeFetch } from "./safe-fetch-30ZzOKHL.js";
+import { a as FlumeStartError, c as safeNormalizeError, i as safeNow, l as safeErrorMessage, o as FlumeParseError, r as FlumeLogger, s as attempt, t as FlumeSource } from "./flume-source-DUvt9aJt.js";
+import { t as FlumeConnectionError } from "./connection-error-HUO3PC3G.js";
+import { t as FlumeHttpError } from "./http-error-CPSKoSie.js";
+import { i as FlumeReconnector, n as isRecord, r as scheduleFlumeReconnect, t as safeStringify } from "./safe-stringify-DbWQw9qe.js";
+import { t as safeJsonParse } from "./safe-json-parse-CfJjt-RY.js";
+import { t as safeReadText } from "./safe-read-text-JQd_5vbd.js";
 import { z } from "zod/v4";
 //#region lib/slack/extract-slack-meta.ts
-function extractSlackMeta(envelope) {
+function flumeExtractSlackMeta(envelope) {
 	const meta = { event_type: envelope.type };
 	const eventPayload = isRecord(envelope.payload.event) ? envelope.payload.event : null;
 	if (!eventPayload) return meta;
@@ -19,41 +19,40 @@ function extractSlackMeta(envelope) {
 //#endregion
 //#region lib/slack/slack-seen-cache.ts
 /**
-* Slack envelope_id の LRU 風キャッシュ。Slack は ack 失敗時に同じ envelope を再送するため、
-* source レイヤで handler への重複配送を防ぐ
+* Slack envelope_id を maxSize / ttlMs で制限するキャッシュ。Slack は ack 失敗時に同じ envelope を
+* 再送してくるため、source 層で重複配送を防ぐ。TTL を過ぎたエントリは has() が false を返し、
+* trim() で容量超過分が古い順に落とされる
 */
 var FlumeSlackSeenCache = class {
 	props;
-	seen = /* @__PURE__ */ new Set();
+	seen = /* @__PURE__ */ new Map();
 	constructor(props) {
 		this.props = props;
 	}
 	has(envelopeId) {
-		return this.seen.has(envelopeId);
+		const timestamp = this.seen.get(envelopeId);
+		if (timestamp === void 0) return false;
+		if (safeNow({ deps: this.props.deps }) - timestamp > this.props.ttlMs) {
+			this.seen.delete(envelopeId);
+			return false;
+		}
+		return true;
 	}
 	add(envelopeId) {
-		this.seen.add(envelopeId);
+		this.seen.set(envelopeId, safeNow({ deps: this.props.deps }));
 	}
 	trim() {
+		const cutoff = safeNow({ deps: this.props.deps }) - this.props.ttlMs;
+		for (const [id, timestamp] of this.seen) if (timestamp < cutoff) this.seen.delete(id);
 		if (this.seen.size <= this.props.maxSize) return;
-		const entries = [...this.seen];
-		this.seen = new Set(entries.slice(entries.length - this.props.maxSize));
+		const entries = [...this.seen.entries()];
+		this.seen = new Map(entries.slice(entries.length - this.props.maxSize));
 	}
 	get size() {
 		return this.seen.size;
 	}
 };
 //#endregion
-//#region lib/slack/slack-envelope-schema.ts
-const FlumeSlackEnvelopeSchema = z.object({
-	envelope_id: z.string(),
-	type: z.string(),
-	payload: z.record(z.string(), z.unknown()),
-	accepts_response_payload: z.boolean().optional(),
-	retry_attempt: z.number().optional(),
-	retry_reason: z.string().optional()
-});
-//#endregion
 //#region lib/slack/slack-connection-response-schema.ts
 const FlumeSlackConnectionResponseSchema = z.object({
 	ok: z.boolean(),
@@ -62,40 +61,65 @@ const FlumeSlackConnectionResponseSchema = z.object({
 });
 //#endregion
 //#region lib/slack/obtain-slack-url.ts
+const URL_ENDPOINT = "https://slack.com/api/apps.connections.open";
 async function obtainSlackUrl(props) {
 	const log = new FlumeLogger({
 		source: "slack.url",
 		handler: props.onLog,
 		deps: props.deps
 	});
-	const url = "https://slack.com/api/apps.connections.open";
 	log.debug({
 		action: "http.request",
-		message: `POST ${url}`
-	});
-	const response = await safeFetch({
-		fetch: props.deps.fetch,
-		url,
-		init: {
-			method: "POST",
-			headers: { Authorization: `Bearer ${props.appToken}` }
-		},
-		log
-	});
-	if (response instanceof Error) return new FlumeHttpError({
-		message: response.message,
-		status: 0
+		message: `POST ${URL_ENDPOINT}`
 	});
+	const response = await attempt(() => props.deps.fetch(URL_ENDPOINT, {
+		method: "POST",
+		headers: { Authorization: `Bearer ${props.appToken}` },
+		signal: props.signal
+	}));
+	if (response instanceof Error) {
+		const error = safeNormalizeError({ value: response });
+		log.error({
+			action: "http.error",
+			message: safeErrorMessage({ error }),
+			error
+		});
+		return new FlumeConnectionError(`apps.connections.open transport: ${response.message}`, { cause: response });
+	}
 	log.debug({
 		action: "http.response",
 		message: `POST ${response.status}`,
 		detail: {
 			status: response.status,
-			url
+			url: URL_ENDPOINT
 		}
 	});
-	const raw = await response.json();
-	const peek = isRecord(raw) ? raw : {};
+	const text = await safeReadText({
+		response,
+		context: "apps.connections.open"
+	});
+	if (text instanceof FlumeHttpError) {
+		log.warn({
+			action: "http.body.read",
+			message: safeErrorMessage({ error: text }),
+			error: text
+		});
+		return text;
+	}
+	const json = safeJsonParse(text);
+	if (json instanceof FlumeParseError) {
+		log.warn({
+			action: "http.body.parse",
+			message: json.message,
+			error: json
+		});
+		return new FlumeHttpError({
+			message: `apps.connections.open: invalid JSON body`,
+			status: response.status,
+			cause: json
+		});
+	}
+	const peek = isRecord(json) ? json : {};
 	log.debug({
 		action: "http.body",
 		message: "apps.connections.open response",
@@ -104,10 +128,10 @@ async function obtainSlackUrl(props) {
 			error: peek.error
 		}
 	});
-	const parsed = FlumeSlackConnectionResponseSchema.safeParse(raw);
+	const parsed = FlumeSlackConnectionResponseSchema.safeParse(json);
 	if (!parsed.success) {
 		log.warn({
-			action: "parse.fail",
+			action: "http.body.schema",
 			message: "apps.connections.open: invalid response shape",
 			detail: { issues: parsed.error.issues.map((i) => ({
 				path: i.path,
@@ -116,12 +140,13 @@ async function obtainSlackUrl(props) {
 		});
 		return new FlumeHttpError({
 			message: "apps.connections.open: invalid response shape",
-			status: response.status
+			status: response.status,
+			cause: parsed.error
 		});
 	}
 	if (!parsed.data.ok || !parsed.data.url) {
 		log.warn({
-			action: "api.fail",
+			action: "slack.api.error",
 			message: `apps.connections.open failed: ${parsed.data.error ?? "no url"}`
 		});
 		return new FlumeHttpError({
@@ -130,21 +155,35 @@ async function obtainSlackUrl(props) {
 		});
 	}
 	log.info({
-		action: "url.obtained",
+		action: "slack.url.obtained",
 		message: "WSS URL obtained"
 	});
 	return parsed.data.url;
 }
 //#endregion
+//#region lib/slack/slack-envelope-schema.ts
+const FlumeSlackEnvelopeSchema = z.object({
+	envelope_id: z.string(),
+	type: z.string(),
+	payload: z.record(z.string(), z.unknown()),
+	accepts_response_payload: z.boolean().optional(),
+	retry_attempt: z.number().optional(),
+	retry_reason: z.string().optional()
+});
+//#endregion
 //#region lib/slack/slack-socket-mode.ts
-function framePreview(raw) {
-	return raw.length > 200 ? `${raw.slice(0, 200)}... (${raw.length} bytes)` : raw;
-}
+const WS_OPEN = 1;
+/**
+* Slack Socket Mode の最小 WebSocket 実装。`apps.connections.open` で URL を取得し
+* `type: "hello"` を待ってから connected を通知する。
+* IO 境界は全て `attempt` 経由で扱い、`connect()` は決して reject しない
+*/
 var FlumeSlackSocketMode = class {
 	props;
 	log;
 	ws = null;
-	stopped = false;
+	isStoppedFlag = false;
+	hasConnected = false;
 	pendingResolve = null;
 	pendingResolved = false;
 	constructor(props) {
@@ -155,13 +194,17 @@ var FlumeSlackSocketMode = class {
 			deps: props.deps
 		});
 	}
-	async connect() {
+	get isStopped() {
+		return this.isStoppedFlag;
+	}
+	async connect(options) {
 		this.log.info({
 			action: "connect.start",
 			message: "opening WebSocket connection"
 		});
 		const url = await obtainSlackUrl({
 			appToken: this.props.appToken,
+			signal: options?.signal,
 			onLog: this.props.onLog,
 			deps: this.props.deps
 		});
@@ -173,8 +216,24 @@ var FlumeSlackSocketMode = class {
 			});
 			return url;
 		}
+		if (url instanceof FlumeConnectionError) {
+			this.log.error({
+				action: "url.error",
+				message: url.message,
+				error: url
+			});
+			return url;
+		}
+		if (this.isStoppedFlag) {
+			const error = new FlumeConnectionError("stopped before WebSocket open");
+			this.log.info({
+				action: "connect.aborted",
+				message: safeErrorMessage({ error })
+			});
+			return error;
+		}
 		this.log.info({
-			action: "url.obtained",
+			action: "slack.url.obtained",
 			message: "WebSocket URL obtained"
 		});
 		return this.openSocket(url);
@@ -184,24 +243,59 @@ var FlumeSlackSocketMode = class {
 			action: "disconnect",
 			message: "stopping socket mode"
 		});
-		this.stopped = true;
-		if (this.ws) {
-			this.ws.close();
-			this.ws = null;
-		}
+		this.isStoppedFlag = true;
+		this.closeSocket(this.ws);
+		this.ws = null;
 	}
 	isConnected() {
-		return this.ws !== null && this.ws.readyState === WebSocket.OPEN;
+		return this.ws !== null && this.ws.readyState === WS_OPEN;
 	}
 	openSocket(url) {
+		const WS = this.props.deps.WebSocket;
+		if (!WS) {
+			const error = new FlumeConnectionError("WebSocket runtime not available");
+			this.log.error({
+				action: "ws.error",
+				message: safeErrorMessage({ error }),
+				error
+			});
+			return Promise.resolve(error);
+		}
 		this.pendingResolved = false;
+		this.hasConnected = false;
 		return new Promise((resolve) => {
 			this.pendingResolve = resolve;
-			const socket = new this.props.deps.WebSocket(url);
+			const socketResult = attempt(() => new WS(url));
+			if (socketResult instanceof Error) {
+				const error = new FlumeConnectionError(`WebSocket construction failed: ${safeErrorMessage({ error: socketResult })}`, { cause: socketResult });
+				this.log.error({
+					action: "ws.construct.error",
+					message: safeErrorMessage({ error }),
+					error
+				});
+				this.ws = null;
+				this.pendingResolved = true;
+				resolve(error);
+				return;
+			}
+			const socket = socketResult;
 			this.ws = socket;
-			socket.addEventListener("message", (ev) => this.onMessage(String(ev.data), socket));
-			socket.addEventListener("close", (ev) => this.onClose(ev));
-			socket.addEventListener("error", () => this.onError());
+			const listenerResult = attempt(() => {
+				socket.addEventListener("message", (ev) => this.safeOnMessage(ev, socket));
+				socket.addEventListener("close", (ev) => this.safeOnClose(ev));
+				socket.addEventListener("error", () => this.safeOnError());
+			});
+			if (listenerResult instanceof Error) {
+				const error = new FlumeConnectionError(`WebSocket listener registration failed: ${safeErrorMessage({ error: listenerResult })}`, { cause: listenerResult });
+				this.log.error({
+					action: "ws.listener.error",
+					message: safeErrorMessage({ error }),
+					error
+				});
+				this.ws = null;
+				this.pendingResolved = true;
+				resolve(error);
+			}
 		});
 	}
 	completeConnect(error) {
@@ -209,25 +303,61 @@ var FlumeSlackSocketMode = class {
 		this.pendingResolved = true;
 		this.pendingResolve(error);
 	}
-	onMessage(raw, socket) {
-		this.log.debug({
-			action: "ws.recv",
-			message: framePreview(raw)
+	safeOnMessage(ev, socket) {
+		const r = attempt(() => this.onMessage(String(ev.data), socket));
+		if (r instanceof Error) this.log.error({
+			action: "ws.message.threw",
+			message: safeErrorMessage({ error: r }),
+			error: r
+		});
+	}
+	safeOnClose(ev) {
+		const r = attempt(() => this.onClose(ev));
+		if (r instanceof Error) this.log.error({
+			action: "ws.close.threw",
+			message: safeErrorMessage({ error: r }),
+			error: r
 		});
+	}
+	safeOnError() {
+		const r = attempt(() => this.onError());
+		if (r instanceof Error) this.log.error({
+			action: "ws.error.threw",
+			message: safeErrorMessage({ error: r }),
+			error: r
+		});
+	}
+	onMessage(raw, socket) {
+		if (this.isStoppedFlag) return;
 		const json = safeJsonParse(raw);
+		if (json instanceof FlumeParseError) {
+			this.log.error({
+				action: "ws.parse.error",
+				message: json.message,
+				error: json,
+				detail: { length: raw.length }
+			});
+			return;
+		}
 		if (!isRecord(json)) {
 			this.log.error({
-				action: "ws.parse-error",
-				message: "invalid JSON",
-				error: new FlumeParseError(raw.slice(0, 200))
+				action: "ws.parse.error",
+				message: "expected JSON object",
+				error: new FlumeParseError(`non-object frame (${typeof json})`)
 			});
 			return;
 		}
+		this.log.debug({
+			action: "ws.recv",
+			message: `type=${typeof json.type === "string" ? json.type : "-"} length=${raw.length}`,
+			detail: { length: raw.length }
+		});
 		if (json.type === "hello") {
 			this.log.info({
-				action: "ws.hello",
+				action: "socket.hello",
 				message: "connection ready"
 			});
+			this.hasConnected = true;
 			this.props.onConnected();
 			this.completeConnect(null);
 			return;
@@ -235,11 +365,11 @@ var FlumeSlackSocketMode = class {
 		if (json.type === "disconnect") {
 			const reason = typeof json.reason === "string" ? json.reason : "unknown";
 			this.log.info({
-				action: "ws.disconnect-requested",
+				action: "ws.disconnect.requested",
 				message: `reason=${reason}`,
 				detail: { reason }
 			});
-			socket.close();
+			this.closeSocket(socket);
 			return;
 		}
 		if (typeof json.envelope_id === "string") {
@@ -247,12 +377,8 @@ var FlumeSlackSocketMode = class {
 				action: "ws.ack",
 				message: `envelope_id=${json.envelope_id}`
 			});
-			const ack = JSON.stringify({ envelope_id: json.envelope_id });
-			socket.send(ack);
-			this.log.debug({
-				action: "ws.send",
-				message: framePreview(ack)
-			});
+			const ack = this.safeSerialize({ envelope_id: json.envelope_id });
+			if (ack !== null) this.send(socket, ack);
 		}
 		const envelope = FlumeSlackEnvelopeSchema.safeParse(json);
 		if (envelope.success) {
@@ -268,7 +394,7 @@ var FlumeSlackSocketMode = class {
 			return;
 		}
 		this.log.warn({
-			action: "envelope.parse-fail",
+			action: "envelope.parse.error",
 			message: "unrecognised envelope shape, dropping",
 			detail: {
 				type: typeof json.type === "string" ? json.type : "unknown",
@@ -282,94 +408,139 @@ var FlumeSlackSocketMode = class {
 	onClose(ev) {
 		this.log.info({
 			action: "ws.close",
-			message: `code=${ev.code} reason=${ev.reason || "none"}`
+			message: `code=${ev.code} reason=${ev.reason || "none"}`,
+			detail: {
+				code: ev.code,
+				reason: ev.reason
+			}
 		});
 		this.ws = null;
-		this.props.onDisconnected();
-		this.completeConnect(new FlumeConnectionError(`WebSocket closed before hello (code=${ev.code})`));
+		if (this.hasConnected) this.props.onDisconnected();
+		if (!this.pendingResolved) {
+			const error = new FlumeConnectionError(`WebSocket closed before hello (code=${ev.code})`, { code: ev.code });
+			this.completeConnect(error);
+		}
 	}
 	onError() {
+		const error = new FlumeConnectionError("WebSocket connection error");
 		this.log.error({
 			action: "ws.error",
-			message: "WebSocket error event"
+			message: safeErrorMessage({ error }),
+			error
+		});
+		this.completeConnect(error);
+	}
+	closeSocket(ws) {
+		if (ws === null) return;
+		const result = attempt(() => ws.close());
+		if (result instanceof Error) this.log.error({
+			action: "ws.close.error",
+			message: safeErrorMessage({ error: result }),
+			error: result
 		});
-		this.completeConnect(new FlumeConnectionError("WebSocket connection error"));
+	}
+	send(socket, payload) {
+		if (socket.readyState !== WS_OPEN) {
+			this.log.warn({
+				action: "ws.send",
+				message: `ws.send skipped: readyState=${socket.readyState} (not OPEN)`,
+				detail: { readyState: socket.readyState }
+			});
+			return;
+		}
+		const result = attempt(() => socket.send(payload));
+		if (result instanceof Error) this.log.error({
+			action: "ws.send",
+			message: `ws.send failed: ${safeErrorMessage({ error: result })}`,
+			error: result
+		});
+	}
+	safeSerialize(value) {
+		const result = safeStringify(value);
+		if (result instanceof Error) {
+			this.log.error({
+				action: "ws.send.serialize.error",
+				message: safeErrorMessage({ error: result }),
+				error: result
+			});
+			return null;
+		}
+		return result;
 	}
 };
 //#endregion
 //#region lib/slack/slack-source.ts
 const SEEN_CACHE_MAX = 1024;
-var FlumeSlackSource = class {
+const SEEN_CACHE_TTL_MS = 300 * 1e3;
+var FlumeSlackSource = class extends FlumeSource {
 	options;
 	name = "slack";
 	socket = null;
 	reconnector = null;
-	handler = null;
-	currentStatus = "disconnected";
-	log;
-	deps;
-	queue = new FlumeSerialQueue();
-	seen = new FlumeSlackSeenCache({ maxSize: SEEN_CACHE_MAX });
+	internalController = null;
+	seen = null;
 	constructor(options) {
+		super();
 		this.options = options;
-		this.deps = options.deps ?? createFlumeDefaultDeps();
-		this.log = new FlumeLogger({
-			source: "slack",
-			handler: options.onLog,
-			deps: this.deps
-		});
-		const rc = resolveFlumeReconnectConfig(options.reconnect);
-		if (rc) this.reconnector = new FlumeReconnector({
-			...rc,
-			deps: this.deps
-		});
 	}
-	async start(handler) {
-		if (this.options.signal?.aborted) return {
-			ok: false,
-			error: /* @__PURE__ */ new Error("Slack source: signal already aborted")
-		};
-		this.options.signal?.addEventListener("abort", () => this.stop(), { once: true });
-		this.handler = handler;
-		this.log.info({
-			action: "start",
-			message: "starting Slack source"
+	async connect(ctx) {
+		if (!this.hasWebSocket(ctx)) return new FlumeStartError("Slack source: deps.WebSocket is null (no WebSocket runtime available)");
+		this.seen = new FlumeSlackSeenCache({
+			maxSize: SEEN_CACHE_MAX,
+			ttlMs: SEEN_CACHE_TTL_MS,
+			deps: ctx.deps
 		});
-		const result = await this.connectInternal();
-		if (result instanceof Error) return {
-			ok: false,
-			error: result
-		};
-		return { ok: true };
-	}
-	async stop() {
-		this.log.info({
-			action: "stop",
-			message: "stopping Slack source"
+		if (ctx.reconnect && !this.reconnector) this.reconnector = new FlumeReconnector({
+			...ctx.reconnect,
+			log: ctx.log,
+			deps: ctx.deps
 		});
-		if (this.reconnector && !this.reconnector.aborted) this.log.debug({
+		const controllerResult = attempt(() => new AbortController());
+		if (controllerResult instanceof Error) {
+			const error = safeNormalizeError({ value: controllerResult });
+			ctx.log.error({
+				action: "slack.abort-controller.new.error",
+				message: safeErrorMessage({ error }),
+				error
+			});
+			this.internalController = null;
+		} else this.internalController = controllerResult;
+		return await this.connectInternal(ctx);
+	}
+	disconnect() {
+		const ctx = this.context;
+		if (ctx && this.reconnector && !this.reconnector.aborted) ctx.log.debug({
 			action: "reconnect.cancel",
 			message: "aborting reconnector"
 		});
 		this.reconnector?.cancel();
+		this.internalController?.abort();
 		this.socket?.disconnect();
 		this.socket = null;
-		this.handler = null;
-		await this.queue.drain();
-		this.setStatus("disconnected");
+		this.internalController = null;
 	}
-	status() {
-		return this.currentStatus;
+	hasWebSocket(ctx) {
+		const result = attempt(() => Boolean(ctx.deps.WebSocket));
+		if (result instanceof Error) {
+			const error = safeNormalizeError({ value: result });
+			ctx.log.error({
+				action: "deps.web-socket.read.error",
+				message: safeErrorMessage({ error }),
+				error
+			});
+			return false;
+		}
+		return result;
 	}
-	async connectInternal() {
+	async connectInternal(ctx) {
 		this.setStatus("connecting");
 		this.socket = new FlumeSlackSocketMode({
 			appToken: this.options.appToken,
-			onLog: this.options.onLog,
-			deps: this.deps,
-			onMessage: (envelope) => this.handleMessage(envelope),
+			onLog: ctx.log.handler,
+			deps: ctx.deps,
+			onMessage: (envelope) => this.handleMessage(ctx, envelope),
 			onConnected: () => {
-				if (this.reconnector && this.reconnector.attempt > 0) this.log.info({
+				if (this.reconnector && this.reconnector.attempt > 0) ctx.log.info({
 					action: "reconnect.reset",
 					message: `cleared ${this.reconnector.attempt} attempts`
 				});
@@ -377,27 +548,33 @@ var FlumeSlackSource = class {
 				this.setStatus("connected");
 			},
 			onDisconnected: () => {
-				if (!this.socket?.stopped) this.scheduleReconnect();
+				if (this.socket?.isStopped) {
+					this.setStatus("disconnected");
+					return;
+				}
+				this.scheduleReconnect(ctx);
 			}
 		});
-		const error = await this.socket.connect();
+		const error = await this.socket.connect({ signal: this.internalController?.signal });
 		if (error instanceof Error) {
-			this.log.error({
+			ctx.log.error({
 				action: "connect.failed",
-				message: error.message,
+				message: safeErrorMessage({ error }),
 				error
 			});
-			if (!this.reconnector || this.reconnector.aborted) {
+			if (this.socket.isStopped || !this.reconnector || this.reconnector.aborted) {
 				this.setStatus("disconnected");
 				return error;
 			}
-			this.scheduleReconnect();
+			this.scheduleReconnect(ctx);
 		}
 		return null;
 	}
-	handleMessage(envelope) {
-		if (this.seen.has(envelope.envelope_id)) {
-			this.log.debug({
+	handleMessage(ctx, envelope) {
+		const seen = this.seen;
+		if (!seen) return;
+		if (seen.has(envelope.envelope_id)) {
+			ctx.log.debug({
 				action: "dedup.skip",
 				message: `duplicate envelope_id=${envelope.envelope_id}`,
 				detail: {
@@ -407,46 +584,48 @@ var FlumeSlackSource = class {
 			});
 			return;
 		}
-		this.seen.add(envelope.envelope_id);
-		this.seen.trim();
-		const event = {
+		seen.add(envelope.envelope_id);
+		seen.trim();
+		this.emit({
 			source: "slack",
 			type: envelope.type,
 			data: envelope.payload,
-			meta: extractSlackMeta(envelope),
-			receivedAt: this.deps.now()
-		};
-		this.queue.add(async () => {
-			try {
-				await this.handler?.(event);
-			} catch (err) {
-				this.log.error({
-					action: "handler.error",
-					message: "user handler threw",
-					error: err instanceof Error ? err : new Error(String(err))
-				});
-			}
+			meta: this.safeExtractMeta(ctx, envelope),
+			receivedAt: safeNow({ deps: ctx.deps })
 		});
 	}
-	scheduleReconnect() {
+	safeExtractMeta(ctx, envelope) {
+		const result = attempt(() => flumeExtractSlackMeta(envelope));
+		if (result instanceof Error) {
+			const error = safeNormalizeError({ value: result });
+			ctx.log.warn({
+				action: "meta.extract.error",
+				message: safeErrorMessage({ error }),
+				error,
+				detail: { envelopeType: envelope.type }
+			});
+			return { event_type: envelope.type };
+		}
+		return result;
+	}
+	scheduleReconnect(ctx) {
 		scheduleFlumeReconnect({
 			reconnector: this.reconnector,
-			log: this.log,
+			log: ctx.log,
 			setStatus: (status) => this.setStatus(status),
 			retry: () => {
-				this.connectInternal();
+				this.connectInternal(ctx).catch((err) => {
+					const error = safeNormalizeError({ value: err });
+					ctx.log.error({
+						action: "reconnect.unhandled",
+						message: safeErrorMessage({ error }),
+						error
+					});
+					this.setStatus("disconnected");
+				});
 			}
 		});
 	}
-	setStatus(next) {
-		if (this.currentStatus === next) return;
-		this.log.info({
-			action: "status",
-			message: `${this.currentStatus} → ${next}`
-		});
-		this.currentStatus = next;
-		this.options.onStatus?.(next);
-	}
 };
 //#endregion
-export { FlumeSlackConnectionResponseSchema, FlumeSlackEnvelopeSchema, FlumeSlackSeenCache, FlumeSlackSocketMode, FlumeSlackSource, extractSlackMeta, obtainSlackUrl };
+export { FlumeSlackSource, flumeExtractSlackMeta };