@openclaw/discord 2026.9.6 → 2026.9.7

package/dist/.setup/thread-bindings.session-updates-CshfKghV.mjs

@@ -0,0 +1,359 @@
+import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.mjs";
+import { O as setBindingRecord, a as THREAD_BINDINGS_MAX_ENTRIES, b as removeBindingRecord, g as openThreadBindingsStore, l as ensureBindingsLoaded, n as MANAGERS_BY_ACCOUNT_ID, o as THREAD_BINDINGS_NAMESPACE, p as normalizePersistedBinding, r as PERSIST_BY_ACCOUNT_ID, s as THREAD_BINDINGS_STATE, t as BINDINGS_BY_THREAD_ID, u as ensureBindingsLoadedAsync, x as resolveBindingIdsForSession } from "./thread-bindings.state-g6v9zAym.mjs";
+import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
+import { createPluginStateErrorReporter } from "openclaw/plugin-sdk/plugin-state-runtime";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
+//#region extensions/discord/src/monitor/thread-bindings.persistence.ts
+function shouldPersistAnyBindingState() {
+	for (const value of PERSIST_BY_ACCOUNT_ID.values()) if (value) return true;
+	return false;
+}
+function shouldPersistBindingMutations() {
+	if (shouldPersistAnyBindingState()) return true;
+	return THREAD_BINDINGS_STATE.loadedPersistentBindings;
+}
+function snapshotThreadBindingJson(value) {
+	const serialized = JSON.stringify(value);
+	return serialized ? JSON.parse(serialized) : void 0;
+}
+function toPersistedBindingRecord(record) {
+	return normalizePersistedBinding(record.threadId, snapshotThreadBindingJson(record)) ?? { ...record };
+}
+function runThreadBindingAccountOperation(managers, operation) {
+	if (managers.length === 0) return operation();
+	const tails = THREAD_BINDINGS_STATE.accountOperationTails;
+	const predecessors = managers.map((manager) => tails.get(manager) ?? Promise.resolve());
+	const result = Promise.all(predecessors).then(operation);
+	const settled = result.then(() => {}, () => {});
+	for (const manager of managers) tails.set(manager, settled);
+	settled.then(() => {
+		for (const manager of managers) if (tails.get(manager) === settled) tails.delete(manager);
+	});
+	return result;
+}
+function drainThreadBindingAccountOperations(manager) {
+	return THREAD_BINDINGS_STATE.accountOperationTails.get(manager) ?? Promise.resolve();
+}
+function runThreadBindingMutation(operation) {
+	const result = THREAD_BINDINGS_STATE.mutationTail.then(operation);
+	THREAD_BINDINGS_STATE.mutationTail = result.then(() => {}, () => {});
+	return result;
+}
+function drainThreadBindingMutations() {
+	return THREAD_BINDINGS_STATE.mutationTail;
+}
+async function commitBindingRecord(params) {
+	const revision = THREAD_BINDINGS_STATE.revision;
+	let authorityRefused = false;
+	let targetCommitted = false;
+	let committedWrites = 0;
+	const assertCurrent = () => {
+		try {
+			params.assertCurrent?.();
+			if (THREAD_BINDINGS_STATE.revision !== revision || BINDINGS_BY_THREAD_ID.get(params.bindingKey) !== params.previous) throw new Error("Discord thread binding changed during persistence");
+		} catch (error) {
+			authorityRefused = true;
+			throw error;
+		}
+	};
+	assertCurrent();
+	const now = Date.now();
+	if (params.persist && THREAD_BINDINGS_STATE.persistenceAvailable && !(params.minIntervalMs && THREAD_BINDINGS_STATE.lastPersistedAtMs > 0 && now - THREAD_BINDINGS_STATE.lastPersistedAtMs < params.minIntervalMs)) {
+		const records = new Map(BINDINGS_BY_THREAD_ID);
+		if (params.next) records.set(params.bindingKey, params.next);
+		else records.delete(params.bindingKey);
+		const active = {
+			targetKey: params.bindingKey,
+			deletingTarget: params.next === null,
+			nextRecord: params.next,
+			writingKey: void 0,
+			committedKeys: /* @__PURE__ */ new Set()
+		};
+		THREAD_BINDINGS_STATE.activePersistence = active;
+		try {
+			const store = getDiscordRuntime().state.openKeyedStore({
+				namespace: THREAD_BINDINGS_NAMESPACE,
+				maxEntries: THREAD_BINDINGS_MAX_ENTRIES
+			});
+			for (const [key, record] of records) {
+				assertCurrent();
+				const persisted = toPersistedBindingRecord(record);
+				if (key === params.bindingKey) active.nextRecord = persisted;
+				active.writingKey = key;
+				await store.register(key, persisted, { assertCurrent });
+				active.writingKey = void 0;
+				active.committedKeys.add(key);
+				committedWrites += 1;
+				targetCommitted ||= key === params.bindingKey;
+			}
+			assertCurrent();
+			const entries = await store.entries();
+			assertCurrent();
+			for (const entry of entries) if (!records.has(entry.key)) {
+				active.writingKey = entry.key;
+				await store.delete(entry.key, { assertCurrent });
+				active.writingKey = void 0;
+				active.committedKeys.add(entry.key);
+				committedWrites += 1;
+				targetCommitted ||= entry.key === params.bindingKey;
+			}
+			if (!params.next) targetCommitted = true;
+			assertCurrent();
+			THREAD_BINDINGS_STATE.loadedPersistentBindings = records.size > 0;
+			THREAD_BINDINGS_STATE.lastPersistedAtMs = now;
+		} catch (error) {
+			let failure = error;
+			if (!authorityRefused) try {
+				assertCurrent();
+			} catch (interruption) {
+				failure = interruption;
+			}
+			if (authorityRefused) {
+				createPluginStateErrorReporter(getDiscordRuntime, "discord", "thread-bindings", "Discord thread binding save interrupted; acknowledged writes were retained.", () => ({
+					committedWrites,
+					targetCommitted
+				}))(failure);
+				if (!targetCommitted) {
+					if (committedWrites === 0) throw failure;
+					throw new Error(`Discord thread binding changed during persistence after ${committedWrites} acknowledged writes`, { cause: error });
+				}
+			} else {
+				THREAD_BINDINGS_STATE.persistenceAvailable = false;
+				logVerbose("discord thread binding persistence unavailable; keeping bindings in memory");
+			}
+		} finally {
+			delete THREAD_BINDINGS_STATE.activePersistence;
+		}
+	}
+	if (!targetCommitted) assertCurrent();
+	if (BINDINGS_BY_THREAD_ID.get(params.bindingKey) !== params.previous) return;
+	if (params.next) setBindingRecord(params.next);
+	else removeBindingRecord(params.bindingKey);
+}
+function persistBindingsSync(update, removedKey) {
+	const store = openThreadBindingsStore();
+	const active = THREAD_BINDINGS_STATE.activePersistence;
+	let updatedRecord;
+	for (const [key, record] of BINDINGS_BY_THREAD_ID) if (key === update?.bindingKey || active?.targetKey === key && active.deletingTarget || active?.writingKey === key || active?.committedKeys.has(key)) {
+		if (!store.update) throw new Error("Discord synchronous compatibility requires atomic state update");
+		let next;
+		store.update(key, (current) => {
+			let base = record;
+			if (active?.targetKey === key) {
+				if (!current && active.deletingTarget) base = void 0;
+				else if (current && active.nextRecord && (active.writingKey === key || active.committedKeys.has(key)) && JSON.stringify(toPersistedBindingRecord(current)) === JSON.stringify(toPersistedBindingRecord(active.nextRecord))) base = normalizePersistedBinding(key, current) ?? record;
+			}
+			if (key === update?.bindingKey) update.observe?.(current && normalizePersistedBinding(key, current) ? base : void 0);
+			next = base ? key === update?.bindingKey ? update.transform(base) : base : void 0;
+			return next ? toPersistedBindingRecord(next) : void 0;
+		});
+		if (key === update?.bindingKey) updatedRecord = next;
+		if (next) {
+			if (next !== record) setBindingRecord(next);
+		} else if (!(active?.targetKey === key && active.deletingTarget)) removeBindingRecord(key);
+	} else store.register(key, toPersistedBindingRecord(record));
+	for (const entry of store.entries()) if (!BINDINGS_BY_THREAD_ID.has(entry.key)) {
+		if (entry.key !== removedKey && active?.targetKey === entry.key && !active.deletingTarget) {
+			const committed = normalizePersistedBinding(entry.key, entry.value);
+			if (committed) {
+				setBindingRecord(committed);
+				continue;
+			}
+		}
+		store.delete(entry.key);
+	}
+	THREAD_BINDINGS_STATE.loadedPersistentBindings = BINDINGS_BY_THREAD_ID.size > 0;
+	THREAD_BINDINGS_STATE.lastPersistedAtMs = Date.now();
+	return updatedRecord;
+}
+/** Public SDK compatibility only; bundled callers await worker mutations. */
+function updateBindingRecordSync(params) {
+	const record = BINDINGS_BY_THREAD_ID.get(params.bindingKey);
+	if (!record) return null;
+	const now = Date.now();
+	const persist = params.persist && THREAD_BINDINGS_STATE.persistenceAvailable && (THREAD_BINDINGS_STATE.activePersistence || !params.minIntervalMs || now - THREAD_BINDINGS_STATE.lastPersistedAtMs >= params.minIntervalMs);
+	let observed;
+	if (persist) try {
+		return persistBindingsSync({
+			...params,
+			observe: (current) => {
+				observed = current;
+			}
+		}) ?? null;
+	} catch {
+		THREAD_BINDINGS_STATE.persistenceAvailable = false;
+		logVerbose("discord thread binding persistence unavailable; keeping bindings in memory");
+	}
+	const current = BINDINGS_BY_THREAD_ID.get(params.bindingKey);
+	if (current !== record) return current ?? null;
+	if (THREAD_BINDINGS_STATE.activePersistence?.targetKey === params.bindingKey && !observed) {
+		logVerbose("discord synchronous binding update skipped: pending target read unavailable");
+		return null;
+	}
+	const next = params.transform(observed ?? record);
+	setBindingRecord(next);
+	return next;
+}
+/** Public SDK compatibility only; bundled callers await worker mutations. */
+function removeBindingRecordSync(bindingKey) {
+	const record = BINDINGS_BY_THREAD_ID.get(bindingKey);
+	if (!record) return null;
+	if (!shouldPersistBindingMutations() || !THREAD_BINDINGS_STATE.persistenceAvailable) return THREAD_BINDINGS_STATE.activePersistence?.targetKey === bindingKey ? null : removeBindingRecord(bindingKey);
+	let removed = null;
+	let observed = null;
+	let replacement;
+	try {
+		const store = openThreadBindingsStore();
+		if (!store.deleteIf) throw new Error("Discord synchronous compatibility requires atomic state deletion");
+		const deleted = store.deleteIf(bindingKey, (current) => {
+			const normalized = normalizePersistedBinding(bindingKey, current);
+			observed = normalized;
+			const pending = THREAD_BINDINGS_STATE.activePersistence;
+			if (normalized && pending?.targetKey === bindingKey && pending.nextRecord && (pending.writingKey === bindingKey || pending.committedKeys.has(bindingKey)) && JSON.stringify(toPersistedBindingRecord(normalized)) === JSON.stringify(toPersistedBindingRecord(pending.nextRecord)) && (normalized.targetSessionKey !== record.targetSessionKey || normalized.targetKind !== record.targetKind)) {
+				replacement = normalized;
+				return false;
+			}
+			return true;
+		});
+		if (replacement) {
+			setBindingRecord(replacement);
+			return null;
+		}
+		const pending = THREAD_BINDINGS_STATE.activePersistence;
+		if (!deleted && pending?.targetKey === bindingKey && pending.deletingTarget) return null;
+		removed = removeBindingRecord(bindingKey);
+		persistBindingsSync(void 0, bindingKey);
+		return removed;
+	} catch {
+		THREAD_BINDINGS_STATE.persistenceAvailable = false;
+		if (replacement) {
+			setBindingRecord(replacement);
+			return null;
+		}
+		if (THREAD_BINDINGS_STATE.activePersistence?.targetKey === bindingKey && !observed && !removed) {
+			logVerbose("discord synchronous binding removal skipped: pending target read unavailable");
+			return null;
+		}
+		return removed ?? removeBindingRecord(bindingKey);
+	}
+}
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.session-shared.ts
+function normalizeNonNegativeMs(raw) {
+	if (!Number.isFinite(raw)) return 0;
+	return Math.max(0, Math.floor(raw));
+}
+function resolveBindingIdsForTargetSession(params) {
+	ensureBindingsLoaded();
+	const targetSessionKey = params.targetSessionKey.trim();
+	if (!targetSessionKey) return [];
+	const accountId = params.accountId ? normalizeAccountId(params.accountId) : void 0;
+	return resolveBindingIdsForSession({
+		targetSessionKey,
+		accountId,
+		targetKind: params.targetKind
+	});
+}
+function mutateBindingsForTargetSession(params, update, onRemoved) {
+	const accountId = params.accountId ? normalizeAccountId(params.accountId) : void 0;
+	const admittedOwners = new Map([...MANAGERS_BY_ACCOUNT_ID].filter(([ownerAccountId]) => accountId === void 0 || ownerAccountId === accountId).map(([ownerAccountId, manager]) => [ownerAccountId, {
+		manager,
+		stopping: manager.isStopping()
+	}]));
+	return runThreadBindingAccountOperation([...admittedOwners.values()].map(({ manager }) => manager), () => runThreadBindingMutation(async () => {
+		await ensureBindingsLoadedAsync();
+		const ids = resolveBindingIdsForTargetSession(params);
+		const owners = /* @__PURE__ */ new Map();
+		for (const bindingKey of ids) {
+			const existing = BINDINGS_BY_THREAD_ID.get(bindingKey);
+			if (!existing) continue;
+			const manager = MANAGERS_BY_ACCOUNT_ID.get(existing.accountId);
+			const admitted = admittedOwners.get(existing.accountId);
+			if (admitted?.stopping || !admitted && manager?.isStopping()) throw new Error("Discord thread binding manager is stopping");
+			if (admitted?.manager !== manager) throw new Error("Discord thread binding manager changed");
+			owners.set(existing.accountId, manager);
+		}
+		const now = Date.now();
+		const updated = [];
+		for (const bindingKey of ids) {
+			const existing = BINDINGS_BY_THREAD_ID.get(bindingKey);
+			if (!existing) continue;
+			const manager = owners.get(existing.accountId);
+			const assertCurrent = () => {
+				if (MANAGERS_BY_ACCOUNT_ID.get(existing.accountId) !== manager) throw new Error("Discord thread binding manager changed");
+			};
+			const nextRecord = update(existing, now);
+			await commitBindingRecord({
+				bindingKey,
+				previous: existing,
+				next: nextRecord,
+				persist: shouldPersistBindingMutations(),
+				assertCurrent
+			});
+			if (!nextRecord) onRemoved?.(existing, manager);
+			updated.push(nextRecord ?? existing);
+		}
+		return updated;
+	}));
+}
+/** @deprecated Generic SDK synchronous lifecycle compatibility. */
+function updateBindingsForTargetSessionSync(ids, update) {
+	const now = Date.now();
+	const updated = [];
+	for (const bindingKey of ids) {
+		const existing = BINDINGS_BY_THREAD_ID.get(bindingKey);
+		if (!existing) continue;
+		if (MANAGERS_BY_ACCOUNT_ID.get(existing.accountId)?.isStopping()) throw new Error("Discord thread binding manager is stopping");
+		const next = updateBindingRecordSync({
+			bindingKey,
+			transform: (record) => record.targetSessionKey === existing.targetSessionKey ? update(record, now) : record,
+			persist: shouldPersistBindingMutations()
+		});
+		if (next?.targetSessionKey === existing.targetSessionKey) updated.push(next);
+	}
+	return updated;
+}
+//#endregion
+//#region extensions/discord/src/monitor/thread-bindings.session-updates.ts
+async function setThreadBindingIdleTimeoutBySessionKeyAsync(input) {
+	const params = { ...input };
+	const idleTimeoutMs = normalizeNonNegativeMs(params.idleTimeoutMs);
+	return mutateBindingsForTargetSession(params, (existing, now) => ({
+		...existing,
+		idleTimeoutMs,
+		lastActivityAt: now
+	}));
+}
+async function setThreadBindingMaxAgeBySessionKeyAsync(input) {
+	const params = { ...input };
+	const maxAgeMs = normalizeNonNegativeMs(params.maxAgeMs);
+	return mutateBindingsForTargetSession(params, (existing, now) => ({
+		...existing,
+		maxAgeMs,
+		boundAt: now,
+		lastActivityAt: now
+	}));
+}
+/** @deprecated Use the awaited lifecycle setter; retained for the generic SDK contract. */
+function setThreadBindingIdleTimeoutBySessionKey(params) {
+	const ids = resolveBindingIdsForTargetSession(params);
+	const idleTimeoutMs = normalizeNonNegativeMs(params.idleTimeoutMs);
+	return updateBindingsForTargetSessionSync(ids, (existing, now) => ({
+		...existing,
+		idleTimeoutMs,
+		lastActivityAt: now
+	}));
+}
+/** @deprecated Use the awaited lifecycle setter; retained for the generic SDK contract. */
+function setThreadBindingMaxAgeBySessionKey(params) {
+	const ids = resolveBindingIdsForTargetSession(params);
+	const maxAgeMs = normalizeNonNegativeMs(params.maxAgeMs);
+	return updateBindingsForTargetSessionSync(ids, (existing, now) => ({
+		...existing,
+		maxAgeMs,
+		boundAt: now,
+		lastActivityAt: now
+	}));
+}
+//#endregion
+export { mutateBindingsForTargetSession as a, drainThreadBindingAccountOperations as c, runThreadBindingAccountOperation as d, runThreadBindingMutation as f, updateBindingRecordSync as h, setThreadBindingMaxAgeBySessionKeyAsync as i, drainThreadBindingMutations as l, snapshotThreadBindingJson as m, setThreadBindingIdleTimeoutBySessionKeyAsync as n, resolveBindingIdsForTargetSession as o, shouldPersistAnyBindingState as p, setThreadBindingMaxAgeBySessionKey as r, commitBindingRecord as s, setThreadBindingIdleTimeoutBySessionKey as t, removeBindingRecordSync as u };

