@openclaw/discord 2026.7.2-beta.5 → 2026.7.33

package/dist/thread-bindings.state-Cgi5uRn-.js

@@ -1,301 +0,0 @@
-import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.js";
-import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { recordOutboundMessageIdentity } from "openclaw/plugin-sdk/channel-outbound";
-//#region extensions/discord/src/monitor/thread-bindings.state.ts
-const THREAD_BINDINGS_STATE_KEY = Symbol.for("openclaw.discordThreadBindingsState");
-let threadBindingsState;
-function createThreadBindingsGlobalState() {
-	return {
-		managersByAccountId: /* @__PURE__ */ new Map(),
-		bindingsByThreadId: /* @__PURE__ */ new Map(),
-		bindingsBySessionKey: /* @__PURE__ */ new Map(),
-		tokensByAccountId: /* @__PURE__ */ new Map(),
-		reusableWebhooksByAccountChannel: /* @__PURE__ */ new Map(),
-		persistByAccountId: /* @__PURE__ */ new Map(),
-		loadedBindings: false,
-		loadedPersistentBindings: false,
-		persistenceAvailable: true,
-		lastPersistedAtMs: 0
-	};
-}
-function resolveThreadBindingsGlobalState() {
-	if (!threadBindingsState) {
-		const globalStore = globalThis;
-		threadBindingsState = globalStore[THREAD_BINDINGS_STATE_KEY] ?? createThreadBindingsGlobalState();
-		globalStore[THREAD_BINDINGS_STATE_KEY] = threadBindingsState;
-	}
-	return threadBindingsState;
-}
-const THREAD_BINDINGS_STATE = resolveThreadBindingsGlobalState();
-const MANAGERS_BY_ACCOUNT_ID = THREAD_BINDINGS_STATE.managersByAccountId;
-const BINDINGS_BY_THREAD_ID = THREAD_BINDINGS_STATE.bindingsByThreadId;
-const BINDINGS_BY_SESSION_KEY = THREAD_BINDINGS_STATE.bindingsBySessionKey;
-const TOKENS_BY_ACCOUNT_ID = THREAD_BINDINGS_STATE.tokensByAccountId;
-const REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL = THREAD_BINDINGS_STATE.reusableWebhooksByAccountChannel;
-const PERSIST_BY_ACCOUNT_ID = THREAD_BINDINGS_STATE.persistByAccountId;
-const THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS = 15e3;
-const THREAD_BINDINGS_NAMESPACE = "thread-bindings";
-const THREAD_BINDINGS_MAX_ENTRIES = 1e4;
-function rememberThreadBindingToken(params) {
-	const normalizedAccountId = normalizeAccountId(params.accountId);
-	const token = params.token?.trim();
-	if (!token) return;
-	TOKENS_BY_ACCOUNT_ID.set(normalizedAccountId, token);
-}
-function forgetThreadBindingToken(accountId) {
-	TOKENS_BY_ACCOUNT_ID.delete(normalizeAccountId(accountId));
-}
-function getThreadBindingToken(accountId) {
-	return TOKENS_BY_ACCOUNT_ID.get(normalizeAccountId(accountId));
-}
-function shouldDefaultPersist() {
-	return !(process.env.VITEST || false);
-}
-function openThreadBindingsStore() {
-	return getDiscordRuntime().state.openSyncKeyedStore({
-		namespace: THREAD_BINDINGS_NAMESPACE,
-		maxEntries: THREAD_BINDINGS_MAX_ENTRIES
-	});
-}
-function normalizeTargetKind(raw, targetSessionKey) {
-	if (raw === "subagent" || raw === "acp") return raw;
-	return targetSessionKey.includes(":subagent:") ? "subagent" : "acp";
-}
-function normalizeThreadId(raw) {
-	return normalizeOptionalStringifiedId(raw);
-}
-function toBindingRecordKey(params) {
-	return `${normalizeAccountId(params.accountId)}:${params.threadId.trim()}`;
-}
-function resolveBindingRecordKey(params) {
-	const threadId = normalizeThreadId(params.threadId);
-	if (!threadId) return;
-	return toBindingRecordKey({
-		accountId: normalizeAccountId(params.accountId),
-		threadId
-	});
-}
-function normalizePersistedBinding(threadIdKey, raw) {
-	if (!raw || typeof raw !== "object") return null;
-	const value = raw;
-	const threadId = normalizeThreadId(value.threadId ?? threadIdKey);
-	const channelId = normalizeOptionalString(value.channelId) ?? "";
-	const targetSessionKey = normalizeOptionalString(value.targetSessionKey) ?? "";
-	if (!threadId || !channelId || !targetSessionKey) return null;
-	const accountId = normalizeAccountId(value.accountId);
-	const targetKind = normalizeTargetKind(value.targetKind, targetSessionKey);
-	const agentId = (normalizeOptionalString(value.agentId) ?? "") || resolveAgentIdFromSessionKey(targetSessionKey);
-	const label = normalizeOptionalString(value.label);
-	const webhookId = normalizeOptionalString(value.webhookId);
-	const webhookToken = normalizeOptionalString(value.webhookToken);
-	const boundBy = normalizeOptionalString(value.boundBy) ?? "system";
-	const boundAt = typeof value.boundAt === "number" && Number.isFinite(value.boundAt) ? Math.floor(value.boundAt) : Date.now();
-	const lastActivityAt = typeof value.lastActivityAt === "number" && Number.isFinite(value.lastActivityAt) ? Math.max(0, Math.floor(value.lastActivityAt)) : boundAt;
-	const idleTimeoutMs = typeof value.idleTimeoutMs === "number" && Number.isFinite(value.idleTimeoutMs) ? Math.max(0, Math.floor(value.idleTimeoutMs)) : void 0;
-	const maxAgeMs = typeof value.maxAgeMs === "number" && Number.isFinite(value.maxAgeMs) ? Math.max(0, Math.floor(value.maxAgeMs)) : void 0;
-	const metadata = value.metadata && typeof value.metadata === "object" ? { ...value.metadata } : void 0;
-	const record = {
-		accountId,
-		channelId,
-		threadId,
-		targetKind,
-		targetSessionKey,
-		agentId,
-		boundBy,
-		boundAt,
-		lastActivityAt
-	};
-	if (label !== void 0) record.label = label;
-	if (webhookId !== void 0) record.webhookId = webhookId;
-	if (webhookToken !== void 0) record.webhookToken = webhookToken;
-	if (idleTimeoutMs !== void 0) record.idleTimeoutMs = idleTimeoutMs;
-	if (maxAgeMs !== void 0) record.maxAgeMs = maxAgeMs;
-	if (metadata !== void 0) record.metadata = metadata;
-	return record;
-}
-function normalizeThreadBindingDurationMs(raw, defaultsTo) {
-	if (typeof raw !== "number" || !Number.isFinite(raw)) return defaultsTo;
-	const durationMs = Math.floor(raw);
-	if (durationMs < 0) return defaultsTo;
-	return durationMs;
-}
-function resolveThreadBindingIdleTimeoutMs(params) {
-	const explicit = params.record.idleTimeoutMs;
-	if (typeof explicit === "number" && Number.isFinite(explicit)) return Math.max(0, Math.floor(explicit));
-	return Math.max(0, Math.floor(params.defaultIdleTimeoutMs));
-}
-function resolveThreadBindingMaxAgeMs(params) {
-	const explicit = params.record.maxAgeMs;
-	if (typeof explicit === "number" && Number.isFinite(explicit)) return Math.max(0, Math.floor(explicit));
-	return Math.max(0, Math.floor(params.defaultMaxAgeMs));
-}
-function resolveThreadBindingInactivityExpiresAt(params) {
-	const idleTimeoutMs = resolveThreadBindingIdleTimeoutMs({
-		record: params.record,
-		defaultIdleTimeoutMs: params.defaultIdleTimeoutMs
-	});
-	if (idleTimeoutMs <= 0) return;
-	const lastActivityAt = Math.floor(params.record.lastActivityAt);
-	if (!Number.isFinite(lastActivityAt) || lastActivityAt <= 0) return;
-	return lastActivityAt + idleTimeoutMs;
-}
-function resolveThreadBindingMaxAgeExpiresAt(params) {
-	const maxAgeMs = resolveThreadBindingMaxAgeMs({
-		record: params.record,
-		defaultMaxAgeMs: params.defaultMaxAgeMs
-	});
-	if (maxAgeMs <= 0) return;
-	const boundAt = Math.floor(params.record.boundAt);
-	if (!Number.isFinite(boundAt) || boundAt <= 0) return;
-	return boundAt + maxAgeMs;
-}
-function linkSessionBinding(targetSessionKey, bindingKey) {
-	const key = targetSessionKey.trim();
-	if (!key) return;
-	const threads = BINDINGS_BY_SESSION_KEY.get(key) ?? /* @__PURE__ */ new Set();
-	threads.add(bindingKey);
-	BINDINGS_BY_SESSION_KEY.set(key, threads);
-}
-function unlinkSessionBinding(targetSessionKey, bindingKey) {
-	const key = targetSessionKey.trim();
-	if (!key) return;
-	const threads = BINDINGS_BY_SESSION_KEY.get(key);
-	if (!threads) return;
-	threads.delete(bindingKey);
-	if (threads.size === 0) BINDINGS_BY_SESSION_KEY.delete(key);
-}
-function toReusableWebhookKey(params) {
-	return `${normalizeLowercaseStringOrEmpty(params.accountId)}:${params.channelId.trim()}`;
-}
-function rememberReusableWebhook(record) {
-	const webhookId = record.webhookId?.trim();
-	const webhookToken = record.webhookToken?.trim();
-	if (!webhookId || !webhookToken) return;
-	const key = toReusableWebhookKey({
-		accountId: record.accountId,
-		channelId: record.channelId
-	});
-	REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.set(key, {
-		webhookId,
-		webhookToken
-	});
-}
-function refreshUnboundThreadWebhookIdentity(record) {
-	const sourceId = record.webhookId?.trim();
-	if (!sourceId) return;
-	recordOutboundMessageIdentity({
-		channel: "discord",
-		accountId: record.accountId,
-		conversationId: record.threadId,
-		sourceId
-	});
-}
-function setBindingRecord(record) {
-	const bindingKey = toBindingRecordKey({
-		accountId: record.accountId,
-		threadId: record.threadId
-	});
-	const existing = BINDINGS_BY_THREAD_ID.get(bindingKey);
-	if (existing) unlinkSessionBinding(existing.targetSessionKey, bindingKey);
-	BINDINGS_BY_THREAD_ID.set(bindingKey, record);
-	linkSessionBinding(record.targetSessionKey, bindingKey);
-	rememberReusableWebhook(record);
-}
-function removeBindingRecord(bindingKeyRaw) {
-	const key = bindingKeyRaw.trim();
-	if (!key) return null;
-	const existing = BINDINGS_BY_THREAD_ID.get(key);
-	if (!existing) return null;
-	BINDINGS_BY_THREAD_ID.delete(key);
-	unlinkSessionBinding(existing.targetSessionKey, key);
-	return existing;
-}
-function shouldPersistAnyBindingState() {
-	for (const value of PERSIST_BY_ACCOUNT_ID.values()) if (value) return true;
-	return false;
-}
-function shouldPersistBindingMutations() {
-	if (!THREAD_BINDINGS_STATE.persistenceAvailable) return false;
-	if (shouldPersistAnyBindingState()) return true;
-	return THREAD_BINDINGS_STATE.loadedPersistentBindings;
-}
-function toPersistedBindingRecord(record) {
-	const serialized = JSON.stringify(record);
-	if (!serialized) return { ...record };
-	return JSON.parse(serialized);
-}
-function saveBindingsToDisk(params = {}) {
-	if (!params.force && !shouldPersistAnyBindingState()) return;
-	if (!THREAD_BINDINGS_STATE.persistenceAvailable) return;
-	const minIntervalMs = typeof params.minIntervalMs === "number" && Number.isFinite(params.minIntervalMs) ? Math.max(0, Math.floor(params.minIntervalMs)) : 0;
-	const now = Date.now();
-	if (!params.force && minIntervalMs > 0 && THREAD_BINDINGS_STATE.lastPersistedAtMs > 0 && now - THREAD_BINDINGS_STATE.lastPersistedAtMs < minIntervalMs) return;
-	try {
-		const store = openThreadBindingsStore();
-		const persistedKeys = /* @__PURE__ */ new Set();
-		for (const [bindingKey, record] of BINDINGS_BY_THREAD_ID.entries()) {
-			store.register(bindingKey, toPersistedBindingRecord(record));
-			persistedKeys.add(bindingKey);
-		}
-		for (const entry of store.entries()) if (!persistedKeys.has(entry.key)) store.delete(entry.key);
-		THREAD_BINDINGS_STATE.loadedPersistentBindings = persistedKeys.size > 0;
-		THREAD_BINDINGS_STATE.lastPersistedAtMs = now;
-	} catch {
-		THREAD_BINDINGS_STATE.persistenceAvailable = false;
-	}
-}
-function ensureBindingsLoaded() {
-	if (THREAD_BINDINGS_STATE.loadedBindings) return;
-	THREAD_BINDINGS_STATE.loadedBindings = true;
-	BINDINGS_BY_THREAD_ID.clear();
-	BINDINGS_BY_SESSION_KEY.clear();
-	REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.clear();
-	THREAD_BINDINGS_STATE.loadedPersistentBindings = false;
-	const entries = (() => {
-		try {
-			return openThreadBindingsStore().entries();
-		} catch {
-			THREAD_BINDINGS_STATE.persistenceAvailable = false;
-			return null;
-		}
-	})();
-	if (!entries) return;
-	THREAD_BINDINGS_STATE.persistenceAvailable = true;
-	THREAD_BINDINGS_STATE.loadedPersistentBindings = entries.length > 0;
-	for (const entry of entries) {
-		const normalized = normalizePersistedBinding(entry.key, entry.value);
-		if (!normalized) continue;
-		setBindingRecord(normalized);
-	}
-}
-function resolveBindingIdsForSession(params) {
-	const key = params.targetSessionKey.trim();
-	if (!key) return [];
-	const ids = BINDINGS_BY_SESSION_KEY.get(key);
-	if (!ids) return [];
-	const out = [];
-	for (const bindingKey of ids.values()) {
-		const record = BINDINGS_BY_THREAD_ID.get(bindingKey);
-		if (!record) continue;
-		if (params.accountId && record.accountId !== params.accountId) continue;
-		if (params.targetKind && record.targetKind !== params.targetKind) continue;
-		out.push(bindingKey);
-	}
-	return out;
-}
-function resetThreadBindingsForTests() {
-	for (const manager of MANAGERS_BY_ACCOUNT_ID.values()) manager.stop();
-	MANAGERS_BY_ACCOUNT_ID.clear();
-	BINDINGS_BY_THREAD_ID.clear();
-	BINDINGS_BY_SESSION_KEY.clear();
-	REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.clear();
-	TOKENS_BY_ACCOUNT_ID.clear();
-	PERSIST_BY_ACCOUNT_ID.clear();
-	THREAD_BINDINGS_STATE.loadedBindings = false;
-	THREAD_BINDINGS_STATE.loadedPersistentBindings = false;
-	THREAD_BINDINGS_STATE.persistenceAvailable = true;
-	THREAD_BINDINGS_STATE.lastPersistedAtMs = 0;
-}
-//#endregion
-export { toBindingRecordKey as A, resolveThreadBindingInactivityExpiresAt as C, setBindingRecord as D, saveBindingsToDisk as E, shouldDefaultPersist as O, resolveThreadBindingIdleTimeoutMs as S, resolveThreadBindingMaxAgeMs as T, rememberThreadBindingToken as _, THREAD_BINDINGS_MAX_ENTRIES as a, resolveBindingIdsForSession as b, ensureBindingsLoaded as c, normalizePersistedBinding as d, normalizeTargetKind as f, rememberReusableWebhook as g, refreshUnboundThreadWebhookIdentity as h, REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL as i, toReusableWebhookKey as j, shouldPersistBindingMutations as k, forgetThreadBindingToken as l, normalizeThreadId as m, MANAGERS_BY_ACCOUNT_ID as n, THREAD_BINDINGS_NAMESPACE as o, normalizeThreadBindingDurationMs as p, PERSIST_BY_ACCOUNT_ID as r, THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS as s, BINDINGS_BY_THREAD_ID as t, getThreadBindingToken as u, removeBindingRecord as v, resolveThreadBindingMaxAgeExpiresAt as w, resolveBindingRecordKey as x, resetThreadBindingsForTests as y };

