@interactive-inc/flume 0.4.0 → 0.9.0

package/dist/index.js

@@ -1,13 +1,146 @@
-import { a as FlumeParseError, c as safeNormalizeError, i as FlumeStartError, l as safeErrorMessage, n as FlumeLogger, o as createFlumeDefaultDeps, s as attempt, t as safeInvokeCallback } from "./safe-invoke-callback-EpWXwfwp.js";
-import { t as FlumeConnectionError } from "./connection-error-HUO3PC3G.js";
-import { t as FlumeHttpError } from "./http-error-CPSKoSie.js";
-//#region lib/flume-stopped.ts
+import { a as FlumeStartError, c as safeNormalizeError, l as safeErrorMessage, n as safeInvokeCallback, o as FlumeParseError, r as FlumeLogger, s as attempt, t as FlumeSource } from "./flume-source.js";
+import { t as FlumeConnectionError } from "./connection-error.js";
+import { t as FlumeHttpError } from "./http-error.js";
+//#region lib/deps.ts
 /**
-* 停止済みの終端状態。最終ステータスのスナップショットのみ観測できる
+* `globalThis.WebSocket` の現在の値を返す。
+* 取得は呼び出しごとに行う — `createFlumeDefaultDeps()` がモジュール初期化時ではなく
+* 呼ばれた瞬間の `globalThis.WebSocket` を見るので、jsdom / happy-dom / vitest の
+* `beforeEach` で `globalThis.WebSocket` を差し込むテスト戦略がそのまま機能する。
+* `WebSocket` が無い環境 (Node の素の global など) では `null` を返す。
 */
