@gaodefa/daocore 2026.5.101 → 2026.5.102

package/dist/monitor-polling.runtime-9_E6Xhol.js

@@ -0,0 +1,883 @@
+import { a as normalizeLowercaseStringOrEmpty } from "./string-coerce-DyL154ka.js";
+import { i as formatErrorMessage } from "./errors-DcaOtHe_.js";
+import { n as sleepWithAbort, t as computeBackoff } from "./backoff-BQ4uO4hX.js";
+import { r as formatDurationPrecise } from "./format-duration-BrZ-AaEJ.js";
+import "./runtime-env-VHMtsJ2y.js";
+import "./string-coerce-runtime-DcopKqDR.js";
+import { a as isRecoverableTelegramNetworkError, t as TELEGRAM_GET_UPDATES_REQUEST_TIMEOUT_MS } from "./request-timeouts-DYVtzAge.js";
+import { a as listTelegramSpooledUpdateClaims, c as releaseTelegramSpooledUpdateClaim, i as isTelegramSpooledUpdateClaimOwnedByOtherLiveProcess, l as resolveTelegramIngressSpoolDir, n as deleteTelegramSpooledUpdate, o as listTelegramSpooledUpdates, r as failTelegramSpooledUpdateClaim, s as recoverStaleTelegramSpooledUpdateClaims, t as claimTelegramSpooledUpdate } from "./telegram-ingress-spool-D8a6fq_w.js";
+import { t as drainPendingDeliveries } from "./delivery-queue-runtime-CgrqvMWp.js";
+import "./ssrf-runtime-DLMlI4lg.js";
+import { n as createTransportActivityStatusPatch, t as createConnectedChannelStatusPatch } from "./gateway-runtime-BOYhuklV.js";
+import { n as readTelegramUpdateOffset, r as writeTelegramUpdateOffset, t as deleteTelegramUpdateOffset } from "./update-offset-store-B9MdjtQ1.js";
+import { O as withTelegramApiErrorLogging } from "./send-DDRSblAi.js";
+import { i as getTelegramSequentialKey, n as buildTelegramReplyFenceLaneKey, r as supersedeTelegramReplyFenceLane, t as createTelegramBot } from "./bot-DHwjnnce.js";
+import { Worker } from "node:worker_threads";
+import { run } from "@grammyjs/runner";
+//#region extensions/telegram/src/polling-liveness.ts
+var TelegramPollingLivenessTracker = class {
+	#lastGetUpdatesAt;
+	#lastGetUpdatesActivityAt;
+	#lastGetUpdatesStartedAt = null;
+	#lastGetUpdatesFinishedAt = null;
+	#lastGetUpdatesDurationMs = null;
+	#lastGetUpdatesOutcome = "not-started";
+	#lastGetUpdatesError = null;
+	#lastGetUpdatesOffset = null;
+	#inFlightGetUpdates = 0;
+	#stallDiagLoggedAt = 0;
+	constructor(options = {}) {
+		this.options = options;
+		this.#lastGetUpdatesAt = this.#now();
+		this.#lastGetUpdatesActivityAt = this.#lastGetUpdatesAt;
+	}
+	get inFlightGetUpdates() {
+		return this.#inFlightGetUpdates;
+	}
+	noteGetUpdatesStarted(payload, at = this.#now()) {
+		this.#lastGetUpdatesAt = at;
+		this.#lastGetUpdatesActivityAt = at;
+		this.#lastGetUpdatesStartedAt = at;
+		this.#lastGetUpdatesOffset = resolveGetUpdatesOffset(payload);
+		this.#inFlightGetUpdates += 1;
+		this.#lastGetUpdatesOutcome = "started";
+		this.#lastGetUpdatesError = null;
+	}
+	noteGetUpdatesSuccess(result, at = this.#now()) {
+		this.#lastGetUpdatesActivityAt = at;
+		this.#lastGetUpdatesFinishedAt = at;
+		this.#lastGetUpdatesDurationMs = this.#lastGetUpdatesStartedAt == null ? null : at - this.#lastGetUpdatesStartedAt;
+		this.#lastGetUpdatesOutcome = Array.isArray(result) ? `ok:${result.length}` : "ok";
+		this.options.onPollSuccess?.(at);
+	}
+	noteGetUpdatesSuccessCount(count, at = this.#now()) {
+		this.#lastGetUpdatesActivityAt = at;
+		this.#lastGetUpdatesFinishedAt = at;
+		this.#lastGetUpdatesDurationMs = this.#lastGetUpdatesStartedAt == null ? null : at - this.#lastGetUpdatesStartedAt;
+		const normalizedCount = Number.isFinite(count) ? Math.max(0, Math.floor(count)) : 0;
+		this.#lastGetUpdatesOutcome = `ok:${normalizedCount}`;
+		this.options.onPollSuccess?.(at);
+	}
+	noteGetUpdatesError(err, at = this.#now()) {
+		this.#lastGetUpdatesActivityAt = at;
+		this.#lastGetUpdatesFinishedAt = at;
+		this.#lastGetUpdatesDurationMs = this.#lastGetUpdatesStartedAt == null ? null : at - this.#lastGetUpdatesStartedAt;
+		this.#lastGetUpdatesOutcome = "error";
+		this.#lastGetUpdatesError = formatErrorMessage(err);
+	}
+	noteGetUpdatesFinished() {
+		this.#inFlightGetUpdates = Math.max(0, this.#inFlightGetUpdates - 1);
+	}
+	noteGetUpdatesActivity(at = this.#now()) {
+		this.#lastGetUpdatesActivityAt = at;
+	}
+	detectStall(params) {
+		const now = params.now ?? this.#now();
+		const activeElapsed = this.#inFlightGetUpdates > 0 && this.#lastGetUpdatesStartedAt != null ? now - this.#lastGetUpdatesActivityAt : 0;
+		const idleElapsed = this.#inFlightGetUpdates > 0 ? 0 : now - (this.#lastGetUpdatesFinishedAt ?? this.#lastGetUpdatesAt);
+		const elapsed = this.#inFlightGetUpdates > 0 ? activeElapsed : idleElapsed;
+		if (elapsed <= params.thresholdMs) return null;
+		if (this.#stallDiagLoggedAt && now - this.#stallDiagLoggedAt < params.thresholdMs / 2) return null;
+		this.#stallDiagLoggedAt = now;
+		return { message: `Polling stall detected (${this.#inFlightGetUpdates > 0 ? `active getUpdates stuck for ${formatDurationPrecise(elapsed)}` : `no completed getUpdates for ${formatDurationPrecise(elapsed)}`}); forcing restart. [diag ${this.formatDiagnosticFields("error")}]` };
+	}
+	formatDiagnosticFields(errorLabel) {
+		const error = this.#lastGetUpdatesError && errorLabel ? ` ${errorLabel}=${this.#lastGetUpdatesError}` : "";
+		return `inFlight=${this.#inFlightGetUpdates} outcome=${this.#lastGetUpdatesOutcome} startedAt=${this.#lastGetUpdatesStartedAt ?? "n/a"} finishedAt=${this.#lastGetUpdatesFinishedAt ?? "n/a"} durationMs=${this.#lastGetUpdatesDurationMs ?? "n/a"} offset=${this.#lastGetUpdatesOffset ?? "n/a"}${error}`;
+	}
+	#now() {
+		return this.options.now?.() ?? Date.now();
+	}
+};
+function resolveGetUpdatesOffset(payload) {
+	if (!payload || typeof payload !== "object" || !("offset" in payload)) return null;
+	const offset = payload.offset;
+	return typeof offset === "number" ? offset : null;
+}
+//#endregion
+//#region extensions/telegram/src/polling-status.ts
+function createTelegramPollingStatusPublisher(setStatus) {
+	return {
+		notePollingStart() {
+			setStatus?.({
+				mode: "polling",
+				connected: false,
+				lastConnectedAt: null,
+				lastEventAt: null,
+				lastTransportActivityAt: null
+			});
+		},
+		notePollSuccess(at = Date.now()) {
+			setStatus?.({
+				...createConnectedChannelStatusPatch(at),
+				...createTransportActivityStatusPatch(at),
+				mode: "polling",
+				lastError: null
+			});
+		},
+		notePollingError(error) {
+			setStatus?.({
+				mode: "polling",
+				connected: false,
+				lastError: error
+			});
+		},
+		notePollingStop() {
+			setStatus?.({
+				mode: "polling",
+				connected: false
+			});
+		}
+	};
+}
+//#endregion
+//#region extensions/telegram/src/polling-transport-state.ts
+var TelegramPollingTransportState = class {
+	#telegramTransport;
+	#transportDirty = false;
+	#disposed = false;
+	constructor(opts) {
+		this.opts = opts;
+		this.#telegramTransport = opts.initialTransport;
+	}
+	markDirty() {
+		this.#transportDirty = true;
+	}
+	acquireForNextCycle() {
+		if (this.#disposed) return;
+		const previous = this.#telegramTransport;
+		const nextTransport = this.#transportDirty || !previous ? this.opts.createTelegramTransport?.() ?? previous : previous;
+		if (this.#transportDirty && previous && nextTransport !== previous) {
+			this.opts.log("[telegram][diag] closing stale transport before rebuild");
+			this.#closeTransportAsync(previous, "stale-transport rebuild");
+		}
+		if (this.#transportDirty && nextTransport) this.opts.log("[telegram][diag] rebuilding transport for next polling cycle");
+		this.#telegramTransport = nextTransport;
+		this.#transportDirty = false;
+		return nextTransport;
+	}
+	async dispose() {
+		if (this.#disposed) return;
+		this.#disposed = true;
+		const transport = this.#telegramTransport;
+		this.#telegramTransport = void 0;
+		if (!transport) return;
+		try {
+			await transport.close();
+		} catch (err) {
+			this.opts.log(`[telegram][diag] failed to close transport during dispose: ${formatCloseError(err)}`);
+		}
+	}
+	#closeTransportAsync(transport, context) {
+		transport.close().catch((err) => {
+			this.opts.log(`[telegram][diag] failed to close transport (${context}): ${formatCloseError(err)}`);
+		});
+	}
+};
+function formatCloseError(err) {
+	if (err instanceof Error) return err.message;
+	return String(err);
+}
+//#endregion
+//#region extensions/telegram/src/telegram-ingress-worker.ts
+const createTelegramIngressWorker = (options) => {
+	const listeners = /* @__PURE__ */ new Set();
+	const worker = new Worker(new URL("./telegram-ingress-worker.runtime.js", import.meta.url), { workerData: options });
+	const taskPromise = new Promise((resolve, reject) => {
+		worker.once("error", reject);
+		worker.once("exit", (code) => {
+			if (code === 0) {
+				resolve();
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(`Telegram ingress worker exited with code ${code}`));
+		});
+	});
+	worker.on("message", (message) => {
+		for (const listener of listeners) listener(message);
+	});
+	return {
+		onMessage(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		async stop() {
+			worker.postMessage({ type: "stop" });
+			const timeout = setTimeout(() => {
+				worker.terminate();
+			}, 15e3);
+			timeout.unref?.();
+			try {
+				await taskPromise.catch(() => void 0);
+			} finally {
+				clearTimeout(timeout);
+			}
+		},
+		task() {
+			return taskPromise;
+		}
+	};
+};
+//#endregion
+//#region extensions/telegram/src/polling-session.ts
+const TELEGRAM_POLL_RESTART_POLICY = {
+	initialMs: 2e3,
+	maxMs: 3e4,
+	factor: 1.8,
+	jitter: .25
+};
+const DEFAULT_POLL_STALL_THRESHOLD_MS = 12e4;
+const MIN_POLL_STALL_THRESHOLD_MS = 3e4;
+const MAX_POLL_STALL_THRESHOLD_MS = 6e5;
+const POLL_WATCHDOG_INTERVAL_MS = 3e4;
+const POLL_STOP_GRACE_MS = 15e3;
+const ISOLATED_INGRESS_BACKLOG_STALL_MS = 25 * 6e4;
+const TELEGRAM_SPOOLED_HANDLER_ABORT_GRACE_MS = 5e3;
+const TELEGRAM_SPOOLED_HANDLER_TIMEOUT_ENV = "DAOCORE_TELEGRAM_SPOOLED_HANDLER_TIMEOUT_MS";
+const TELEGRAM_SPOOLED_DRAIN_START_LIMIT = 100;
+const TELEGRAM_SPOOLED_DRAIN_SCAN_LIMIT = TELEGRAM_SPOOLED_DRAIN_START_LIMIT * 10;
+const TELEGRAM_POLLING_CLIENT_TIMEOUT_FLOOR_SECONDS = Math.ceil(TELEGRAM_GET_UPDATES_REQUEST_TIMEOUT_MS / 1e3);
+function normalizeTelegramAccountId(accountId) {
+	return accountId?.trim() || "default";
+}
+const waitForGracefulStop = async (stop) => {
+	let timer;
+	try {
+		await Promise.race([stop(), new Promise((resolve) => {
+			timer = setTimeout(resolve, POLL_STOP_GRACE_MS);
+			timer.unref?.();
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+	}
+};
+const waitForSpooledHandlerTaskSettlement = async (params) => {
+	if (params.abortSignal?.aborted) return false;
+	let timer;
+	let removeAbortListener;
+	try {
+		return await Promise.race([params.task.then(() => true, () => true), new Promise((resolve) => {
+			timer = setTimeout(() => resolve(false), params.timeoutMs);
+			timer.unref?.();
+			const abort = () => resolve(false);
+			params.abortSignal?.addEventListener("abort", abort, { once: true });
+			removeAbortListener = () => params.abortSignal?.removeEventListener("abort", abort);
+		})]);
+	} finally {
+		if (timer) clearTimeout(timer);
+		removeAbortListener?.();
+	}
+};
+const resolvePollingStallThresholdMs = (value) => {
+	if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_POLL_STALL_THRESHOLD_MS;
+	return Math.min(MAX_POLL_STALL_THRESHOLD_MS, Math.max(MIN_POLL_STALL_THRESHOLD_MS, Math.floor(value)));
+};
+const activeSpooledUpdateHandlersByLane = /* @__PURE__ */ new Map();
+function resolveSpooledUpdateHandlerTimeoutMs(params) {
+	const candidates = [params.configured, Number(params.env?.[TELEGRAM_SPOOLED_HANDLER_TIMEOUT_ENV])];
+	for (const candidate of candidates) if (typeof candidate === "number" && Number.isFinite(candidate) && candidate > 0) return Math.floor(candidate);
+	return ISOLATED_INGRESS_BACKLOG_STALL_MS;
+}
+function resolvePositiveFiniteMs(value, fallback) {
+	if (typeof value === "number" && Number.isFinite(value) && value > 0) return Math.floor(value);
+	return fallback;
+}
+function buildSpooledUpdateHandlerKey(params) {
+	return `${params.spoolDir}\0${params.laneKey}`;
+}
+function isSpooledUpdateHandlerKeyForSpool(handlerKey, spoolDir) {
+	return handlerKey.startsWith(`${spoolDir}\0`);
+}
+var TelegramPollingSession = class {
+	#restartAttempts = 0;
+	#webhookCleared = false;
+	#forceRestarted = false;
+	#activeRunner;
+	#activeFetchAbort;
+	#spooledUpdateHandlerKeys = /* @__PURE__ */ new Set();
+	#transportState;
+	#status;
+	#stallThresholdMs;
+	#spooledUpdateHandlerTimeoutMs;
+	#spooledUpdateHandlerAbortGraceMs;
+	#deliveryDrainInFlight = false;
+	constructor(opts) {
+		this.opts = opts;
+		this.#transportState = new TelegramPollingTransportState({
+			log: opts.log,
+			initialTransport: opts.telegramTransport,
+			createTelegramTransport: opts.createTelegramTransport
+		});
+		this.#status = createTelegramPollingStatusPublisher(opts.setStatus);
+		this.#stallThresholdMs = resolvePollingStallThresholdMs(opts.stallThresholdMs);
+		this.#spooledUpdateHandlerTimeoutMs = resolveSpooledUpdateHandlerTimeoutMs({
+			...opts.isolatedIngress?.spooledUpdateHandlerTimeoutMs !== void 0 ? { configured: opts.isolatedIngress.spooledUpdateHandlerTimeoutMs } : {},
+			env: process.env
+		});
+		this.#spooledUpdateHandlerAbortGraceMs = resolvePositiveFiniteMs(opts.isolatedIngress?.spooledUpdateHandlerAbortGraceMs, TELEGRAM_SPOOLED_HANDLER_ABORT_GRACE_MS);
+	}
+	get activeRunner() {
+		return this.#activeRunner;
+	}
+	markForceRestarted() {
+		this.#forceRestarted = true;
+	}
+	markTransportDirty() {
+		this.#transportState.markDirty();
+	}
+	abortActiveFetch() {
+		this.#activeFetchAbort?.abort();
+	}
+	async runUntilAbort() {
+		this.#status.notePollingStart();
+		try {
+			while (!this.opts.abortSignal?.aborted) {
+				const bot = await this.#createPollingBot();
+				if (!bot) continue;
+				const cleanupState = await this.#ensureWebhookCleanup(bot);
+				if (cleanupState === "retry") continue;
+				if (cleanupState === "exit") return;
+				if ((this.opts.isolatedIngress?.enabled ? await this.#runIsolatedIngressCycle(bot) : await this.#runPollingCycle(bot)) === "exit") return;
+			}
+		} finally {
+			await this.#transportState.dispose();
+			this.#status.notePollingStop();
+		}
+	}
+	async #waitBeforeRestart(buildLine) {
+		this.#restartAttempts += 1;
+		const delayMs = computeBackoff(TELEGRAM_POLL_RESTART_POLICY, this.#restartAttempts);
+		const delay = formatDurationPrecise(delayMs);
+		this.opts.log(buildLine(delay));
+		try {
+			await sleepWithAbort(delayMs, this.opts.abortSignal);
+		} catch (sleepErr) {
+			if (this.opts.abortSignal?.aborted) return false;
+			throw sleepErr;
+		}
+		return true;
+	}
+	async #waitBeforeRetryOnRecoverableSetupError(err, logPrefix) {
+		if (this.opts.abortSignal?.aborted) return false;
+		if (!isRecoverableTelegramNetworkError(err, { context: "unknown" })) throw err;
+		return this.#waitBeforeRestart((delay) => `${logPrefix}: ${formatErrorMessage(err)}; retrying in ${delay}.`);
+	}
+	#drainPendingDeliveriesAfterReconnect() {
+		if (this.#deliveryDrainInFlight) return;
+		if (!this.opts.config) return;
+		this.#deliveryDrainInFlight = true;
+		const accountId = normalizeTelegramAccountId(this.opts.accountId);
+		const cfg = this.opts.config;
+		drainPendingDeliveries({
+			drainKey: `telegram:${accountId}`,
+			logLabel: "Telegram reconnect drain",
+			cfg,
+			log: {
+				info: (message) => this.opts.log(`[telegram][diag] ${message}`),
+				warn: (message) => this.opts.log(`[telegram] ${message}`),
+				error: (message) => this.opts.log(`[telegram] ${message}`)
+			},
+			selectEntry: (entry) => ({
+				match: entry.channel === "telegram" && normalizeTelegramAccountId(entry.accountId) === accountId,
+				bypassBackoff: false
+			})
+		}).catch((err) => {
+			this.opts.log(`[telegram] reconnect delivery drain failed: ${formatErrorMessage(err)}`);
+		}).finally(() => {
+			this.#deliveryDrainInFlight = false;
+		});
+	}
+	async #createPollingBot() {
+		const fetchAbortController = new AbortController();
+		this.#activeFetchAbort = fetchAbortController;
+		const telegramTransport = this.#transportState.acquireForNextCycle();
+		const persistedLastUpdateId = this.opts.getLastUpdateId();
+		const updateOffset = {
+			lastUpdateId: this.opts.isolatedIngress?.enabled ? null : persistedLastUpdateId,
+			persistenceFloorUpdateId: persistedLastUpdateId,
+			onUpdateId: this.opts.persistUpdateId
+		};
+		try {
+			return createTelegramBot({
+				token: this.opts.token,
+				runtime: this.opts.runtime,
+				proxyFetch: this.opts.proxyFetch,
+				config: this.opts.config,
+				accountId: this.opts.accountId,
+				botInfo: this.opts.botInfo,
+				fetchAbortSignal: fetchAbortController.signal,
+				minimumClientTimeoutSeconds: TELEGRAM_POLLING_CLIENT_TIMEOUT_FLOOR_SECONDS,
+				...updateOffset ? { updateOffset } : {},
+				telegramTransport
+			});
+		} catch (err) {
+			await this.#waitBeforeRetryOnRecoverableSetupError(err, "Telegram setup network error");
+			if (this.#activeFetchAbort === fetchAbortController) this.#activeFetchAbort = void 0;
+			return;
+		}
+	}
+	async #ensureWebhookCleanup(bot) {
+		if (this.#webhookCleared) return "ready";
+		try {
+			await withTelegramApiErrorLogging({
+				operation: "deleteWebhook",
+				runtime: this.opts.runtime,
+				fn: () => bot.api.deleteWebhook({ drop_pending_updates: false })
+			});
+			this.#webhookCleared = true;
+			return "ready";
+		} catch (err) {
+			if (isRecoverableTelegramNetworkError(err, { context: "unknown" })) {
+				this.opts.log(`[telegram] deleteWebhook failed with a recoverable network error; continuing to polling so getUpdates can confirm webhook state: ${formatErrorMessage(err)}`);
+				return "ready";
+			}
+			return await this.#waitBeforeRetryOnRecoverableSetupError(err, "Telegram webhook cleanup failed") ? "retry" : "exit";
+		}
+	}
+	async #claimSpooledUpdate(update) {
+		try {
+			return await claimTelegramSpooledUpdate(update);
+		} catch (err) {
+			this.opts.log(`[telegram][diag] spooled update ${update.updateId} claim failed; keeping for retry: ${formatErrorMessage(err)}`);
+			return null;
+		}
+	}
+	async #handleClaimedSpooledUpdate(params) {
+		try {
+			await params.bot.handleUpdate(params.update.update);
+		} catch (err) {
+			await this.#releaseFailedSpooledUpdate({
+				err,
+				update: params.update
+			});
+			return false;
+		}
+		try {
+			await deleteTelegramSpooledUpdate(params.update);
+			return true;
+		} catch (err) {
+			this.opts.log(`[telegram][diag] spooled update ${params.update.updateId} completed but processing marker cleanup failed: ${formatErrorMessage(err)}`);
+			return false;
+		}
+	}
+	async #releaseFailedSpooledUpdate(params) {
+		try {
+			await releaseTelegramSpooledUpdateClaim(params.update);
+		} catch (releaseErr) {
+			this.opts.log(`[telegram][diag] spooled update ${params.update.updateId} failed and could not be requeued: ${formatErrorMessage(releaseErr)}`);
+			return;
+		}
+		this.opts.log(`[telegram][diag] spooled update ${params.update.updateId} failed; keeping for retry: ${formatErrorMessage(params.err)}`);
+	}
+	async #waitForSpooledUpdateHandlers() {
+		await Promise.allSettled([...this.#spooledUpdateHandlerKeys].map((handlerKey) => activeSpooledUpdateHandlersByLane.get(handlerKey)?.task).filter((task) => Boolean(task)));
+	}
+	#spooledUpdateLaneKey(update) {
+		return getTelegramSequentialKey({
+			update: update.update,
+			...this.opts.botInfo ? { me: this.opts.botInfo } : {}
+		});
+	}
+	#activeSpooledUpdateLaneKeysForSpool(spoolDir) {
+		const laneKeys = /* @__PURE__ */ new Set();
+		for (const [handlerKey, handler] of activeSpooledUpdateHandlersByLane) if (isSpooledUpdateHandlerKeyForSpool(handlerKey, spoolDir)) laneKeys.add(handler.laneKey);
+		return laneKeys;
+	}
+	async #drainSpooledUpdates(params) {
+		const activeLaneKeys = this.#activeSpooledUpdateLaneKeysForSpool(params.spoolDir);
+		await recoverStaleTelegramSpooledUpdateClaims({
+			spoolDir: params.spoolDir,
+			staleMs: 0,
+			shouldRecover: (claim) => !activeLaneKeys.has(this.#spooledUpdateLaneKey(claim)) && !isTelegramSpooledUpdateClaimOwnedByOtherLiveProcess(claim)
+		});
+		const claimedLaneKeys = new Set((await listTelegramSpooledUpdateClaims({ spoolDir: params.spoolDir })).map((claim) => this.#spooledUpdateLaneKey(claim)));
+		const updates = await listTelegramSpooledUpdates({
+			spoolDir: params.spoolDir,
+			limit: TELEGRAM_SPOOLED_DRAIN_SCAN_LIMIT
+		});
+		const blockedByLane = /* @__PURE__ */ new Set();
+		let started = 0;
+		for (const update of updates) {
+			const laneKey = this.#spooledUpdateLaneKey(update);
+			if (this.opts.abortSignal?.aborted) break;
+			const handlerKey = buildSpooledUpdateHandlerKey({
+				spoolDir: params.spoolDir,
+				laneKey
+			});
+			if (activeSpooledUpdateHandlersByLane.has(handlerKey)) {
+				blockedByLane.add(handlerKey);
+				continue;
+			}
+			if (claimedLaneKeys.has(laneKey)) continue;
+			const claimedUpdate = await this.#claimSpooledUpdate(update);
+			if (!claimedUpdate) {
+				claimedLaneKeys.add(laneKey);
+				continue;
+			}
+			const handler = this.#handleClaimedSpooledUpdate({
+				bot: params.bot,
+				update: claimedUpdate
+			});
+			const state = {
+				handlerKey,
+				laneKey,
+				task: handler,
+				update: claimedUpdate,
+				updateId: update.updateId,
+				startedAt: Date.now()
+			};
+			activeSpooledUpdateHandlersByLane.set(handlerKey, state);
+			this.#spooledUpdateHandlerKeys.add(handlerKey);
+			claimedLaneKeys.add(laneKey);
+			handler.finally(() => {
+				if (activeSpooledUpdateHandlersByLane.get(handlerKey) === state) activeSpooledUpdateHandlersByLane.delete(handlerKey);
+				this.#spooledUpdateHandlerKeys.delete(handlerKey);
+			});
+			started += 1;
+			if (started >= TELEGRAM_SPOOLED_DRAIN_START_LIMIT) break;
+		}
+		return {
+			blockedByLane,
+			started
+		};
+	}
+	#detectTimedOutSpooledHandler(blockedHandlerKeys) {
+		const now = Date.now();
+		let timedOut = null;
+		for (const handlerKey of blockedHandlerKeys) {
+			const handler = activeSpooledUpdateHandlersByLane.get(handlerKey);
+			if (!handler || handler.timedOutAt !== void 0) continue;
+			const ageMs = now - handler.startedAt;
+			if (ageMs <= this.#spooledUpdateHandlerTimeoutMs) continue;
+			if (!timedOut || ageMs > timedOut.ageMs) timedOut = {
+				handler,
+				ageMs
+			};
+		}
+		return timedOut;
+	}
+	async #recoverTimedOutSpooledHandler(blockedHandlerKeys) {
+		const timedOutHandler = this.#detectTimedOutSpooledHandler(blockedHandlerKeys);
+		if (!timedOutHandler) return null;
+		const handler = timedOutHandler.handler;
+		const activeHandler = activeSpooledUpdateHandlersByLane.get(handler.handlerKey);
+		if (!activeHandler || activeHandler !== handler) return null;
+		const age = formatDurationPrecise(timedOutHandler.ageMs);
+		activeHandler.timedOutAt = Date.now();
+		const message = `Telegram isolated polling spool handler timed out behind update ${handler.updateId} on lane ${handler.laneKey} after ${age}; marking the update failed, aborting active reply work, and restarting isolated ingress so later updates can drain.`;
+		activeHandler.timeoutMessage = message;
+		try {
+			if (!await failTelegramSpooledUpdateClaim({
+				update: handler.update,
+				reason: "handler-timeout",
+				message
+			})) {
+				this.opts.log(`[telegram][diag] timed out spooled update ${handler.updateId} no longer had a processing marker to fail.`);
+				this.#status.notePollingError(message);
+				return {
+					handlerKey: handler.handlerKey,
+					restart: false
+				};
+			}
+		} catch (err) {
+			this.opts.log(`[telegram][diag] timed out spooled update ${handler.updateId} could not be marked failed: ${formatErrorMessage(err)}`);
+			this.#status.notePollingError(message);
+			return {
+				handlerKey: handler.handlerKey,
+				restart: false
+			};
+		}
+		if (!supersedeTelegramReplyFenceLane(buildTelegramReplyFenceLaneKey({
+			accountId: this.opts.accountId,
+			sequentialKey: handler.laneKey
+		}))) this.opts.log(`[telegram][diag] timed out spooled update ${handler.updateId} had no active reply fence on lane ${handler.laneKey}; keeping the lane guarded until the handler stops.`);
+		if (!await waitForSpooledHandlerTaskSettlement({
+			task: handler.task,
+			timeoutMs: this.#spooledUpdateHandlerAbortGraceMs,
+			abortSignal: this.opts.abortSignal
+		}) && activeSpooledUpdateHandlersByLane.get(handler.handlerKey) === activeHandler) {
+			this.opts.log(`[telegram][diag] timed out spooled update ${handler.updateId} did not stop within ${formatDurationPrecise(this.#spooledUpdateHandlerAbortGraceMs)} after reply abort; keeping lane ${handler.laneKey} guarded.`);
+			this.#status.notePollingError(message);
+			return {
+				handlerKey: handler.handlerKey,
+				restart: false
+			};
+		}
+		if (activeSpooledUpdateHandlersByLane.get(handler.handlerKey) === activeHandler) activeSpooledUpdateHandlersByLane.delete(handler.handlerKey);
+		this.#spooledUpdateHandlerKeys.delete(handler.handlerKey);
+		this.opts.log(`[telegram] ${message}`);
+		this.#status.notePollingError(message);
+		return {
+			handlerKey: handler.handlerKey,
+			restart: true
+		};
+	}
+	async #runIsolatedIngressCycle(bot) {
+		const ingress = this.opts.isolatedIngress;
+		if (!ingress?.enabled) return this.#runPollingCycle(bot);
+		try {
+			await bot.init();
+		} catch (err) {
+			return await this.#waitBeforeRetryOnRecoverableSetupError(err, "Telegram bot init failed") ? "continue" : "exit";
+		}
+		const spoolDir = ingress.spoolDir ?? resolveTelegramIngressSpoolDir({ accountId: this.opts.accountId });
+		const worker = (ingress.createWorker ?? createTelegramIngressWorker)({
+			token: this.opts.token,
+			accountId: this.opts.accountId,
+			initialUpdateId: this.opts.getLastUpdateId(),
+			spoolDir,
+			apiRoot: ingress.apiRoot,
+			timeoutSeconds: ingress.timeoutSeconds,
+			network: ingress.network,
+			proxy: ingress.proxy
+		});
+		let stopWorkerPromise;
+		const stopWorker = () => {
+			stopWorkerPromise ??= Promise.resolve(worker.stop()).then(() => void 0).catch(() => {});
+			return stopWorkerPromise;
+		};
+		this.opts.log(`[telegram][diag] isolated polling ingress started spool=${spoolDir}`);
+		const pollState = {
+			startedAt: null,
+			offset: null,
+			outcome: "not-started"
+		};
+		const liveness = new TelegramPollingLivenessTracker();
+		let consecutiveDrainFailures = 0;
+		let restartRequested = false;
+		let stalledRestart = false;
+		let forceCycleTimer;
+		let forceCycleResolve;
+		const forceCyclePromise = new Promise((resolve) => {
+			forceCycleResolve = resolve;
+		});
+		const stalledBacklogKeys = /* @__PURE__ */ new Set();
+		const unsubscribe = worker.onMessage((message) => {
+			if (message.type === "poll-start") {
+				liveness.noteGetUpdatesStarted({ offset: message.offset }, message.startedAt);
+				pollState.startedAt = message.startedAt;
+				pollState.offset = message.offset;
+				pollState.outcome = "started";
+				delete pollState.error;
+				return;
+			}
+			if (message.type === "poll-success") {
+				liveness.noteGetUpdatesSuccessCount(message.count, message.finishedAt);
+				liveness.noteGetUpdatesFinished();
+				if (!restartRequested && stalledBacklogKeys.size === 0) this.#status.notePollSuccess(message.finishedAt);
+				this.#drainPendingDeliveriesAfterReconnect();
+				pollState.outcome = `ok:${message.count}`;
+				return;
+			}
+			if (message.type === "poll-error") {
+				liveness.noteGetUpdatesError(new Error(message.message), message.finishedAt);
+				liveness.noteGetUpdatesFinished();
+				pollState.outcome = "error";
+				pollState.error = message.message;
+				return;
+			}
+			if (message.type === "spooled") liveness.noteGetUpdatesActivity();
+		});
+		const stopOnAbort = () => {
+			stopWorker();
+		};
+		this.opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
+		const drainIntervalMs = Math.max(100, Math.floor(ingress.drainIntervalMs ?? 500));
+		let drainActive = false;
+		const stopBot = () => {
+			return Promise.resolve(bot.stop()).then(() => void 0).catch(() => {});
+		};
+		const drainOnce = async () => {
+			if (restartRequested || drainActive || this.opts.abortSignal?.aborted) return;
+			drainActive = true;
+			try {
+				const drain = await this.#drainSpooledUpdates({
+					bot,
+					spoolDir
+				});
+				consecutiveDrainFailures = 0;
+				for (const handlerKey of stalledBacklogKeys) if (!activeSpooledUpdateHandlersByLane.has(handlerKey) || !drain.blockedByLane.has(handlerKey)) stalledBacklogKeys.delete(handlerKey);
+				for (const handlerKey of drain.blockedByLane) {
+					const handler = activeSpooledUpdateHandlersByLane.get(handlerKey);
+					if (handler?.timedOutAt === void 0) continue;
+					stalledBacklogKeys.add(handlerKey);
+					if (handler.timeoutMessage) this.#status.notePollingError(handler.timeoutMessage);
+				}
+				const timedOutRecovery = await this.#recoverTimedOutSpooledHandler(drain.blockedByLane);
+				if (timedOutRecovery?.restart) {
+					restartRequested = true;
+					stopWorker();
+				} else if (timedOutRecovery) stalledBacklogKeys.add(timedOutRecovery.handlerKey);
+			} catch (err) {
+				consecutiveDrainFailures += 1;
+				this.opts.log(`[telegram][diag] isolated polling spool drain failed (${consecutiveDrainFailures}): ${formatErrorMessage(err)}`);
+			} finally {
+				drainActive = false;
+			}
+		};
+		await drainOnce();
+		const drainTimer = setInterval(() => {
+			drainOnce();
+		}, drainIntervalMs);
+		drainTimer.unref?.();
+		const watchdog = setInterval(() => {
+			if (this.opts.abortSignal?.aborted || restartRequested) return;
+			const stall = liveness.detectStall({ thresholdMs: this.#stallThresholdMs });
+			if (!stall) return;
+			this.#transportState.markDirty();
+			stalledRestart = true;
+			restartRequested = true;
+			this.opts.log(`[telegram] ${stall.message}`);
+			this.#status.notePollingError(stall.message);
+			stopWorker();
+			if (!forceCycleTimer) forceCycleTimer = setTimeout(() => {
+				if (this.opts.abortSignal?.aborted) return;
+				this.opts.log(`[telegram] Isolated polling ingress stop timed out after ${formatDurationPrecise(POLL_STOP_GRACE_MS)}; forcing restart cycle.`);
+				forceCycleResolve?.();
+			}, POLL_STOP_GRACE_MS);
+		}, POLL_WATCHDOG_INTERVAL_MS);
+		watchdog.unref?.();
+		try {
+			try {
+				await Promise.race([worker.task(), forceCyclePromise]);
+			} catch (err) {
+				if (this.opts.abortSignal?.aborted) return "exit";
+				if (pollState.error && !isRecoverableTelegramNetworkError(new Error(pollState.error), { context: "polling" })) {
+					this.#status.notePollingError(pollState.error);
+					throw new Error(pollState.error, { cause: err });
+				}
+				const message = formatErrorMessage(err);
+				this.opts.log(`[telegram][diag] isolated polling ingress failed: ${message}`);
+				this.#status.notePollingError(message);
+				return await this.#waitBeforeRestart((delay) => `Telegram isolated polling ingress failed; restarting in ${delay}.`) ? "continue" : "exit";
+			}
+			if (this.opts.abortSignal?.aborted) return "exit";
+			if (restartRequested) {
+				if (stalledRestart) this.opts.log(`[telegram][diag] isolated polling ingress finished reason=polling stall detected ${liveness.formatDiagnosticFields("error")}`);
+				return "continue";
+			}
+			const errorText = pollState.error ? ` error=${pollState.error}` : "";
+			this.opts.log(`[telegram][diag] isolated polling ingress stopped outcome=${pollState.outcome} startedAt=${pollState.startedAt ?? "n/a"} offset=${pollState.offset ?? "n/a"}${errorText}`);
+			return await this.#waitBeforeRestart((delay) => `Telegram isolated polling ingress stopped; restarting in ${delay}.`) ? "continue" : "exit";
+		} finally {
+			clearInterval(watchdog);
+			clearInterval(drainTimer);
+			if (forceCycleTimer) clearTimeout(forceCycleTimer);
+			unsubscribe();
+			this.opts.abortSignal?.removeEventListener("abort", stopOnAbort);
+			await stopWorker();
+			if (!restartRequested) {
+				await drainOnce();
+				await waitForGracefulStop(() => this.#waitForSpooledUpdateHandlers());
+			}
+			await waitForGracefulStop(stopBot);
+		}
+	}
+	async #runPollingCycle(bot) {
+		const liveness = new TelegramPollingLivenessTracker({ onPollSuccess: (finishedAt) => {
+			this.#status.notePollSuccess(finishedAt);
+			this.#drainPendingDeliveriesAfterReconnect();
+		} });
+		bot.api.config.use(async (prev, method, payload, signal) => {
+			if (method !== "getUpdates") return await prev(method, payload, signal);
+			liveness.noteGetUpdatesStarted(payload);
+			try {
+				const result = await prev(method, payload, signal);
+				liveness.noteGetUpdatesSuccess(result);
+				return result;
+			} catch (err) {
+				liveness.noteGetUpdatesError(err);
+				throw err;
+			} finally {
+				liveness.noteGetUpdatesFinished();
+			}
+		});
+		const runner = run(bot, this.opts.runnerOptions);
+		this.opts.log(`[telegram][diag] polling cycle started ${liveness.formatDiagnosticFields()}`);
+		this.#activeRunner = runner;
+		const fetchAbortController = this.#activeFetchAbort;
+		const abortFetch = () => {
+			fetchAbortController?.abort();
+		};
+		if (this.opts.abortSignal && fetchAbortController) this.opts.abortSignal.addEventListener("abort", abortFetch, { once: true });
+		let stopPromise;
+		let stalledRestart = false;
+		let forceCycleTimer;
+		let forceCycleResolve;
+		const forceCyclePromise = new Promise((resolve) => {
+			forceCycleResolve = resolve;
+		});
+		const stopRunner = () => {
+			fetchAbortController?.abort();
+			stopPromise ??= Promise.resolve(runner.stop()).then(() => void 0).catch(() => {});
+			return stopPromise;
+		};
+		const stopBot = () => {
+			return Promise.resolve(bot.stop()).then(() => void 0).catch(() => {});
+		};
+		const stopOnAbort = () => {
+			if (this.opts.abortSignal?.aborted) stopRunner();
+		};
+		const watchdog = setInterval(() => {
+			if (this.opts.abortSignal?.aborted) return;
+			const stall = liveness.detectStall({ thresholdMs: this.#stallThresholdMs });
+			if (stall) {
+				this.#transportState.markDirty();
+				stalledRestart = true;
+				this.opts.log(`[telegram] ${stall.message}`);
+				stopRunner();
+				stopBot();
+				if (!forceCycleTimer) forceCycleTimer = setTimeout(() => {
+					if (this.opts.abortSignal?.aborted) return;
+					this.opts.log(`[telegram] Polling runner stop timed out after ${formatDurationPrecise(POLL_STOP_GRACE_MS)}; forcing restart cycle.`);
+					forceCycleResolve?.();
+				}, POLL_STOP_GRACE_MS);
+			}
+		}, POLL_WATCHDOG_INTERVAL_MS);
+		this.opts.abortSignal?.addEventListener("abort", stopOnAbort, { once: true });
+		try {
+			await Promise.race([runner.task(), forceCyclePromise]);
+			if (this.opts.abortSignal?.aborted) return "exit";
+			const reason = stalledRestart ? "polling stall detected" : this.#forceRestarted ? "unhandled network error" : "runner stopped (maxRetryTime exceeded or graceful stop)";
+			this.#forceRestarted = false;
+			this.opts.log(`[telegram][diag] polling cycle finished reason=${reason} ${liveness.formatDiagnosticFields("error")}`);
+			return await this.#waitBeforeRestart((delay) => `Telegram polling runner stopped (${reason}); restarting in ${delay}.`) ? "continue" : "exit";
+		} catch (err) {
+			this.#forceRestarted = false;
+			if (this.opts.abortSignal?.aborted) throw err;
+			const isConflict = isGetUpdatesConflict(err);
+			if (isConflict) this.#webhookCleared = false;
+			const isRecoverable = isRecoverableTelegramNetworkError(err, { context: "polling" });
+			if (isRecoverable || isConflict) this.#transportState.markDirty();
+			if (!isConflict && !isRecoverable) throw err;
+			const reason = isConflict ? "getUpdates conflict" : "network error";
+			const errMsg = formatErrorMessage(err);
+			const conflictHint = isConflict ? " Another DaoCore gateway, script, or Telegram poller may be using this bot token; stop the duplicate poller or switch this account to webhook mode." : "";
+			this.opts.log(`[telegram][diag] polling cycle error reason=${reason} ${liveness.formatDiagnosticFields("lastGetUpdatesError")} err=${errMsg}${conflictHint}`);
+			return await this.#waitBeforeRestart((delay) => `Telegram ${reason}: ${errMsg};${conflictHint} retrying in ${delay}.`) ? "continue" : "exit";
+		} finally {
+			clearInterval(watchdog);
+			if (forceCycleTimer) clearTimeout(forceCycleTimer);
+			this.opts.abortSignal?.removeEventListener("abort", abortFetch);
+			this.opts.abortSignal?.removeEventListener("abort", stopOnAbort);
+			await waitForGracefulStop(stopRunner);
+			await waitForGracefulStop(stopBot);
+			this.#activeRunner = void 0;
+			if (this.#activeFetchAbort === fetchAbortController) this.#activeFetchAbort = void 0;
+		}
+	}
+};
+const isGetUpdatesConflict = (err) => {
+	if (!err || typeof err !== "object") return false;
+	const typed = err;
+	if ((typed.error_code ?? typed.errorCode) !== 409) return false;
+	return normalizeLowercaseStringOrEmpty([
+		typed.method,
+		typed.description,
+		typed.message
+	].filter((value) => typeof value === "string").join(" ")).includes("getupdates");
+};
+//#endregion
+export { TelegramPollingSession, deleteTelegramUpdateOffset, readTelegramUpdateOffset, writeTelegramUpdateOffset };