@interactive-inc/flume 0.3.0 → 0.6.0

package/dist/index.d.ts

@@ -1,51 +1,56 @@
-import { C as FlumeStartResult, E as FlumeTimerHandle, S as FlumeStartOk, T as FlumeStatusHandler, _ as FlumeSource, a as FlumeGitHubSourceOptions, b as FlumeSourceStatus, c as FlumeLogHandler, d as FlumeReconnectConfig, f as FlumeReconnectOptions, g as FlumeSlackSourceOptions, h as FlumeSlackEnvelope, i as FlumeGitHubNotification, l as FlumeLogInput, m as FlumeSlackConnectionResponse, n as FlumeEvent, o as FlumeHandler, p as FlumeRuntimeDeps, r as FlumeGatewayMessage, s as FlumeLog, t as FlumeDiscordSourceOptions, u as FlumeLogLevel, v as FlumeSourceName, w as FlumeStatus, x as FlumeStartErr, y as FlumeSourceOptions } from "./types-Bm9uKUQz.js";
-import { t as FlumeConnectionError } from "./connection-error-BOk97djj.js";
-import { t as FlumeParseError } from "./parse-error-BAiCLRmk.js";
-import { t as FlumeHttpError } from "./http-error-K-Ym4lfK.js";
+import { C as FlumeSourceStartContext, D as FlumeStatusHandler, E as FlumeStatusEvent, O as FlumeTimerHandle, S as FlumeSourceName, T as FlumeStatus, _ as FlumeSlackConnectionResponse, a as FlumeEventHandler, b as FlumeSlackSourceOptions, c as FlumeGitHubNotification, d as FlumeLogHandler, f as FlumeLogInput, g as FlumeRuntimeDeps, h as FlumeReconnectOptions, i as FlumeEvent, k as FlumeLogger, l as FlumeGitHubSourceOptions, m as FlumeReconnectConfig, n as FlumeDiscordEvent, o as FlumeGatewayMessage, p as FlumeLogLevel, r as FlumeDiscordSourceOptions, s as FlumeGitHubEvent, t as FlumeSource, u as FlumeLog, v as FlumeSlackEnvelope, w as FlumeSourceStatus, x as FlumeSourceLocalStatusHandler, y as FlumeSlackEvent } from "./flume-source-DuUFPhSe.js";
 
 //#region lib/deps.d.ts
+/**
+ * platform 既定の IO を束ねた `FlumeRuntimeDeps`。
+ * `FlumeTimerHandle` は不透明型 (`unknown`) のため、setTimeout / clearTimeout の戻り値・引数を
+ * platform 型と橋渡しする際に境界で `as unknown as` を使う (IO 境界の最終手段)
+ */
 declare function createFlumeDefaultDeps(): FlumeRuntimeDeps;
 //#endregion