-var FlumeStopped = class {
+function resolveCurrentWebSocket() {
+	const candidate = attempt(() => globalThis.WebSocket);
+	if (candidate instanceof Error || typeof candidate !== "function") return null;
+	return candidate;
+}
+/**
+* platform 既定の IO を束ねた `FlumeRuntimeDeps`。
+* `FlumeTimerHandle` は不透明型 (`unknown`) のため、setTimeout / clearTimeout の戻り値・引数を
+* platform 型と橋渡しする際に境界で `as unknown as` を使う (IO 境界の最終手段)。
+*
+* `WebSocket` を含む全 IO は呼び出しごとに `globalThis` から引く lazy lookup。
+* モジュール初期化後に `globalThis.WebSocket` が差し替わる環境
+* (テストの `beforeEach` パッチ、jsdom などのブラウザ環境エミュレータ) でも
+* `createFlumeDefaultDeps()` が返した deps が常に最新の参照を見る。
+*/
+function createFlumeDefaultDeps() {
+	return {
+		fetch: (url, init) => globalThis.fetch(url, init),
+		WebSocket: resolveCurrentWebSocket(),
+		now: () => Date.now(),
+		random: () => Math.random(),
+		setTimeout: (fn, ms) => globalThis.setTimeout(fn, ms),
+		clearTimeout: (id) => globalThis.clearTimeout(id),
+		setInterval: (fn, ms) => globalThis.setInterval(fn, ms),
+		clearInterval: (id) => globalThis.clearInterval(id)
+	};
+}
+//#endregion
+//#region lib/flume-stream.ts
+const DONE = {
+	value: void 0,
+	done: true
+};
+/**
+* push (`FlumeStreamHub.publish`) を pull (`for await`) に変換する async iterator。
+* consumer が待っていれば即 resolve、いなければ buffer に積み、溢れたら onOverflow に従う。
+* `return()` (break / 例外) と hub.close() のどちらでも自然に done へ落ちる
+*/
+var FlumeStream = class {
+	props;
+	items = [];
+	resolvers = [];
+	closed = false;
+	constructor(props) {
+		this.props = props;
+	}
+	push(item) {
+		if (this.closed) return;
+		const resolver = this.resolvers.shift();
+		if (resolver) {
+			resolver({
+				value: item,
+				done: false
+			});
+			return;
+		}
+		if (this.items.length >= this.props.buffer) {
+			if (this.props.onOverflow === "drop-newest") return;
+			this.items.shift();
+		}
+		this.items.push(item);
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		while (this.resolvers.length > 0) {
+			const resolver = this.resolvers.shift();
+			if (resolver) resolver(DONE);
+		}
+	}
+	next() {
+		const item = this.items.shift();
+		if (item !== void 0) return Promise.resolve({
+			value: item,
+			done: false
+		});
+		if (this.closed) return Promise.resolve(DONE);
+		return new Promise((resolve) => this.resolvers.push(resolve));
+	}
+	return() {
+		this.close();
+		this.props.onClose();
+		return Promise.resolve(DONE);
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+};
+//#endregion
+//#region lib/flume-stream-hub.ts
+const DEFAULT_BUFFER = 1e3;
+/**
+* firehose (`onEvent` / `stream()`) の item を複数の pull consumer へ fan-out する内部ハブ。
+* subscriber が居なければ publish は実質 no-op。Flume 停止時に close() で全 stream を終端する
+*/
+var FlumeStreamHub = class {
+	streams = /* @__PURE__ */ new Set();
+	closed = false;
+	publish(item) {
+		if (this.closed) return;
+		for (const stream of this.streams) stream.push(item);
+	}
+	subscribe(options) {
+		const stream = new FlumeStream({
+			buffer: options?.buffer ?? DEFAULT_BUFFER,
+			onOverflow: options?.onOverflow ?? "drop-oldest",
+			onClose: () => this.streams.delete(stream)
+		});
+		if (this.closed) {
+			stream.close();
+			return stream;
+		}
+		this.streams.add(stream);
+		return stream;
+	}
+	close() {
+		if (this.closed) return;
+		this.closed = true;
+		for (const stream of this.streams) stream.close();
+		this.streams.clear();
+	}
+};
+//#endregion
+//#region lib/flume-closed.ts
+/**
+* 停止済みの終端状態。最終ステータスと、停止時に source.disconnect が throw した
+* エラー一覧を観測できる。`errors()` を読めば `onLog` を grep せずに「どの source が
+* きれいに close したか / どれが失敗したか」を直接判定できる
+*/
+var FlumeClosed = class {
 	props;
-	kind = "stopped";
+	kind = "closed";
 	constructor(props) {
 		this.props = props;
 		Object.freeze(this);
@@ -15,31 +148,39 @@ var FlumeStopped = class {
 	statuses() {
 		return this.props.finalStatuses;
 	}
+	/**
+	* `runClose` 中に `source.stop()` が rejected で settle した source の名前と
+	* 正規化済み Error の組。`onEvent` firehose の `flume.close.failed` log と 1:1 対応する。
+	* 全 source が clean close した場合は空配列。
+	*/
+	errors() {
+		return this.props.closeErrors;
+	}
 };
 //#endregion
 //#region lib/flume-running.ts
 /**
-* 稼働中の Flume。stop() で FlumeStopped へ遷移する。signal が abort されると自動 stop。
+* 稼働中の Flume。close() で FlumeClosed へ遷移する。signal が abort されると自動 close。
 * 全ての source 呼び出し・signal 操作・status 読み取りを `attempt` 経由で扱い、
-* `runStop` の最外殻 try/catch で想定外の throw も `FlumeStopped` の resolve に変換する
+* `runClose` の最外殻 try/catch で想定外の throw も `FlumeClosed` の resolve に変換する
 */
 var FlumeRunning = class {
 	props;
 	kind = "running";
-	stopPromise = null;
+	closePromise = null;
 	onAbort;
 	constructor(props) {
 		this.props = props;
 		this.onAbort = () => {
 			this.props.log.info({
 				action: "flume.abort",
-				message: "signal aborted, stopping"
+				message: "signal aborted, closing"
 			});
 			safeInvokeCallback({
-				fn: () => this.stop(),
+				fn: () => this.close(),
 				onError: (error) => {
 					this.props.log.error({
-						action: "flume.abort.stop.failed",
+						action: "flume.abort.close.failed",
 						message: safeErrorMessage({ error }),
 						error
 					});
@@ -59,27 +200,49 @@ var FlumeRunning = class {
 			}
 		}
 	}
-	stop() {
-		if (this.stopPromise) return this.stopPromise;
-		this.stopPromise = this.runStop();
-		return this.stopPromise;
+	close() {
+		if (this.closePromise) return this.closePromise;
+		this.closePromise = this.runClose();
+		return this.closePromise;
 	}
 	statuses() {
 		return this.snapshotStatuses();
 	}
-	async runStop() {
+	/**
+	* 統合 firehose を pull で受け取る async iterator。`for await (const item of running.stream())`。
+	* item は events + 全ログの union (`FlumeStreamItem`)。`item.kind` で判別する。
+	* close() / signal abort で iterator は自然に終了し、`break` すると hub から自動 unsubscribe する。
+	* consumer が遅れて buffer を超えたら `onOverflow` (既定 drop-oldest) に従う
+	*/
+	stream(options) {
+		return this.props.hub.subscribe(options);
+	}
+	/**
+	* Host が `Flume({ signal })` で渡した AbortSignal をそのまま公開する。
+	* 直接の controller を持っていない呼び出し元が `running.signal?.aborted`
+	* で abort 状態を確認できる
+	*/
+	get signal() {
+		return this.props.signal;
+	}
+	async runClose() {
+		const closeErrors = [];
 		try {
 			this.props.log.info({
-				action: "flume.stop",
-				message: `stopping ${this.props.sources.length} source(s)`
+				action: "flume.close",
+				message: `closing ${this.props.sources.length} source(s)`
 			});
 			const settled = await Promise.allSettled(this.props.sources.map((source) => Promise.resolve().then(() => source.stop())));
 			for (const [index, result] of settled.entries()) if (result.status === "rejected") {
 				const source = this.props.sources[index];
 				const name = source ? this.sourceName(source) : "?";
 				const error = safeNormalizeError({ value: result.reason });
+				closeErrors.push({
+					source: name,
+					error
+				});
 				this.props.log.error({
-					action: "flume.stop.failed",
+					action: "flume.close.failed",
 					message: `${name}: ${safeErrorMessage({ error })}`,
 					error,
 					detail: { source: name }
@@ -98,18 +261,26 @@ var FlumeRunning = class {
 				}
 			}
 			this.props.log.info({
-				action: "flume.stop.complete",
-				message: "all sources stopped"
+				action: "flume.close.complete",
+				message: "all sources closed"
+			});
+			this.props.hub.close();
+			return new FlumeClosed({
+				finalStatuses: this.snapshotStatuses(),
+				closeErrors
 			});
-			return new FlumeStopped({ finalStatuses: this.snapshotStatuses() });
 		} catch (err) {
 			const error = safeNormalizeError({ value: err });
 			this.props.log.error({
-				action: "flume.stop.unhandled",
+				action: "flume.close.unhandled",
 				message: safeErrorMessage({ error }),
 				error
 			});
-			return new FlumeStopped({ finalStatuses: this.snapshotStatuses() });
+			this.props.hub.close();
+			return new FlumeClosed({
+				finalStatuses: this.snapshotStatuses(),
+				closeErrors
+			});
 		}
 	}
 	snapshotStatuses() {
@@ -143,42 +314,95 @@ var FlumeRunning = class {
 	}
 };
 //#endregion
+//#region lib/reconnect-config.ts
+const DEFAULTS = {
+	maxAttempts: Infinity,
+	baseDelay: 1e3,
+	maxDelay: 3e4
+};
+function resolveFlumeReconnectConfig(input) {
+	if (input === false || input === void 0) return null;
+	if (input === true) return { ...DEFAULTS };
+	return {
+		...DEFAULTS,
+		...input
+	};
+}
+//#endregion
 //#region lib/flume.ts
 /**
-* 起動前の Flume。`start()` で `FlumeRunning` へ遷移する。
+* 起動前の Flume。`open()` で `FlumeRunning` へ遷移する。
+* コンストラクタは単一オブジェクト `{ sources, ...options }` を受け取る (`sources` のみ必須)。
+* events も全ログも 1 本の firehose (`onEvent` push / `stream()` pull) に流れ、購読側が filter する。
 * いずれかの source 失敗時は既に成功した source を全て `stop()` してロールバックし
 * `FlumeStartError` を返す。
 * `source.start()` / `source.stop()` の sync throw も `Promise.resolve().then` 経由で
-* Promise rejection に正規化して `allSettled` で捕捉する (`start()` は決して reject しない)
+* Promise rejection に正規化して `allSettled` で捕捉する (`open()` は決して reject しない)
 */
 var Flume = class {
-	props;
+	options;
 	consumed = false;
 	log;
 	deps;
-	constructor(props) {
-		this.props = props;
-		this.deps = props.deps ?? createFlumeDefaultDeps();
+	sources;
+	sourceEventHandler;
+	hub = new FlumeStreamHub();
+	constructor(options) {
+		this.options = options;
+		this.sources = options.sources;
+		this.deps = options.deps ?? createFlumeDefaultDeps();
 		this.log = new FlumeLogger({
 			source: "flume",
-			handler: props.onLog,
+			handler: this.buildLogHandler(),
 			deps: this.deps
 		});
+		this.sourceEventHandler = (event) => this.emitItem({
+			kind: "event",
+			event
+		});
+	}
+	/** source が受信したログを firehose へ流す handler。error は onError にも分岐する */
+	buildLogHandler() {
+		return (log) => {
+			this.emitItem({
+				kind: "log",
+				log
+			});
+			const onError = this.options.onError;
+			if (!onError || log.level !== "error") return;
+			try {
+				Promise.resolve(onError(log)).catch(() => {});
+			} catch {}
+		};
 	}
-	async start(handler) {
-		const guard = this.guardStart();
+	/**
+	* firehose の単一 sink: pull の hub と push の onEvent の両方へ item を配る。
+	* onEvent への転送は this.log を経由しない (経由すると log item 経路で再帰する) ため
+	* 例外をここで握り潰す
+	*/
+	emitItem(item) {
+		this.hub.publish(item);
+		const onEvent = this.options.onEvent;
+		if (!onEvent) return;
+		try {
+			Promise.resolve(onEvent(item)).catch(() => {});
+		} catch {}
+	}
+	async open() {
+		const guard = this.guardOpen();
 		if (guard) return guard;
 		this.consumed = true;
 		this.log.info({
-			action: "flume.start",
-			message: `starting ${this.props.sources.length} source(s)`,
-			detail: { count: this.props.sources.length }
+			action: "flume.open",
+			message: `opening ${this.sources.length} source(s)`,
+			detail: { count: this.sources.length }
 		});
-		const settled = await Promise.allSettled(this.props.sources.map((source) => this.safeStart(source, handler)));
+		const reconnect = resolveFlumeReconnectConfig(this.options.reconnect);
+		const settled = await Promise.allSettled(this.sources.map((source) => this.safeStart(source, reconnect)));
 		const failures = [];
 		const started = [];
 		for (const [index, result] of settled.entries()) {
-			const source = this.props.sources[index];
+			const source = this.sources[index];
 			if (source === void 0) continue;
 			const name = this.sourceName(source);
 			if (result.status === "rejected") {
@@ -206,48 +430,49 @@ var Flume = class {
 			});
 			await this.rollback(started);
 			const detail = failures.map((f) => `${f.name}: ${safeErrorMessage({ error: f.error })}`).join("; ");
-			const error = new FlumeStartError(`Flume.start: ${failures.length} source(s) failed: ${detail}`);
+			const error = new FlumeStartError(`Flume.open: ${failures.length} source(s) failed: ${detail}`);
 			this.log.error({
-				action: "flume.start.failed",
+				action: "flume.open.failed",
 				message: safeErrorMessage({ error }),
 				error
 			});
 			return error;
 		}
 		if (this.isSignalAborted()) {
-			await this.rollback(this.props.sources);
-			const error = new FlumeStartError("Flume.start: aborted during start");
+			await this.rollback(this.sources);
+			const error = new FlumeStartError("Flume.open: aborted during open");
 			this.log.warn({
-				action: "flume.start.aborted",
+				action: "flume.open.aborted",
 				message: safeErrorMessage({ error }),
 				error
 			});
 			return error;
 		}
 		this.log.info({
-			action: "flume.start.complete",
-			message: "all sources started"
+			action: "flume.open.complete",
+			message: "all sources opened"
 		});
 		return new FlumeRunning({
-			sources: this.props.sources,
-			signal: this.props.signal,
-			log: this.log
+			sources: this.sources,
+			signal: this.options.signal,
+			log: this.log,
+			hub: this.hub
 		});
 	}
-	guardStart() {
+	guardOpen() {
 		if (this.consumed) {
-			const error = new FlumeStartError("Flume.start: already started");
+			const error = new FlumeStartError("Flume.open: already opened");
 			this.log.warn({
-				action: "flume.start.refused",
+				action: "flume.open.refused",
 				message: safeErrorMessage({ error }),
 				error
 			});
 			return error;
 		}
 		if (this.isSignalAborted()) {
-			const error = new FlumeStartError("Flume.start: signal already aborted");
+			const error = new FlumeStartError("Flume.open: signal already aborted");
 			this.log.warn({
-				action: "flume.start.refused",
+				action: "flume.open.refused",
 				message: safeErrorMessage({ error }),
 				error
 			});
@@ -256,7 +481,7 @@ var Flume = class {
 		return null;
 	}
 	isSignalAborted() {
-		const signal = this.props.signal;
+		const signal = this.options.signal;
 		if (!signal) return false;
 		const result = attempt(() => signal.aborted === true);
 		return result instanceof Error ? true : result;
@@ -267,8 +492,16 @@ var Flume = class {
 		if (typeof result !== "string") return "?";
 		return result;
 	}
-	safeStart(source, handler) {
-		return Promise.resolve().then(() => source.start(handler, { signal: this.props.signal }));
+	safeStart(source, reconnect) {
+		const name = this.sourceName(source);
+		const ctx = {
+			onEvent: this.sourceEventHandler,
+			log: this.log.child(name),
+			deps: this.deps,
+			reconnect,
+			signal: this.options.signal
+		};
+		return Promise.resolve().then(() => source.start(ctx));
 	}
 	async rollback(sources) {
 		const settled = await Promise.allSettled(sources.map((source) => Promise.resolve().then(() => source.stop())));
@@ -286,4 +519,52 @@ var Flume = class {
 	}
 };
 //#endregion
-export { Flume, FlumeConnectionError, FlumeHttpError, FlumeParseError, FlumeRunning, FlumeStartError, FlumeStopped, createFlumeDefaultDeps };
+//#region lib/flume-confluence.ts
+/**
+* 複数の `Flume` を束ねて動的に増減させる上位レイヤー。各 Flume は immutable のまま、
+* `add()` で新しいグループを起動し `remove()` で個別に停止する。全グループの firehose は
+* `onEvent` 1 本に合流する。Flume 本体の FSM / rollback / reconnect はそのまま再利用される。
+*
+* id はグループの管理ハンドル (add/remove 用)。合流ストリーム自体は id を持たず、
+* item の中の source 名で発信元を判別する。throw しない流儀に従い `add()` は `Error | null` を返す
+*/
+var FlumeConfluence = class {
+	props;
+	running = /* @__PURE__ */ new Map();
+	constructor(props = {}) {
+		this.props = props;
+	}
+	/** sources を 1 グループとして起動。id 重複や起動失敗は `Error` で返す (throw しない) */
+	async add(id, sources) {
+		if (this.running.has(id)) return new FlumeStartError(`FlumeConfluence: id already added: ${id}`);
+		const running = await new Flume({
+			sources,
+			onEvent: this.props.onEvent,
+			onError: this.props.onError,
+			deps: this.props.deps,
+			reconnect: this.props.reconnect
+		}).open();
+		if (running instanceof Error) return running;
+		this.running.set(id, running);
+		return null;
+	}
+	/** 指定グループだけ close。他グループは無停止。未知の id は no-op */
+	async remove(id) {
+		const running = this.running.get(id);
+		if (!running) return;
+		this.running.delete(id);
+		await running.close();
+	}
+	async closeAll() {
+		const ids = [...this.running.keys()];
+		await Promise.all(ids.map((id) => this.remove(id)));
+	}
+	has(id) {
+		return this.running.has(id);
+	}
+	ids() {
+		return [...this.running.keys()];
+	}
+};
+//#endregion
+export { Flume, FlumeClosed, FlumeConfluence, FlumeConnectionError, FlumeHttpError, FlumeParseError, FlumeRunning, FlumeSource, FlumeStartError, createFlumeDefaultDeps };

package/dist/is-record.js

@@ -0,0 +1,6 @@
+//#region lib/utils/is-record.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+export { isRecord as t };

package/dist/parse-error.d.ts

@@ -0,0 +1,9 @@
+//#region lib/errors/parse-error.d.ts
+type Options = {
+  cause?: unknown;
+};
+declare class FlumeParseError extends Error {
+  constructor(message: string, options?: Options);
+}
+//#endregion
+export { FlumeParseError as t };

package/dist/safe-json-parse.js

@@ -0,0 +1,11 @@
+import { o as FlumeParseError } from "./flume-source.js";
+//#region lib/utils/safe-json-parse.ts
+function safeJsonParse(raw) {
+	try {
+		return JSON.parse(raw);
+	} catch (error) {
+		return new FlumeParseError(error instanceof Error ? `invalid JSON: ${error.message}` : "invalid JSON", { cause: error });
+	}
+}
+//#endregion
+export { safeJsonParse as t };

package/dist/{safe-read-text-DgrJ4Uhl.js → safe-read-text.js}

@@ -1,5 +1,5 @@
-import { l as safeErrorMessage } from "./safe-invoke-callback-EpWXwfwp.js";
-import { t as FlumeHttpError } from "./http-error-CPSKoSie.js";
+import { l as safeErrorMessage } from "./flume-source.js";
+import { t as FlumeHttpError } from "./http-error.js";
 //#region lib/utils/safe-read-text.ts
 /**
 * `response.text()` を保護する。body 読み取り中の reject (接続切断 / 解凍失敗 / 二重消費) を

package/dist/{safe-stringify-BWS-uXZP.js → safe-stringify.js}

@@ -1,5 +1,5 @@
-import { l as safeErrorMessage, s as attempt, t as safeInvokeCallback } from "./safe-invoke-callback-EpWXwfwp.js";
-import { t as FlumeConnectionError } from "./connection-error-HUO3PC3G.js";
+import { l as safeErrorMessage, n as safeInvokeCallback, s as attempt } from "./flume-source.js";
+import { t as FlumeConnectionError } from "./connection-error.js";
 //#region lib/utils/safe-random.ts
 /**
 * `deps.random()` を保護する。throw / 範囲外値 / 非数値が返った場合は 0.5 を返す。
@@ -40,7 +40,7 @@ var FlumeReconnector = class {
 		if (this.isAborted) return 0;
 		if (this.currentAttempt >= this.props.maxAttempts) return -1;
 		this.clearTimer();
-		const delay = this.nextDelay();
+		const delay = this.computeDelay();
 		const timerResult = attempt(() => this.props.deps.setTimeout(() => this.runRetry(fn), delay));
 		if (timerResult instanceof Error) {
 			this.props.log.error({
@@ -51,6 +51,7 @@ var FlumeReconnector = class {
 			this.timer = null;
 			return 0;
 		}
+		this.currentAttempt++;
 		this.timer = timerResult;
 		return delay;
 	}
@@ -85,28 +86,11 @@ var FlumeReconnector = class {
 		});
 		this.timer = null;
 	}
-	nextDelay() {
-		const jitter = Math.min(this.props.baseDelay * 2 ** this.currentAttempt, this.props.maxDelay) * (.5 + safeRandom({ deps: this.props.deps }) * .5);
-		this.currentAttempt++;
-		return jitter;
+	computeDelay() {
+		return Math.min(this.props.baseDelay * 2 ** this.currentAttempt, this.props.maxDelay) * (.5 + safeRandom({ deps: this.props.deps }) * .5);
 	}
 };
 //#endregion
-//#region lib/reconnect-config.ts
-const DEFAULTS = {
-	maxAttempts: Infinity,
-	baseDelay: 1e3,
-	maxDelay: 3e4
-};
-function resolveFlumeReconnectConfig(input) {
-	if (input === false || input === void 0) return null;
-	if (input === true) return { ...DEFAULTS };
-	return {
-		...DEFAULTS,
-		...input
-	};
-}
-//#endregion
 //#region lib/schedule-reconnect.ts
 /**
 * 接続が落ちた際の共通再接続スケジューラ。
@@ -155,11 +139,6 @@ function scheduleFlumeReconnect(props) {
 	});
 }
 //#endregion
-//#region lib/utils/is-record.ts
-function isRecord(value) {
-	return typeof value === "object" && value !== null;
-}
-//#endregion
 //#region lib/utils/safe-stringify.ts
 /**
 * `JSON.stringify` を `string | Error` に変換するだけのラッパ。
@@ -169,4 +148,4 @@ function safeStringify(value) {
 	return attempt(() => JSON.stringify(value));
 }
 //#endregion
-export { FlumeReconnector as a, resolveFlumeReconnectConfig as i, isRecord as n, safeRandom as o, scheduleFlumeReconnect as r, safeStringify as t };
+export { safeRandom as i, scheduleFlumeReconnect as n, FlumeReconnector as r, safeStringify as t };

package/dist/slack.d.ts

@@ -1,24 +1,16 @@
-import { C as FlumeSourceStartOptions, T as FlumeStatus, _ as FlumeSlackEnvelope, c as FlumeHandler, y as FlumeSlackSourceOptions } from "./types-D-tO-Mh2.js";
+import { t as FlumeSource, w as FlumeSourceStartContext, x as FlumeSlackSourceOptions, y as FlumeSlackEnvelope } from "./flume-source.js";
 
 //#region lib/slack/slack-source.d.ts
-declare class FlumeSlackSource {
+declare class FlumeSlackSource extends FlumeSource {
   private readonly options;
   readonly name: "slack";
   private socket;
   private reconnector;
-  private handler;
   private internalController;
-  private readonly log;
-  private readonly deps;
-  private readonly queue;
-  private readonly seen;
-  private readonly signals;
-  private readonly statusEmitter;
-  private readonly onSignalAbort;
+  private seen;
   constructor(options: FlumeSlackSourceOptions);
-  start(handler: FlumeHandler, options?: FlumeSourceStartOptions): Promise<Error | null>;
-  stop(): Promise<void>;
-  status(): FlumeStatus;
+  protected connect(ctx: FlumeSourceStartContext): Promise<Error | null>;
+  protected disconnect(): void;
   private hasWebSocket;
   private connectInternal;
   private handleMessage;