@interactive-inc/flume 0.3.0 → 0.4.0

package/dist/safe-read-text-DgrJ4Uhl.js

@@ -0,0 +1,20 @@
+import { l as safeErrorMessage } from "./safe-invoke-callback-EpWXwfwp.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 };

package/dist/safe-stringify-BWS-uXZP.js

@@ -0,0 +1,172 @@
+import { l as safeErrorMessage, s as attempt, t as safeInvokeCallback } from "./safe-invoke-callback-EpWXwfwp.js";
+import { t as FlumeConnectionError } from "./connection-error-HUO3PC3G.js";
+//#region lib/utils/safe-random.ts
+/**
+* `deps.random()` を保護する。throw / 範囲外値 / 非数値が返った場合は 0.5 を返す。
+* 0 以上 1 未満 (Math.random と同等) の値のみそのまま透過
+*/
+function safeRandom(props) {
+	try {
+		const value = props.deps.random();
+		if (typeof value !== "number" || !Number.isFinite(value)) return .5;
+		if (value < 0 || value >= 1) return .5;
+		return value;
+	} catch {
+		return .5;
+	}
+}
+//#endregion
+//#region lib/reconnector.ts
+/**
+* 指数バックオフ + ジッタ付きの再接続スケジューラ。
+* `schedule()` の戻り値: 正の delay = 予約成功 / -1 = 試行上限到達 / 0 = cancel 済み or 内部 timer 拒否。
+* setTimeout コールバック内のユーザー fn が throw / reject しても reconnect ループは止めない
+*/
+var FlumeReconnector = class {
+	props;
+	currentAttempt = 0;
+	isAborted = false;
+	timer = null;
+	constructor(props) {
+		this.props = props;
+	}
+	get attempt() {
+		return this.currentAttempt;
+	}
+	get aborted() {
+		return this.isAborted;
+	}
+	schedule(fn) {
+		if (this.isAborted) return 0;
+		if (this.currentAttempt >= this.props.maxAttempts) return -1;
+		this.clearTimer();
+		const delay = this.nextDelay();
+		const timerResult = attempt(() => this.props.deps.setTimeout(() => this.runRetry(fn), delay));
+		if (timerResult instanceof Error) {
+			this.props.log.error({
+				action: "reconnect.timer.schedule.error",
+				message: safeErrorMessage({ error: timerResult }),
+				error: timerResult
+			});
+			this.timer = null;
+			return 0;
+		}
+		this.timer = timerResult;
+		return delay;
+	}
+	reset() {
+		this.currentAttempt = 0;
+	}
+	cancel() {
+		this.isAborted = true;
+		this.clearTimer();
+	}
+	runRetry(fn) {
+		this.timer = null;
+		safeInvokeCallback({
+			fn,
+			onError: (error) => {
+				this.props.log.error({
+					action: "reconnect.timer.error",
+					message: safeErrorMessage({ error }),
+					error
+				});
+			}
+		});
+	}
+	clearTimer() {
+		if (this.timer === null) return;
+		const handle = this.timer;
+		const result = attempt(() => this.props.deps.clearTimeout(handle));
+		if (result instanceof Error) this.props.log.error({
+			action: "reconnect.timer.clear.error",
+			message: safeErrorMessage({ error: result }),
+			error: result
+		});
+		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;
+	}
+};
+//#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/schedule-reconnect.ts
+/**
+* 接続が落ちた際の共通再接続スケジューラ。
+* 再接続の設定状況 (無効 / 中止 / 試行尽き) を見極めてからステータス遷移する。
+* - reconnector が無ければ reconnect.disabled を info ログし disconnected へ
+* - cancel 済みなら reconnect.aborted を info ログし disconnected へ
+* - schedule() が -1 を返したら reconnect.exhausted を error ログし disconnected へ
+* - それ以外は reconnecting へ遷移し reconnect.scheduled を info ログ
+*/
+function scheduleFlumeReconnect(props) {
+	if (!props.reconnector) {
+		props.log.info({
+			action: "reconnect.disabled",
+			message: "reconnect is disabled, staying disconnected"
+		});
+		props.setStatus("disconnected");
+		return;
+	}
+	if (props.reconnector.aborted) {
+		props.log.info({
+			action: "reconnect.aborted",
+			message: "reconnector cancelled, staying disconnected"
+		});
+		props.setStatus("disconnected");
+		return;
+	}
+	const delay = props.reconnector.schedule(props.retry);
+	if (delay === -1) {
+		const error = new FlumeConnectionError(`reconnect exhausted after ${props.reconnector.attempt} attempts`);
+		props.log.error({
+			action: "reconnect.exhausted",
+			message: safeErrorMessage({ error }),
+			error
+		});
+		props.setStatus("disconnected");
+		return;
+	}
+	props.setStatus("reconnecting");
+	props.log.info({
+		action: "reconnect.scheduled",
+		message: `next attempt in ${Math.round(delay)}ms`,
+		detail: {
+			attempt: props.reconnector.attempt,
+			delayMs: Math.round(delay)
+		}
+	});
+}
+//#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` に変換するだけのラッパ。
+* cyclic / BigInt / throwing toJSON など標準が throw するケースを Error として返す
+*/
+function safeStringify(value) {
+	return attempt(() => JSON.stringify(value));
+}
+//#endregion
+export { FlumeReconnector as a, resolveFlumeReconnectConfig as i, isRecord as n, safeRandom as o, scheduleFlumeReconnect as r, safeStringify as t };