-//#region lib/logger.d.ts
-type Props$4 = {
-  source: string;
-  handler?: FlumeLogHandler;
-  deps: Pick<FlumeRuntimeDeps, "now">;
+//#region lib/errors/connection-error.d.ts
+type Options$3 = {
+  cause?: unknown;
+  code?: number;
 };
-declare class FlumeLogger {
-  private readonly props;
-  constructor(props: Props$4);
-  debug(entry: FlumeLogInput): void;
-  info(entry: FlumeLogInput): void;
-  warn(entry: FlumeLogInput): void;
-  error(entry: FlumeLogInput): void;
-  private emit;
+/**
+ * 接続失敗を表す。Discord Gateway / Slack Socket Mode / その他 WebSocket 系の close で発生。
+ * `code` は接続が落ちた際の close code (Discord は 4xxx 帯が再接続可否を示す)
+ */
+declare class FlumeConnectionError extends Error {
+  readonly code: number | null;
+  constructor(message: string, options?: Options$3);
 }
 //#endregion
-//#region lib/reconnect-config.d.ts
-declare function resolveFlumeReconnectConfig(input: boolean | FlumeReconnectOptions | undefined): FlumeReconnectConfig | null;
+//#region lib/errors/http-error.d.ts
+type Props$2 = {
+  message: string;
+  status: number;
+  cause?: unknown;
+};
+declare class FlumeHttpError extends Error {
+  readonly status: number;
+  constructor(props: Props$2);
+}
 //#endregion
-//#region lib/reconnector.d.ts
-type Props$3 = {
-  maxAttempts: number;
-  baseDelay: number;
-  maxDelay: number;
-  deps: Pick<FlumeRuntimeDeps, "setTimeout" | "clearTimeout" | "random">;
+//#region lib/errors/parse-error.d.ts
+type Options$2 = {
+  cause?: unknown;
 };
-declare class FlumeReconnector {
-  private readonly props;
-  attempt: number;
-  aborted: boolean;
-  private timer;
-  constructor(props: Props$3);
-  schedule(fn: () => void): number;
-  reset(): void;
-  cancel(): void;
-  private nextDelay;
+declare class FlumeParseError extends Error {
+  constructor(message: string, options?: Options$2);
+}
+//#endregion
+//#region lib/errors/start-error.d.ts
+type Options$1 = {
+  cause?: unknown;
+};
+declare class FlumeStartError extends Error {
+  constructor(message: string, options?: Options$1);
 }
 //#endregion
 //#region lib/flume-stopped.d.ts
-type Props$2 = {
+type Props$1 = {
   finalStatuses: ReadonlyArray<FlumeSourceStatus>;
 };
 /**
@@ -53,43 +58,68 @@ type Props$2 = {
  */
 declare class FlumeStopped {
   private readonly props;
-  constructor(props: Props$2);
+  readonly kind: "stopped";
+  constructor(props: Props$1);
   statuses(): ReadonlyArray<FlumeSourceStatus>;
 }
 //#endregion
 //#region lib/flume-running.d.ts
-type Props$1 = {
+type Props = {
   sources: ReadonlyArray<FlumeSource>;
   signal?: AbortSignal;
+  log: FlumeLogger;
 };
 /**
- * 稼働中の Flume。stop() で FlumeStopped へ遷移する。signal が abort されると自動 stop
+ * 稼働中の Flume。stop() で FlumeStopped へ遷移する。signal が abort されると自動 stop。
+ * 全ての source 呼び出し・signal 操作・status 読み取りを `attempt` 経由で扱い、
+ * `runStop` の最外殻 try/catch で想定外の throw も `FlumeStopped` の resolve に変換する
  */
 declare class FlumeRunning {
   private readonly props;
+  readonly kind: "running";
   private stopPromise;
   private readonly onAbort;
-  constructor(props: Props$1);
+  constructor(props: Props);
   stop(): Promise<FlumeStopped>;
   statuses(): ReadonlyArray<FlumeSourceStatus>;
   private runStop;
+  private snapshotStatuses;
+  private sourceName;
 }
 //#endregion
 //#region lib/flume.d.ts
-type Props = {
-  sources: ReadonlyArray<FlumeSource>;
+type Options = {
+  onEvent?: FlumeEventHandler;
   signal?: AbortSignal;
+  onLog?: FlumeLogHandler;
+  onStatus?: FlumeStatusHandler;
+  deps?: FlumeRuntimeDeps;
+  reconnect?: FlumeReconnectOptions;
 };
 /**
- * 起動前の Flume。start() で FlumeRunning へ遷移する
+ * 起動前の Flume。`start()` で `FlumeRunning` へ遷移する。
+ * 第一引数は sources、第二引数は cross-cutting options (全て optional)。
+ * `onEvent` を省略するとイベントは黙って捨てられる (接続観測専用モード)。
+ * いずれかの source 失敗時は既に成功した source を全て `stop()` してロールバックし
+ * `FlumeStartError` を返す。
+ * `source.start()` / `source.stop()` の sync throw も `Promise.resolve().then` 経由で
+ * Promise rejection に正規化して `allSettled` で捕捉する (`start()` は決して reject しない)
  */
 declare class Flume {
-  private readonly props;
+  private readonly sources;
+  private readonly options;
   private consumed;
-  constructor(props: Props);
-  start(handler: FlumeHandler): Promise<FlumeStartResult>;
-  private running;
-  runningState(): FlumeRunning | null;
+  private readonly log;
+  private readonly deps;
+  private readonly onEvent;
+  constructor(sources: ReadonlyArray<FlumeSource>, options?: Options);
+  start(): Promise<FlumeRunning | FlumeStartError>;
+  private guardStart;
+  private isSignalAborted;
+  private sourceName;
+  private safeStart;
+  private notifyStatus;
+  private rollback;
 }
 //#endregion
-export { Flume, FlumeConnectionError, type FlumeDiscordSourceOptions, type FlumeEvent, type FlumeGatewayMessage, type FlumeGitHubNotification, type FlumeGitHubSourceOptions, type FlumeHandler, FlumeHttpError, type FlumeLog, type FlumeLogHandler, type FlumeLogInput, type FlumeLogLevel, FlumeLogger, FlumeParseError, type FlumeReconnectConfig, type FlumeReconnectOptions, FlumeReconnector, FlumeRunning, type FlumeRuntimeDeps, type FlumeSlackConnectionResponse, type FlumeSlackEnvelope, type FlumeSlackSourceOptions, type FlumeSource, type FlumeSourceName, type FlumeSourceOptions, type FlumeSourceStatus, type FlumeStartErr, type FlumeStartOk, type FlumeStartResult, type FlumeStatus, type FlumeStatusHandler, FlumeStopped, type FlumeTimerHandle, createFlumeDefaultDeps, resolveFlumeReconnectConfig };
+export { Flume, FlumeConnectionError, type FlumeDiscordEvent, type FlumeDiscordSourceOptions, type FlumeEvent, type FlumeEventHandler, type FlumeGatewayMessage, type FlumeGitHubEvent, type FlumeGitHubNotification, type FlumeGitHubSourceOptions, FlumeHttpError, type FlumeLog, type FlumeLogHandler, type FlumeLogInput, type FlumeLogLevel, FlumeParseError, type FlumeReconnectConfig, type FlumeReconnectOptions, FlumeRunning, type FlumeRuntimeDeps, type FlumeSlackConnectionResponse, type FlumeSlackEnvelope, type FlumeSlackEvent, type FlumeSlackSourceOptions, FlumeSource, type FlumeSourceLocalStatusHandler, type FlumeSourceName, type FlumeSourceStartContext, type FlumeSourceStatus, FlumeStartError, type FlumeStatus, type FlumeStatusEvent, type FlumeStatusHandler, FlumeStopped, type FlumeTimerHandle, createFlumeDefaultDeps };

package/dist/index.js

@@ -1,12 +1,34 @@
-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 { 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";
+//#region lib/deps.ts
+const wsCandidate = attempt(() => globalThis.WebSocket);
+const cachedWebSocket = wsCandidate instanceof Error || typeof wsCandidate !== "function" ? null : wsCandidate;
+/**
+* platform 既定の IO を束ねた `FlumeRuntimeDeps`。
+* `FlumeTimerHandle` は不透明型 (`unknown`) のため、setTimeout / clearTimeout の戻り値・引数を
+* platform 型と橋渡しする際に境界で `as unknown as` を使う (IO 境界の最終手段)
+*/
+function createFlumeDefaultDeps() {
+	return {
+		fetch: (url, init) => globalThis.fetch(url, init),
+		WebSocket: cachedWebSocket,
+		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-stopped.ts
 /**
 * 停止済みの終端状態。最終ステータスのスナップショットのみ観測できる
 */
 var FlumeStopped = class {
 	props;
+	kind = "stopped";
 	constructor(props) {
 		this.props = props;
 		Object.freeze(this);
@@ -18,18 +40,45 @@ var FlumeStopped = class {
 //#endregion
 //#region lib/flume-running.ts
 /**
-* 稼働中の Flume。stop() で FlumeStopped へ遷移する。signal が abort されると自動 stop
+* 稼働中の Flume。stop() で FlumeStopped へ遷移する。signal が abort されると自動 stop。
+* 全ての source 呼び出し・signal 操作・status 読み取りを `attempt` 経由で扱い、
+* `runStop` の最外殻 try/catch で想定外の throw も `FlumeStopped` の resolve に変換する
 */
 var FlumeRunning = class {
 	props;
+	kind = "running";
 	stopPromise = null;
 	onAbort;
 	constructor(props) {
 		this.props = props;
 		this.onAbort = () => {
-			this.stop();
+			this.props.log.info({
+				action: "flume.abort",
+				message: "signal aborted, stopping"
+			});
+			safeInvokeCallback({
+				fn: () => this.stop(),
+				onError: (error) => {
+					this.props.log.error({
+						action: "flume.abort.stop.failed",
+						message: safeErrorMessage({ error }),
+						error
+					});
+				}
+			});
 		};
-		if (props.signal) props.signal.addEventListener("abort", this.onAbort, { once: true });
+		const signal = props.signal;
+		if (signal) {
+			const result = attempt(() => signal.addEventListener("abort", this.onAbort, { once: true }));
+			if (result instanceof Error) {
+				const error = safeNormalizeError({ value: result });
+				props.log.error({
+					action: "signal.addListener.failed",
+					message: safeErrorMessage({ error }),
+					error
+				});
+			}
+		}
 	}
 	stop() {
 		if (this.stopPromise) return this.stopPromise;
@@ -37,85 +86,278 @@ var FlumeRunning = class {
 		return this.stopPromise;
 	}
 	statuses() {
-		return this.props.sources.map((source) => ({
-			name: source.name,
-			status: source.status()
-		}));
+		return this.snapshotStatuses();
 	}
 	async runStop() {
-		await Promise.allSettled(this.props.sources.map((source) => source.stop()));
-		this.props.signal?.removeEventListener("abort", this.onAbort);
-		return new FlumeStopped({ finalStatuses: this.props.sources.map((source) => ({
-			name: source.name,
-			status: source.status()
-		})) });
+		try {
+			this.props.log.info({
+				action: "flume.stop",
+				message: `stopping ${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 });
+				this.props.log.error({
+					action: "flume.stop.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.stop.complete",
+				message: "all sources stopped"
+			});
+			return new FlumeStopped({ finalStatuses: this.snapshotStatuses() });
+		} catch (err) {
+			const error = safeNormalizeError({ value: err });
+			this.props.log.error({
+				action: "flume.stop.unhandled",
+				message: safeErrorMessage({ error }),
+				error
+			});
+			return new FlumeStopped({ finalStatuses: this.snapshotStatuses() });
+		}
+	}
+	snapshotStatuses() {
+		return this.props.sources.map((source) => {
+			const name = this.sourceName(source);
+			const status = attempt(() => source.status());
+			if (status instanceof Error) {
+				const error = safeNormalizeError({ value: status });
+				this.props.log.error({
+					action: "source.status.failed",
+					message: `${name}: ${safeErrorMessage({ error })}`,
+					error,
+					detail: { source: name }
+				});
+				return {
+					source: name,
+					status: "disconnected"
+				};
+			}
+			return {
+				source: name,
+				status
+			};
+		});
+	}
+	sourceName(source) {
+		const result = attempt(() => source.name);
+		if (result instanceof Error) return "?";
+		if (typeof result !== "string") return "?";
+		return result;
 	}
 };
 //#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
+const noopOnEvent = () => {};
 /**
-* 起動前の Flume。start() で FlumeRunning へ遷移する
+* 起動前の Flume。`start()` で `FlumeRunning` へ遷移する。
+* 第一引数は sources、第二引数は cross-cutting options (全て optional)。
+* `onEvent` を省略するとイベントは黙って捨てられる (接続観測専用モード)。
+* いずれかの source 失敗時は既に成功した source を全て `stop()` してロールバックし
+* `FlumeStartError` を返す。
+* `source.start()` / `source.stop()` の sync throw も `Promise.resolve().then` 経由で
+* Promise rejection に正規化して `allSettled` で捕捉する (`start()` は決して reject しない)
 */
 var Flume = class {
-	props;
+	sources;
+	options;
 	consumed = false;
-	constructor(props) {
-		this.props = props;
+	log;
+	deps;
+	onEvent;
+	constructor(sources, options = {}) {
+		this.sources = sources;
+		this.options = options;
+		this.deps = options.deps ?? createFlumeDefaultDeps();
+		this.log = new FlumeLogger({
+			source: "flume",
+			handler: options.onLog,
+			deps: this.deps
+		});
+		this.onEvent = options.onEvent ?? noopOnEvent;
 	}
-	async start(handler) {
-		if (this.consumed) return {
-			ok: false,
-			error: /* @__PURE__ */ new Error("Flume.start: already started")
-		};
-		if (this.props.signal?.aborted) return {
-			ok: false,
-			error: /* @__PURE__ */ new Error("Flume.start: signal already aborted")
-		};
+	async start() {
+		const guard = this.guardStart();
+		if (guard) return guard;
 		this.consumed = true;
-		const settled = await Promise.allSettled(this.props.sources.map((source) => source.start(handler)));
+		this.log.info({
+			action: "flume.start",
+			message: `starting ${this.sources.length} source(s)`,
+			detail: { count: this.sources.length }
+		});
+		const reconnect = resolveFlumeReconnectConfig(this.options.reconnect);
+		const settled = await Promise.allSettled(this.sources.map((source) => this.safeStart(source, reconnect)));
 		const failures = [];
 		const started = [];
-		for (let i = 0; i < settled.length; i++) {
-			const result = settled[i];
-			const source = this.props.sources[i];
-			if (result === void 0 || source === void 0) continue;
+		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") {
-				const reason = result.reason;
 				failures.push({
-					name: source.name,
-					error: reason instanceof Error ? reason : new Error(String(reason))
+					name,
+					error: safeNormalizeError({ value: result.reason })
 				});
-			} else if (!result.value.ok) failures.push({
-				name: source.name,
-				error: result.value.error
-			});
-			else started.push(source);
+				continue;
+			}
+			if (result.value instanceof Error) {
+				failures.push({
+					name,
+					error: result.value
+				});
+				continue;
+			}
+			started.push(source);
 		}
 		if (failures.length > 0) {
-			await Promise.allSettled(started.map((source) => source.stop()));
-			const detail = failures.map((f) => `${f.name}: ${f.error.message}`).join("; ");
-			return {
-				ok: false,
-				error: /* @__PURE__ */ new Error(`Flume.start: ${failures.length} source(s) failed: ${detail}`)
-			};
+			for (const failure of failures) this.log.error({
+				action: "flume.source.failed",
+				message: `${failure.name}: ${safeErrorMessage({ error: failure.error })}`,
+				error: failure.error,
+				detail: { source: failure.name }
+			});
+			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}`);
+			this.log.error({
+				action: "flume.start.failed",
+				message: safeErrorMessage({ error }),
+				error
+			});
+			return error;
 		}
-		if (this.props.signal?.aborted) {
-			await Promise.allSettled(this.props.sources.map((source) => source.stop()));
-			return {
-				ok: false,
-				error: /* @__PURE__ */ new Error("Flume.start: aborted during start")
-			};
+		if (this.isSignalAborted()) {
+			await this.rollback(this.sources);
+			const error = new FlumeStartError("Flume.start: aborted during start");
+			this.log.warn({
+				action: "flume.start.aborted",
+				message: safeErrorMessage({ error }),
+				error
+			});
+			return error;
+		}
+		this.log.info({
+			action: "flume.start.complete",
+			message: "all sources started"
+		});
+		return new FlumeRunning({
+			sources: this.sources,
+			signal: this.options.signal,
+			log: this.log
+		});
+	}
+	guardStart() {
+		if (this.consumed) {
+			const error = new FlumeStartError("Flume.start: already started");
+			this.log.warn({
+				action: "flume.start.refused",
+				message: safeErrorMessage({ error }),
+				error
+			});
+			return error;
+		}
+		if (this.isSignalAborted()) {
+			const error = new FlumeStartError("Flume.start: signal already aborted");
+			this.log.warn({
+				action: "flume.start.refused",
+				message: safeErrorMessage({ error }),
+				error
+			});
+			return error;
 		}
-		this.running = new FlumeRunning({
-			sources: this.props.sources,
-			signal: this.props.signal
+		return null;
+	}
+	isSignalAborted() {
+		const signal = this.options.signal;
+		if (!signal) return false;
+		const result = attempt(() => signal.aborted === true);
+		return result instanceof Error ? true : result;
+	}
+	sourceName(source) {
+		const result = attempt(() => source.name);
+		if (result instanceof Error) return "?";
+		if (typeof result !== "string") return "?";
+		return result;
+	}
+	safeStart(source, reconnect) {
+		const name = this.sourceName(source);
+		const ctx = {
+			onEvent: this.onEvent,
+			log: this.log.child(name),
+			deps: this.deps,
+			onStatus: (status, detail) => this.notifyStatus(name, status, detail),
+			reconnect
+		};
+		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
+				});
+			}
 		});
-		return { ok: true };
 	}
-	running = null;
-	runningState() {
-		return this.running;
+	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") {
+			const source = sources[index];
+			const name = source ? this.sourceName(source) : "?";
+			const error = safeNormalizeError({ value: result.reason });
+			this.log.error({
+				action: "flume.rollback.failed",
+				message: `${name}: ${safeErrorMessage({ error })}`,
+				error,
+				detail: { source: name }
+			});
+		}
 	}
 };
 //#endregion
-export { Flume, FlumeConnectionError, FlumeHttpError, FlumeLogger, FlumeParseError, FlumeReconnector, FlumeRunning, FlumeStopped, createFlumeDefaultDeps, resolveFlumeReconnectConfig };
+export { Flume, FlumeConnectionError, FlumeHttpError, FlumeParseError, FlumeRunning, FlumeSource, FlumeStartError, FlumeStopped, createFlumeDefaultDeps };

package/dist/safe-json-parse-CfJjt-RY.js

@@ -0,0 +1,11 @@
+import { o as FlumeParseError } from "./flume-source-DUvt9aJt.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-JQd_5vbd.js

@@ -0,0 +1,20 @@
+import { l as safeErrorMessage } from "./flume-source-DUvt9aJt.js";
+import { t as FlumeHttpError } from "./http-error-CPSKoSie.js";
+//#region lib/utils/safe-read-text.ts
+/**
+* `response.text()` を保護する。body 読み取り中の reject (接続切断 / 解凍失敗 / 二重消費) を
+* `FlumeHttpError` (status / cause 保持) に変換する。log には書かない (呼び出し側で書く)
+*/
+async function safeReadText(props) {
+	try {
+		return await props.response.text();
+	} catch (err) {
+		return new FlumeHttpError({
+			message: `${props.context}: failed to read body: ${safeErrorMessage({ error: err })}`,
+			status: props.response.status,
+			cause: err
+		});
+	}
+}
+//#endregion
+export { safeReadText as t };