@interactive-inc/flume 0.10.1 → 0.11.0

package/dist/index.js

@@ -1,6 +1,8 @@
-import { a as safeNow, c as attempt, i as FlumeLogger, l as safeNormalizeError, n as FlumeSerialQueue, o as FlumeStartError, r as safeInvokeCallback, s as FlumeParseError, t as FlumeSource, u as safeErrorMessage } from "./flume-source.js";
-import { t as FlumeConnectionError } from "./connection-error.js";
-import { t as FlumeHttpError } from "./http-error.js";
+import { a as safeInvokeCallback, c as FlumeParseError, d as safeErrorMessage, i as safeNow, l as attempt, n as FlumeSerialQueue, o as FlumeSourceReuseError, r as FlumeLogger, s as FlumeStartError, t as FlumeSource, u as safeNormalizeError } from "./flume-source.js";
+import { n as safeRandom, r as FlumeConnectionError, t as safeStringify } from "./safe-stringify.js";
+import { n as FlumeHttpError, t as safeReadText } from "./safe-read-text.js";
+import { t as isRecord } from "./is-record.js";
+import { t as safeJsonParse } from "./safe-json-parse.js";
 //#region lib/deps.ts
 /**
 * `globalThis.WebSocket` の現在の値を返す。
@@ -87,9 +89,6 @@ var FlumeStream = class {
 			if (resolver) resolver(doneResult());
 		}
 	}
-	get dropped() {
-		return this.droppedCount;
-	}
 	next() {
 		const item = this.items.shift();
 		if (item !== void 0) return Promise.resolve({
@@ -224,7 +223,7 @@ var FlumeClosed = class {
 /**
 * 稼働中の Flume。close() で FlumeClosed へ遷移する。signal が abort されると自動 close。
 * 全ての source 呼び出し・signal 操作・status 読み取りを `attempt` 経由で扱い、
-* `runClose` の最外殻 try/catch で想定外の throw も `FlumeClosed` の resolve に変換する
+* `runClose` の最外殻でも `attempt` を通して想定外の throw を `FlumeClosed` の resolve に変換する
 */
 var FlumeRunning = class {
 	props;
@@ -262,18 +261,28 @@ var FlumeRunning = class {
 			}
 		}
 	}
+	/** Source の停止まで待つ。callback の完了は callback 外から drain() で待つ。 */
 	close() {
 		if (this.closePromise) return this.closePromise;
 		this.closePromise = this.runClose();
 		return this.closePromise;
 	}