package/dist/serial-queue-B9LoBc64.js

@@ -0,0 +1,162 @@
+import { a as FlumeParseError, c as safeNormalizeError, l as safeErrorMessage, s as attempt, t as safeInvokeCallback } from "./safe-invoke-callback-EpWXwfwp.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
+//#region lib/source-helpers/flume-signal-registry.ts
+/**
+* Source 群に共通する AbortSignal の登録・解除・abort 判定を集約する。
+* 異常な polyfill / poisoned getter / 凍結 signal を吸収するため境界呼び出しは全て try/catch で
+* 包み、失敗時はログに流して握り潰す
+*/
+var FlumeSignalRegistry = class {
+	props;
+	signals = [];
+	constructor(props) {
+		this.props = props;
+	}
+	isAnyAborted(extra) {
+		if (this.isAborted(extra)) return true;
+		for (const signal of this.signals) if (this.isAborted(signal)) return true;
+		return false;
+	}
+	register(signal) {
+		if (!signal) return;
+		const result = attempt(() => signal.addEventListener("abort", this.props.onAbort, { once: true }));
+		if (result instanceof Error) {
+			const error = safeNormalizeError({ value: result });
+			this.props.log.error({
+				action: "signal.addListener.failed",
+				message: safeErrorMessage({ error }),
+				error
+			});
+			return;
+		}
+		this.signals.push(signal);
+	}
+	unregisterAll() {
+		for (const signal of this.signals) {
+			const result = attempt(() => signal.removeEventListener("abort", this.props.onAbort));
+			if (result instanceof Error) {
+				const error = safeNormalizeError({ value: result });
+				this.props.log.error({
+					action: "signal.removeListener.failed",
+					message: safeErrorMessage({ error }),
+					error
+				});
+			}
+		}
+		this.signals.length = 0;
+	}
+	get size() {
+		return this.signals.length;
+	}
+	isAborted(signal) {
+		if (!signal) return false;
+		const result = attempt(() => signal.aborted === true);
+		return result instanceof Error ? true : result;
+	}
+};
+//#endregion
+//#region lib/source-helpers/flume-status-emitter.ts
+/**
+* Source の `currentStatus` と `onStatus` 通知を集約する。
+* 同一 (status, detail) の連続遷移は冪等に握り潰し、ユーザーコールバックは `safeInvokeCallback`
+* 経由で例外を隔離する
+*/
+var FlumeStatusEmitter = class {
+	props;
+	currentStatus = "disconnected";
+	currentDetail = null;
+	constructor(props) {
+		this.props = props;
+	}
+	get value() {
+		return this.currentStatus;
+	}
+	set(next, detail) {
+		const normalizedDetail = detail ?? null;
+		if (this.currentStatus === next && this.currentDetail === normalizedDetail) return;
+		const prev = this.currentStatus;
+		const suffix = detail ? ` (${detail})` : "";
+		this.props.log.info({
+			action: "status",
+			message: `${prev} → ${next}${suffix}`,
+			detail: {
+				from: prev,
+				to: next,
+				reason: normalizedDetail
+			}
+		});
+		this.currentStatus = next;
+		this.currentDetail = normalizedDetail;
+		const onStatus = this.props.onStatus;
+		if (!onStatus) return;
+		safeInvokeCallback({
+			fn: detail !== void 0 ? () => onStatus(next, detail) : () => onStatus(next),
+			onError: (error) => {
+				this.props.log.error({
+					action: "onStatus.error",
+					message: safeErrorMessage({ error }),
+					error
+				});
+			}
+		});
+	}
+};
+//#endregion
+//#region lib/utils/serial-queue.ts
+/**
+* 投入順を保ったまま task を直列実行する。各 task は前の完了を待ってから走る。
+* task が throw しても後続には伝播しない (キュー自体は止まらない)。
+* maxDepth を超えた場合は新規 task を drop し onOverflow に通知。
+* cancel() 後の add() は no-op となり drain() は即時 resolve する
+*/
+var FlumeSerialQueue = class {
+	props;
+	chain = Promise.resolve();
+	depth = 0;
+	cancelled = false;
+	constructor(props = {}) {
+		this.props = props;
+	}
+	add(task) {
+		if (this.cancelled) return;
+		if (this.props.maxDepth !== void 0 && this.depth >= this.props.maxDepth) {
+			this.props.onOverflow?.({
+				dropped: 1,
+				depth: this.depth
+			});
+			return;
+		}
+		this.depth++;
+		this.chain = this.chain.then(async () => {
+			try {
+				await task();
+			} catch {} finally {
+				this.depth--;
+			}
+		});
+	}
+	async drain() {
+		await this.chain;
+	}
+	cancel() {
+		this.cancelled = true;
+		this.depth = 0;
+		this.chain = Promise.resolve();
+	}
+	size() {
+		return this.depth;
+	}
+	isCancelled() {
+		return this.cancelled;
+	}
+};
+//#endregion
+export { safeJsonParse as i, FlumeStatusEmitter as n, FlumeSignalRegistry as r, FlumeSerialQueue as t };

