@openclaw/discord 2026.10.2 → 2026.10.5-beta.2

package/dist/.setup/{provider-session.runtime-D1gkPxHT.mjs → provider-session.runtime-CsnRvddI.mjs}

@@ -1,6 +1,6 @@
-import { i as createNoopThreadBindingManager, t as createThreadBindingManager } from "./thread-bindings.manager-D2-GYZ5s.mjs";
-import { c as reconcileAcpThreadBindingsOnStartup } from "./thread-bindings-DjQCkmsd.mjs";
-import { t as createDiscordMessageHandler } from "./message-handler-BK69A-NB.mjs";
+import { i as createNoopThreadBindingManager, t as createThreadBindingManager } from "./thread-bindings.manager-CdNa6UIs.mjs";
+import { c as reconcileAcpThreadBindingsOnStartup } from "./thread-bindings-0hPTSK14.mjs";
+import { t as createDiscordMessageHandler } from "./message-handler-Ii_etru1.mjs";
 import { resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled } from "openclaw/plugin-sdk/conversation-runtime";
-import { getAcpSessionManager, isAcpRuntimeError } from "openclaw/plugin-sdk/acp-runtime";
-export { createDiscordMessageHandler, createNoopThreadBindingManager, createThreadBindingManager, getAcpSessionManager, isAcpRuntimeError, reconcileAcpThreadBindingsOnStartup, resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled };
+import { getAcpSessionManager, isAcpRuntimeError, rethrowIncognitoSessionError } from "openclaw/plugin-sdk/acp-runtime";
+export { createDiscordMessageHandler, createNoopThreadBindingManager, createThreadBindingManager, getAcpSessionManager, isAcpRuntimeError, reconcileAcpThreadBindingsOnStartup, resolveThreadBindingIdleTimeoutMs, resolveThreadBindingMaxAgeMs, resolveThreadBindingsEnabled, rethrowIncognitoSessionError };

package/dist/.setup/provider.runtime-BQVcM7Pg.mjs

@@ -0,0 +1,2 @@
+import { t as monitorDiscordProvider } from "./provider-D9EzOfG8.mjs";
+export { monitorDiscordProvider };

package/dist/.setup/{realtime-session.runtime-BKUQBy1u.mjs → realtime-session.runtime-CxGBk8H-.mjs}

@@ -1,9 +1,10 @@
-import { _ as releaseDiscordAudioInput, g as getDiscordAudioOutputStatus, h as admitDiscordAudioInput, m as DiscordAudioOutputStatus, u as createDiscordPcmToRealtimeConverter, v as restoreDiscordAudioError, x as setDiscordAudioOutputStatus } from "./receive-recovery-DgkX7Qvi.mjs";
-import { n as discordRealtimeVoiceSecretOwnerId } from "./secret-config-contract-uOE2J7yM.mjs";
-import { g as logVoiceVerbose } from "./provider-YP8gN9_o.mjs";
-import { a as logDiscordVoiceAgentControlResult, c as formatRealtimeLifecycleLog, i as handleDiscordVoiceAgentControlToolCall, l as formatVoiceLogPreview, n as DiscordRealtimeRecording, o as maybeControlDiscordVoiceAgentRun, r as formatVoiceIngressPrompt, s as formatRealtimeInterruptionLog, u as shouldLogRealtimeVerboseEvent } from "./voice-runtime-DDymtIw8.mjs";
+import { _ as restoreDiscordAudioError, b as setDiscordAudioOutputStatus, g as releaseDiscordAudioInput, h as getDiscordAudioOutputStatus, l as createDiscordPcmToRealtimeConverter, m as admitDiscordAudioInput, p as DiscordAudioOutputStatus } from "./receive-recovery-eVmK2_hl.mjs";
+import { t as resolveDiscordOutputAudioDelta } from "./output-activity-uBpMSX75.mjs";
+import { n as discordRealtimeVoiceSecretOwnerId } from "./secret-config-contract-CIsH7R3B.mjs";
+import { y as logVoiceVerbose } from "./provider-D9EzOfG8.mjs";
+import { a as logDiscordVoiceAgentControlResult, c as formatVoiceLogPreview, i as handleDiscordVoiceAgentControlToolCall, l as shouldLogRealtimeVerboseEvent, n as DiscordRealtimeRecording, o as maybeControlDiscordVoiceAgentRun, r as formatVoiceIngressPrompt, s as formatRealtimeInfoLog } from "./voice-runtime-QlZJ4sHv.mjs";
 import { MessageChannel } from "node:worker_threads";