package/dist/timeouts-B9cy6RvQ.js

@@ -1,90 +0,0 @@
-import { resolveTimerTimeoutMs } from "openclaw/plugin-sdk/number-runtime";
-//#region extensions/discord/src/monitor/timeouts.ts
-const DISCORD_DEFAULT_LISTENER_TIMEOUT_MS = 12e4;
-const DISCORD_DEFAULT_INBOUND_WORKER_TIMEOUT_MS = 30 * 6e4;
-const DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS = 6e4;
-const DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS = 12e4;
-/** @deprecated Discord listener timeouts are compatibility-only. */
-function normalizeDiscordListenerTimeoutMs(raw) {
-	if (!Number.isFinite(raw) || (raw ?? 0) <= 0) return DISCORD_DEFAULT_LISTENER_TIMEOUT_MS;
-	return resolveTimerTimeoutMs(raw, DISCORD_DEFAULT_LISTENER_TIMEOUT_MS, 1e3);
-}
-/** @deprecated Discord no longer applies channel-owned inbound run timeouts. */
-function normalizeDiscordInboundWorkerTimeoutMs(raw) {
-	if (raw === 0) return;
-	if (typeof raw !== "number" || !Number.isFinite(raw) || raw < 0) return DISCORD_DEFAULT_INBOUND_WORKER_TIMEOUT_MS;
-	return resolveTimerTimeoutMs(raw, DISCORD_DEFAULT_INBOUND_WORKER_TIMEOUT_MS, 1);
-}
-/** @deprecated Compatibility helper for old Discord timeout integrations. */
-function isAbortError(error) {
-	if (typeof error !== "object" || error === null) return false;
-	return "name" in error && String(error.name) === "AbortError";
-}
-/** @deprecated Discord no longer uses this for channel-owned message run timeouts. */
-async function runDiscordTaskWithTimeout(params) {
-	const timeoutMs = params.timeoutMs === void 0 ? void 0 : resolveTimerTimeoutMs(params.timeoutMs, 0, 0);
-	const timeoutAbortController = timeoutMs ? new AbortController() : void 0;
-	const abortSignals = [...params.abortSignals ?? [], timeoutAbortController?.signal].filter((signal) => Boolean(signal));
-	const mergedAbortSignal = abortSignals.length > 1 ? AbortSignal.any(abortSignals) : abortSignals[0];
-	let timedOut = false;
-	let timeoutHandle = null;
-	const runPromise = params.run(mergedAbortSignal).catch((error) => {
-		if (!timedOut) throw error;
-		if (timeoutAbortController?.signal.aborted && isAbortError(error)) {
-			params.onAbortAfterTimeout?.();
-			return;
-		}
-		params.onErrorAfterTimeout?.(error);
-	});
-	try {
-		if (!timeoutMs) {
-			await runPromise;
-			return false;
-		}
-		const timeoutPromise = new Promise((resolve) => {
-			timeoutHandle = setTimeout(() => resolve("timeout"), timeoutMs);
-			timeoutHandle.unref?.();
-		});
-		if (await Promise.race([runPromise.then(() => "completed"), timeoutPromise]) === "timeout") {
-			timedOut = true;
-			timeoutAbortController?.abort();
-			await params.onTimeout(timeoutMs);
-			return true;
-		}
-		return false;
-	} finally {
-		if (timeoutHandle) clearTimeout(timeoutHandle);
-	}
-}
-async function raceWithTimeout(params) {
-	const timeoutMs = resolveTimerTimeoutMs(params.timeoutMs, 1);
-	let timeoutTimer;
-	const timeoutPromise = new Promise((resolve) => {
-		timeoutTimer = setTimeout(() => resolve(params.onTimeout()), timeoutMs);
-		timeoutTimer.unref?.();
-	});
-	try {
-		return await Promise.race([params.promise, timeoutPromise]);
-	} finally {
-		if (timeoutTimer) clearTimeout(timeoutTimer);
-	}
-}
-async function withAbortTimeout(params) {
-	const timeoutMs = resolveTimerTimeoutMs(params.timeoutMs, 1);
-	const controller = new AbortController();
-	let timeoutTimer;
-	const timeoutPromise = new Promise((_, reject) => {
-		timeoutTimer = setTimeout(() => {
-			controller.abort();
-			reject(params.createTimeoutError());
-		}, timeoutMs);
-		timeoutTimer.unref?.();
-	});
-	try {
-		return await Promise.race([params.run(controller.signal), timeoutPromise]);
-	} finally {
-		if (timeoutTimer) clearTimeout(timeoutTimer);
-	}
-}
-//#endregion
-export { isAbortError as a, raceWithTimeout as c, DISCORD_DEFAULT_LISTENER_TIMEOUT_MS as i, runDiscordTaskWithTimeout as l, DISCORD_ATTACHMENT_TOTAL_TIMEOUT_MS as n, normalizeDiscordInboundWorkerTimeoutMs as o, DISCORD_DEFAULT_INBOUND_WORKER_TIMEOUT_MS as r, normalizeDiscordListenerTimeoutMs as s, DISCORD_ATTACHMENT_IDLE_TIMEOUT_MS as t, withAbortTimeout as u };

