@interactive-inc/flume 0.9.4 → 0.10.1

package/README.md

@@ -168,9 +168,10 @@ class MyWebhookSource extends FlumeSource {
     const res = await ctx.deps.fetch(this.options.url)
     const payload = await res.json()
     this.emit({
-      source: this.name as "discord", // declare your own discriminant via FlumeEvent extension
+      source: "custom",
+      sourceName: this.name,
       type: "webhook",
-      data: payload,
+      data: { payload },
       meta: { event_type: "webhook" },
       receivedAt: ctx.deps.now(),
     })

package/dist/discord.d.ts

@@ -1,4 +1,4 @@
-import { r as FlumeDiscordSourceOptions, t as FlumeSource, w as FlumeSourceStartContext } from "./flume-source.js";
+import { O as FlumeSourceStartContext, s as FlumeDiscordSourceOptions, t as FlumeSource } from "./flume-source.js";
 
 //#region lib/discord/discord-source.d.ts
 declare class FlumeDiscordSource extends FlumeSource {
@@ -10,10 +10,24 @@ declare class FlumeDiscordSource extends FlumeSource {
   protected connect(ctx: FlumeSourceStartContext): Promise<Error | null>;
   protected disconnect(): void;
   private hasWebSocket;
+  /**
+   * gateway を 1 接続 = 1 インスタンスで作り直す。`session` は前回接続から引き継いだ
+   * resume 可能な session (無ければ IDENTIFY)。await 後は `this.gateway` でなく local な
+   * `gateway` を参照する (並行する close() が `this.gateway` を null 化しても壊れない)
+   */
   private connectInternal;
   private dispatch;
   private safeExtractMeta;
+  /**
+   * status は発火元 gateway に束縛して受ける。交換済み (stale) な gateway からの通知は無視し、
+   * 現行 gateway の状態を誤って上書きしない
+   */
   private handleGatewayStatus;
+  /**
+   * resume 可能な session はこの時点で捕捉して次の gateway へ引き継ぐ (gateway インスタンスは
+   * 接続ごとに破棄されるため)。resume できない = IDENTIFY し直す再接続には identify rate limit
+   * (1 回 / 5 秒) を守る下限 delay を敷く
+   */
   private scheduleReconnect;
 }
 //#endregion

package/dist/discord.js

@@ -1,4 +1,4 @@
-import { a as FlumeStartError, c as safeNormalizeError, i as safeNow, l as safeErrorMessage, n as safeInvokeCallback, o as FlumeParseError, r as FlumeLogger, s as attempt, t as FlumeSource } from "./flume-source.js";
+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 { t as FlumeConnectionError } from "./connection-error.js";
 import { i as safeRandom, n as scheduleFlumeReconnect, r as FlumeReconnector, t as safeStringify } from "./safe-stringify.js";
 import { t as isRecord } from "./is-record.js";
@@ -56,17 +56,23 @@ var FlumeDiscordHeartbeat = class {
 	initialTimer = null;
 	intervalTimer = null;
 	ackReceived = true;
+	generation = 0;
 	constructor(props) {
 		this.props = props;
 	}
 	start(intervalMs) {
 		this.stop();
 		this.ackReceived = true;
+		const scheduledGeneration = ++this.generation;
 		const initialDelay = safeRandom({ deps: this.props.deps }) * intervalMs;
 		const initialResult = attempt(() => this.props.deps.setTimeout(() => {
+			if (scheduledGeneration !== this.generation) return;
 			this.initialTimer = null;
 			this.safeFire();
-			const intervalResult = attempt(() => this.props.deps.setInterval(() => this.safeFire(), intervalMs));
+			if (scheduledGeneration !== this.generation) return;
+			const intervalResult = attempt(() => this.props.deps.setInterval(() => {
+				if (scheduledGeneration === this.generation) this.safeFire();
+			}, intervalMs));
 			if (intervalResult instanceof Error) {
 				this.props.log.error({
 					action: "heartbeat.interval.schedule.error",
@@ -74,6 +80,7 @@ var FlumeDiscordHeartbeat = class {
 					error: intervalResult
 				});
 				this.intervalTimer = null;
+				this.safeZombie();
 			} else this.intervalTimer = intervalResult;
 		}, initialDelay));
 		if (initialResult instanceof Error) {
@@ -83,9 +90,12 @@ var FlumeDiscordHeartbeat = class {
 				error: initialResult
 			});
 			this.initialTimer = null;
+			return initialResult;
 		} else this.initialTimer = initialResult;
+		return null;
 	}
 	stop() {
+		this.generation++;
 		if (this.initialTimer !== null) {
 			const handle = this.initialTimer;
 			const r = attempt(() => this.props.deps.clearTimeout(handle));
@@ -110,6 +120,9 @@ var FlumeDiscordHeartbeat = class {
 	ack() {
 		this.ackReceived = true;
 	}
+	request() {
+		this.safeFire();
+	}
 	isRunning() {
 		return this.initialTimer !== null || this.intervalTimer !== null;
 	}
@@ -125,6 +138,18 @@ var FlumeDiscordHeartbeat = class {
 			}
 		});
 	}
+	safeZombie() {
+		safeInvokeCallback({
+			fn: this.props.onZombie,
+			onError: (error) => {
+				this.props.log.error({
+					action: "heartbeat.zombie.error",
+					message: safeErrorMessage({ error }),
+					error
+				});
+			}
+		});
+	}
 	fire() {
 		if (!this.ackReceived) {
 			this.props.onZombie();
@@ -138,22 +163,35 @@ var FlumeDiscordHeartbeat = class {
 //#region lib/discord/discord-gateway-message-schema.ts
 const FlumeGatewayMessageSchema = z.object({
 	op: z.number(),
-	d: z.unknown(),
-	s: z.number().nullable(),
-	t: z.string().nullable()
+	d: z.unknown().optional(),
+	s: z.number().nullish(),
+	t: z.string().nullish()
 });
 //#endregion
 //#region lib/discord/parse-discord-gateway-message.ts
+/**
+* 省略された d / s / t は null に正規化して返す (schema は nullish を許すが、
+* 消費側が undefined を意識しなくて済むようここで揃える)
+*/
 function parseFlumeDiscordGatewayMessage(raw) {
 	const json = safeJsonParse(raw);
 	if (json instanceof FlumeParseError) return json;
 	const parsed = FlumeGatewayMessageSchema.safeParse(json);
 	if (!parsed.success) return new FlumeParseError(`invalid gateway message frame (${raw.length} bytes)`, { cause: parsed.error });
-	return parsed.data;
+	return {
+		op: parsed.data.op,
+		d: parsed.data.d ?? null,
+		s: parsed.data.s ?? null,
+		t: parsed.data.t ?? null
+	};
 }
 //#endregion
 //#region lib/discord/discord-gateway.ts
 const GATEWAY_URL = "wss://gateway.discord.gg/?v=10&encoding=json";
+const GATEWAY_VERSION = "10";
+const GATEWAY_ENCODING = "json";
+const DEFAULT_HANDSHAKE_TIMEOUT_MS = 3e4;
+const FORCED_CLOSE_FALLBACK_MS = 5e3;
 const OP_DISPATCH = 0;
 const OP_HEARTBEAT = 1;
 const OP_IDENTIFY = 2;
@@ -181,10 +219,13 @@ const TERMINAL_CLOSE_CODES = new Set([
 	4013,
 	4014
 ]);
+const NON_RESUMABLE_CLOSE_CODES = new Set([4007, 4009]);
 /**
 * Discord Gateway v10 の最小実装。HELLO -> IDENTIFY/RESUME -> READY/RESUMED -> dispatch を扱う。
 * READY 後の WebSocket 切断のみ `onStatus("disconnected")` を発火し source 側で再接続する。
 * 終端 close code (4004 / 401x) を受けた場合は stopped 化して再接続を抑止。
+* close code 4007/4009 と INVALID_SESSION (resumable=false) では session を破棄する
+* (source が次の gateway へ session を引き継ぐ前にここでリセットしておく)。
 * IO 境界は全て `attempt` 経由で扱い、コンストラクタ throw も `FlumeConnectionError` として返す
 * (`connect()` は決して reject しない)
 */
@@ -193,14 +234,18 @@ var FlumeDiscordGateway = class {
 	log;
 	ws = null;
 	heartbeat = null;
-	currentSession = FlumeDiscordGatewaySession.empty();
+	currentSession;
 	isStoppedFlag = false;
 	hasConnected = false;
 	pendingResolve = null;
 	pendingResolved = false;
 	invalidSessionTimer = null;
+	handshakeTimer = null;
+	forcedCloseFallbackTimer = null;
+	teardownDone = false;
 	constructor(props) {
 		this.props = props;
+		this.currentSession = props.session ?? FlumeDiscordGatewaySession.empty();
 		this.log = new FlumeLogger({
 			source: "discord.gateway",
 			handler: props.onLog,
@@ -224,7 +269,7 @@ var FlumeDiscordGateway = class {
 			});
 			return Promise.resolve(error);
 		}
-		const target = url ?? GATEWAY_URL;
+		const target = this.resolveTargetUrl(url);
 		const hostResult = attempt(() => new URL(target).hostname);
 		const host = hostResult instanceof Error ? "unknown" : hostResult;
 		this.log.info({
@@ -233,6 +278,7 @@ var FlumeDiscordGateway = class {
 		});
 		this.pendingResolved = false;
 		this.hasConnected = false;
+		this.teardownDone = false;
 		return new Promise((resolve) => {
 			this.pendingResolve = resolve;
 			const socketResult = attempt(() => new WS(target));
@@ -262,10 +308,13 @@ var FlumeDiscordGateway = class {
 					message: safeErrorMessage({ error }),
 					error
 				});
+				this.closeSocket({ ws: socket });
 				this.ws = null;
 				this.pendingResolved = true;
 				resolve(error);
+				return;
 			}
+			this.armHandshakeTimer();
 		});
 	}
 	disconnect() {
@@ -276,6 +325,8 @@ var FlumeDiscordGateway = class {
 		this.isStoppedFlag = true;
 		this.heartbeat?.stop();
 		this.clearInvalidSessionTimer();
+		this.clearForcedCloseFallbackTimer();
+		this.completeConnect(new FlumeConnectionError("gateway disconnected before ready"));
 		this.closeSocket({
 			ws: this.ws,
 			code: 1e3,
@@ -286,7 +337,153 @@ var FlumeDiscordGateway = class {
 	isConnected() {
 		return this.ws !== null && this.ws.readyState === WS_OPEN;
 	}
+	/**
+	* resume 時は Discord の `resume_gateway_url` に query (?v=10&encoding=json) を付与する
+	* (Discord が返す URL に query は付かない)。URL が壊れている場合は session を破棄して
+	* 通常の Gateway URL で IDENTIFY し直す
+	*/
+	resolveTargetUrl(url) {
+		if (url === void 0) return GATEWAY_URL;
+		const rebuilt = attempt(() => {
+			const parsed = new URL(url);
+			parsed.searchParams.set("v", GATEWAY_VERSION);
+			parsed.searchParams.set("encoding", GATEWAY_ENCODING);
+			return parsed.toString();
+		});
+		if (rebuilt instanceof Error) {
+			this.log.warn({
+				action: "resume.url.invalid",
+				message: `resume url unparseable, dropping session and identifying fresh: ${safeErrorMessage({ error: rebuilt })}`
+			});
+			this.currentSession = this.currentSession.withReset();
+			return GATEWAY_URL;
+		}
+		return rebuilt;
+	}
+	resolveHandshakeTimeoutMs() {
+		const configured = this.props.handshakeTimeoutMs;
+		if (typeof configured !== "number" || !Number.isFinite(configured) || configured <= 0) return DEFAULT_HANDSHAKE_TIMEOUT_MS;
+		return configured;
+	}
+	armHandshakeTimer() {
+		this.clearHandshakeTimer();
+		const timeoutMs = this.resolveHandshakeTimeoutMs();
+		const timerResult = attempt(() => this.props.deps.setTimeout(() => {
+			this.handshakeTimer = null;
+			this.onHandshakeTimeout(timeoutMs);
+		}, timeoutMs));
+		if (timerResult instanceof Error) {
+			const error = new FlumeConnectionError(`handshake timer scheduling failed: ${safeErrorMessage({ error: timerResult })}`, { cause: timerResult });
+			this.log.error({
+				action: "handshake.timer.schedule.error",
+				message: safeErrorMessage({ error }),
+				error
+			});
+			this.handshakeTimer = null;
+			this.completeConnect(error);
+			this.forceClose({
+				code: 4e3,
+				reason: "handshake timer failure"
+			});
+			return;
+		}
+		this.handshakeTimer = timerResult;
+	}
+	clearHandshakeTimer() {
+		if (this.handshakeTimer === null) return;
+		const handle = this.handshakeTimer;
+		const result = attempt(() => this.props.deps.clearTimeout(handle));
+		if (result instanceof Error) this.log.error({
+			action: "handshake.timer.clear.error",
+			message: safeErrorMessage({ error: result }),
+			error: result
+		});
+		this.handshakeTimer = null;
+	}
+	/**
+	* READY/RESUMED が期限内に来なかった half-open socket。connect() を Error で解放して
+	* source の再接続経路に乗せ、socket は強制 close する (close event が来なければ
+	* fallback が teardown を合成する)
+	*/
+	onHandshakeTimeout(timeoutMs) {
+		if (this.pendingResolved) return;
+		const error = new FlumeConnectionError(`handshake timeout after ${timeoutMs}ms (no READY/RESUMED)`);
+		this.log.error({
+			action: "handshake.timeout",
+			message: safeErrorMessage({ error }),
+			error
+		});
+		this.completeConnect(error);
+		this.forceClose({
+			code: 4e3,
+			reason: "handshake timeout"
+		});
+	}
+	/**
+	* zombie / handshake timeout / malformed HELLO で自発的に接続を落とす。死んだ TCP 経路では
+	* close event が届かないことがあるため fallback timer で teardown を保証する。heartbeat は
+	* 即座に止めて onZombie が interval ごとに再発火するのを防ぐ。close code は resume 可能な
+	* 4000 を使う (4009 は session 無効化コードと衝突する)
+	*/
+	forceClose(input) {
+		this.heartbeat?.stop();
+		this.closeSocket({
+			ws: input.ws ?? this.ws,
+			code: input.code,
+			reason: input.reason
+		});
+		this.armForcedCloseFallback();
+	}
+	armForcedCloseFallback() {
+		if (this.teardownDone) return;
+		if (this.forcedCloseFallbackTimer !== null) return;
+		const timerResult = attempt(() => this.props.deps.setTimeout(() => {
+			this.forcedCloseFallbackTimer = null;
+			this.synthesizeTeardown();
+		}, FORCED_CLOSE_FALLBACK_MS));
+		if (timerResult instanceof Error) {
+			this.log.error({
+				action: "ws.close.fallback.schedule.error",
+				message: safeErrorMessage({ error: timerResult }),
+				error: timerResult
+			});
+			this.forcedCloseFallbackTimer = null;
+			this.synthesizeTeardown();
+			return;
+		}
+		this.forcedCloseFallbackTimer = timerResult;
+	}
+	clearForcedCloseFallbackTimer() {
+		if (this.forcedCloseFallbackTimer === null) return;
+		const handle = this.forcedCloseFallbackTimer;
+		const result = attempt(() => this.props.deps.clearTimeout(handle));
+		if (result instanceof Error) this.log.error({
+			action: "ws.close.fallback.clear.error",
+			message: safeErrorMessage({ error: result }),
+			error: result
+		});
+		this.forcedCloseFallbackTimer = null;
+	}
+	/**
+	* 強制 close 後に close event が届かなかった場合の合成 teardown。`onClose` と排他で
+	* 一度だけ実行する。READY 後なら `onStatus("disconnected")` で source の再接続に繋ぐ
+	* (READY 前は connect() の Error 解決が既に再接続を駆動しているため通知しない)
+	*/
+	synthesizeTeardown() {
+		if (this.teardownDone) return;
+		this.teardownDone = true;
+		this.log.warn({
+			action: "ws.close.synthesized",
+			message: "close event not received after forced close, synthesizing teardown"
+		});
+		this.ws = null;
+		this.heartbeat?.stop();
+		this.clearInvalidSessionTimer();
+		if (!this.pendingResolved) this.completeConnect(new FlumeConnectionError("WebSocket force-closed (no close event)"));
+		if (this.hasConnected && !this.isStoppedFlag) this.props.onStatus("disconnected");
+	}
 	completeConnect(error) {
+		this.clearHandshakeTimer();
 		if (this.pendingResolved || !this.pendingResolve) return;
 		this.pendingResolved = true;
 		this.pendingResolve(error);
@@ -337,7 +534,7 @@ var FlumeDiscordGateway = class {
 				length: raw.length
 			}
 		});
-		if (parsed.s !== null) this.currentSession = this.currentSession.withSeq(parsed.s);
+		if (typeof parsed.s === "number") this.currentSession = this.currentSession.withSeq(parsed.s);
 		if (parsed.op === OP_HELLO) return this.onHello(parsed);
 		if (parsed.op === OP_HEARTBEAT_ACK) return this.onHeartbeatAck();
 		if (parsed.op === OP_HEARTBEAT) return this.onHeartbeatRequest();
@@ -352,7 +549,23 @@ var FlumeDiscordGateway = class {
 	}
 	onHello(msg) {
 		const d = isRecord(msg.d) ? msg.d : null;
-		const interval = d && typeof d.heartbeat_interval === "number" ? d.heartbeat_interval : 0;
+		const rawInterval = d === null ? null : d.heartbeat_interval;
+		if (typeof rawInterval !== "number" || !Number.isFinite(rawInterval) || rawInterval <= 0) {
+			const error = new FlumeConnectionError("malformed HELLO: heartbeat_interval is not a finite number > 0");
+			this.log.error({
+				action: "gateway.hello.invalid",
+				message: safeErrorMessage({ error }),
+				error,
+				detail: { intervalType: typeof rawInterval }
+			});
+			this.completeConnect(error);
+			this.forceClose({
+				code: 4e3,
+				reason: "malformed HELLO"
+			});
+			return;
+		}
+		const interval = rawInterval;
 		this.log.info({
 			action: "gateway.hello",
 			message: `heartbeat_interval=${interval}ms`,
@@ -377,14 +590,22 @@ var FlumeDiscordGateway = class {
 					action: "heartbeat.zombie",
 					message: "no ACK received, closing connection"
 				});
-				this.closeSocket({
-					ws: this.ws,
-					code: 4009,
+				this.forceClose({
+					code: 4e3,
 					reason: "zombie connection"
 				});
 			}
 		});
-		this.heartbeat.start(interval);
+		const heartbeatError = this.heartbeat.start(interval);
+		if (heartbeatError instanceof Error) {
+			const error = new FlumeConnectionError(`heartbeat timer scheduling failed: ${safeErrorMessage({ error: heartbeatError })}`, { cause: heartbeatError });
+			this.completeConnect(error);
+			this.forceClose({
+				code: 4e3,
+				reason: "heartbeat timer failure"
+			});
+			return;
+		}
 		if (this.currentSession.canResume()) this.sendResume();
 		else this.sendIdentify();
 	}
@@ -400,17 +621,14 @@ var FlumeDiscordGateway = class {
 			action: "heartbeat.requested",
 			message: "server requested heartbeat"
 		});
-		this.send({
-			op: OP_HEARTBEAT,
-			d: this.currentSession.seq
-		});
+		this.heartbeat?.request();
 	}
 	onReconnectRequest(socket) {
 		this.log.info({
 			action: "ws.reconnect.requested",
 			message: "server requested reconnect"
 		});
-		this.closeSocket({
+		this.forceClose({
 			ws: socket,
 			code: 4e3,
 			reason: "reconnect requested"
@@ -428,7 +646,7 @@ var FlumeDiscordGateway = class {
 		this.clearInvalidSessionTimer();
 		const timerResult = attempt(() => this.props.deps.setTimeout(() => {
 			this.invalidSessionTimer = null;
-			this.closeSocket({
+			this.forceClose({
 				ws: socket,
 				code: 4e3,
 				reason: "invalid session"
@@ -441,6 +659,11 @@ var FlumeDiscordGateway = class {
 				error: timerResult
 			});
 			this.invalidSessionTimer = null;
+			this.forceClose({
+				ws: socket,
+				code: 4e3,
+				reason: "invalid session timer failure"
+			});
 		} else this.invalidSessionTimer = timerResult;
 	}
 	onDispatch(msg) {
@@ -475,6 +698,16 @@ var FlumeDiscordGateway = class {
 		});
 	}
 	onClose(ev) {
+		this.clearForcedCloseFallbackTimer();
+		if (this.teardownDone) {
+			this.log.debug({
+				action: "ws.close.stale",
+				message: `ignored close after synthesized teardown (code=${ev.code})`,
+				detail: { code: ev.code }
+			});
+			return;
+		}
+		this.teardownDone = true;
 		const terminal = TERMINAL_CLOSE_CODES.has(ev.code);
 		this.log.info({
 			action: "ws.close",
@@ -488,6 +721,14 @@ var FlumeDiscordGateway = class {
 		this.ws = null;
 		this.heartbeat?.stop();
 		this.clearInvalidSessionTimer();
+		if (NON_RESUMABLE_CLOSE_CODES.has(ev.code)) {
+			this.log.info({
+				action: "session.reset",
+				message: `close code ${ev.code} invalidates session, next attempt will identify`,
+				detail: { code: ev.code }
+			});
+			this.currentSession = this.currentSession.withReset();
+		}
 		if (terminal) this.isStoppedFlag = true;
 		if (this.hasConnected || terminal) this.props.onStatus("disconnected");
 		if (!this.pendingResolved) {
@@ -642,12 +883,14 @@ function flumeExtractDiscordMeta(eventName, eventData) {
 	const meta = { event_type: eventName };
 	if (typeof eventData.channel_id === "string") meta.channel_id = eventData.channel_id;
 	if (typeof eventData.guild_id === "string") meta.guild_id = eventData.guild_id;
-	if (isRecord(eventData.author) && typeof eventData.author.id === "string") meta.user_id = eventData.author.id;
+	if (typeof eventData.user_id === "string") meta.user_id = eventData.user_id;
+	else if (isRecord(eventData.author) && typeof eventData.author.id === "string") meta.user_id = eventData.author.id;
 	return meta;
 }
 //#endregion
 //#region lib/discord/discord-source.ts
 const DEFAULT_INTENTS = FlumeDiscordGatewayIntents.Guilds | FlumeDiscordGatewayIntents.GuildMessages | FlumeDiscordGatewayIntents.DirectMessages;
+const IDENTIFY_MIN_RECONNECT_DELAY_MS = 5e3;
 var FlumeDiscordSource = class extends FlumeSource {
 	options;
 	name = "discord";
@@ -688,28 +931,37 @@ var FlumeDiscordSource = class extends FlumeSource {
 		}
 		return result;
 	}
-	async connectInternal(ctx, resumeUrl) {
+	/**
+	* gateway を 1 接続 = 1 インスタンスで作り直す。`session` は前回接続から引き継いだ
+	* resume 可能な session (無ければ IDENTIFY)。await 後は `this.gateway` でなく local な
+	* `gateway` を参照する (並行する close() が `this.gateway` を null 化しても壊れない)
+	*/
+	async connectInternal(ctx, session) {
 		this.setStatus("connecting");
-		this.gateway = new FlumeDiscordGateway({
+		const gateway = new FlumeDiscordGateway({
 			token: this.options.token,
 			intents: this.options.intents ?? DEFAULT_INTENTS,
+			handshakeTimeoutMs: this.options.handshakeTimeoutMs,
+			session,
 			onLog: ctx.log.handler,
 			deps: ctx.deps,
 			onDispatch: (eventName, eventData) => this.dispatch(ctx, eventName, eventData),
-			onStatus: (status) => this.handleGatewayStatus(ctx, status)
+			onStatus: (status) => this.handleGatewayStatus(ctx, gateway, status)
 		});
-		const error = await this.gateway.connect(resumeUrl);
+		this.gateway = gateway;
+		const resumeUrl = session !== void 0 && session.canResume() && session.resumeUrl !== null ? session.resumeUrl : void 0;
+		const error = await gateway.connect(resumeUrl);
 		if (error instanceof FlumeConnectionError) {
 			ctx.log.error({
 				action: "connect.failed",
 				message: safeErrorMessage({ error }),
 				error
 			});
-			if (this.gateway.isStopped || !this.reconnector || this.reconnector.aborted) {
+			if (gateway.isStopped || !this.reconnector || this.reconnector.aborted) {
 				this.setStatus("disconnected");
 				return error;
 			}
-			this.scheduleReconnect(ctx);
+			this.scheduleReconnect(ctx, gateway);
 		}
 		return null;
 	}
@@ -736,7 +988,18 @@ var FlumeDiscordSource = class extends FlumeSource {
 		}
 		return result;
 	}
-	handleGatewayStatus(ctx, status) {
+	/**
+	* status は発火元 gateway に束縛して受ける。交換済み (stale) な gateway からの通知は無視し、
+	* 現行 gateway の状態を誤って上書きしない
+	*/
+	handleGatewayStatus(ctx, gateway, status) {
+		if (gateway !== this.gateway) {
+			ctx.log.debug({
+				action: "gateway.status.stale",
+				message: `ignored ${status} from replaced gateway`
+			});
+			return;
+		}
 		if (status === "connected") {
 			if (this.reconnector && this.reconnector.attempt > 0) ctx.log.info({
 				action: "reconnect.reset",
@@ -746,20 +1009,26 @@ var FlumeDiscordSource = class extends FlumeSource {
 			this.setStatus("connected");
 			return;
 		}
-		if (this.gateway?.isStopped) {
+		if (gateway.isStopped) {
 			this.setStatus("disconnected");
 			return;
 		}
-		this.scheduleReconnect(ctx);
+		this.scheduleReconnect(ctx, gateway);
 	}
-	scheduleReconnect(ctx) {
-		const url = this.gateway?.session.resumeUrl ?? void 0;
+	/**
+	* resume 可能な session はこの時点で捕捉して次の gateway へ引き継ぐ (gateway インスタンスは
+	* 接続ごとに破棄されるため)。resume できない = IDENTIFY し直す再接続には identify rate limit
+	* (1 回 / 5 秒) を守る下限 delay を敷く
+	*/
+	scheduleReconnect(ctx, gateway) {
+		const capturedSession = gateway.session.canResume() ? gateway.session : void 0;
 		scheduleFlumeReconnect({
 			reconnector: this.reconnector,
 			log: ctx.log,
 			setStatus: (status) => this.setStatus(status),
+			minDelayMs: capturedSession === void 0 ? IDENTIFY_MIN_RECONNECT_DELAY_MS : void 0,
 			retry: () => {
-				this.connectInternal(ctx, url).catch((err) => {
+				this.connectInternal(ctx, capturedSession).catch((err) => {
 					const error = safeNormalizeError({ value: err });
 					ctx.log.error({
 						action: "reconnect.unhandled",