@interactive-inc/flume 0.2.0 → 0.4.0

package/dist/index.d.ts

@@ -1,20 +1,66 @@
-import { C as FlumeTimerHandle, S 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, x as FlumeStatus, y as FlumeSourceOptions } from "./types-tnOPBc1p.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 FlumeSourceStartOptions, D as FlumeTimerHandle, E as FlumeStatusHandler, S as FlumeSourceOptions, T as FlumeStatus, _ as FlumeSlackEnvelope, a as FlumeGitHubEvent, b as FlumeSource, c as FlumeHandler, d as FlumeLogInput, f as FlumeLogLevel, g as FlumeSlackConnectionResponse, h as FlumeRuntimeDeps, i as FlumeGatewayMessage, l as FlumeLog, m as FlumeReconnectOptions, n as FlumeDiscordSourceOptions, o as FlumeGitHubNotification, p as FlumeReconnectConfig, r as FlumeEvent, s as FlumeGitHubSourceOptions, t as FlumeDiscordEvent, u as FlumeLogHandler, v as FlumeSlackEvent, w as FlumeSourceStatus, x as FlumeSourceName, y as FlumeSlackSourceOptions } from "./types-D-tO-Mh2.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/errors/connection-error.d.ts
+type Options$2 = {
+  cause?: unknown;
+  code?: number;
+};
+/**
+ * 接続失敗を表す。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$2);
+}
+//#endregion
+//#region lib/errors/http-error.d.ts
+type Props$4 = {
+  message: string;
+  status: number;
+  cause?: unknown;
+};
+declare class FlumeHttpError extends Error {
+  readonly status: number;
+  constructor(props: Props$4);
+}
+//#endregion
+//#region lib/errors/parse-error.d.ts
+type Options$1 = {
+  cause?: unknown;
+};
+declare class FlumeParseError extends Error {
+  constructor(message: string, options?: Options$1);
+}
+//#endregion
+//#region lib/errors/start-error.d.ts
+type Options = {
+  cause?: unknown;
+};
+declare class FlumeStartError extends Error {
+  constructor(message: string, options?: Options);
+}
+//#endregion
 //#region lib/logger.d.ts
-type Props$5 = {
+type Props$3 = {
   source: string;
   handler?: FlumeLogHandler;
   deps: Pick<FlumeRuntimeDeps, "now">;
 };
+/**
+ * 構造化ログを onLog に流す。handler が throw / reject してもループは継続する
+ */
 declare class FlumeLogger {
   private readonly props;
-  constructor(props: Props$5);
+  constructor(props: Props$3);
   debug(entry: FlumeLogInput): void;
   info(entry: FlumeLogInput): void;
   warn(entry: FlumeLogInput): void;
@@ -22,41 +68,6 @@ declare class FlumeLogger {
   private emit;
 }
 //#endregion
-//#region lib/reconnect-config.d.ts
-declare function resolveFlumeReconnectConfig(input: boolean | FlumeReconnectOptions | undefined): FlumeReconnectConfig | null;
-//#endregion
-//#region lib/reconnector.d.ts
-type Props$4 = {
-  maxAttempts: number;
-  baseDelay: number;
-  maxDelay: number;
-  deps: Pick<FlumeRuntimeDeps, "setTimeout" | "clearTimeout" | "random">;
-};
-declare class FlumeReconnector {
-  private readonly props;
-  attempt: number;
-  aborted: boolean;
-  private timer;
-  constructor(props: Props$4);
-  schedule(fn: () => void): number;
-  reset(): void;
-  cancel(): void;
-  private nextDelay;
-}
-//#endregion
-//#region lib/schedule-reconnect.d.ts
-type Props$3 = {
-  reconnector: FlumeReconnector | null;
-  log: FlumeLogger;
-  setStatus: (status: FlumeStatus) => void;
-  retry: () => void;
-};
-/**
- * 接続が落ちた際の共通再接続スケジューラ。reconnector の状態を見て次回試行を予約し、
- * 試行回数が尽きていれば disconnected に落とす
- */
-declare function scheduleFlumeReconnect(props: Props$3): void;
-//#endregion
 //#region lib/flume-stopped.d.ts
 type Props$2 = {
   finalStatuses: ReadonlyArray<FlumeSourceStatus>;
@@ -66,6 +77,7 @@ type Props$2 = {
  */
 declare class FlumeStopped {
   private readonly props;
+  readonly kind: "stopped";
   constructor(props: Props$2);
   statuses(): ReadonlyArray<FlumeSourceStatus>;
 }
@@ -74,33 +86,52 @@ declare class FlumeStopped {
 type Props$1 = {
   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);
   stop(): Promise<FlumeStopped>;
   statuses(): ReadonlyArray<FlumeSourceStatus>;
   private runStop;
+  private snapshotStatuses;
+  private sourceName;
 }
 //#endregion
 //#region lib/flume.d.ts
 type Props = {
   sources: ReadonlyArray<FlumeSource>;
   signal?: AbortSignal;
+  onLog?: FlumeLogHandler;
+  deps?: FlumeRuntimeDeps;
 };
 /**
- * 起動前の Flume。start() で FlumeRunning へ遷移する
+ * 起動前の Flume。`start()` で `FlumeRunning` へ遷移する。
+ * いずれかの 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 consumed;
+  private readonly log;
+  private readonly deps;
   constructor(props: Props);
-  start(handler: FlumeHandler): Promise<FlumeRunning | Error>;
+  start(handler: FlumeHandler): Promise<FlumeRunning | FlumeStartError>;
+  private guardStart;
+  private isSignalAborted;
+  private sourceName;
+  private safeStart;
+  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 FlumeStatus, type FlumeStatusHandler, FlumeStopped, type FlumeTimerHandle, createFlumeDefaultDeps, resolveFlumeReconnectConfig, scheduleFlumeReconnect };
+export { Flume, FlumeConnectionError, type FlumeDiscordEvent, type FlumeDiscordSourceOptions, type FlumeEvent, type FlumeGatewayMessage, type FlumeGitHubEvent, type FlumeGitHubNotification, type FlumeGitHubSourceOptions, type FlumeHandler, 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, type FlumeSource, type FlumeSourceName, type FlumeSourceOptions, type FlumeSourceStartOptions, type FlumeSourceStatus, FlumeStartError, type FlumeStatus, type FlumeStatusHandler, FlumeStopped, type FlumeTimerHandle, createFlumeDefaultDeps };

package/dist/index.js

@@ -1,12 +1,13 @@
-import { n as createFlumeDefaultDeps, t as FlumeLogger } from "./logger-CpGB9WO_.js";
-import { a as FlumeConnectionError, i as FlumeParseError, n as FlumeReconnector, r as resolveFlumeReconnectConfig, t as scheduleFlumeReconnect } from "./schedule-reconnect-DSxZJG3h.js";
-import { t as FlumeHttpError } from "./http-error-BtXonO-W.js";
+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
 /**
 * 停止済みの終端状態。最終ステータスのスナップショットのみ観測できる
 */
 var FlumeStopped = class {
 	props;
+	kind = "stopped";
 	constructor(props) {
 		this.props = props;
 		Object.freeze(this);
@@ -18,18 +19,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,68 +65,225 @@ 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/flume.ts
 /**
-* 起動前の Flume。start() で FlumeRunning へ遷移する
+* 起動前の Flume。`start()` で `FlumeRunning` へ遷移する。
+* いずれかの source 失敗時は既に成功した source を全て `stop()` してロールバックし
+* `FlumeStartError` を返す。
+* `source.start()` / `source.stop()` の sync throw も `Promise.resolve().then` 経由で
+* Promise rejection に正規化して `allSettled` で捕捉する (`start()` は決して reject しない)
 */
 var Flume = class {
 	props;
 	consumed = false;
+	log;
+	deps;
 	constructor(props) {
 		this.props = props;
+		this.deps = props.deps ?? createFlumeDefaultDeps();
+		this.log = new FlumeLogger({
+			source: "flume",
+			handler: props.onLog,
+			deps: this.deps
+		});
 	}
 	async start(handler) {
-		if (this.consumed) return /* @__PURE__ */ new Error("Flume.start: already started");
-		if (this.props.signal?.aborted) return /* @__PURE__ */ new Error("Flume.start: signal already aborted");
+		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.props.sources.length} source(s)`,
+			detail: { count: this.props.sources.length }
+		});
+		const settled = await Promise.allSettled(this.props.sources.map((source) => this.safeStart(source, handler)));
 		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.props.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 instanceof Error) failures.push({
-				name: source.name,
-				error: result.value
-			});
-			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 /* @__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 /* @__PURE__ */ new Error("Flume.start: aborted during start");
+		if (this.isSignalAborted()) {
+			await this.rollback(this.props.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.props.sources,
-			signal: this.props.signal
+			signal: this.props.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;
+		}
+		return null;
+	}
+	isSignalAborted() {
+		const signal = this.props.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, handler) {
+		return Promise.resolve().then(() => source.start(handler, { signal: this.props.signal }));
+	}
+	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, scheduleFlumeReconnect };
+export { Flume, FlumeConnectionError, FlumeHttpError, FlumeParseError, FlumeRunning, FlumeStartError, FlumeStopped, createFlumeDefaultDeps };

package/dist/safe-invoke-callback-EpWXwfwp.js

@@ -0,0 +1,170 @@
+//#region lib/utils/safe-error-message.ts
+/**
+* 任意の値から人が読めるメッセージ文字列を取り出す。
+* `Error.message` getter / `Symbol.toPrimitive` / `toString` / `valueOf` が throw しても固定文字列に fallback。
+* 自身は決して throw しない
+*/
+function safeErrorMessage(props) {
+	if (props.error instanceof Error) try {
+		const message = props.error.message;
+		if (typeof message === "string") return message;
+		return "<non-string error message>";
+	} catch {
+		return "<unreadable error message>";
+	}
+	try {
+		return String(props.error);
+	} catch {
+		return "<unprintable error>";
+	}
+}
+//#endregion
+//#region lib/utils/safe-normalize-error.ts
+/**
+* 任意の値を `Error` インスタンスへ正規化する。すでに Error ならそのまま返し、
+* それ以外は `safeErrorMessage` で安全な文字列化を経由して new Error する。
+* Error コンストラクタ自体が throw する病的環境でも fallback を返し、決して throw しない
+*/
+function safeNormalizeError(props) {
+	if (props.value instanceof Error) return props.value;
+	const message = safeErrorMessage({ error: props.value });
+	try {
+		return new Error(message);
+	} catch {
+		try {
+			return /* @__PURE__ */ new Error("unknown error");
+		} catch {
+			const fallback = Object.create(Error.prototype);
+			fallback.name = "Error";
+			fallback.message = "unknown error";
+			return fallback;
+		}
+	}
+}
+//#endregion
+//#region lib/utils/attempt.ts
+function attempt(fn) {
+	try {
+		const result = fn();
+		if (result instanceof Promise) return result.catch((err) => safeNormalizeError({ value: err }));
+		return result;
+	} catch (err) {
+		return safeNormalizeError({ value: err });
+	}
+}
+//#endregion
+//#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/errors/parse-error.ts
+var FlumeParseError = class extends Error {
+	constructor(message, options) {
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "FlumeParseError";
+		Object.freeze(this);
+	}
+};
+//#endregion
+//#region lib/errors/start-error.ts
+var FlumeStartError = class extends Error {
+	constructor(message, options) {
+		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+		this.name = "FlumeStartError";
+		Object.freeze(this);
+	}
+};
+//#endregion
+//#region lib/utils/safe-now.ts
+/**
+* `deps.now()` を保護する。throw / 非数値が返った場合は 0 を返す。
+* IO 境界のため呼び出し側はこの戻り値を信頼できる
+*/
+function safeNow(props) {
+	try {
+		const value = props.deps.now();
+		if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+		return value;
+	} catch {
+		return 0;
+	}
+}
+//#endregion
+//#region lib/logger.ts
+/**
+* 構造化ログを onLog に流す。handler が throw / reject してもループは継続する
+*/
+var FlumeLogger = class {
+	props;
+	constructor(props) {
+		this.props = props;
+		Object.freeze(this);
+	}
+	debug(entry) {
+		this.emit("debug", entry);
+	}
+	info(entry) {
+		this.emit("info", entry);
+	}
+	warn(entry) {
+		this.emit("warn", entry);
+	}
+	error(entry) {
+		this.emit("error", entry);
+	}
+	emit(level, input) {
+		const handler = this.props.handler;
+		if (!handler) return;
+		const log = {
+			level,
+			source: this.props.source,
+			action: input.action,
+			message: input.message,
+			timestamp: safeNow({ deps: this.props.deps }),
+			error: input.error,
+			detail: input.detail
+		};
+		try {
+			Promise.resolve(handler(log)).catch(() => {});
+		} catch {}
+	}
+};
+//#endregion
+//#region lib/utils/safe-invoke-callback.ts
+/**
+* fire-and-forget でユーザーコールバックを呼び出す。sync throw と async reject のどちらも
+* `onError(Error)` に正規化して通知。`onError` 自身が throw しても外に漏らさない。
+* 戻り値を持たない fire-and-forget 専用のため log/出力先には依存しない (caller が onError で決める)
+*/
+function safeInvokeCallback(props) {
+	try {
+		Promise.resolve(props.fn()).catch((err) => {
+			try {
+				props.onError(safeNormalizeError({ value: err }));
+			} catch {}
+		}).catch(() => {});
+	} catch (err) {
+		try {
+			props.onError(safeNormalizeError({ value: err }));
+		} catch {}
+	}
+}
+//#endregion
+export { FlumeParseError as a, safeNormalizeError as c, FlumeStartError as i, safeErrorMessage as l, FlumeLogger as n, createFlumeDefaultDeps as o, safeNow as r, attempt as s, safeInvokeCallback as t };