@interactive-inc/flume 0.6.0 → 0.9.0

package/dist/index.js

@@ -1,18 +1,33 @@
-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-DUvt9aJt.js";
-import { t as FlumeConnectionError } from "./connection-error-HUO3PC3G.js";
-import { t as FlumeHttpError } from "./http-error-CPSKoSie.js";
+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
-const wsCandidate = attempt(() => globalThis.WebSocket);
-const cachedWebSocket = wsCandidate instanceof Error || typeof wsCandidate !== "function" ? null : wsCandidate;
+/**
+* `globalThis.WebSocket` の現在の値を返す。
+* 取得は呼び出しごとに行う — `createFlumeDefaultDeps()` がモジュール初期化時ではなく
+* 呼ばれた瞬間の `globalThis.WebSocket` を見るので、jsdom / happy-dom / vitest の
+* `beforeEach` で `globalThis.WebSocket` を差し込むテスト戦略がそのまま機能する。
+* `WebSocket` が無い環境 (Node の素の global など) では `null` を返す。
+*/
+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 境界の最終手段)
+* 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: cachedWebSocket,
+		WebSocket: resolveCurrentWebSocket(),
 		now: () => Date.now(),
 		random: () => Math.random(),
 		setTimeout: (fn, ms) => globalThis.setTimeout(fn, ms),
@@ -22,13 +37,110 @@ function createFlumeDefaultDeps() {
 	};
 }
 //#endregion
-//#region lib/flume-stopped.ts
+//#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 FlumeStopped = class {
+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);
@@ -36,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
 					});
@@ -80,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 }
@@ -119,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() {
@@ -180,41 +330,71 @@ function resolveFlumeReconnectConfig(input) {
 }
 //#endregion
 //#region lib/flume.ts
-const noopOnEvent = () => {};
 /**
-* 起動前の Flume。`start()` で `FlumeRunning` へ遷移する。
-* 第一引数は sources、第二引数は cross-cutting options (全て optional)。
-* `onEvent` を省略するとイベントは黙って捨てられる (接続観測専用モード)。
+* 起動前の 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 {
-	sources;
 	options;
 	consumed = false;
 	log;
 	deps;
-	onEvent;
-	constructor(sources, options = {}) {
-		this.sources = sources;
+	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: options.onLog,
+			handler: this.buildLogHandler(),
 			deps: this.deps
 		});
-		this.onEvent = options.onEvent ?? noopOnEvent;
+		this.sourceEventHandler = (event) => this.emitItem({
+			kind: "event",
+			event
+		});
 	}
-	async start() {
-		const guard = this.guardStart();
+	/** 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 {}
+		};
+	}
+	/**
+	* 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.sources.length} source(s)`,
+			action: "flume.open",
+			message: `opening ${this.sources.length} source(s)`,
 			detail: { count: this.sources.length }
 		});
 		const reconnect = resolveFlumeReconnectConfig(this.options.reconnect);
@@ -250,9 +430,9 @@ 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
 			});
@@ -260,38 +440,39 @@ var Flume = class {
 		}
 		if (this.isSignalAborted()) {
 			await this.rollback(this.sources);
-			const error = new FlumeStartError("Flume.start: aborted during start");
+			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.sources,
 			signal: this.options.signal,
-			log: this.log
+			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
 			});
@@ -314,36 +495,14 @@ var Flume = class {
 	safeStart(source, reconnect) {
 		const name = this.sourceName(source);
 		const ctx = {
-			onEvent: this.onEvent,
+			onEvent: this.sourceEventHandler,
 			log: this.log.child(name),
 			deps: this.deps,
-			onStatus: (status, detail) => this.notifyStatus(name, status, detail),
-			reconnect
+			reconnect,
+			signal: this.options.signal
 		};
 		return Promise.resolve().then(() => source.start(ctx));
 	}
-	notifyStatus(name, status, detail) {
-		const handler = this.options.onStatus;
-		if (!handler) return;
-		const event = detail !== void 0 ? {
-			source: name,
-			status,
-			detail
-		} : {
-			source: name,
-			status
-		};
-		safeInvokeCallback({
-			fn: () => handler(event),
-			onError: (error) => {
-				this.log.error({
-					action: "onStatus.error",
-					message: safeErrorMessage({ error }),
-					error
-				});
-			}
-		});
-	}
 	async rollback(sources) {
 		const settled = await Promise.allSettled(sources.map((source) => Promise.resolve().then(() => source.stop())));
 		for (const [index, result] of settled.entries()) if (result.status === "rejected") {
@@ -360,4 +519,52 @@ var Flume = class {
 	}
 };
 //#endregion
-export { Flume, FlumeConnectionError, FlumeHttpError, FlumeParseError, FlumeRunning, FlumeSource, 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-CfJjt-RY.js → safe-json-parse.js}

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

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

@@ -1,5 +1,5 @@
-import { l as safeErrorMessage } from "./flume-source-DUvt9aJt.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-DbWQw9qe.js → safe-stringify.js}

@@ -1,5 +1,5 @@
-import { l as safeErrorMessage, n as safeInvokeCallback, s as attempt } from "./flume-source-DUvt9aJt.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,10 +86,8 @@ 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
@@ -140,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` に変換するだけのラッパ。
@@ -154,4 +148,4 @@ function safeStringify(value) {
 	return attempt(() => JSON.stringify(value));
 }
 //#endregion
-export { safeRandom as a, FlumeReconnector as i, isRecord as n, 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,4 +1,4 @@
-import { C as FlumeSourceStartContext, b as FlumeSlackSourceOptions, t as FlumeSource, v as FlumeSlackEnvelope } from "./flume-source-DuUFPhSe.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 extends FlumeSource {

package/dist/slack.js

@@ -1,9 +1,10 @@
-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 { 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.js";
+import { t as FlumeConnectionError } from "./connection-error.js";
+import { t as FlumeHttpError } from "./http-error.js";
+import { n as scheduleFlumeReconnect, r as FlumeReconnector, t as safeStringify } from "./safe-stringify.js";
+import { t as isRecord } from "./is-record.js";
+import { t as safeJsonParse } from "./safe-json-parse.js";
+import { t as safeReadText } from "./safe-read-text.js";
 import { z } from "zod/v4";
 //#region lib/slack/extract-slack-meta.ts
 function flumeExtractSlackMeta(envelope) {
@@ -45,8 +46,12 @@ var FlumeSlackSeenCache = class {
 		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.entries()];
-		this.seen = new Map(entries.slice(entries.length - this.props.maxSize));
+		let removeCount = this.seen.size - this.props.maxSize;
+		for (const id of this.seen.keys()) {
+			if (removeCount <= 0) break;
+			this.seen.delete(id);
+			removeCount--;
+		}
 	}
 	get size() {
 		return this.seen.size;