@interactive-inc/flume 0.10.1 → 0.11.0

package/dist/schedule-reconnect.js

@@ -0,0 +1,153 @@
+import { a as safeInvokeCallback, d as safeErrorMessage, l as attempt } from "./flume-source.js";
+import { n as safeRandom, r as FlumeConnectionError } from "./safe-stringify.js";
+//#region lib/reconnector.ts
+const MAX_TIMER_DELAY_MS = 2147483647;
+/**
+* 指数バックオフ + ジッタ付きの再接続スケジューラ。
+* setTimeout コールバック内のユーザー fn が throw / reject しても reconnect ループは止めない。
+* `generation` は clearTimeout が throw して古い timer が生き残った場合でも
+* stale な発火を無視するための世代トークン
+*/
+var FlumeReconnector = class {
+	props;
+	currentAttempt = 0;
+	isAborted = false;
+	timer = null;
+	generation = 0;
+	constructor(props) {
+		this.props = props;
+	}
+	get attempt() {
+		return this.currentAttempt;
+	}
+	get aborted() {
+		return this.isAborted;
+	}
+	schedule(fn, options) {
+		if (this.isAborted) return { kind: "refused" };
+		if (this.currentAttempt >= this.props.maxAttempts) {
+			this.generation++;
+			this.clearTimer();
+			return { kind: "exhausted" };
+		}
+		this.clearTimer();
+		const delay = this.computeDelay(options?.minDelayMs ?? 0);
+		const scheduledGeneration = ++this.generation;
+		const timerResult = attempt(() => this.props.deps.setTimeout(() => this.runRetry(fn, scheduledGeneration), delay));
+		if (timerResult instanceof Error) {
+			this.props.log.error({
+				action: "reconnect.timer.schedule.error",
+				message: safeErrorMessage({ error: timerResult }),
+				error: timerResult
+			});
+			this.timer = null;
+			return { kind: "refused" };
+		}
+		this.currentAttempt++;
+		this.timer = timerResult;
+		return {
+			kind: "scheduled",
+			delayMs: delay
+		};
+	}
+	reset() {
+		this.currentAttempt = 0;
+	}
+	cancel() {
+		this.isAborted = true;
+		this.generation++;
+		this.clearTimer();
+	}
+	runRetry(fn, scheduledGeneration) {
+		if (this.isAborted) return;
+		if (scheduledGeneration !== this.generation) return;
+		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;
+	}
+	computeDelay(minDelayMs) {
+		const jittered = Math.min(this.props.baseDelay * 2 ** this.currentAttempt, this.props.maxDelay) * (.5 + safeRandom({ deps: this.props.deps }) * .5);
+		return Math.min(Math.max(jittered, Number.isFinite(minDelayMs) && minDelayMs > 0 ? minDelayMs : 0), MAX_TIMER_DELAY_MS);
+	}
+};
+//#endregion
+//#region lib/schedule-reconnect.ts
+/**
+* 接続が落ちた際の共通再接続スケジューラ。
+* 再接続の設定状況 (無効 / 中止 / 試行尽き / timer 拒否) を見極めてからステータス遷移する。
+* - reconnector が無ければ reconnect.disabled を info ログし disconnected へ
+* - cancel 済みなら reconnect.aborted を info ログし disconnected へ
+* - schedule() が exhausted なら reconnect.exhausted を error ログし disconnected へ
+* - schedule() が refused (timer 予約失敗) なら reconnect.refused を error ログし disconnected へ
+*   ("reconnecting" のまま発火しない timer を待ち続けるハングを防ぐ)
+* - scheduled なら 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 schedule = props.reconnector.schedule(props.retry, { minDelayMs: props.minDelayMs });
+	if (schedule.kind === "exhausted") {
+		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;
+	}
+	if (schedule.kind === "refused") {
+		const error = new FlumeConnectionError("reconnect timer could not be scheduled");
+		props.log.error({
+			action: "reconnect.refused",
+			message: safeErrorMessage({ error }),
+			error
+		});
+		props.setStatus("disconnected");
+		return;
+	}
+	props.setStatus("reconnecting");
+	props.log.info({
+		action: "reconnect.scheduled",
+		message: `next attempt in ${Math.round(schedule.delayMs)}ms`,
+		detail: {
+			attempt: props.reconnector.attempt,
+			delayMs: Math.round(schedule.delayMs)
+		}
+	});
+}
+//#endregion
+export { FlumeReconnector as n, scheduleFlumeReconnect as t };

package/dist/slack.js

@@ -1,10 +1,9 @@
-import { a as safeNow, c as attempt, i as FlumeLogger, l as safeNormalizeError, o as FlumeStartError, s as FlumeParseError, t as FlumeSource, u as safeErrorMessage } from "./flume-source.js";
-import { t as FlumeConnectionError } from "./connection-error.js";
-import { t as FlumeHttpError } from "./http-error.js";
-import { n as scheduleFlumeReconnect, r as FlumeReconnector, t as safeStringify } from "./safe-stringify.js";
+import { c as FlumeParseError, d as safeErrorMessage, i as safeNow, l as attempt, r as FlumeLogger, s as FlumeStartError, t as FlumeSource, u as safeNormalizeError } from "./flume-source.js";
+import { r as FlumeConnectionError, t as safeStringify } from "./safe-stringify.js";
+import { n as FlumeHttpError, t as safeReadText } from "./safe-read-text.js";
 import { t as isRecord } from "./is-record.js";
 import { t as safeJsonParse } from "./safe-json-parse.js";
-import { t as safeReadText } from "./safe-read-text.js";
+import { n as FlumeReconnector, t as scheduleFlumeReconnect } from "./schedule-reconnect.js";
 import { z } from "zod/v4";
 //#region lib/slack/extract-slack-meta.ts
 function flumeExtractSlackMeta(envelope) {

package/dist/time.d.ts

@@ -9,7 +9,7 @@ import { t as FlumeParseError } from "./parse-error.js";
  * options.statePersister + options.catchupPolicy を渡すと:
  *  1. 起動時に lastFiredAt を読み出す
  *  2. lastFiredAt から now までの過ぎ去った cron マッチを policy に従って再発火する
- *  3. 各 tick 後に lastFiredAt を保存する (best-effort, ブロックしない)
+ *  3. 各 tick 後に lastFiredAt を順番に保存する (tick をブロックせず、停止時に完了を待つ)
  *
  * 保存先や形式は flume の関知ではなく statePersister の実装が決める (純粋 DI)。
  *
@@ -21,9 +21,11 @@ declare class FlumeTimeSource extends FlumeSource {
   private readonly options;
   readonly name: "time";
   private scheduler;
+  private readonly loadCancelled;
+  private readonly saveQueue;
   constructor(options: FlumeTimeSourceOptions);
   protected connect(ctx: FlumeSourceStartContext): Promise<Error | null>;
-  protected disconnect(): void;
+  protected disconnect(): Promise<void>;
   private handleTick;
   private emitTick;
   private runCatchup;

package/dist/time.js

@@ -1,4 +1,4 @@
-import { a as safeNow, c as attempt, i as FlumeLogger, l as safeNormalizeError, o as FlumeStartError, r as safeInvokeCallback, s as FlumeParseError, t as FlumeSource, u as safeErrorMessage } from "./flume-source.js";
+import { a as safeInvokeCallback, c as FlumeParseError, d as safeErrorMessage, i as safeNow, l as attempt, n as FlumeSerialQueue, r as FlumeLogger, s as FlumeStartError, t as FlumeSource, u as safeNormalizeError } from "./flume-source.js";
 import { t as isRecord } from "./is-record.js";
 //#region lib/time/parse-cron-field.ts
 /**
@@ -437,7 +437,7 @@ function hasMatchBefore(cron, windowStart, recentStart) {
 * options.statePersister + options.catchupPolicy を渡すと:
 *  1. 起動時に lastFiredAt を読み出す
 *  2. lastFiredAt から now までの過ぎ去った cron マッチを policy に従って再発火する
-*  3. 各 tick 後に lastFiredAt を保存する (best-effort, ブロックしない)
+*  3. 各 tick 後に lastFiredAt を順番に保存する (tick をブロックせず、停止時に完了を待つ)
 *
 * 保存先や形式は flume の関知ではなく statePersister の実装が決める (純粋 DI)。
 *
@@ -449,6 +449,8 @@ var FlumeTimeSource = class extends FlumeSource {
 	options;
 	name = "time";
 	scheduler = null;
+	loadCancelled = Promise.withResolvers();
+	saveQueue = new FlumeSerialQueue();
 	constructor(options) {
 		super();
 		this.options = options;
@@ -468,6 +470,7 @@ var FlumeTimeSource = class extends FlumeSource {
 		}
 		const persister = this.options.statePersister ?? null;
 		const lastFiredAt = persister === null ? null : await this.loadLastFiredAt(ctx, persister);
+		if (this.isStopped) return new FlumeStartError("Time source: stopped during state load");
 		this.scheduler = new FlumeTimeScheduler({
 			cron,
 			onLog: ctx.log.handler,
@@ -492,9 +495,11 @@ var FlumeTimeSource = class extends FlumeSource {
 		});
 		return null;
 	}
-	disconnect() {
+	async disconnect() {
+		this.loadCancelled.resolve(null);
 		this.scheduler?.stop();
 		this.scheduler = null;
+		await this.saveQueue.drain();
 	}
 	handleTick(ctx, firedAt, persister) {
 		this.emitTick(ctx, firedAt);
@@ -565,7 +570,7 @@ var FlumeTimeSource = class extends FlumeSource {
 		this.setStatus("disconnected", "scheduler halted");
 	}
 	async loadLastFiredAt(ctx, persister) {
-		const result = await attempt(() => persister.load());
+		const result = await Promise.race([attempt(() => persister.load()), this.loadCancelled.promise]);
 		if (result instanceof Error) {
 			ctx.log.warn({
 				action: "time.state.load.error",
@@ -579,15 +584,14 @@ var FlumeTimeSource = class extends FlumeSource {
 		return result.lastFiredAt;
 	}
 	saveLastFiredAt(ctx, persister, lastFiredAt) {
-		safeInvokeCallback({
-			fn: () => persister.save({ lastFiredAt }),
-			onError: (error) => {
-				ctx.log.warn({
-					action: "time.state.save.error",
-					message: safeErrorMessage({ error: safeNormalizeError({ value: error }) }),
-					error
-				});
-			}
+		this.saveQueue.add(async () => {
+			const error = await attempt(() => persister.save({ lastFiredAt }));
+			if (!(error instanceof Error)) return;
+			ctx.log.warn({
+				action: "time.state.save.error",
+				message: safeErrorMessage({ error }),
+				error
+			});
 		});
 	}
 	safeMessage(ctx, tick) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interactive-inc/flume",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "description": "Unified notification listener for Discord, Slack, and GitHub. Raw WebSocket + fetch + Zod. No SDK dependencies.",
   "keywords": [
     "discord",
@@ -76,9 +76,16 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "typescript": "^5.6.0",
-    "vite-plus": "^0.1.21",
-    "vitest": "^4.1.9"
+    "typescript": "^5.9.3",
+    "vite-plus": "^0.1.24",
+    "vitest": "^4.1.10"
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "bun",
+      "version": "1.3.14",
+      "onFail": "download"
+    }
   },
   "engines": {
     "node": ">=22"

package/dist/connection-error.js

@@ -1,16 +0,0 @@
-//#region lib/errors/connection-error.ts
-/**
-* 接続失敗を表す。Discord Gateway / Slack Socket Mode / その他 WebSocket 系の close で発生。
-* `code` は接続が落ちた際の close code (Discord は 4xxx 帯が再接続可否を示す)
-*/
-var FlumeConnectionError = class extends Error {
-	code;
-	constructor(message, options) {
-		super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
-		this.name = "FlumeConnectionError";
-		this.code = options?.code ?? null;
-		Object.freeze(this);
-	}
-};
-//#endregion
-export { FlumeConnectionError as t };

package/dist/http-error.js

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