@interactive-inc/flume 0.10.0 → 0.11.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { A as FlumeStatus, B as FlumeTimerHandle, C as FlumeSlackEvent, D as FlumeSourceStartContext, E as FlumeSourceName, F as FlumeTimeEvent, I as FlumeTimeMessage, L as FlumeTimeSourceOptions, M as FlumeStreamItem, N as FlumeStreamOptions, O as FlumeSourceStatus, P as FlumeStreamOverflow, R as FlumeTimeSourceState, S as FlumeSlackEnvelope, T as FlumeSourceLocalStatusHandler, V as FlumeLogger, _ as FlumeLogLevel, a as FlumeDiscordEvent, b as FlumeRuntimeDeps, c as FlumeEvent, d as FlumeGitHubEvent, f as FlumeGitHubNotification, g as FlumeLogInput, h as FlumeLogHandler, i as FlumeConfluenceItemHandler, j as FlumeStreamHandler, k as FlumeStatePersister, l as FlumeEventHandler, m as FlumeLog, n as FlumeCatchupPolicy, o as FlumeDiscordSourceOptions, p as FlumeGitHubSourceOptions, r as FlumeConfluenceItem, s as FlumeErrorHandler, t as FlumeSource, u as FlumeGatewayMessage, v as FlumeReconnectConfig, w as FlumeSlackSourceOptions, x as FlumeSlackConnectionResponse, y as FlumeReconnectOptions, z as FlumeTimeTick } from "./flume-source.js";
-import { i as FlumeParseError, r as FlumeTimeSource, t as FlumeCron } from "./parse-cron.js";
+import { A as FlumeStatePersister, B as FlumeTimeTick, C as FlumeSlackEnvelope, D as FlumeSourceName, E as FlumeSourceLocalStatusHandler, F as FlumeStreamOverflow, H as FlumeLogger, I as FlumeTimeEvent, L as FlumeTimeMessage, M as FlumeStreamHandler, N as FlumeStreamItem, O as FlumeSourceStartContext, P as FlumeStreamOptions, R as FlumeTimeSourceOptions, S as FlumeSlackConnectionResponse, T as FlumeSlackSourceOptions, V as FlumeTimerHandle, _ as FlumeLogInput, a as FlumeCustomEvent, b as FlumeReconnectOptions, c as FlumeErrorHandler, d as FlumeGatewayMessage, f as FlumeGitHubEvent, g as FlumeLogHandler, h as FlumeLog, i as FlumeConfluenceItemHandler, j as FlumeStatus, k as FlumeSourceStatus, l as FlumeEvent, m as FlumeGitHubSourceOptions, n as FlumeCatchupPolicy, o as FlumeDiscordEvent, p as FlumeGitHubNotification, r as FlumeConfluenceItem, s as FlumeDiscordSourceOptions, t as FlumeSource, u as FlumeEventHandler, v as FlumeLogLevel, w as FlumeSlackEvent, x as FlumeRuntimeDeps, y as FlumeReconnectConfig, z as FlumeTimeSourceState } from "./flume-source.js";
+import { t as FlumeParseError } from "./parse-error.js";
 
 //#region lib/deps.d.ts
 /**
@@ -29,14 +29,18 @@ declare class FlumeConnectionError extends Error {
 }
 //#endregion
 //#region lib/errors/http-error.d.ts
-type Props$5 = {
+type Props$11 = {
   message: string;
   status: number;
-  cause?: unknown;
+  cause?: unknown; /** API 固有のエラーコード (Slack の `invalid_auth` 等)。呼び出し側が恒久/一時を分類するのに使う */
+  code?: string | null; /** サーバーが `Retry-After` 等で指示した再試行までの待機時間 (ms) */
+  retryAfterMs?: number | null;
 };
 declare class FlumeHttpError extends Error {
   readonly status: number;
-  constructor(props: Props$5);
+  readonly code: string | null;
+  readonly retryAfterMs: number | null;
+  constructor(props: Props$11);
 }
 //#endregion
 //#region lib/errors/start-error.d.ts
@@ -48,37 +52,56 @@ declare class FlumeStartError extends Error {
 }
 //#endregion
 //#region lib/flume-stream.d.ts