-import { formatErrorMessage, readErrorName, toErrorObject } from "openclaw/plugin-sdk/error-runtime";
+import { formatErrorMessage, readErrorName, toErrorObject, toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
 import { createSubsystemLogger } from "openclaw/plugin-sdk/runtime-env";
 import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { asDateTimestampMs, resolveExpiresAtMsFromDurationMs } from "openclaw/plugin-sdk/number-runtime";
@@ -395,7 +396,7 @@ var DiscordRealtimeConsults = class {
 		logger$3.info(`discord voice: realtime consult requested call=${callId} voiceSession=${this.params.entry.voiceSessionKey} supervisorSession=${this.params.entry.route.sessionKey} agent=${this.params.entry.route.agentId} question=${formatVoiceLogPreview(consultMessage)}`);
 		const nativeConsult = this.params.harness.forcedConsults.recordNativeConsult(event.args, callId);
 		if (nativeConsult.kind === "already_delivered" && this.params.harness.forcedConsults.isCancelled(nativeConsult.handle)) {
-			await this.submitTerminalRealtimeToolResult(callId, session, CANCELLED_CONSULT_RESULT);
+			await this.submitAgentProxyConsultResult(callId, session, CANCELLED_CONSULT_RESULT);
 			return;
 		}
 		const pendingConsult = nativeConsult.kind === "pending" ? nativeConsult.handle : void 0;
@@ -413,8 +414,6 @@ var DiscordRealtimeConsults = class {
 				}
 				if (await this.submitRecentAgentProxyConsultResult(callId, recentConsult, session)) return;
 			}
-		}
-		if (!context) {
 			context = this.params.turns.consumePendingSpeakerContext();
 			if (context) {
 				recent = this.params.harness.forcedConsults.prepare(consultMessage, {
@@ -471,7 +470,6 @@ var DiscordRealtimeConsults = class {
 				return;
 			}
 			logger$3.warn(`discord voice: realtime active-run control failed; falling back to normal transcript handling: ${formatErrorMessage(error)}`);
-			control = void 0;
 		}
 		if (this.params.stopped() || providerEpoch !== this.params.providerEpoch()) return;
 		if (control?.handled) {
@@ -612,13 +610,6 @@ var DiscordRealtimeConsults = class {
 		if (state) state.promise = tracked;
 		return tracked;
 	}
-	async submitTerminalRealtimeToolResult(callId, session, result) {
-		if (session.bridge.supportsToolResultSuppression === false) {
-			await session.submitToolResult(callId, result);
-			return;
-		}
-		await session.submitToolResult(callId, result, { suppressResponse: true });
-	}
 	async submitRecentAgentProxyConsultResult(callId, recent, session) {
 		const state = recent.context;
 		if (!state) return false;
@@ -655,12 +646,13 @@ var DiscordRealtimeConsults = class {
 		if (deliveries?.size === 0) this.providerDeliveries.delete(state);
 	}
 	async submitAgentProxyConsultResult(callId, session, result, alreadyDelivered = false) {
-		if ("status" in result) await this.submitTerminalRealtimeToolResult(callId, session, CANCELLED_CONSULT_RESULT);
-		else if (alreadyDelivered) await this.submitTerminalRealtimeToolResult(callId, session, {
+		const terminal = "status" in result || alreadyDelivered;
+		const payload = "status" in result ? CANCELLED_CONSULT_RESULT : alreadyDelivered ? {
 			status: "already_delivered",
 			message: "OpenClaw already delivered this answer to Discord voice. Do not repeat it."
-		});
-		else await session.submitToolResult(callId, result);
+		} : result;
+		if (terminal && session.bridge.supportsToolResultSuppression !== false) await session.submitToolResult(callId, payload, { suppressResponse: true });
+		else await session.submitToolResult(callId, payload);
 	}
 	deliverDetachedResult(state) {
 		const result = state.result;
@@ -688,13 +680,9 @@ var DiscordRealtimeConsults = class {
 //#region extensions/discord/src/voice/realtime-output.ts
 /** Main retains provider item identity; physical output state belongs to the worker. */
 var DiscordRealtimeOutput = class {
-	get activity() {
-		if (Atomics.load(this.clock, 2) !== 0n && !this.activityTracker.snapshot().playbackStarted) this.activityTracker.markPlaybackStarted();
-		return this.activityTracker;
-	}
 	constructor(params) {
 		this.params = params;
-		this.activityTracker = createRealtimeVoiceOutputActivityTracker();
+		this.activity = createRealtimeVoiceOutputActivityTracker();
 		this.clock = new BigInt64Array(new SharedArrayBuffer(24));
 		this.marks = /* @__PURE__ */ new Map();
 		this.nextMark = 0;
@@ -746,6 +734,9 @@ var DiscordRealtimeOutput = class {
 	playedBytes() {
 		return Number(Atomics.load(this.clock, 0));
 	}
+	hasStarted() {
+		return Atomics.load(this.clock, 2) !== 0n || this.activity.snapshot().playbackStarted;
+	}
 	pendingBytes() {
 		return this.closed ? 0 : Math.max(0, this.activity.snapshot().sourceAudioBytes * 4 - this.playedBytes());
 	}
@@ -781,8 +772,8 @@ var DiscordRealtimeOutput = class {
 			return true;
 		}
 		const previous = this.activity.snapshot();
-		const sinkBytes = Math.floor((previous.sourceAudioBytes + audio.length) / 2) * 8;
-		const audioMs = (sinkBytes - previous.sinkAudioBytes) / 192;
+		const delta = resolveDiscordOutputAudioDelta(previous, audio.length);
+		const { audioMs } = delta;
 		if (item) {
 			const last = this.spans.at(-1);
 			if (last?.item === item && last.endMs === previous.audioMs) last.endMs += audioMs;
@@ -792,11 +783,7 @@ var DiscordRealtimeOutput = class {
 				endMs: previous.audioMs + audioMs
 			});
 		}
-		this.activity.markAudio({
-			audioMs,
-			sourceAudioBytes: audio.length,
-			sinkAudioBytes: sinkBytes - previous.sinkAudioBytes
-		});
+		this.activity.markAudio(delta);
 		this.params.player.audio.send({
 			type: "output-audio",
 			id: this.id,
@@ -939,7 +926,6 @@ var DiscordRealtimePlayback = class {
 			this.retainedSpeechClosed = true;
 			this.speechSuccessor = void 0;
 			this.queuedExactSpeechMessages = [];
-			this.retireExactSpeech();
 		}
 		this.clearOutputAudio("session-close");
 		this.directOutput?.close();
@@ -1177,7 +1163,7 @@ var DiscordRealtimePlayback = class {
 		this.exactSpeechState = { status: "idle" };
 		if (speech.status !== "active") return;
 		const directStarted = speech.direct && Atomics.exchange(speech.direct.clock, 2, 0n) === -speech.direct.epoch;
-		if (preserveUnplayed && !directStarted && !speech.output?.activity.snapshot().playbackStarted) this.queuedExactSpeechMessages.unshift(speech.message);
+		if (preserveUnplayed && !directStarted && !speech.output?.hasStarted()) this.queuedExactSpeechMessages.unshift(speech.message);
 	}
 	outputAudioMs() {
 		return this.directOutput ? Math.floor(Number(Atomics.load(this.directOutput.clock, 1)) / 48) : Math.floor(this.params.harness.outputActivity.snapshot().audioMs);
@@ -1193,7 +1179,6 @@ var DiscordRealtimePlayback = class {
 		this.speechSuccessor = void 0;
 		this.params.stopTerminally();
 		this.queuedExactSpeechMessages = [];
-		this.retireExactSpeech();
 		this.clearOutputAudio(reason);
 		this.params.onTerminalError(error);
 	}
@@ -1364,11 +1349,14 @@ var DiscordRealtimeSpeakerSession = class {
 			status: "inactive",
 			generation: 0
 		};
-		this.consultToolPolicy = "safe-read-only";
-		this.consultPolicy = "auto";
-		this.wakeNamePolicy = "never";
-		this.wakeNames = [];
-		this.handlesAgentConsult = false;
+		this.policy = {
+			toolPolicy: "safe-read-only",
+			consultToolsAllow: void 0,
+			consultPolicy: "auto",
+			wakeNamePolicy: "never",
+			wakeNames: [],
+			handlesAgentConsult: false
+		};
 		this.providerGenerationObserved = false;
 		this.providerContinuityEpoch = 0;
 		this.captures = /* @__PURE__ */ new Set();
@@ -1406,64 +1394,54 @@ var DiscordRealtimeSpeakerSession = class {
 			}
 		});
 		for (const item of params.conversationHistory ?? []) this.harness.recordTranscript(item.role, item.text);
-		this.playback = new DiscordRealtimePlayback({
+		const context = {
+			...params,
 			bridge: () => this.bridge,
+			harness: this.harness,
+			providerEpoch: () => this.providerContinuityEpoch,
+			providerId: () => this.realtimeProviderId,
+			realtimeConfig: () => this.realtimeConfig,
+			stopped: () => this.isStopped(),
+			wakeNamePolicy: () => this.policy.wakeNamePolicy
+		};
+		this.playback = new DiscordRealtimePlayback({
+			...context,
 			bridgeReady: () => this.isReady(),
 			buildSpeakExactMessage: (text) => buildRealtimeVoiceSpeakExactMessage({
 				text,
 				surfaceLabel: "the Discord voice channel"
 			}),
-			entry: this.params.entry,
-			player: this.params.player,
-			harness: this.harness,
 			markProviderGenerationObserved: () => this.markProviderGenerationObserved(),
-			mode: this.params.mode,
-			onTerminalError: this.params.onTerminalError,
-			providerId: () => this.realtimeProviderId,
-			realtimeConfig: () => this.realtimeConfig,
 			stopTerminally: () => {
 				this.lifecycle.status = "stopped";
 				this.consults.close();
 			},
-			stopped: () => this.isStopped(),
 			wakeNameRequired: () => this.isWakeNameRequired()
 		});
 		this.turns = new DiscordRealtimeTurns({
-			bridge: () => this.bridge,
-			entry: this.params.entry,
+			...context,
 			getHumanParticipantCount: () => this.humanParticipantCount(),
 			interruptRoomPlayback: () => {
 				if (!this.playback.isBargeInEnabled() || !this.params.player.isActive()) return false;
 				return this.params.player.handleBargeIn("active-speaker-audio");
 			},
-			onAcceptedTranscript: (text, context, providerEpoch) => this.consults.handleAcceptedTranscript(text, context, providerEpoch),
+			onAcceptedTranscript: (text, speakerContext, providerEpoch) => this.consults.handleAcceptedTranscript(text, speakerContext, providerEpoch),
 			playback: this.playback,
-			providerEpoch: () => this.providerContinuityEpoch,
-			providerId: () => this.realtimeProviderId,
-			realtimeConfig: () => this.realtimeConfig,
 			recordInputAudio: (audio) => this.harness.recordInputAudio(audio),
-			stopped: () => this.isStopped(),
-			wakeNamePolicy: () => this.wakeNamePolicy,
-			wakeNames: () => this.wakeNames
+			wakeNames: () => this.policy.wakeNames
 		});
 		this.consults = new DiscordRealtimeConsults({
-			accountId: this.params.accountId,
-			consultPolicy: () => this.consultPolicy,
-			consultToolPolicy: () => this.consultToolPolicy,
-			consultToolsAllow: () => this.consultToolsAllow,
+			...context,
+			consultPolicy: () => this.policy.consultPolicy,
+			consultToolPolicy: () => this.policy.toolPolicy,
+			consultToolsAllow: () => this.policy.consultToolsAllow,
 			debounceMs: () => this.realtimeConfig?.debounceMs,
-			entry: this.params.entry,
-			harness: this.harness,
-			isAgentProxy: () => this.params.mode === "agent-proxy" && !this.handlesAgentConsult,
+			isAgentProxy: () => this.params.mode === "agent-proxy" && !this.policy.handlesAgentConsult,
 			isWakeNameRequired: () => this.isWakeNameRequired(),
 			playback: this.playback,
-			providerEpoch: () => this.providerContinuityEpoch,
 			runAgentTurn: (turn) => this.trackOperation(() => this.params.runAgentTurn(turn)),
-			resolveSpeakerContext: this.params.resolveSpeakerContext,
-			stopped: () => this.isStopped(),
 			turns: this.turns,
-			usesRealtimeAgentHandoff: () => this.params.mode === "bidi" || this.consultToolPolicy !== "none",
-			wakeNamePolicy: () => this.wakeNamePolicy
+			usesRealtimeAgentHandoff: () => this.params.mode === "bidi" || this.policy.toolPolicy !== "none"
 		});
 	}
 	async connect() {
@@ -1485,13 +1463,8 @@ var DiscordRealtimeSpeakerSession = class {
 		this.realtimeProviderId = resolved.provider.id;
 		this.selection = selection;
 		const capabilities = resolved.capabilities;
-		const { toolPolicy, consultToolsAllow, consultPolicy, wakeNamePolicy, wakeNames, autoRespondToAudio } = sessionPolicy;
-		this.handlesAgentConsult = sessionPolicy.handlesAgentConsult;
-		this.consultToolPolicy = toolPolicy;
-		this.consultToolsAllow = consultToolsAllow;
-		this.consultPolicy = consultPolicy;
-		this.wakeNamePolicy = wakeNamePolicy;
-		this.wakeNames = wakeNames;
+		this.policy = sessionPolicy;
+		const { toolPolicy, consultPolicy, autoRespondToAudio } = sessionPolicy;
 		const usesRealtimeAgentHandoff = this.params.mode === "bidi" || toolPolicy !== "none";
 		const onReady = () => {
 			this.markProviderGenerationObserved();
@@ -1508,7 +1481,7 @@ var DiscordRealtimeSpeakerSession = class {
 			autoRespondToAudio,
 			interruptResponseOnInputAudio,
 			markStrategy: "transport",
-			...this.handlesAgentConsult ? { runAgentConsult: (request) => this.trackOperation(() => this.consults.runAgentConsult(request)) } : {},
+			...this.policy.handlesAgentConsult ? { runAgentConsult: (request) => this.trackOperation(() => this.consults.runAgentConsult(request)) } : {},
 			tools: usesRealtimeAgentHandoff ? resolveRealtimeVoiceAgentConsultTools(toolPolicy, toolPolicy !== "none" ? [REALTIME_VOICE_AGENT_CONTROL_TOOL] : []) : [],
 			audioSink: {
 				isOpen: () => !this.isStopped() && this.outputEnabled,
@@ -1540,7 +1513,7 @@ var DiscordRealtimeSpeakerSession = class {
 					return;
 				}
 				if (text.trim()) this.recording.transcript(text.trim());
-				if (this.handlesAgentConsult) return;
+				if (this.policy.handlesAgentConsult) return;
 				this.trackOperation(() => this.turns.handleFinalUserTranscript(text)).catch((error) => this.logRealtimeError(formatErrorMessage$1(error)));
 			},
 			onToolCall: (event, session) => {
@@ -1574,7 +1547,7 @@ var DiscordRealtimeSpeakerSession = class {
 			return;
 		}
 		const humanParticipantCount = this.humanParticipantCount();
-		logger$1.info(`discord voice: realtime bridge starting mode=${this.params.mode} provider=${resolved.provider.id} model=${resolvedModel ?? "default"} voice=${resolvedVoice ?? "default"} consultPolicy=${consultPolicy} toolPolicy=${toolPolicy} autoRespond=${autoRespondToAudio} wakeNamePolicy=${this.wakeNamePolicy} requireWakeName=${this.isWakeNameRequired(humanParticipantCount)} humanParticipants=${humanParticipantCount} wakeNames=${this.wakeNames.join(",") || "none"} interruptResponse=${interruptResponseOnInputAudio} bargeIn=${bargeIn} minBargeInAudioEndMs=${minBargeInAudioEndMs}`);
+		logger$1.info(`discord voice: realtime bridge starting mode=${this.params.mode} provider=${resolved.provider.id} model=${resolvedModel ?? "default"} voice=${resolvedVoice ?? "default"} consultPolicy=${consultPolicy} toolPolicy=${toolPolicy} autoRespond=${autoRespondToAudio} wakeNamePolicy=${this.policy.wakeNamePolicy} requireWakeName=${this.isWakeNameRequired(humanParticipantCount)} humanParticipants=${humanParticipantCount} wakeNames=${this.policy.wakeNames.join(",") || "none"} interruptResponse=${interruptResponseOnInputAudio} bargeIn=${bargeIn} minBargeInAudioEndMs=${minBargeInAudioEndMs}`);
 		this.attachOutputAudioPort();
 		await this.bridge.connect();
 		if (!this.markLifecycleReady(lifecycleGeneration)) {
@@ -1650,7 +1623,7 @@ var DiscordRealtimeSpeakerSession = class {
 					recordingInput?.exclude();
 					throw error;
 				} finally {
-					recordingInput?.sealAudio();
+					recordingInput?.seal("audio");
 				}
 			}
 		};
@@ -1703,7 +1676,7 @@ var DiscordRealtimeSpeakerSession = class {
 	}
 	attachOutputAudioPort() {
 		const provider = this.bridge?.bridge;
-		if (this.wakeNamePolicy === "never" && provider?.outputAudioMode === "continuous" && provider.setAudioOutputPort) provider.setAudioOutputPort(this.playback.createOutputAudioPort(this.outputEnabled));
+		if (this.policy.wakeNamePolicy === "never" && provider?.outputAudioMode === "continuous" && provider.setAudioOutputPort) provider.setAudioOutputPort(this.playback.createOutputAudioPort(this.outputEnabled));
 	}
 	hasActiveInput() {
 		return this.captures.size > 0;
@@ -1755,7 +1728,7 @@ var DiscordRealtimeSpeakerSession = class {
 		return this.params.getHumanParticipantCount?.() ?? 0;
 	}
 	isWakeNameRequired(humanParticipantCount = this.humanParticipantCount()) {
-		return isRealtimeVoiceWakeNameRequired(this.wakeNamePolicy, humanParticipantCount);
+		return isRealtimeVoiceWakeNameRequired(this.policy.wakeNamePolicy, humanParticipantCount);
 	}
 	handleBridgeEvent(event) {
 		if (!(event.direction === "client" && event.type === "session.continuity.reset") && !event.type.endsWith("audio.delta") && event.type !== "output_audio.rtp") this.markProviderGenerationObserved();
@@ -1764,10 +1737,8 @@ var DiscordRealtimeSpeakerSession = class {
 		if (event.direction === "server" && event.type === "response.created") this.playback.beginResponse();
 		if (event.direction === "server" && event.type === "input_audio_buffer.speech_started") this.turns.resetPartialWakeNameTracking();
 		if (shouldLogRealtimeVerboseEvent(event)) logVoiceVerbose(`realtime ${event.direction}:${event.type}${detail}`);
-		const interruptionLog = formatRealtimeInterruptionLog(event);
-		if (interruptionLog) logger$1.info(interruptionLog);
-		const lifecycleLog = formatRealtimeLifecycleLog(event);
-		if (lifecycleLog) logger$1.info(lifecycleLog);
+		const info = formatRealtimeInfoLog(event);
+		if (info) logger$1.info(info);
 	}
 	markProviderGenerationObserved() {
 		this.lastActivityAt = Date.now();
@@ -1923,7 +1894,7 @@ var DiscordRealtimeVoiceSession = class {
 	handleSpeakerFailure(session, error) {
 		if (this.closed) return;
 		if (this.warmSession === session) {
-			this.params.onTerminalError(error instanceof Error ? error : new Error(String(error)));
+			this.params.onTerminalError(toStringifiedError(error));
 			return;
 		}
 		for (const speaker of this.sessions) {
@@ -2060,18 +2031,18 @@ var DiscordRealtimeVoiceSession = class {
 		}
 	}
 	async connectCandidate(session, signal) {
-		signal?.throwIfAborted();
-		let abort;
+		signal.throwIfAborted();
+		const cancelled = createDeferred();
+		const abort = () => {
+			this.closeSpeaker(session);
+			cancelled.reject(toErrorObject(signal.reason, "Discord voice change cancelled"));
+		};
 		try {
-			await Promise.race([session.connect(), new Promise((_resolve, reject) => {
-				abort = () => {
-					this.closeSpeaker(session);
-					reject(toErrorObject(signal?.reason, "Discord voice change cancelled"));
-				};
-				signal?.addEventListener("abort", abort, { once: true });
-			})]);
+			const connecting = session.connect();
+			signal.addEventListener("abort", abort, { once: true });
+			await Promise.race([connecting, cancelled.promise]);
 		} finally {
-			if (abort) signal?.removeEventListener("abort", abort);
+			signal.removeEventListener("abort", abort);
 		}
 	}
 	releaseIdleSpeakers() {

package/dist/.setup/{receive-recovery-DgkX7Qvi.mjs → receive-recovery-eVmK2_hl.mjs}

@@ -111,9 +111,6 @@ function buildWavBuffer(chunks) {
 	for (const chunk of chunks) offset += chunk.copy(wav, offset);
 	return wav;
 }
-function createDiscordOpusEncodeStream() {
-	return new DiscordOpusEncodeStream();
-}
 function createDiscordOpusPlaybackStream(input) {
 	const inputSource = typeof input === "string" ? input : "pipe:0";
 	const ffmpeg = spawn(resolveFfmpegBin(), [
@@ -129,7 +126,7 @@ function createDiscordOpusPlaybackStream(input) {
 		],
 		windowsHide: true
 	});
-	const opusStream = createDiscordOpusEncodeStream();
+	const opusStream = new DiscordOpusEncodeStream();
 	const stderr = Buffer.alloc(FFMPEG_ERROR_OUTPUT_BYTES);
 	let stderrBytes = 0;
 	let ffmpegClosed = false;
@@ -423,13 +420,6 @@ const DECRYPT_FAILURE_MARKER = "DecryptionFailed(";
 const DAVE_PASSTHROUGH_DISABLED_MARKER = "UnencryptedWhenPassthroughDisabled";
 const WASM_MEMORY_ACCESS_MARKER = "memory access out of bounds";
 const OPUS_INVALID_PACKET_CODE = -4;
-function createVoiceReceiveRecoveryState() {
-	return {
-		decryptFailureCount: 0,
-		lastDecryptFailureAt: 0,
-		decryptRecoveryInFlight: false
-	};
-}
 function isAbortLikeReceiveError(err) {
 	if (!err || typeof err !== "object") return false;
 	const name = "name" in err && typeof err.name === "string" ? err.name : "";
@@ -508,4 +498,4 @@ function enableDaveReceivePassthrough(params) {
 	}
 }
 //#endregion
-export { releaseDiscordAudioInput as _, noteVoiceDecryptFailure as a, serializeDiscordAudioError as b, createDiscordOpusEncodeStream as c, createRealtimePcmToDiscordConverter as d, decodeOpusStreamChunks as f, getDiscordAudioOutputStatus as g, admitDiscordAudioInput as h, enableDaveReceivePassthrough as i, createDiscordOpusPlaybackStream as l, DiscordAudioOutputStatus as m, analyzeVoiceReceiveError as n, recoverDaveZeroTransition as o, writeVoiceWavFile as p, createVoiceReceiveRecoveryState as r, resetVoiceReceiveRecoveryState as s, DECRYPT_FAILURE_WINDOW_MS as t, createDiscordPcmToRealtimeConverter as u, restoreDiscordAudioError as v, setDiscordAudioOutputStatus as x, retireDiscordAudioOutput as y };
+export { restoreDiscordAudioError as _, recoverDaveZeroTransition as a, setDiscordAudioOutputStatus as b, createDiscordOpusPlaybackStream as c, decodeOpusStreamChunks as d, writeVoiceWavFile as f, releaseDiscordAudioInput as g, getDiscordAudioOutputStatus as h, noteVoiceDecryptFailure as i, createDiscordPcmToRealtimeConverter as l, admitDiscordAudioInput as m, analyzeVoiceReceiveError as n, resetVoiceReceiveRecoveryState as o, DiscordAudioOutputStatus as p, enableDaveReceivePassthrough as r, DiscordOpusEncodeStream as s, DECRYPT_FAILURE_WINDOW_MS as t, createRealtimePcmToDiscordConverter as u, retireDiscordAudioOutput as v, serializeDiscordAudioError as y };

package/dist/.setup/resolve-allowlist-common-DNSsUQRF.mjs

@@ -0,0 +1,66 @@
+import { h as normalizeDiscordToken } from "./accounts-ljrzXBJi.mjs";
+import { o as normalizeDiscordSlug } from "./allow-list-B_ToXtew.mjs";
+import { r as fetchDiscord } from "./api-CtmE1OUN.mjs";
+//#region extensions/discord/src/guilds.ts
+async function listGuilds(token, fetcher, options) {
+	return (await fetchDiscord("/users/@me/guilds", token, fetcher, options)).flatMap((guild) => typeof guild.id === "string" && typeof guild.name === "string" ? [{
+		id: guild.id,
+		name: guild.name,
+		slug: normalizeDiscordSlug(guild.name)
+	}] : []);
+}
+//#endregion
+//#region extensions/discord/src/resolve-allowlist-common.ts
+function resolveDiscordAllowlistToken(token) {
+	return normalizeDiscordToken(token, "channels.discord.token");
+}
+function filterDiscordGuilds(guilds, params) {
+	if (params.guildId) return guilds.filter((guild) => guild.id === params.guildId);
+	if (params.guildName) {
+		const slug = normalizeDiscordSlug(params.guildName);
+		const match = slug ? guilds.find((guild) => guild.slug === slug) : void 0;
+		return match ? [match] : [];
+	}
+	return guilds;
+}
+function parseDiscordAllowlistInput(raw, kind) {
+	const trimmed = raw.trim();
+	if (!trimmed) return {};
+	const mention = trimmed.match(kind === "channel" ? /^<#(\d+)>$/ : /^<@!?(\d+)>$/);
+	if (mention) return { id: mention[1] };
+	const prefixed = trimmed.match(kind === "channel" ? /^(?:channel:|discord:)?(\d+)$/i : /^(?:user:|discord:)?(\d+)$/i);
+	if (prefixed) return { id: prefixed[1] };
+	if (kind === "channel") {
+		const guildPrefix = trimmed.match(/^(?:guild:|server:)?(\d+)$/i);
+		if (guildPrefix) return {
+			guildId: guildPrefix[1],
+			guildOnly: true
+		};
+	}
+	const split = trimmed.includes("/") ? trimmed.split("/") : trimmed.split("#");
+	if (split.length >= 2) {
+		const guild = split[0]?.trim();
+		const name = split.slice(1).join("#").trim();
+		if (kind === "channel" && !name) return guild ? {
+			guild,
+			guildOnly: true
+		} : {};
+		if (guild && /^\d+$/.test(guild)) return kind === "channel" && /^\d+$/.test(name) ? {
+			guildId: guild,
+			id: name
+		} : {
+			guildId: guild,
+			name
+		};
+		return {
+			guild,
+			name
+		};
+	}
+	return kind === "channel" ? {
+		guild: trimmed,
+		guildOnly: true
+	} : { name: trimmed.replace(/^@/, "") };
+}
+//#endregion
+export { listGuilds as i, parseDiscordAllowlistInput as n, resolveDiscordAllowlistToken as r, filterDiscordGuilds as t };

package/dist/.setup/resolve-channels-UdT38DzU.mjs

@@ -0,0 +1,173 @@
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
+import { A as isDiscordThreadChannelType, o as normalizeDiscordSlug } from "./allow-list-B_ToXtew.mjs";
+import { n as DiscordApiError, r as fetchDiscord, t as DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS } from "./api-CtmE1OUN.mjs";
+import { i as listGuilds, n as parseDiscordAllowlistInput, r as resolveDiscordAllowlistToken, t as filterDiscordGuilds } from "./resolve-allowlist-common-DNSsUQRF.mjs";
+//#region extensions/discord/src/resolve-channels.ts
+var resolve_channels_exports = /* @__PURE__ */ __exportAll({ resolveDiscordChannelAllowlist: () => resolveDiscordChannelAllowlist });
+async function listGuildChannels(token, fetcher, guildId) {
+	return (await fetchDiscord(`/guilds/${guildId}/channels`, token, fetcher, { timeoutMs: DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS })).map((channel) => {
+		const archived = channel.thread_metadata?.archived;
+		return {
+			id: typeof channel.id === "string" ? channel.id : "",
+			name: typeof channel.name === "string" ? channel.name : "",
+			guildId,
+			type: channel.type,
+			archived
+		};
+	}).filter((channel) => Boolean(channel.id) && Boolean(channel.name));
+}
+async function fetchChannel(token, fetcher, channelId) {
+	let raw;
+	try {
+		raw = await fetchDiscord(`/channels/${channelId}`, token, fetcher, { timeoutMs: DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS });
+	} catch (err) {
+		if (err instanceof DiscordApiError && err.status === 403) return { status: "forbidden" };
+		if (err instanceof DiscordApiError && err.status === 404) return { status: "not-found" };
+		throw err;
+	}
+	if (!raw || typeof raw.guild_id !== "string" || typeof raw.id !== "string") return { status: "invalid" };
+	return {
+		status: "found",
+		channel: {
+			id: raw.id,
+			name: typeof raw.name === "string" ? raw.name : "",
+			guildId: raw.guild_id,
+			type: raw.type
+		}
+	};
+}
+function preferActiveMatch(candidates) {
+	const scored = candidates.map((channel) => {
+		const isThread = isDiscordThreadChannelType(channel.type);
+		return {
+			channel,
+			score: (Boolean(channel.archived) ? 0 : 2) + (isThread ? 0 : 1)
+		};
+	});
+	scored.sort((a, b) => b.score - a.score);
+	return scored[0]?.channel ?? candidates[0];
+}
+function resolvedChannelResult(input, channel, guildName) {
+	return {
+		input,
+		resolved: true,
+		guildId: channel.guildId,
+		guildName,
+		channelId: channel.id,
+		channelName: channel.name,
+		archived: channel.archived
+	};
+}
+async function resolveDiscordChannelAllowlist(params) {
+	const token = resolveDiscordAllowlistToken(params.token);
+	if (!token) return params.entries.map((input) => ({
+		input,
+		resolved: false
+	}));
+	const fetcher = params.fetcher ?? fetch;
+	const guilds = await listGuilds(token, fetcher, { timeoutMs: DISCORD_DIRECTORY_LOOKUP_TIMEOUT_MS });
+	const channelsByGuild = /* @__PURE__ */ new Map();
+	const getChannels = (guildId) => {
+		const existing = channelsByGuild.get(guildId);
+		if (existing) return existing;
+		const promise = listGuildChannels(token, fetcher, guildId);
+		channelsByGuild.set(guildId, promise);
+		return promise;
+	};
+	async function matchingChannels(guildId, query, matchId = false) {
+		const channels = await getChannels(guildId);
+		if (matchId && /^\d+$/.test(query)) {
+			const ids = channels.filter((channel) => channel.id === query);
+			if (ids.length) return ids;
+		}
+		const slug = normalizeDiscordSlug(query);
+		return channels.filter((channel) => normalizeDiscordSlug(channel.name) === slug);
+	}
+	const resolveEntry = async (input) => {
+		const parsed = parseDiscordAllowlistInput(input, "channel");
+		const unresolved = {
+			input,
+			resolved: false
+		};
+		if (parsed.guildOnly) {
+			const guild = filterDiscordGuilds(guilds, {
+				guildId: parsed.guildId,
+				guildName: parsed.guild
+			})[0];
+			return {
+				input,
+				resolved: Boolean(guild),
+				guildId: guild ? guild.id : parsed.guildId,
+				guildName: guild ? guild.name : parsed.guild
+			};
+		}
+		if (parsed.id) {
+			const channelId = parsed.id;
+			const result = await fetchChannel(token, fetcher, channelId);
+			if (result.status === "found") {
+				const channel = result.channel;
+				const guild = guilds.find((entry) => entry.id === channel.guildId);
+				if (parsed.guildId && parsed.guildId !== channel.guildId) return {
+					...unresolved,
+					guildId: parsed.guildId,
+					guildName: guilds.find((entry) => entry.id === parsed.guildId)?.name,
+					channelId,
+					channelName: channel.name,
+					note: guild?.name ? `channel belongs to guild ${guild.name}` : "channel belongs to a different guild"
+				};
+				return resolvedChannelResult(input, channel, guild?.name);
+			}
+			if (result.status === "not-found" && parsed.guildId) {
+				const guild = guilds.find((entry) => entry.id === parsed.guildId);
+				const match = guild && preferActiveMatch(await matchingChannels(guild.id, channelId));
+				if (match) return resolvedChannelResult(input, match, guild?.name);
+			}
+			return {
+				...unresolved,
+				guildId: parsed.guildId,
+				channelId
+			};
+		}
+		const guildScoped = Boolean(parsed.guildId || parsed.guild);
+		const guild = guildScoped ? filterDiscordGuilds(guilds, {
+			guildId: parsed.guildId,
+			guildName: parsed.guild
+		})[0] : void 0;
+		const channelName = guildScoped ? parsed.name?.trim() : input.trim().replace(/^#/, "");
+		if (guildScoped && (!guild || !channelName)) return {
+			...unresolved,
+			guildId: parsed.guildId,
+			guildName: parsed.guild,
+			channelName: channelName ?? parsed.name
+		};
+		if (!channelName) return {
+			...unresolved,
+			channelName
+		};
+		let candidates = [];
+		for (const candidateGuild of guild ? [guild] : guilds) candidates = candidates.concat(await matchingChannels(candidateGuild.id, channelName, guildScoped));
+		const match = preferActiveMatch(candidates);
+		if (match) {
+			const matchedGuild = guild ?? guilds.find((entry) => entry.id === match.guildId);
+			return {
+				...resolvedChannelResult(input, match, matchedGuild?.name),
+				...!guildScoped ? { note: candidates.length > 1 && matchedGuild?.name ? `matched multiple; chose ${matchedGuild.name}` : void 0 } : {}
+			};
+		}
+		return guild ? {
+			...unresolved,
+			guildId: guild.id,
+			guildName: guild.name,
+			channelName: parsed.name,
+			note: `channel not found in guild ${guild.name}`
+		} : {
+			...unresolved,
+			channelName
+		};
+	};
+	const results = [];
+	for (const input of params.entries) results.push(await resolveEntry(input));
+	return results;
+}
+//#endregion
+export { resolve_channels_exports as n, resolveDiscordChannelAllowlist as t };