@interactive-inc/flume 0.1.0 → 0.3.0

package/dist/github.js

@@ -1,2 +1,314 @@
-import { t as FlumeGitHubSource } from "./github-source-D7Z1RUbe.js";
-export { FlumeGitHubSource };
+import { n as createFlumeDefaultDeps, t as FlumeLogger } from "./logger-CpGB9WO_.js";
+import { t as FlumeSerialQueue } from "./serial-queue-ExmlnpzQ.js";
+import { t as safeFetch } from "./safe-fetch-30ZzOKHL.js";
+import { z } from "zod/v4";
+//#region lib/github/extract-github-meta.ts
+function extractGitHubMeta(notification) {
+	return {
+		event_type: "notification",
+		reason: notification.reason,
+		subject_type: notification.subject.type,
+		repository: notification.repository.full_name,
+		thread_id: notification.id
+	};
+}
+//#endregion
+//#region lib/github/github-notification-schema.ts
+const FlumeGitHubNotificationSchema = z.object({
+	id: z.string(),
+	reason: z.string(),
+	unread: z.boolean(),
+	updated_at: z.string(),
+	subject: z.object({
+		title: z.string(),
+		url: z.string().nullable(),
+		type: z.string()
+	}),
+	repository: z.object({ full_name: z.string() })
+});
+//#endregion
+//#region lib/github/github-seen-cache.ts
+var FlumeGitHubSeenCache = class {
+	props;
+	seen = /* @__PURE__ */ new Map();
+	constructor(props) {
+		this.props = props;
+	}
+	has(id, updatedAt) {
+		return this.seen.get(id) === updatedAt;
+	}
+	add(id, updatedAt) {
+		this.seen.set(id, updatedAt);
+	}
+	trim() {
+		if (this.seen.size <= this.props.maxSize) return;
+		const entries = [...this.seen.entries()];
+		this.seen = new Map(entries.slice(entries.length - this.props.maxSize));
+	}
+	get size() {
+		return this.seen.size;
+	}
+};
+//#endregion
+//#region lib/github/github-poller.ts
+var FlumeGitHubPoller = class {
+	props;
+	log;
+	cache = new FlumeGitHubSeenCache({ maxSize: 5e3 });
+	timer = null;
+	since = null;
+	bootstrapped = false;
+	stopped = false;
+	consecutiveErrors = 0;
+	constructor(props) {
+		this.props = props;
+		this.log = new FlumeLogger({
+			source: "github.poller",
+			handler: props.onLog,
+			deps: props.deps
+		});
+	}
+	async start() {
+		this.stopped = false;
+		this.log.info({
+			action: "start",
+			message: `polling every ${this.props.interval}s`
+		});
+		await this.poll();
+		this.timer = this.props.deps.setInterval(() => {
+			this.poll().catch((err) => {
+				this.log.error({
+					action: "poll.unhandled",
+					message: "unexpected error in poll loop",
+					error: err instanceof Error ? err : new Error(String(err))
+				});
+			});
+		}, this.props.interval * 1e3);
+	}
+	stop() {
+		this.log.info({
+			action: "stop",
+			message: "stopping poller"
+		});
+		this.stopped = true;
+		if (this.timer !== null) {
+			this.props.deps.clearInterval(this.timer);
+			this.timer = null;
+		}
+	}
+	async poll() {
+		const params = new URLSearchParams({ all: "false" });
+		if (this.since) params.set("since", this.since);
+		const url = `https://api.github.com/notifications?${params}`;
+		this.log.debug({
+			action: "http.request",
+			message: `GET ${url}`
+		});
+		const response = await this.safeFetch(url);
+		if (response instanceof Error) return;
+		this.log.debug({
+			action: "http.response",
+			message: `GET ${response.status}`,
+			detail: {
+				status: response.status,
+				url
+			}
+		});
+		if (!response.ok) {
+			this.consecutiveErrors++;
+			this.log.error({
+				action: "http.error",
+				message: `HTTP ${response.status} (consecutive=${this.consecutiveErrors})`
+			});
+			if (this.consecutiveErrors >= 3) this.props.onDisconnected(`HTTP ${response.status}`);
+			return;
+		}
+		this.consecutiveErrors = 0;
+		const body = await response.json();
+		if (!Array.isArray(body)) {
+			this.log.warn({
+				action: "http.body",
+				message: "response body is not an array, dropping",
+				detail: { bodyType: typeof body }
+			});
+			return;
+		}
+		this.processNotifications(body);
+	}
+	processNotifications(raw) {
+		let dropped = 0;
+		const notifications = raw.flatMap((item) => {
+			const parsed = FlumeGitHubNotificationSchema.safeParse(item);
+			if (!parsed.success) {
+				dropped++;
+				this.log.warn({
+					action: "parse.skip",
+					message: "notification did not match schema",
+					detail: { issues: parsed.error.issues.map((i) => ({
+						path: i.path,
+						message: i.message
+					})) }
+				});
+				return [];
+			}
+			return [parsed.data];
+		});
+		if (dropped > 0) this.log.warn({
+			action: "parse.summary",
+			message: `${dropped}/${raw.length} notifications dropped by schema`
+		});
+		if (!this.bootstrapped) {
+			this.bootstrapped = true;
+			for (const notification of notifications) this.cache.add(notification.id, notification.updated_at);
+			this.since = new Date(this.props.deps.now()).toISOString();
+			this.log.info({
+				action: "bootstrap",
+				message: `seeded ${notifications.length} existing notifications`
+			});
+			this.props.onConnected();
+			return;
+		}
+		const fresh = [];
+		for (const notification of notifications) {
+			if (this.cache.has(notification.id, notification.updated_at)) continue;
+			this.cache.add(notification.id, notification.updated_at);
+			fresh.push(notification);
+		}
+		this.cache.trim();
+		this.since = new Date(this.props.deps.now()).toISOString();
+		if (fresh.length > 0) {
+			this.log.info({
+				action: "poll.fresh",
+				message: `${fresh.length} new notifications`
+			});
+			this.props.onNotifications(fresh);
+		} else this.log.debug({
+			action: "poll.idle",
+			message: "0 new notifications"
+		});
+	}
+	async safeFetch(url) {
+		const result = await safeFetch({
+			fetch: this.props.deps.fetch,
+			url,
+			init: { headers: {
+				Authorization: `Bearer ${this.props.token}`,
+				Accept: "application/vnd.github+json",
+				"X-GitHub-Api-Version": "2022-11-28"
+			} },
+			log: this.log
+		});
+		if (result instanceof Error) {
+			this.consecutiveErrors++;
+			this.log.warn({
+				action: "http.error",
+				message: `consecutive=${this.consecutiveErrors}`
+			});
+			if (this.consecutiveErrors >= 3) this.props.onDisconnected("network error");
+		}
+		return result;
+	}
+};
+//#endregion
+//#region lib/github/github-source.ts
+var FlumeGitHubSource = class {
+	options;
+	name = "github";
+	poller = null;
+	currentStatus = "disconnected";
+	log;
+	deps;
+	queue = new FlumeSerialQueue();
+	constructor(options) {
+		this.options = options;
+		this.deps = options.deps ?? createFlumeDefaultDeps();
+		this.log = new FlumeLogger({
+			source: "github",
+			handler: options.onLog,
+			deps: this.deps
+		});
+	}
+	async start(handler) {
+		if (this.options.signal?.aborted) return {
+			ok: false,
+			error: /* @__PURE__ */ new Error("GitHub source: signal already aborted")
+		};
+		this.options.signal?.addEventListener("abort", () => this.stop(), { once: true });
+		this.log.info({
+			action: "start",
+			message: "starting GitHub source"
+		});
+		this.setStatus("connecting");
+		this.poller = new FlumeGitHubPoller({
+			token: this.options.token,
+			interval: this.options.pollInterval ?? 60,
+			onLog: this.options.onLog,
+			deps: this.deps,
+			onNotifications: (notifications) => this.handleNotifications(handler, notifications),
+			onConnected: () => this.setStatus("connected"),
+			onDisconnected: (detail) => this.setStatus("disconnected", detail)
+		});
+		try {
+			await this.poller.start();
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.log.error({
+				action: "start.failed",
+				message: err.message,
+				error: err
+			});
+			this.setStatus("disconnected");
+			return {
+				ok: false,
+				error: err
+			};
+		}
+		return { ok: true };
+	}
+	async stop() {
+		this.log.info({
+			action: "stop",
+			message: "stopping GitHub source"
+		});
+		this.poller?.stop();
+		this.poller = null;
+		await this.queue.drain();
+		this.setStatus("disconnected");
+	}
+	status() {
+		return this.currentStatus;
+	}
+	handleNotifications(handler, notifications) {
+		for (const notification of notifications) {
+			const event = {
+				source: "github",
+				type: "notification",
+				data: notification,
+				meta: extractGitHubMeta(notification),
+				receivedAt: this.deps.now()
+			};
+			this.queue.add(async () => {
+				try {
+					await handler(event);
+				} catch (err) {
+					this.log.error({
+						action: "handler.error",
+						message: "user handler threw",
+						error: err instanceof Error ? err : new Error(String(err))
+					});
+				}
+			});
+		}
+	}
+	setStatus(next, detail) {
+		if (this.currentStatus === next) return;
+		this.log.info({
+			action: "status",
+			message: `${this.currentStatus} → ${next}${detail ? ` (${detail})` : ""}`
+		});
+		this.currentStatus = next;
+		this.options.onStatus?.(next, detail);
+	}
+};
+//#endregion
+export { FlumeGitHubNotificationSchema, FlumeGitHubPoller, FlumeGitHubSeenCache, FlumeGitHubSource, extractGitHubMeta };