-type Props$4 = {
+type Props$10 = {
   buffer: number;
   onOverflow: FlumeStreamOverflow;
-  onClose: () => void;
+  onClose: () => void; /** buffer 溢れで item を落とした時の通知 (この stream で最初の 1 回だけ発火する) */
+  onDrop?: (input: {
+    dropped: number;
+  }) => void;
 };
 /**
  * push (`FlumeStreamHub.publish`) を pull (`for await`) に変換する async iterator。
  * consumer が待っていれば即 resolve、いなければ buffer に積み、溢れたら onOverflow に従う。
- * `return()` (break / 例外) と hub.close() のどちらでも自然に done へ落ちる
+ * hub.close() ではバッファ済み item を吐き切ってから done へ落ちる (graceful tail drain)。
+ * consumer 側の `return()` (break / 例外) はバッファを破棄して即 done になる (iterator 仕様)。
+ * drop の観測は onDrop 経由 — drop 通知自体が firehose に還流して再帰しないよう初回のみ発火
  */
 declare class FlumeStream implements AsyncIterableIterator<FlumeStreamItem> {
   private readonly props;
   private readonly items;
   private readonly resolvers;
   private closed;
-  constructor(props: Props$4);
+  private droppedCount;
+  constructor(props: Props$10);
   push(item: FlumeStreamItem): void;
   close(): void;
   next(): Promise<IteratorResult<FlumeStreamItem>>;
   return(): Promise<IteratorResult<FlumeStreamItem>>;
+  throw(error?: unknown): Promise<IteratorResult<FlumeStreamItem>>;
   [Symbol.asyncIterator](): AsyncIterableIterator<FlumeStreamItem>;
+  private recordDrop;
 }
 //#endregion
 //#region lib/flume-stream-hub.d.ts
+type Props$9 = {
+  /** buffer 溢れ通知。Flume が warn ログへ橋渡しする */onDrop?: (input: {
+    dropped: number;
+  }) => void;
+};
 /**
  * firehose (`onEvent` / `stream()`) の item を複数の pull consumer へ fan-out する内部ハブ。
  * subscriber が居なければ publish は実質 no-op。Flume 停止時に close() で全 stream を終端する
  */
 declare class FlumeStreamHub {
+  private readonly props;
   private readonly streams;
+  private readonly startupItems;
+  private startupDropNotified;
+  private hasSubscribed;
   private closed;
+  constructor(props?: Props$9);
+  get isClosed(): boolean;
   publish(item: FlumeStreamItem): void;
   subscribe(options?: FlumeStreamOptions): FlumeStream;
   close(): void;
@@ -89,7 +112,7 @@ type FlumeCloseError = {
   source: string;
   error: Error;
 };
-type Props$3 = {
+type Props$8 = {
   finalStatuses: ReadonlyArray<FlumeSourceStatus>;
   closeErrors: ReadonlyArray<FlumeCloseError>;
 };
@@ -99,9 +122,10 @@ type Props$3 = {
  * きれいに close したか / どれが失敗したか」を直接判定できる
  */
 declare class FlumeClosed {
-  private readonly props;
   readonly kind: "closed";
-  constructor(props: Props$3);
+  private readonly finalStatuses;
+  private readonly closeErrors;
+  constructor(props: Props$8);
   statuses(): ReadonlyArray<FlumeSourceStatus>;
   /**
    * `runClose` 中に `source.stop()` が rejected で settle した source の名前と
@@ -111,40 +135,63 @@ declare class FlumeClosed {
   errors(): ReadonlyArray<FlumeCloseError>;
 }
 //#endregion
+//#region lib/utils/serial-queue.d.ts
+/**
+ * 投入順を保ったまま task を直列実行する。各 task は前の完了を待ってから走る。
+ * task が throw しても後続には伝播しない (キュー自体は止まらない)。
+ * drain() は待機中に追加された task も含めてキューが空になるまで待つ
+ */
+declare class FlumeSerialQueue {
+  private chain;
+  add(task: () => Promise<void>): Promise<void>;
+  drain(): Promise<void>;
+}
+//#endregion
 //#region lib/flume-running.d.ts
-type Props$2 = {
+type Props$7 = {
   sources: ReadonlyArray<FlumeSource>;
   signal?: AbortSignal;
   log: FlumeLogger;
   hub: FlumeStreamHub;
+  callbackQueue: FlumeSerialQueue;
+  seal: () => void;
 };
 /**
  * 稼働中の Flume。close() で FlumeClosed へ遷移する。signal が abort されると自動 close。
  * 全ての source 呼び出し・signal 操作・status 読み取りを `attempt` 経由で扱い、
- * `runClose` の最外殻 try/catch で想定外の throw も `FlumeClosed` の resolve に変換する
+ * `runClose` の最外殻でも `attempt` を通して想定外の throw を `FlumeClosed` の resolve に変換する
  */
 declare class FlumeRunning {
   private readonly props;
   readonly kind: "running";
   private closePromise;
   private readonly onAbort;
-  constructor(props: Props$2);
+  constructor(props: Props$7);
+  /** Source の停止まで待つ。callback の完了は callback 外から drain() で待つ。 */
   close(): Promise<FlumeClosed>;
+  /**
+   * 配送済み callback とその失敗診断が完了するまで待つ。通常は close() の後に呼ぶ。
+   * onEvent / onError 内では自身の完了待ちになるため呼ばない。
+   */
+  drain(): Promise<void>;
   statuses(): ReadonlyArray<FlumeSourceStatus>;
   /**
    * 統合 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?: FlumeStreamOptions): AsyncIterableIterator<FlumeStreamItem>;
   /**
-   * Host が `Flume({ signal })` で渡した AbortSignal をそのまま公開する。
+   * `Flume({ signal })` に渡された AbortSignal をそのまま公開する。
    * 直接の controller を持っていない呼び出し元が `running.signal?.aborted`
-   * で abort 状態を確認できる
+   * で abort 状態を確認できる。`FlumeConfluence` 経由で開かれたグループでは
+   * host の signal ではなく confluence 内部の timeout controller の signal になる点に注意
    */
   get signal(): AbortSignal | undefined;
   private runClose;
+  private closeSources;
   private snapshotStatuses;
   private sourceName;
 }
@@ -161,44 +208,74 @@ type FlumeOptions = {
   onError?: FlumeErrorHandler;
   signal?: AbortSignal;
   deps?: FlumeRuntimeDeps;
-  reconnect?: FlumeReconnectOptions;
+  /**
+   * 再接続方針。未指定 / false は無効 (接続断で source は disconnected のまま)。
+   * true は既定値 (maxAttempts: Infinity / baseDelay: 1s / maxDelay: 30s)。
+   * 常駐リスナー用途では明示的に有効化を推奨
+   */
+  reconnect?: boolean | FlumeReconnectOptions;
 };
 /**
  * 起動前の Flume。`open()` で `FlumeRunning` へ遷移する。
  * コンストラクタは単一オブジェクト `{ sources, ...options }` を受け取る (`sources` のみ必須)。
  * events も全ログも 1 本の firehose (`onEvent` push / `stream()` pull) に流れ、購読側が filter する。
- * いずれかの source 失敗時は既に成功した source を全て `stop()` してロールバックし
- * `FlumeStartError` を返す。
+ * 起動失敗時はこの open が取得した source を `stop()` してロールバックする。
+ * 半接続状態で失敗した source も含むが、再利用を拒否した source は他の所有者のため停止しない。
  * `source.start()` / `source.stop()` の sync throw も `Promise.resolve().then` 経由で
  * Promise rejection に正規化して `allSettled` で捕捉する (`open()` は決して reject しない)
  */
 declare class Flume {
   private readonly options;
   private consumed;
+  private isAcceptingItems;
   private readonly log;
   private readonly deps;
   private readonly sources;
   private readonly sourceEventHandler;
   private readonly hub;
+  private readonly callbackQueue;
   constructor(options: FlumeOptions);
+  /**
+   * stream の buffer 溢れ通知 (stream ごとに初回 1 回)。
+   * firehose (hub) には流さない — 溢れている stream 自身に還流して実イベントを
+   * さらに追い出す自己破壊になるため、push の `onEvent` にだけ warn log として届ける
+   */
+  private notifyStreamOverflow;
   /** source が受信したログを firehose へ流す handler。error は onError にも分岐する */
   private buildLogHandler;
   /**
    * firehose の単一 sink: pull の hub と push の onEvent の両方へ item を配る。
-   * onEvent への転送は this.log を経由しない (経由すると log item 経路で再帰する) ため
-   * 例外をここで握り潰す
+   * close 後の遅延 emit (stop 中の straggler) は push 側にも流さない (pull 側と対称にする)。
+   * onEvent への転送は this.log を経由しない (経由すると log item 経路で再帰する)。
+   * callback failure は reportCallbackFailure が pull hub と peer callback へ直接診断する。
    */
   private emitItem;
+  private enqueueCallback;
+  /**
+   * error log 専用 sink も callbackQueue に載せ、drain() が in-flight callback と
+   * その失敗診断まで drain できるようにする
+   */
+  private invokeOnError;
+  /**
+   * 観測 sink 自身の失敗は同じ sink へ戻すと再帰するため、まず pull stream へ直接 publish し、
+   * もう一方の callback にだけ転送する。peer も失敗した場合は hub-only の診断を残して終端する
+   */
+  private reportCallbackFailure;
   open(): Promise<FlumeRunning | FlumeStartError>;
+  /** 起動失敗の戻り値は callback を待たず、配送済み診断の完了後に hub を閉じる。 */
+  private finishFailedOpen;
   private guardOpen;
+  /** reconnect オプションの解決。throwing getter を持つ hostile 入力でも open() を reject させない */
+  private resolveReconnect;
   private isSignalAborted;
   private sourceName;
   private safeStart;
   private rollback;
+  private logRollbackFailure;
 }
 //#endregion
 //#region lib/flume-confluence.d.ts
-type Props$1 = {
+type Props$6 = {
   /**
    * 配下の全 Flume の firehose をここへ合流させる単一 sink。
    * 各 item には発信元グループの id が `groupId` としてスタンプされる
@@ -206,7 +283,7 @@ type Props$1 = {
   onEvent?: FlumeConfluenceItemHandler; /** error レベル log だけ (全 Flume 共通) */
   onError?: FlumeErrorHandler;
   deps?: FlumeRuntimeDeps;
-  reconnect?: FlumeReconnectOptions;
+  reconnect?: boolean | FlumeReconnectOptions;
 };
 /**
  * 複数の `Flume` を束ねて動的に増減させる上位レイヤー。各 Flume は immutable のまま、
@@ -217,14 +294,26 @@ type Props$1 = {
  * `replace(id, sources)` は同じ id のグループを差し替える。新グループを先に起動し、
  * 起動成功時にのみ旧グループを停止するので連続稼働を維持できる (token rotation 用途)。
  * 起動失敗時は旧グループはそのまま走り続ける。
+ * 注意: 失敗した replace / add に渡した source インスタンスは consumed になるため、
+ * リトライには新しいインスタンスを構築する必要がある。
+ *
+ * `closeAll()` は終端操作。以後の `add()` / `replace()` は拒否され、closeAll と並行して
+ * 起動中だったグループも abort して完了を待つ (シャットダウン後に誰にも止められない
+ * グループが残らない)。
  *
  * throw しない流儀に従い `add()` / `replace()` は `Error | null` を返す
  */
 declare class FlumeConfluence {
   private readonly props;
   private readonly running;
+  /** open() を await 中でまだ Map に commit されていないグループの id (add 重複と remove 追跡用) */
+  private readonly pendingIds;
+  private readonly removedWhilePending;
+  private readonly pendingOpens;
+  private isClosedFlag;
   private readonly deps;
-  constructor(props?: Props$1);
+  constructor(props?: Props$6);
+  get isClosed(): boolean;
   /** sources を 1 グループとして起動。id 重複や起動失敗は `Error` で返す (throw しない) */
   add(id: string, sources: ReadonlyArray<FlumeSource>): Promise<Error | null>;
   /**
@@ -235,38 +324,126 @@ declare class FlumeConfluence {
   replace(id: string, sources: ReadonlyArray<FlumeSource>, options?: {
     readonly replaceTimeoutMs?: number;
   }): Promise<Error | null>;
-  /** 指定グループだけ close。他グループは無停止。未知の id は no-op */
+  /**
+   * 指定グループだけ close。他グループは無停止。未知の id は no-op。
+   * 起動中 (add が open を await 中) の id は commit 時点で破棄されるよう予約する
+   */
   remove(id: string): Promise<void>;
+  /** 終端操作。全グループを close し、以後の add / replace を拒否する */
   closeAll(): Promise<void>;
   has(id: string): boolean;
   ids(): ReadonlyArray<string>;
   /**
-   * 1 グループ分の Flume を開いて FlumeRunning を返す。timeoutMs を指定すると open() を
-   * AbortSignal でレース掛けし、超過時に新グループ起動を中止する。失敗時の rollback は
-   * Flume 本体に任せる
+   * 1 グループ分の Flume を開いて FlumeRunning を返す。timeoutMs を指定すると AbortSignal を
+   * ctx.signal として各 source へ注入し、超過時に abort して進行中の connect ごと中止する
+   * (source 側は base クラスが signal を購読して stop() を発火する)。
+   * 失敗時の rollback は Flume 本体に任せる
    */
   private openGroup;
+  private createPendingOpen;
   private wrapOnEvent;
+  private wrapOnError;
 }
 //#endregion
-//#region lib/time/time-catchup.d.ts
-type Props = {
-  cron: FlumeCron;
-  lastFiredAt: number;
-  now: number;
-  policy: FlumeCatchupPolicy;
-};
+//#region lib/utils/attempt.d.ts
 /**
- * `lastFiredAt` から `now` までに過ぎ去った cron マッチを policy に従って列挙する。
+ * 関数を呼び出して throw / async reject を `T | Error` に変換する。
  *
- * - policy.mode === "off"      : 常に空配列
- * - policy.mode === "lastOnly" : 過ぎ去ったマッチの中で最も新しいもの 1 件
- * - policy.mode === "missed"   : maxWindowMs (既定 24h) 以内に過ぎ去ったすべてのマッチ。
- *                                window の起点は `max(lastFiredAt, now - maxWindowMs)`
+ * - sync 関数を渡すと `T | Error` を返す
+ * - Promise を返す関数を渡すと `Promise<T | Error>` を返す (caller は `await` する)
+ * - `new X(...)` や `obj.method(...)` は `() => new X(...)` のようにアローで包む
  *
- * 到達不能 cron や catastrophic な policy ミス指定の場合は FlumeParseError を返す
- * (catchup 列挙だけで失敗させる。source 本体の起動は別判断)
+ * sync / async は arrow の戻り型から TS が推論する。
+ * native Promise でない thenable (DI モックや promise ライブラリ) の reject も
+ * `Promise.resolve` で吸収する — その代償として、`.then` メソッドを持つ純粋な値を
+ * sync overload で返すことはできない (Promise 扱いになる)
+ */
+declare function attempt<T>(fn: () => Promise<T>): Promise<T | Error>;
+declare function attempt<T>(fn: () => T): T | Error;
+//#endregion
+//#region lib/utils/is-record.d.ts
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+//#endregion
+//#region lib/utils/safe-error-message.d.ts
+type Props$5 = {
+  error: unknown;
+};
+/**
+ * 任意の値から人が読めるメッセージ文字列を取り出す。
+ * `Error.message` getter / `Symbol.toPrimitive` / `toString` / `valueOf` が throw しても固定文字列に fallback。
+ * `instanceof` 自体が throw する値 (revoked Proxy 等) にも耐える。自身は決して throw しない
+ */
+declare function safeErrorMessage(props: Props$5): string;
+//#endregion
+//#region lib/utils/safe-invoke-callback.d.ts
+type Props$4 = {
+  fn: () => void;
+  onError: (error: Error) => void;
+};
+/**
+ * fire-and-forget でユーザーコールバックを呼び出す。sync throw と async reject のどちらも
+ * `onError(Error)` に正規化して通知。`onError` 自身が throw しても外に漏らさない。
+ * 戻り値を持たない fire-and-forget 専用のため log/出力先には依存しない (caller が onError で決める)
+ */
+declare function safeInvokeCallback(props: Props$4): void;
+//#endregion
+//#region lib/utils/safe-json-parse.d.ts
+declare function safeJsonParse(raw: string): unknown | FlumeParseError;
+//#endregion
+//#region lib/utils/safe-normalize-error.d.ts
+type Props$3 = {
+  value: unknown;
+};
+/**
+ * 任意の値を `Error` インスタンスへ正規化する。すでに Error ならそのまま返し、
+ * それ以外は `safeErrorMessage` で安全な文字列化を経由して new Error する。
+ * `instanceof` 自体が throw する値 (revoked Proxy 等) や Error コンストラクタが throw する
+ * 病的環境でも fallback を返し、決して throw しない
+ */
+declare function safeNormalizeError(props: Props$3): Error;
+//#endregion
+//#region lib/utils/safe-now.d.ts
+type Props$2 = {
+  deps: Pick<FlumeRuntimeDeps, "now">;
+};
+/**
+ * `deps.now()` を保護する。throw / 非数値 / 非有限値が返った場合は `Date.now()` へ
+ * フォールバックする (0 を返すと epoch 1970 が TTL / cron / レート計算へ伝播するため)。
+ * `Date.now` 自体まで壊れている病的環境でのみ 0 を返す。
+ * IO 境界のため呼び出し側はこの戻り値を信頼できる
+ */
+declare function safeNow(props: Props$2): number;
+//#endregion
+//#region lib/utils/safe-random.d.ts
+type Props$1 = {
+  deps: Pick<FlumeRuntimeDeps, "random">;
+};
+/**
+ * `deps.random()` を保護する。throw / 範囲外値 / 非数値が返った場合は `Math.random()` へ
+ * フォールバックする。0 以上 1 未満 (Math.random と同等) の値のみそのまま透過。
+ * `Math.random` 自体まで壊れている病的環境でのみ 0.5 を返す
+ */
+declare function safeRandom(props: Props$1): number;
+//#endregion
+//#region lib/utils/safe-read-text.d.ts
+type Props = {
+  response: Response;
+  context: string;
+};
+/**
+ * `response.text()` を保護する。body 読み取り中の reject (接続切断 / 解凍失敗 / 二重消費) を
+ * `FlumeHttpError` (status / cause 保持) に変換する。DI モックの `status` getter が throw
+ * しても reject しない。log には書かない (呼び出し側で書く)
+ */
+declare function safeReadText(props: Props): Promise<string | FlumeHttpError>;
+//#endregion
+//#region lib/utils/safe-stringify.d.ts
+/**
+ * `JSON.stringify` を `string | Error` に変換するラッパ。
+ * cyclic / BigInt / throwing toJSON など標準が throw するケースを Error として返す。
+ * `undefined` / function / symbol は `JSON.stringify` が (型定義に反して) `undefined` を
+ * 返すため、これも Error に正規化して戻り値を必ず string にする
  */
-declare function flumeCollectCatchupMatches(props: Props): ReadonlyArray<number> | FlumeParseError;
+declare function safeStringify(value: unknown): string | Error;
 //#endregion
-export { Flume, type FlumeCatchupPolicy, type FlumeCloseError, FlumeClosed, FlumeConfluence, type FlumeConfluenceItem, type FlumeConfluenceItemHandler, FlumeConnectionError, type FlumeDiscordEvent, type FlumeDiscordSourceOptions, type FlumeErrorHandler, type FlumeEvent, type FlumeEventHandler, type FlumeGatewayMessage, type FlumeGitHubEvent, type FlumeGitHubNotification, type FlumeGitHubSourceOptions, FlumeHttpError, type FlumeLog, type FlumeLogHandler, type FlumeLogInput, type FlumeLogLevel, type FlumeOptions, 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 FlumeStatePersister, type FlumeStatus, type FlumeStreamHandler, type FlumeStreamItem, type FlumeStreamOptions, type FlumeStreamOverflow, type FlumeTimeEvent, type FlumeTimeMessage, FlumeTimeSource, type FlumeTimeSourceOptions, type FlumeTimeSourceState, type FlumeTimeTick, type FlumeTimerHandle, createFlumeDefaultDeps, flumeCollectCatchupMatches };
+export { Flume, type FlumeCatchupPolicy, type FlumeCloseError, FlumeClosed, FlumeConfluence, type FlumeConfluenceItem, type FlumeConfluenceItemHandler, FlumeConnectionError, type FlumeCustomEvent, type FlumeDiscordEvent, type FlumeDiscordSourceOptions, type FlumeErrorHandler, type FlumeEvent, type FlumeEventHandler, type FlumeGatewayMessage, type FlumeGitHubEvent, type FlumeGitHubNotification, type FlumeGitHubSourceOptions, FlumeHttpError, type FlumeLog, type FlumeLogHandler, type FlumeLogInput, type FlumeLogLevel, type FlumeOptions, 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 FlumeStatePersister, type FlumeStatus, type FlumeStreamHandler, type FlumeStreamItem, type FlumeStreamOptions, type FlumeStreamOverflow, type FlumeTimeEvent, type FlumeTimeMessage, type FlumeTimeSourceOptions, type FlumeTimeSourceState, type FlumeTimeTick, type FlumeTimerHandle, attempt, createFlumeDefaultDeps, isRecord, safeErrorMessage, safeInvokeCallback, safeJsonParse, safeNormalizeError, safeNow, safeRandom, safeReadText, safeStringify };