+	/**
+	* 配送済み callback とその失敗診断が完了するまで待つ。通常は close() の後に呼ぶ。
+	* onEvent / onError 内では自身の完了待ちになるため呼ばない。
+	*/
+	async drain() {
+		if (this.closePromise) await this.closePromise;
+		await this.props.callbackQueue.drain();
+	}
 	statuses() {
 		return this.snapshotStatuses();
 	}
 	/**
 	* 統合 firehose を pull で受け取る async iterator。`for await (const item of running.stream())`。
 	* item は events + 全ログの union (`FlumeStreamItem`)。`item.kind` で判別する。
-	* close() / signal abort で iterator は自然に終了し、`break` すると hub から自動 unsubscribe する。
+	* close() / signal abort 後、callback の失敗診断まで配送して終了する。
+	* `break` すると hub から自動 unsubscribe する。
 	* consumer が遅れて buffer を超えたら `onOverflow` (既定 drop-oldest) に従う
 	*/
 	stream(options) {
@@ -290,64 +299,65 @@ var FlumeRunning = class {
 	}
 	async runClose() {
 		const closeErrors = [];
-		try {
-			this.props.log.info({
-				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()) {
-				const source = this.props.sources[index];
-				const name = source ? this.sourceName(source) : "?";
-				const error = result.status === "rejected" ? safeNormalizeError({ value: result.reason }) : result.value instanceof Error ? result.value : null;
-				if (error === null) continue;
-				closeErrors.push({
-					source: name,
-					error
-				});
-				this.props.log.error({
-					action: "flume.close.failed",
-					message: `${name}: ${safeErrorMessage({ error })}`,
-					error,
-					detail: { source: name }
-				});
-			}
-			const signal = this.props.signal;
-			if (signal) {
-				const result = attempt(() => signal.removeEventListener("abort", this.onAbort));
-				if (result instanceof Error) {
-					const error = safeNormalizeError({ value: result });
-					this.props.log.error({
-						action: "signal.removeListener.failed",
-						message: safeErrorMessage({ error }),
-						error
-					});
-				}
-			}
-			await this.props.callbackQueue.drain();
-			this.props.log.info({
-				action: "flume.close.complete",
-				message: "all sources closed"
-			});
-			await this.props.callbackQueue.drain();
-			this.props.hub.close();
-			return new FlumeClosed({
-				finalStatuses: this.snapshotStatuses(),
-				closeErrors
-			});
-		} catch (err) {
-			const error = safeNormalizeError({ value: err });
+		const result = await attempt(() => this.closeSources(closeErrors));
+		if (result instanceof Error) {
+			const error = safeNormalizeError({ value: result });
 			this.props.log.error({
 				action: "flume.close.unhandled",
 				message: safeErrorMessage({ error }),
 				error
 			});
-			this.props.hub.close();
-			return new FlumeClosed({
-				finalStatuses: this.snapshotStatuses(),
-				closeErrors
+		}
+		const sealed = attempt(() => this.props.seal());
+		if (sealed instanceof Error) this.props.log.error({
+			action: "flume.close.seal.failed",
+			message: safeErrorMessage({ error: sealed }),
+			error: sealed
+		});
+		this.props.callbackQueue.drain().then(() => this.props.hub.close());
+		return new FlumeClosed({
+			finalStatuses: this.snapshotStatuses(),
+			closeErrors
+		});
+	}
+	async closeSources(closeErrors) {
+		this.props.log.info({
+			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()) {
+			const source = this.props.sources[index];
+			const name = source ? this.sourceName(source) : "?";
+			const error = result.status === "rejected" ? safeNormalizeError({ value: result.reason }) : result.value instanceof Error ? result.value : null;
+			if (error === null) continue;
+			closeErrors.push({
+				source: name,
+				error
+			});
+			this.props.log.error({
+				action: "flume.close.failed",
+				message: `${name}: ${safeErrorMessage({ error })}`,
+				error,
+				detail: { source: name }
 			});
 		}
+		const signal = this.props.signal;
+		if (signal) {
+			const result = attempt(() => signal.removeEventListener("abort", this.onAbort));
+			if (result instanceof Error) {
+				const error = safeNormalizeError({ value: result });
+				this.props.log.error({
+					action: "signal.removeListener.failed",
+					message: safeErrorMessage({ error }),
+					error
+				});
+			}
+		}
+		this.props.log.info({
+			action: "flume.close.complete",
+			message: "all sources closed"
+		});
 	}
 	snapshotStatuses() {
 		return this.props.sources.map((source) => {
@@ -430,14 +440,15 @@ function resolveFlumeReconnectConfig(input) {
 * 起動前の Flume。`open()` で `FlumeRunning` へ遷移する。
 * コンストラクタは単一オブジェクト `{ sources, ...options }` を受け取る (`sources` のみ必須)。
 * events も全ログも 1 本の firehose (`onEvent` push / `stream()` pull) に流れ、購読側が filter する。
-* いずれかの source 失敗時は全 source を `stop()` してロールバックし `FlumeStartError` を返す
-* (失敗した source も半接続状態のリソースを持ち得るため、成功分だけでなく全数を stop する)。
+* 起動失敗時はこの open が取得した source を `stop()` してロールバックする。
+* 半接続状態で失敗した source も含むが、再利用を拒否した source は他の所有者のため停止しない。
 * `source.start()` / `source.stop()` の sync throw も `Promise.resolve().then` 経由で
 * Promise rejection に正規化して `allSettled` で捕捉する (`open()` は決して reject しない)
 */
 var Flume = class {
 	options;
 	consumed = false;
+	isAcceptingItems = true;
 	log;
 	deps;
 	sources;
@@ -454,10 +465,12 @@ var Flume = class {
 			handler: this.buildLogHandler(),
 			deps: this.deps
 		});
-		this.sourceEventHandler = (event) => this.emitItem({
-			kind: "event",
-			event
-		});
+		this.sourceEventHandler = (event) => {
+			this.emitItem({
+				kind: "event",
+				event
+			});
+		};
 	}
 	/**
 	* stream の buffer 溢れ通知 (stream ごとに初回 1 回)。
@@ -465,7 +478,6 @@ var Flume = class {
 	* さらに追い出す自己破壊になるため、push の `onEvent` にだけ warn log として届ける
 	*/
 	notifyStreamOverflow() {
-		if (!this.options.onEvent) return;
 		const log = {
 			level: "warn",
 			source: "flume",
@@ -481,35 +493,100 @@ var Flume = class {
 	/** source が受信したログを firehose へ流す handler。error は onError にも分岐する */
 	buildLogHandler() {
 		return (log) => {
+			if (!this.isAcceptingItems) return;
 			this.emitItem({
 				kind: "log",
 				log
 			});
-			const onError = this.options.onError;
-			if (!onError || log.level !== "error") return;
-			try {
-				Promise.resolve(onError(log)).catch(() => {});
-			} catch {}
+			if (log.level === "error") this.invokeOnError(log);
 		};
 	}
 	/**
 	* firehose の単一 sink: pull の hub と push の onEvent の両方へ item を配る。
 	* close 後の遅延 emit (stop 中の straggler) は push 側にも流さない (pull 側と対称にする)。
-	* onEvent への転送は this.log を経由しない (経由すると log item 経路で再帰する) ため
-	* 例外をここで握り潰す
+	* onEvent への転送は this.log を経由しない (経由すると log item 経路で再帰する)。
+	* callback failure は reportCallbackFailure が pull hub と peer callback へ直接診断する。
 	*/
 	emitItem(item) {
-		if (this.hub.isClosed) return Promise.resolve();
+		if (!this.isAcceptingItems || this.hub.isClosed) return Promise.resolve();
 		this.hub.publish(item);
 		return this.enqueueCallback(item);
 	}
-	enqueueCallback(item) {
-		const onEvent = this.options.onEvent;
-		if (!onEvent) return Promise.resolve();
+	enqueueCallback(item, notifyPeerOnFailure = true) {
+		const onEventResult = attempt(() => this.options.onEvent);
+		if (onEventResult instanceof Error) {
+			this.reportCallbackFailure("onEvent", onEventResult, notifyPeerOnFailure, item);
+			return Promise.resolve();
+		}
+		if (!onEventResult) return Promise.resolve();
+		return this.callbackQueue.add(async () => {
+			const result = await attempt(() => Promise.resolve(onEventResult(item)));
+			if (result instanceof Error) this.reportCallbackFailure("onEvent", result, notifyPeerOnFailure, item);
+		});
+	}
+	/**
+	* error log 専用 sink も callbackQueue に載せ、drain() が in-flight callback と
+	* その失敗診断まで drain できるようにする
+	*/
+	invokeOnError(log, notifyPeerOnFailure = true) {
+		const onErrorResult = attempt(() => this.options.onError);
+		if (onErrorResult instanceof Error) {
+			this.reportCallbackFailure("onError", onErrorResult, notifyPeerOnFailure, {
+				kind: "log",
+				log
+			});
+			return Promise.resolve();
+		}
+		if (!onErrorResult) return Promise.resolve();
 		return this.callbackQueue.add(async () => {
-			await attempt(() => Promise.resolve(onEvent(item)));
+			const result = await attempt(() => Promise.resolve(onErrorResult(log)));
+			if (result instanceof Error) this.reportCallbackFailure("onError", result, notifyPeerOnFailure, {
+				kind: "log",
+				log
+			});
 		});
 	}
+	/**
+	* 観測 sink 自身の失敗は同じ sink へ戻すと再帰するため、まず pull stream へ直接 publish し、
+	* もう一方の callback にだけ転送する。peer も失敗した場合は hub-only の診断を残して終端する
+	*/
+	reportCallbackFailure(callback, error, notifyPeer, failedItem) {
+		const itemDetail = failedItem?.kind === "event" ? {
+			itemKind: failedItem.kind,
+			itemSource: failedItem.event.source,
+			itemType: failedItem.event.type
+		} : failedItem?.kind === "log" ? {
+			itemKind: failedItem.kind,
+			itemSource: failedItem.log.source,
+			itemAction: failedItem.log.action,
+			itemDetail: failedItem.log.detail
+		} : {};
+		const log = {
+			level: "error",
+			source: "flume",
+			action: `${callback}.error`,
+			message: `${callback} callback failed: ${safeErrorMessage({ error })}`,
+			error,
+			detail: {
+				callback,
+				...itemDetail
+			},
+			timestamp: safeNow({ deps: this.deps })
+		};
+		this.hub.publish({
+			kind: "log",
+			log
+		});
+		if (!notifyPeer) return;
+		if (callback === "onEvent") {
+			this.invokeOnError(log, false);
+			return;
+		}
+		this.enqueueCallback({
+			kind: "log",
+			log
+		}, false);
+	}
 	async open() {
 		const guard = this.guardOpen();
 		if (guard) return guard;
@@ -522,10 +599,12 @@ var Flume = class {
 		const reconnect = this.resolveReconnect();
 		const settled = await Promise.allSettled(this.sources.map((source) => this.safeStart(source, reconnect)));
 		const failures = [];
+		const ownedSources = /* @__PURE__ */ new Set();
 		for (const [index, result] of settled.entries()) {
 			const source = this.sources[index];
 			if (source === void 0) continue;
 			const name = this.sourceName(source);
+			if (!((result.status === "rejected" ? result.reason : result.value) instanceof FlumeSourceReuseError)) ownedSources.add(source);
 			if (result.status === "rejected") {
 				failures.push({
 					name,
@@ -545,7 +624,7 @@ var Flume = class {
 				error: failure.error,
 				detail: { source: failure.name }
 			});
-			await this.rollback(this.sources);
+			await this.rollback([...ownedSources]);
 			const detail = failures.map((f) => `${f.name}: ${safeErrorMessage({ error: f.error })}`).join("; ");
 			const error = new FlumeStartError(`Flume.open: ${failures.length} source(s) failed: ${detail}`);
 			this.log.error({
@@ -553,42 +632,33 @@ var Flume = class {
 				message: safeErrorMessage({ error }),
 				error
 			});
-			await this.callbackQueue.drain();
+			this.finishFailedOpen();
 			return error;
 		}
 		if (this.isSignalAborted()) {
-			await this.rollback(this.sources);
+			await this.rollback([...ownedSources]);
 			const error = new FlumeStartError("Flume.open: aborted during open");
 			this.log.warn({
 				action: "flume.open.aborted",
 				message: safeErrorMessage({ error }),
 				error
 			});
-			await this.callbackQueue.drain();
+			this.finishFailedOpen();
 			return error;
 		}
 		this.log.info({
 			action: "flume.open.complete",
 			message: "all sources opened"
 		});
-		await this.callbackQueue.drain();
-		if (this.isSignalAborted()) {
-			await this.rollback(this.sources);
-			const error = new FlumeStartError("Flume.open: aborted during completion");
-			this.log.warn({
-				action: "flume.open.aborted",
-				message: safeErrorMessage({ error }),
-				error
-			});
-			await this.callbackQueue.drain();
-			return error;
-		}
 		const running = new FlumeRunning({
 			sources: this.sources,
 			signal: this.options.signal,
 			log: this.log,
 			hub: this.hub,
-			callbackQueue: this.callbackQueue
+			callbackQueue: this.callbackQueue,
+			seal: () => {
+				this.isAcceptingItems = false;
+			}
 		});
 		if (!this.isSignalAborted()) return running;
 		await running.close();
@@ -598,9 +668,13 @@ var Flume = class {
 			message: safeErrorMessage({ error }),
 			error
 		});
-		await this.callbackQueue.drain();
 		return error;
 	}
+	/** 起動失敗の戻り値は callback を待たず、配送済み診断の完了後に hub を閉じる。 */
+	finishFailedOpen() {
+		this.isAcceptingItems = false;
+		this.callbackQueue.drain().then(() => this.hub.close());
+	}
 	guardOpen() {
 		if (this.consumed) {
 			const error = new FlumeStartError("Flume.open: already opened");
@@ -823,7 +897,7 @@ var FlumeConfluence = class {
 		const flume = new Flume({
 			sources,
 			onEvent: this.wrapOnEvent(id),
-			onError: this.props.onError,
+			onError: this.wrapOnError(id),
 			deps: this.props.deps,
 			reconnect: this.props.reconnect,
 			signal: controller.signal
@@ -855,6 +929,17 @@ var FlumeConfluence = class {
 			});
 		};
 	}
+	wrapOnError(id) {
+		const onError = this.props.onError;
+		if (!onError) return void 0;
+		return (log) => onError({
+			...log,
+			detail: {
+				...log.detail,
+				groupId: id
+			}
+		});
+	}
 };
 //#endregion
-export { Flume, FlumeClosed, FlumeConfluence, FlumeConnectionError, FlumeHttpError, FlumeParseError, FlumeRunning, FlumeSource, FlumeStartError, createFlumeDefaultDeps };
+export { Flume, FlumeClosed, FlumeConfluence, FlumeConnectionError, FlumeHttpError, FlumeParseError, FlumeRunning, FlumeSource, FlumeStartError, attempt, createFlumeDefaultDeps, isRecord, safeErrorMessage, safeInvokeCallback, safeJsonParse, safeNormalizeError, safeNow, safeRandom, safeReadText, safeStringify };

package/dist/safe-json-parse.js

@@ -1,4 +1,4 @@
-import { s as FlumeParseError } from "./flume-source.js";
+import { c as FlumeParseError } from "./flume-source.js";
 //#region lib/utils/safe-json-parse.ts
 function safeJsonParse(raw) {
 	try {

package/dist/safe-read-text.js

@@ -1,5 +1,19 @@
-import { c as attempt, u as safeErrorMessage } from "./flume-source.js";
-import { t as FlumeHttpError } from "./http-error.js";
+import { d as safeErrorMessage, l as attempt } from "./flume-source.js";
+//#region lib/errors/http-error.ts
+var FlumeHttpError = class extends Error {
+	status;
+	code;
+	retryAfterMs;
+	constructor(props) {
+		super(props.message, props.cause === void 0 ? void 0 : { cause: props.cause });
+		this.name = "FlumeHttpError";
+		this.status = props.status;
+		this.code = props.code ?? null;
+		this.retryAfterMs = props.retryAfterMs ?? null;
+		Object.freeze(this);
+	}
+};
+//#endregion
 //#region lib/utils/safe-read-text.ts
 /**
 * `response.text()` を保護する。body 読み取り中の reject (接続切断 / 解凍失敗 / 二重消費) を
@@ -20,4 +34,4 @@ async function safeReadText(props) {
 	}
 }
 //#endregion
-export { safeReadText as t };
+export { FlumeHttpError as n, safeReadText as t };

package/dist/safe-stringify.js

@@ -1,5 +1,19 @@
-import { c as attempt, r as safeInvokeCallback, s as FlumeParseError, u as safeErrorMessage } from "./flume-source.js";
-import { t as FlumeConnectionError } from "./connection-error.js";
+import { c as FlumeParseError, l as attempt } from "./flume-source.js";
+//#region lib/errors/connection-error.ts
+/**
+* 接続失敗を表す。Discord Gateway / Slack Socket Mode / その他 WebSocket 系の close で発生。
+* `code` は接続が落ちた際の close code (Discord は 4xxx 帯が再接続可否を示す)
+*/
+var FlumeConnectionError = class extends Error {
+	code;
+	constructor(message, options) {
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "FlumeConnectionError";
+		this.code = options?.code ?? null;
+		Object.freeze(this);
+	}
+};
+//#endregion
 //#region lib/utils/safe-random.ts
 /**
 * `deps.random()` を保護する。throw / 範囲外値 / 非数値が返った場合は `Math.random()` へ
@@ -20,156 +34,6 @@ function safeRandom(props) {
 	}
 }
 //#endregion
-//#region lib/reconnector.ts
-const MAX_TIMER_DELAY_MS = 2147483647;
-/**
-* 指数バックオフ + ジッタ付きの再接続スケジューラ。
-* setTimeout コールバック内のユーザー fn が throw / reject しても reconnect ループは止めない。
-* `generation` は clearTimeout が throw して古い timer が生き残った場合でも
-* stale な発火を無視するための世代トークン
-*/
-var FlumeReconnector = class {
-	props;
-	currentAttempt = 0;
-	isAborted = false;
-	timer = null;
-	generation = 0;
-	constructor(props) {
-		this.props = props;
-	}
-	get attempt() {
-		return this.currentAttempt;
-	}
-	get aborted() {
-		return this.isAborted;
-	}
-	schedule(fn, options) {
-		if (this.isAborted) return { kind: "refused" };
-		if (this.currentAttempt >= this.props.maxAttempts) {
-			this.generation++;
-			this.clearTimer();
-			return { kind: "exhausted" };
-		}
-		this.clearTimer();
-		const delay = this.computeDelay(options?.minDelayMs ?? 0);
-		const scheduledGeneration = ++this.generation;
-		const timerResult = attempt(() => this.props.deps.setTimeout(() => this.runRetry(fn, scheduledGeneration), delay));
-		if (timerResult instanceof Error) {
-			this.props.log.error({
-				action: "reconnect.timer.schedule.error",
-				message: safeErrorMessage({ error: timerResult }),
-				error: timerResult
-			});
-			this.timer = null;
-			return { kind: "refused" };
-		}
-		this.currentAttempt++;
-		this.timer = timerResult;
-		return {
-			kind: "scheduled",
-			delayMs: delay
-		};
-	}
-	reset() {
-		this.currentAttempt = 0;
-	}
-	cancel() {
-		this.isAborted = true;
-		this.generation++;
-		this.clearTimer();
-	}
-	runRetry(fn, scheduledGeneration) {
-		if (this.isAborted) return;
-		if (scheduledGeneration !== this.generation) return;
-		this.timer = null;
-		safeInvokeCallback({
-			fn,
-			onError: (error) => {
-				this.props.log.error({
-					action: "reconnect.timer.error",
-					message: safeErrorMessage({ error }),
-					error
-				});
-			}
-		});
-	}
-	clearTimer() {
-		if (this.timer === null) return;
-		const handle = this.timer;
-		const result = attempt(() => this.props.deps.clearTimeout(handle));
-		if (result instanceof Error) this.props.log.error({
-			action: "reconnect.timer.clear.error",
-			message: safeErrorMessage({ error: result }),
-			error: result
-		});
-		this.timer = null;
-	}
-	computeDelay(minDelayMs) {
-		const jittered = Math.min(this.props.baseDelay * 2 ** this.currentAttempt, this.props.maxDelay) * (.5 + safeRandom({ deps: this.props.deps }) * .5);
-		return Math.min(Math.max(jittered, Number.isFinite(minDelayMs) && minDelayMs > 0 ? minDelayMs : 0), MAX_TIMER_DELAY_MS);
-	}
-};
-//#endregion
-//#region lib/schedule-reconnect.ts
-/**
-* 接続が落ちた際の共通再接続スケジューラ。
-* 再接続の設定状況 (無効 / 中止 / 試行尽き / timer 拒否) を見極めてからステータス遷移する。
-* - reconnector が無ければ reconnect.disabled を info ログし disconnected へ
-* - cancel 済みなら reconnect.aborted を info ログし disconnected へ
-* - schedule() が exhausted なら reconnect.exhausted を error ログし disconnected へ
-* - schedule() が refused (timer 予約失敗) なら reconnect.refused を error ログし disconnected へ
-*   ("reconnecting" のまま発火しない timer を待ち続けるハングを防ぐ)
-* - scheduled なら reconnecting へ遷移し reconnect.scheduled を info ログ
-*/
-function scheduleFlumeReconnect(props) {
-	if (!props.reconnector) {
-		props.log.info({
-			action: "reconnect.disabled",
-			message: "reconnect is disabled, staying disconnected"
-		});
-		props.setStatus("disconnected");
-		return;
-	}
-	if (props.reconnector.aborted) {
-		props.log.info({
-			action: "reconnect.aborted",
-			message: "reconnector cancelled, staying disconnected"
-		});
-		props.setStatus("disconnected");
-		return;
-	}
-	const schedule = props.reconnector.schedule(props.retry, { minDelayMs: props.minDelayMs });
-	if (schedule.kind === "exhausted") {
-		const error = new FlumeConnectionError(`reconnect exhausted after ${props.reconnector.attempt} attempts`);
-		props.log.error({
-			action: "reconnect.exhausted",
-			message: safeErrorMessage({ error }),
-			error
-		});
-		props.setStatus("disconnected");
-		return;
-	}
-	if (schedule.kind === "refused") {
-		const error = new FlumeConnectionError("reconnect timer could not be scheduled");
-		props.log.error({
-			action: "reconnect.refused",
-			message: safeErrorMessage({ error }),
-			error
-		});
-		props.setStatus("disconnected");
-		return;
-	}
-	props.setStatus("reconnecting");
-	props.log.info({
-		action: "reconnect.scheduled",
-		message: `next attempt in ${Math.round(schedule.delayMs)}ms`,
-		detail: {
-			attempt: props.reconnector.attempt,
-			delayMs: Math.round(schedule.delayMs)
-		}
-	});
-}
-//#endregion
 //#region lib/utils/safe-stringify.ts
 /**
 * `JSON.stringify` を `string | Error` に変換するラッパ。
@@ -184,4 +48,4 @@ function safeStringify(value) {
 	return result;
 }
 //#endregion
-export { safeRandom as i, scheduleFlumeReconnect as n, FlumeReconnector as r, safeStringify as t };
+export { safeRandom as n, FlumeConnectionError as r, safeStringify as t };