package/dist/http-error-BtXonO-W.js

@@ -0,0 +1,12 @@
+//#region lib/errors/http-error.ts
+var FlumeHttpError = class extends Error {
+	status;
+	constructor(props) {
+		super(props.message);
+		this.name = "FlumeHttpError";
+		this.status = props.status;
+		Object.freeze(this);
+	}
+};
+//#endregion
+export { FlumeHttpError as t };

package/dist/http-error-K-Ym4lfK.d.ts

@@ -0,0 +1,11 @@
+//#region lib/errors/http-error.d.ts
+type Props = {
+  message: string;
+  status: number;
+};
+declare class FlumeHttpError extends Error {
+  readonly status: number;
+  constructor(props: Props);
+}
+//#endregion
+export { FlumeHttpError as t };

package/dist/index.d.ts

@@ -1,40 +1,20 @@
-import { C as FlumeGitHubNotificationSchema, S as FlumeGatewayMessageSchema, T as FlumeSlackEnvelopeSchema, _ as FlumeSourceName, a as FlumeGitHubSourceOptions, b as FlumeStatusHandler, 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 FlumeSourceOptions, w as FlumeSlackConnectionResponseSchema, x as FlumeTimerHandle, y as FlumeStatus } from "./types-BVQSU336.js";
-import { FlumeDiscordSource } from "./discord.js";
-import { FlumeGitHubSource } from "./github.js";
-import { FlumeSlackSource } from "./slack.js";
+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";
 
 //#region lib/deps.d.ts
 declare function createFlumeDefaultDeps(): FlumeRuntimeDeps;
 //#endregion