package/dist/transcripts-source-BW2VfPX0.js

@@ -1,123 +0,0 @@
-import { Yt as __exportAll } from "./chunk-CMVEczdm.js";
-//#region extensions/discord/src/voice/transcripts-source.ts
-var transcripts_source_exports = /* @__PURE__ */ __exportAll({
-	discordVoiceTranscriptsSourceProvider: () => discordVoiceTranscriptsSourceProvider,
-	setDiscordTranscriptsVoiceManager: () => setDiscordTranscriptsVoiceManager
-});
-const managersByAccountId = /* @__PURE__ */ new Map();
-const managerWaiters = /* @__PURE__ */ new Set();
-function setDiscordTranscriptsVoiceManager(params) {
-	if (params.manager) {
-		managersByAccountId.set(params.accountId, params.manager);
-		for (const waiter of managerWaiters) if (!waiter.accountId || waiter.accountId === params.accountId) waiter.resolve();
-	} else managersByAccountId.delete(params.accountId);
-}
-function resolveManager(request) {
-	const accountId = request.session.source.accountId?.trim();
-	if (accountId) return managersByAccountId.get(accountId);
-	return [...managersByAccountId.values()][0];
-}
-async function waitForManager(request) {
-	const existing = resolveManager(request);
-	if (existing) return existing;
-	if (request.abortSignal?.aborted) return;
-	const startupWaitMs = request.startupWaitMs ?? 0;
-	if (startupWaitMs <= 0) return;
-	const accountId = request.session.source.accountId?.trim() || void 0;
-	await new Promise((resolve) => {
-		const waiter = {
-			accountId,
-			resolve: () => {
-				clearTimeout(timer);
-				request.abortSignal?.removeEventListener("abort", waiter.resolve);
-				managerWaiters.delete(waiter);
-				resolve();
-			}
-		};
-		const timer = setTimeout(waiter.resolve, startupWaitMs);
-		timer.unref?.();
-		request.abortSignal?.addEventListener("abort", waiter.resolve, { once: true });
-		managerWaiters.add(waiter);
-	});
-	if (request.abortSignal?.aborted) return;
-	return resolveManager(request);
-}
-const discordVoiceTranscriptsSourceProvider = {
-	id: "discord-voice",
-	aliases: ["discord"],
-	name: "Discord Voice",
-	sourceKinds: ["live-audio"],
-	async start(request) {
-		const manager = await waitForManager(request);
-		if (!manager) return {
-			ok: false,
-			error: "Discord voice manager is not available."
-		};
-		if (request.abortSignal?.aborted) return {
-			ok: false,
-			error: "Discord transcripts start aborted."
-		};
-		const guildId = request.session.source.guildId?.trim();
-		const channelId = request.session.source.channelId?.trim();
-		if (!guildId || !channelId) return {
-			ok: false,
-			error: "Discord transcripts require guildId and channelId."
-		};
-		const joined = await manager.join({
-			guildId,
-			channelId
-		}, { transcripts: {
-			sessionId: request.session.sessionId,
-			onUtterance: request.onUtterance
-		} });
-		if (!joined.ok) return {
-			ok: false,
-			error: joined.message
-		};
-		return {
-			ok: true,
-			session: request.session
-		};
-	},
-	async stop(request) {
-		const accountId = request.source.accountId?.trim();
-		const manager = accountId ? managersByAccountId.get(accountId) : [...managersByAccountId.values()][0];
-		if (!manager) return {
-			ok: false,
-			error: "Discord voice manager is not available."
-		};
-		const guildId = request.source.guildId?.trim();
-		if (!guildId) return {
-			ok: false,
-			error: "Discord transcripts require guildId."
-		};
-		const result = await manager.leave({
-			guildId,
-			channelId: request.source.channelId
-		}, { transcriptsSessionId: request.sessionId });
-		if (!result.ok) return {
-			ok: false,
-			error: result.message
-		};
-		return {
-			ok: true,
-			sessionId: request.sessionId,
-			stoppedAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-	},
-	async status(source) {
-		const accountId = source.accountId?.trim();
-		return (accountId ? managersByAccountId.get(accountId) : [...managersByAccountId.values()][0])?.status().map((entry) => ({
-			active: entry.ok,
-			message: entry.message,
-			source: {
-				providerId: "discord-voice",
-				accountId,
-				guildId: entry.guildId,
-				channelId: entry.channelId
-			}
-		})) ?? [];
-	}
-};
-//#endregion
-export { transcripts_source_exports as n, discordVoiceTranscriptsSourceProvider as t };

package/dist/typing-eAhz8LT2.js

@@ -1,14 +0,0 @@
-import { Dt as sendChannelTyping, Yt as __exportAll } from "./chunk-CMVEczdm.js";
-import { c as raceWithTimeout } from "./timeouts-B9cy6RvQ.js";
-//#region extensions/discord/src/monitor/typing.ts
-var typing_exports = /* @__PURE__ */ __exportAll({ sendTyping: () => sendTyping });
-const DISCORD_TYPING_START_TIMEOUT_MS = 5e3;
-async function sendTyping(params) {
-	if ((await raceWithTimeout({
-		promise: sendChannelTyping(params.rest, params.channelId).then(() => ({ kind: "sent" })),
-		timeoutMs: DISCORD_TYPING_START_TIMEOUT_MS,
-		onTimeout: () => ({ kind: "timeout" })
-	})).kind === "timeout") throw new Error(`discord typing start timed out after ${DISCORD_TYPING_START_TIMEOUT_MS}ms`);
-}
-//#endregion
-export { typing_exports as n, sendTyping as t };

package/node_modules/@discord/embedded-app-sdk/LICENSE.md

@@ -1,9 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Discord Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/node_modules/@discord/embedded-app-sdk/README.md

@@ -1,74 +0,0 @@
-# @discord/embedded-app-sdk
-
-<p align="center">
-  <img src="/assets/discord-embedded-apps.svg" alt="Discord Embedded App SDK" />
-<p>
-
-### The Embedded App SDK enables you to build rich, multiplayer experiences inside Discord.
-
-Activities are multiplayer games and social experiences in Discord. An Activity is a web application hosted in an iframe that can run within the Discord client on desktop, web, or mobile. The Embedded App SDK handles the communication between Discord and your iframed application.
-
-Read more about building Discord Activities with the Embedded App SDK on [https://docs.discord.com/developers/activities/overview](https://docs.discord.com/developers/activities/overview).
-
-## Resources
-
-- **[Embedded App SDK Docs](https://docs.discord.com/developers/developer-tools/embedded-app-sdk)** - Get familiar with the Embedded App SDK
-- **[Activity Examples](https://github.com/discord/embedded-app-sdk-examples)** - Explore examples of Discord Activities
-- **[Technical chat on Discord](https://discord.com/invite/discord-developers)** - Join us and other devs at DDevs at `#activities-dev-help`
-
-## Installing this package
-
-```shell
-npm install @discord/embedded-app-sdk
-```
-
-## Usage
-
-To use the SDK, import it into your project and construct a new instance of the DiscordSDK class.
-
-Below is a minimal example of setting up the SDK.
-Visit <https://github.com/discord/embedded-app-sdk-examples/tree/main/discord-activity-starter> for a complete example application. See more info on environment variables (`YOUR_OAUTH2_CLIENT_ID`, etc...) [here](https://docs.discord.com/developers/activities/building-an-activity#find-your-oauth2-credentials).
-
-```typescript
-import {DiscordSDK} from '@discord/embedded-app-sdk';
-const discordSdk = new DiscordSDK(YOUR_OAUTH2_CLIENT_ID);
-
-async function setup() {
-  // Wait for READY payload from the discord client
-  await discordSdk.ready();
-
-  // Pop open the OAuth permission modal and request for access to scopes listed in scope array below
-  const {code} = await discordSdk.commands.authorize({
-    client_id: YOUR_OAUTH2_CLIENT_ID,
-    response_type: 'code',
-    state: '',
-    prompt: 'none',
-    scope: ['identify', 'applications.commands'],
-  });
-
-  // Retrieve an access_token from your application's server
-  const response = await fetch('/.proxy/api/token', {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({
-      code,
-    }),
-  });
-  const {access_token} = await response.json();
-
-  // Authenticate with Discord client (using the access_token)
-  auth = await discordSdk.commands.authenticate({
-    access_token,
-  });
-}
-```
-
-## SDK development
-
-Developing a new feature or patching a bug on the SDK? Check out [this guide](/docs/local-sdk-development.md) to learn how to set up your local dev environment.
-
-## Discord Developer Terms of Service & Developer Policy
-
-Please note that while this SDK is licensed under the MIT License, the [Discord Developer Terms of Service](https://discord.com/developers/docs/policies-and-agreements/developer-terms-of-service) and [Discord Developer Policy](https://discord.com/developers/docs/policies-and-agreements/developer-policy) otherwise still apply to you and the applications you develop utilizing this SDK.

package/node_modules/@discord/embedded-app-sdk/node_modules/zod/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2025 Colin McDonnell
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.