package/dist/.setup/{thread-bindings.state-BThFQEga.mjs → thread-bindings.state-g6v9zAym.mjs}

@@ -1,7 +1,9 @@
-import { Ut as __exportAll } from "./discord-BXpHW-cu.mjs";
+import { t as __exportAll } from "./rolldown-runtime-B4FMCO8f.mjs";
 import { t as getDiscordRuntime } from "./runtime-DgnVQ7zW.mjs";
+import { resolveGlobalSingleton } from "openclaw/plugin-sdk/global-singleton";
 import { normalizeAccountId, resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/routing";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { asFiniteNumber, normalizeLowercaseStringOrEmpty, normalizeOptionalString, normalizeOptionalStringifiedId } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { logVerbose } from "openclaw/plugin-sdk/runtime-env";
 import { recordOutboundMessageIdentity } from "openclaw/plugin-sdk/outbound-echo-runtime";
 import { resolveThreadBindingExpiry } from "openclaw/plugin-sdk/thread-bindings-session-runtime";
 //#region extensions/discord/src/monitor/thread-bindings.state.ts
@@ -12,6 +14,7 @@ var thread_bindings_state_exports = /* @__PURE__ */ __exportAll({
 	REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL: () => REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL,
 	THREAD_BINDINGS_MAX_ENTRIES: () => THREAD_BINDINGS_MAX_ENTRIES,
 	THREAD_BINDINGS_NAMESPACE: () => THREAD_BINDINGS_NAMESPACE,
+	THREAD_BINDINGS_STATE: () => THREAD_BINDINGS_STATE,
 	THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS: () => THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS,
 	ensureBindingsLoaded: () => ensureBindingsLoaded,
 	ensureBindingsLoadedAsync: () => ensureBindingsLoadedAsync,
@@ -20,7 +23,7 @@ var thread_bindings_state_exports = /* @__PURE__ */ __exportAll({
 	normalizePersistedBinding: () => normalizePersistedBinding,
 	normalizeTargetKind: () => normalizeTargetKind,
 	normalizeThreadBindingDurationMs: () => normalizeThreadBindingDurationMs,
-	normalizeThreadId: () => normalizeThreadId,
+	openThreadBindingsStore: () => openThreadBindingsStore,
 	refreshUnboundThreadWebhookIdentity: () => refreshUnboundThreadWebhookIdentity,
 	rememberReusableWebhook: () => rememberReusableWebhook,
 	rememberThreadBindingToken: () => rememberThreadBindingToken,
@@ -32,15 +35,12 @@ var thread_bindings_state_exports = /* @__PURE__ */ __exportAll({
 	resolveThreadBindingInactivityExpiresAt: () => resolveThreadBindingInactivityExpiresAt,
 	resolveThreadBindingMaxAgeExpiresAt: () => resolveThreadBindingMaxAgeExpiresAt,
 	resolveThreadBindingMaxAgeMs: () => resolveThreadBindingMaxAgeMs,
-	saveBindingsToDisk: () => saveBindingsToDisk,
 	setBindingRecord: () => setBindingRecord,
 	shouldDefaultPersist: () => shouldDefaultPersist,
-	shouldPersistBindingMutations: () => shouldPersistBindingMutations,
 	toBindingRecordKey: () => toBindingRecordKey,
 	toReusableWebhookKey: () => toReusableWebhookKey
 });
 const THREAD_BINDINGS_STATE_KEY = Symbol.for("openclaw.discordThreadBindingsState");
-let threadBindingsState;
 function createThreadBindingsGlobalState() {
 	return {
 		managersByAccountId: /* @__PURE__ */ new Map(),
@@ -52,18 +52,14 @@ function createThreadBindingsGlobalState() {
 		loadedBindings: false,
 		loadedPersistentBindings: false,
 		persistenceAvailable: true,
-		lastPersistedAtMs: 0
+		lastPersistedAtMs: 0,
+		revision: 0,
+		mutationTail: Promise.resolve(),
+		accountOperationTails: /* @__PURE__ */ new WeakMap()
 	};
 }
-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 THREAD_BINDINGS_STATE = resolveGlobalSingleton(THREAD_BINDINGS_STATE_KEY, createThreadBindingsGlobalState);
+THREAD_BINDINGS_STATE.accountOperationTails ??= /* @__PURE__ */ new WeakMap();
 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;
@@ -98,14 +94,11 @@ 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);
+	const threadId = normalizeOptionalStringifiedId(params.threadId);
 	if (!threadId) return;
 	return toBindingRecordKey({
 		accountId: normalizeAccountId(params.accountId),
@@ -115,7 +108,7 @@ function resolveBindingRecordKey(params) {
 function normalizePersistedBinding(threadIdKey, raw) {
 	if (!raw || typeof raw !== "object") return null;
 	const value = raw;
-	const threadId = normalizeThreadId(value.threadId ?? threadIdKey);
+	const threadId = normalizeOptionalStringifiedId(value.threadId ?? threadIdKey);
 	const channelId = normalizeOptionalString(value.channelId) ?? "";
 	const targetSessionKey = normalizeOptionalString(value.targetSessionKey) ?? "";
 	if (!threadId || !channelId || !targetSessionKey) return null;
@@ -157,14 +150,10 @@ function normalizeThreadBindingDurationMs(raw, 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));
+	return Math.max(0, Math.floor(asFiniteNumber(params.record.idleTimeoutMs) ?? 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));
+	return Math.max(0, Math.floor(asFiniteNumber(params.record.maxAgeMs) ?? params.defaultMaxAgeMs));
 }
 function resolveTimestampExpiry(timestamp, durationMs) {
 	if (durationMs <= 0) return;
@@ -252,6 +241,7 @@ function setBindingRecord(record) {
 	const existing = BINDINGS_BY_THREAD_ID.get(bindingKey);
 	if (existing) unlinkSessionBinding(existing.targetSessionKey, bindingKey);
 	BINDINGS_BY_THREAD_ID.set(bindingKey, record);
+	THREAD_BINDINGS_STATE.revision += 1;
 	linkSessionBinding(record.targetSessionKey, bindingKey);
 	rememberReusableWebhook(record);
 }
@@ -261,46 +251,14 @@ function removeBindingRecord(bindingKeyRaw) {
 	const existing = BINDINGS_BY_THREAD_ID.get(key);
 	if (!existing) return null;
 	BINDINGS_BY_THREAD_ID.delete(key);
+	THREAD_BINDINGS_STATE.revision += 1;
 	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 normalizePersistedBinding(record.threadId, JSON.parse(serialized)) ?? { ...record };
-}
-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 beginBindingsLoad() {
 	THREAD_BINDINGS_STATE.loadedBindings = true;
 	BINDINGS_BY_THREAD_ID.clear();
+	THREAD_BINDINGS_STATE.revision += 1;
 	BINDINGS_BY_SESSION_KEY.clear();
 	REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL.clear();
 	THREAD_BINDINGS_STATE.loadedPersistentBindings = false;
@@ -337,6 +295,7 @@ async function loadBindingsAsync() {
 		if (!THREAD_BINDINGS_STATE.loadedBindings) {
 			beginBindingsLoad();
 			THREAD_BINDINGS_STATE.persistenceAvailable = false;
+			logVerbose("discord thread binding persistence unavailable; keeping bindings in memory");
 		}
 		return;
 	}
@@ -369,4 +328,4 @@ function resolveBindingIdsForSession(params) {
 	return out;
 }
 //#endregion
-export { resolveThreadBindingMaxAgeMs as C, shouldPersistBindingMutations as D, shouldDefaultPersist as E, thread_bindings_state_exports as O, resolveThreadBindingMaxAgeExpiresAt as S, setBindingRecord as T, resolveBindingIdsForSession as _, THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS as a, resolveThreadBindingIdleTimeoutMs as b, forgetThreadBindingToken as c, normalizeThreadBindingDurationMs as d, normalizeThreadId as f, removeBindingRecord as g, rememberThreadBindingToken as h, REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL as i, toReusableWebhookKey as k, getThreadBindingToken as l, rememberReusableWebhook as m, MANAGERS_BY_ACCOUNT_ID as n, ensureBindingsLoaded as o, refreshUnboundThreadWebhookIdentity as p, PERSIST_BY_ACCOUNT_ID as r, ensureBindingsLoadedAsync as s, BINDINGS_BY_THREAD_ID as t, normalizeTargetKind as u, resolveBindingRecordKey as v, saveBindingsToDisk as w, resolveThreadBindingInactivityExpiresAt as x, resolvePreparedThreadBindingLifecycle as y };
+export { thread_bindings_state_exports as A, resolvePreparedThreadBindingLifecycle as C, resolveThreadBindingMaxAgeMs as D, resolveThreadBindingMaxAgeExpiresAt as E, toReusableWebhookKey as M, setBindingRecord as O, resolveBindingRecordKey as S, resolveThreadBindingInactivityExpiresAt as T, refreshUnboundThreadWebhookIdentity as _, THREAD_BINDINGS_MAX_ENTRIES as a, removeBindingRecord as b, THREAD_BINDING_TOUCH_PERSIST_MIN_INTERVAL_MS as c, forgetThreadBindingToken as d, getThreadBindingToken as f, openThreadBindingsStore as g, normalizeThreadBindingDurationMs as h, REUSABLE_WEBHOOKS_BY_ACCOUNT_CHANNEL as i, toBindingRecordKey as j, shouldDefaultPersist as k, ensureBindingsLoaded as l, normalizeTargetKind as m, MANAGERS_BY_ACCOUNT_ID as n, THREAD_BINDINGS_NAMESPACE as o, normalizePersistedBinding as p, PERSIST_BY_ACCOUNT_ID as r, THREAD_BINDINGS_STATE as s, BINDINGS_BY_THREAD_ID as t, ensureBindingsLoadedAsync as u, rememberReusableWebhook as v, resolveThreadBindingIdleTimeoutMs as w, resolveBindingIdsForSession as x, rememberThreadBindingToken as y };