package/dist/slack.d.ts

@@ -1,6 +1,4 @@
-import { C as FlumeStartResult, D as FlumeSlackEnvelopeSchema, O as FlumeSlackConnectionResponseSchema, c as FlumeLogHandler, g as FlumeSlackSourceOptions, h as FlumeSlackEnvelope, o as FlumeHandler, p as FlumeRuntimeDeps, w as FlumeStatus } from "./types-Bm9uKUQz.js";
-import { t as FlumeConnectionError } from "./connection-error-BOk97djj.js";
-import { t as FlumeHttpError } from "./http-error-K-Ym4lfK.js";
+import { C as FlumeSourceStartOptions, T as FlumeStatus, _ as FlumeSlackEnvelope, c as FlumeHandler, y as FlumeSlackSourceOptions } from "./types-D-tO-Mh2.js";
 
 //#region lib/slack/slack-source.d.ts
 declare class FlumeSlackSource {
@@ -9,76 +7,26 @@ declare class FlumeSlackSource {
   private socket;
   private reconnector;
   private handler;
-  private currentStatus;
+  private internalController;
   private readonly log;
   private readonly deps;
   private readonly queue;
   private readonly seen;
+  private readonly signals;
+  private readonly statusEmitter;
+  private readonly onSignalAbort;
   constructor(options: FlumeSlackSourceOptions);
-  start(handler: FlumeHandler): Promise<FlumeStartResult>;
+  start(handler: FlumeHandler, options?: FlumeSourceStartOptions): Promise<Error | null>;
   stop(): Promise<void>;
   status(): FlumeStatus;
+  private hasWebSocket;
   private connectInternal;
   private handleMessage;
+  private safeExtractMeta;
   private scheduleReconnect;
-  private setStatus;
 }
 //#endregion
 //#region lib/slack/extract-slack-meta.d.ts
-declare function extractSlackMeta(envelope: FlumeSlackEnvelope): Record<string, string>;
+declare function flumeExtractSlackMeta(envelope: FlumeSlackEnvelope): Record<string, string>;
 //#endregion
-//#region lib/slack/slack-socket-mode.d.ts
-type Deps = Pick<FlumeRuntimeDeps, "WebSocket" | "fetch" | "now">;
-type Props$2 = {
-  appToken: string;
-  onMessage: (envelope: FlumeSlackEnvelope) => void;
-  onConnected: () => void;
-  onDisconnected: () => void;
-  onLog?: FlumeLogHandler;
-  deps: Deps;
-};
-declare class FlumeSlackSocketMode {
-  private readonly props;
-  private readonly log;
-  private ws;
-  stopped: boolean;
-  private pendingResolve;
-  private pendingResolved;
-  constructor(props: Props$2);
-  connect(): Promise<FlumeConnectionError | FlumeHttpError | null>;
-  disconnect(): void;
-  isConnected(): boolean;
-  private openSocket;
-  private completeConnect;
-  private onMessage;
-  private onClose;
-  private onError;
-}
-//#endregion
-//#region lib/slack/slack-seen-cache.d.ts
-type Props$1 = {
-  maxSize: number;
-};
-/**
- * Slack envelope_id の LRU 風キャッシュ。Slack は ack 失敗時に同じ envelope を再送するため、
- * source レイヤで handler への重複配送を防ぐ
- */
-declare class FlumeSlackSeenCache {
-  private readonly props;
-  private seen;
-  constructor(props: Props$1);
-  has(envelopeId: string): boolean;
-  add(envelopeId: string): void;
-  trim(): void;
-  get size(): number;
-}
-//#endregion
-//#region lib/slack/obtain-slack-url.d.ts
-type Props = {
-  appToken: string;
-  onLog?: FlumeLogHandler;
-  deps: Pick<FlumeRuntimeDeps, "fetch" | "now">;
-};
-declare function obtainSlackUrl(props: Props): Promise<string | FlumeHttpError>;
-//#endregion
-export { FlumeSlackConnectionResponseSchema, FlumeSlackEnvelopeSchema, FlumeSlackSeenCache, FlumeSlackSocketMode, FlumeSlackSource, extractSlackMeta, obtainSlackUrl };
+export { FlumeSlackSource, flumeExtractSlackMeta };