-//#region lib/errors/connection-error.d.ts
-declare class FlumeConnectionError extends Error {
-  constructor(message: string);
-}
-//#endregion
-//#region lib/errors/http-error.d.ts
-type Props$10 = {
-  message: string;
-  status: number;
-};
-declare class FlumeHttpError extends Error {
-  readonly status: number;
-  constructor(props: Props$10);
-}
-//#endregion
-//#region lib/errors/parse-error.d.ts
-declare class FlumeParseError extends Error {
-  constructor(message: string);
-}
-//#endregion
 //#region lib/logger.d.ts
-type Props$9 = {
+type Props$4 = {
   source: string;
   handler?: FlumeLogHandler;
   deps: Pick<FlumeRuntimeDeps, "now">;
 };
 declare class FlumeLogger {
   private readonly props;
-  constructor(props: Props$9);
+  constructor(props: Props$4);
   debug(entry: FlumeLogInput): void;
   info(entry: FlumeLogInput): void;
   warn(entry: FlumeLogInput): void;
@@ -46,7 +26,7 @@ declare class FlumeLogger {
 declare function resolveFlumeReconnectConfig(input: boolean | FlumeReconnectOptions | undefined): FlumeReconnectConfig | null;
 //#endregion
 //#region lib/reconnector.d.ts
-type Props$8 = {
+type Props$3 = {
   maxAttempts: number;
   baseDelay: number;
   maxDelay: number;
@@ -57,222 +37,59 @@ declare class FlumeReconnector {
   attempt: number;
   aborted: boolean;
   private timer;
-  constructor(props: Props$8);
+  constructor(props: Props$3);
   schedule(fn: () => void): number;
   reset(): void;
   cancel(): void;
   private nextDelay;
 }
 //#endregion
-//#region lib/flume.d.ts
-type Props$7 = {
-  onLog?: FlumeLogHandler;
-  onStatus?: FlumeStatusHandler;
-  reconnect?: boolean | FlumeReconnectOptions;
-  signal?: AbortSignal;
-  deps?: Partial<FlumeRuntimeDeps>;
+//#region lib/flume-stopped.d.ts
+type Props$2 = {
+  finalStatuses: ReadonlyArray<FlumeSourceStatus>;
 };
 /**
- * 共有設定を持つ DI コンテナ。各 Source に共通の deps / logging / reconnect を注入する
+ * 停止済みの終端状態。最終ステータスのスナップショットのみ観測できる
  */
-declare class Flume {
+declare class FlumeStopped {
   private readonly props;
-  private readonly resolvedDeps;
-  constructor(props: Props$7);
-  discord(options: {
-    token: string;
-    intents?: number;
-  }): FlumeDiscordSource;
-  slack(options: {
-    appToken: string;
-    botToken?: string;
-  }): FlumeSlackSource;
-  github(options: {
-    token: string;
-    pollInterval?: number;
-  }): FlumeGitHubSource;
-}
-//#endregion
-//#region lib/discord/discord-gateway-intents.d.ts
-declare const FlumeDiscordGatewayIntents: {
-  readonly Guilds: number;
-  readonly GuildMembers: number;
-  readonly GuildModeration: number;
-  readonly GuildExpressions: number;
-  readonly GuildIntegrations: number;
-  readonly GuildWebhooks: number;
-  readonly GuildInvites: number;
-  readonly GuildVoiceStates: number;
-  readonly GuildPresences: number;
-  readonly GuildMessages: number;
-  readonly GuildMessageReactions: number;
-  readonly GuildMessageTyping: number;
-  readonly DirectMessages: number;
-  readonly DirectMessageReactions: number;
-  readonly DirectMessageTyping: number;
-  readonly MessageContent: number;
-  readonly GuildScheduledEvents: number;
-  readonly AutoModerationConfiguration: number;
-  readonly AutoModerationExecution: number;
-  readonly GuildMessagePolls: number;
-  readonly DirectMessagePolls: number;
-};
-//#endregion
-//#region lib/discord/discord-gateway-session.d.ts
-type Props$6 = {
-  sessionId: string | null;
-  resumeUrl: string | null;
-  seq: number | null;
-};
-declare class FlumeDiscordGatewaySession {
-  readonly sessionId: string | null;
-  readonly resumeUrl: string | null;
-  readonly seq: number | null;
-  constructor(props: Props$6);
-  static empty(): FlumeDiscordGatewaySession;
-  canResume(): boolean;
-  withSeq(seq: number): FlumeDiscordGatewaySession;
-  withReady(sessionId: string, resumeUrl: string): FlumeDiscordGatewaySession;
-  withReset(): FlumeDiscordGatewaySession;
+  constructor(props: Props$2);
+  statuses(): ReadonlyArray<FlumeSourceStatus>;
 }
 //#endregion
-//#region lib/discord/discord-gateway.d.ts
-type Deps$2 = Pick<FlumeRuntimeDeps, "WebSocket" | "setInterval" | "clearInterval" | "setTimeout" | "random" | "now">;
-type Props$5 = {
-  token: string;
-  intents: number;
-  onDispatch: (event: string, data: Record<string, unknown>) => void;
-  onStatus: (status: "connected" | "disconnected") => void;
-  onLog?: FlumeLogHandler;
-  deps: Deps$2;
-};
-declare class FlumeDiscordGateway {
-  private readonly props;
-  private readonly log;
-  private ws;
-  private heartbeat;
-  session: FlumeDiscordGatewaySession;
-  stopped: boolean;
-  private pendingResolve;
-  private pendingResolved;
-  constructor(props: Props$5);
-  connect(url?: string): Promise<FlumeConnectionError | null>;
-  disconnect(): void;
-  isConnected(): boolean;
-  private completeConnect;
-  private onMessage;
-  private onHello;
-  private onHeartbeatAck;
-  private onHeartbeatRequest;
-  private onReconnectRequest;
-  private onInvalidSession;
-  private onDispatch;
-  private onClose;
-  private onError;
-  private send;
-  private sendIdentify;
-  private sendResume;
-}
-//#endregion
-//#region lib/discord/discord-heartbeat.d.ts
-type Props$4 = {
-  onSend: () => void;
-  onZombie: () => void;
-  deps: Pick<FlumeRuntimeDeps, "setInterval" | "clearInterval">;
-};
-declare class FlumeDiscordHeartbeat {
-  private readonly props;
-  private timer;
-  private ackReceived;
-  constructor(props: Props$4);
-  start(intervalMs: number): void;
-  stop(): void;
-  ack(): void;
-  isRunning(): boolean;
-}
-//#endregion
-//#region lib/discord/parse-discord-gateway-message.d.ts
-declare function parseDiscordGatewayMessage(raw: string): FlumeGatewayMessage | FlumeParseError;
-//#endregion
-//#region lib/slack/slack-socket-mode.d.ts
-type Deps$1 = Pick<FlumeRuntimeDeps, "WebSocket" | "fetch" | "now">;
-type Props$3 = {
-  appToken: string;
-  onMessage: (envelope: FlumeSlackEnvelope) => void;
-  onConnected: () => void;
-  onDisconnected: () => void;
-  onLog?: FlumeLogHandler;
-  deps: Deps$1;
-};
-declare class FlumeSlackSocketMode {
-  private readonly props;
-  private readonly log;
-  private ws;
-  stopped: boolean;
-  private pendingResolve;
-  private pendingResolved;
-  constructor(props: Props$3);
-  connect(): Promise<FlumeConnectionError | FlumeHttpError | null>;
-  disconnect(): void;
-  isConnected(): boolean;
-  private openSocket;
-  private completeConnect;
-  private onMessage;
-  private onClose;
-  private onError;
-}
-//#endregion
-//#region lib/slack/obtain-slack-url.d.ts
-type Props$2 = {
-  appToken: string;
-  onLog?: FlumeLogHandler;
-  deps: Pick<FlumeRuntimeDeps, "fetch" | "now">;
-};
-declare function obtainSlackUrl(props: Props$2): Promise<string | FlumeHttpError>;
-//#endregion
-//#region lib/github/github-poller.d.ts
-type Deps = Pick<FlumeRuntimeDeps, "fetch" | "setInterval" | "clearInterval" | "now">;
+//#region lib/flume-running.d.ts
 type Props$1 = {
-  token: string;
-  interval: number;
-  onNotifications: (notifications: FlumeGitHubNotification[]) => void;
-  onConnected: () => void;
-  onDisconnected: (detail: string) => void;
-  onLog?: FlumeLogHandler;
-  deps: Deps;
+  sources: ReadonlyArray<FlumeSource>;
+  signal?: AbortSignal;
 };
-declare class FlumeGitHubPoller {
+/**
+ * 稼働中の Flume。stop() で FlumeStopped へ遷移する。signal が abort されると自動 stop
+ */
+declare class FlumeRunning {
   private readonly props;
-  private readonly log;
-  private readonly cache;
-  private timer;
-  private since;
-  private bootstrapped;
-  stopped: boolean;
-  private consecutiveErrors;
+  private stopPromise;
+  private readonly onAbort;
   constructor(props: Props$1);
-  start(): Promise<void>;
-  stop(): void;
-  private poll;
-  private processNotifications;
-  private safeFetch;
+  stop(): Promise<FlumeStopped>;
+  statuses(): ReadonlyArray<FlumeSourceStatus>;
+  private runStop;
 }
 //#endregion
-//#region lib/github/github-seen-cache.d.ts
+//#region lib/flume.d.ts
 type Props = {
-  maxSize: number;
+  sources: ReadonlyArray<FlumeSource>;
+  signal?: AbortSignal;
 };
-declare class FlumeGitHubSeenCache {
+/**
+ * 起動前の Flume。start() で FlumeRunning へ遷移する
+ */
+declare class Flume {
   private readonly props;
-  private seen;
+  private consumed;
   constructor(props: Props);
-  has(id: string, updatedAt: string): boolean;
-  add(id: string, updatedAt: string): void;
-  trim(): void;
-  get size(): number;
+  start(handler: FlumeHandler): Promise<FlumeStartResult>;
+  private running;
+  runningState(): FlumeRunning | null;
 }
 //#endregion
-//#region lib/index.d.ts
-type FlumeSource = FlumeDiscordSource | FlumeSlackSource | FlumeGitHubSource;
-//#endregion
-export { Flume, FlumeConnectionError, FlumeDiscordGateway, FlumeDiscordGatewayIntents, FlumeDiscordGatewaySession, FlumeDiscordHeartbeat, FlumeDiscordSource, type FlumeDiscordSourceOptions, type FlumeEvent, type FlumeGatewayMessage, FlumeGatewayMessageSchema, type FlumeGitHubNotification, FlumeGitHubNotificationSchema, FlumeGitHubPoller, FlumeGitHubSeenCache, FlumeGitHubSource, type FlumeGitHubSourceOptions, type FlumeHandler, FlumeHttpError, type FlumeLog, type FlumeLogHandler, type FlumeLogInput, type FlumeLogLevel, FlumeLogger, FlumeParseError, type FlumeReconnectConfig, type FlumeReconnectOptions, FlumeReconnector, type FlumeRuntimeDeps, type FlumeSlackConnectionResponse, FlumeSlackConnectionResponseSchema, type FlumeSlackEnvelope, FlumeSlackEnvelopeSchema, FlumeSlackSocketMode, FlumeSlackSource, type FlumeSlackSourceOptions, FlumeSource, type FlumeSourceName, type FlumeSourceOptions, type FlumeStatus, type FlumeStatusHandler, type FlumeTimerHandle, createFlumeDefaultDeps, obtainSlackUrl, parseDiscordGatewayMessage, resolveFlumeReconnectConfig };
+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 };