@openclaw/matrix 2026.9.6 → 2026.9.7

package/dist/.setup/sync-cache-state-BMtGMxU1.mjs

@@ -1,227 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
-import { O as resolveMatrixSqliteStateEnv } from "./storage-metadata-fHN6Df2m.mjs";
-import { isRecord } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createHash, randomUUID } from "node:crypto";
-import path from "node:path";
-import fs from "node:fs/promises";
-import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
-//#region extensions/matrix/src/matrix/client/sync-cache-state.ts
-var sync_cache_state_exports = /* @__PURE__ */ __exportAll({
-	MATRIX_SYNC_CACHE_VERSION: () => 1,
-	deleteMatrixSyncCacheStateFromStore: () => deleteMatrixSyncCacheStateFromStore,
-	hasMatrixSyncCacheStateInStore: () => hasMatrixSyncCacheStateInStore,
-	openMatrixSyncCacheStoreOptions: () => openMatrixSyncCacheStoreOptions,
-	readLegacyMatrixSyncCacheState: () => readLegacyMatrixSyncCacheState,
-	readPersistedStoreFromStore: () => readPersistedStoreFromStore,
-	writeMatrixSyncCacheStateToStore: () => writeMatrixSyncCacheStateToStore
-});
-const MATRIX_SYNC_CACHE_VERSION = 1;
-const SYNC_CACHE_NAMESPACE = "sync-cache";
-const SYNC_CACHE_MAX_ENTRIES = 2e4;
-const SYNC_CACHE_MAX_CHUNKS = Math.floor(19999 / 2);
-const SYNC_CACHE_STATE_KEY = "current";
-const SYNC_CACHE_CHUNK_BYTES = 24e3;
-const syncCacheOperations = new KeyedAsyncQueue();
-function normalizeRoomsData(value) {
-	if (!isRecord(value)) return null;
-	return {
-		join: isRecord(value.join) ? value.join : {},
-		invite: isRecord(value.invite) ? value.invite : {},
-		leave: isRecord(value.leave) ? value.leave : {},
-		knock: isRecord(value.knock) ? value.knock : {}
-	};
-}
-function toPersistedSyncData(value) {
-	if (!isRecord(value)) return null;
-	if (typeof value.nextBatch === "string" && value.nextBatch.trim()) {
-		const roomsData = normalizeRoomsData(value.roomsData);
-		if (!Array.isArray(value.accountData) || !roomsData) return null;
-		return {
-			nextBatch: value.nextBatch,
-			accountData: value.accountData,
-			roomsData
-		};
-	}
-	if (typeof value.next_batch === "string" && value.next_batch.trim()) {
-		const roomsData = normalizeRoomsData(value.rooms);
-		if (!roomsData) return null;
-		return {
-			nextBatch: value.next_batch,
-			accountData: isRecord(value.account_data) && Array.isArray(value.account_data.events) ? value.account_data.events : [],
-			roomsData
-		};
-	}
-	return null;
-}
-function normalizePersistedStore(value) {
-	if (!isRecord(value) || value.version !== 1) return null;
-	return {
-		version: 1,
-		savedSync: toPersistedSyncData(value.savedSync),
-		clientOptions: isRecord(value.clientOptions) ? value.clientOptions : void 0,
-		cleanShutdown: value.cleanShutdown === true
-	};
-}
-function normalizeLegacyPersistedStore(value) {
-	const persisted = normalizePersistedStore(value);
-	if (persisted) return persisted;
-	return {
-		version: 1,
-		savedSync: toPersistedSyncData(value),
-		cleanShutdown: false
-	};
-}
-async function readPersistedStoreFromStore(params) {
-	const { storageRootDir, store } = params;
-	return syncCacheOperations.enqueue(path.resolve(storageRootDir), () => readPersistedStore(store));
-}
-async function readPersistedStore(store) {
-	const stateKey = SYNC_CACHE_STATE_KEY;
-	const meta = await store.lookup(metaKey(stateKey));
-	if (!isSyncCacheMeta(meta)) return null;
-	const records = await store.lookupMany?.(Array.from({ length: meta.chunkCount }, (_, index) => chunkKey(stateKey, meta.generation, index)));
-	const chunks = [];
-	for (let index = 0; index < meta.chunkCount; index += 1) {
-		const result = records?.[index];
-		if (result && !result.ok) throw result.error;
-		const chunk = records ? result?.value : await store.lookup(chunkKey(stateKey, meta.generation, index));
-		if (!isSyncCacheChunk(chunk) || chunk.index !== index) return normalizePersistedStore({
-			version: 1,
-			savedSync: null,
-			clientOptions: meta.clientOptions,
-			cleanShutdown: false
-		});
-		chunks.push(chunk.data);
-	}
-	let savedSync = null;
-	if (chunks.length > 0) {
-		const syncJson = chunks.join("");
-		if (meta.syncDigest !== digestText(syncJson)) return normalizePersistedStore({
-			version: 1,
-			savedSync: null,
-			clientOptions: meta.clientOptions,
-			cleanShutdown: false
-		});
-		try {
-			savedSync = toPersistedSyncData(JSON.parse(syncJson));
-		} catch {
-			savedSync = null;
-		}
-	}
-	return normalizePersistedStore({
-		version: 1,
-		savedSync,
-		clientOptions: meta.clientOptions,
-		cleanShutdown: meta.cleanShutdown
-	});
-}
-function metaKey(stateKey) {
-	return `${stateKey}:meta`;
-}
-function chunkKeyPrefix(stateKey) {
-	return `${stateKey}:sync:`;
-}
-function chunkKey(stateKey, generation, index) {
-	return `${chunkKeyPrefix(stateKey)}${generation}:${index}`;
-}
-function resolveLegacySyncCachePath(storageRootDir) {
-	return path.join(storageRootDir, "bot-storage.json");
-}
-function digestText(value) {
-	return createHash("sha256").update(value, "utf8").digest("hex");
-}
-function isSyncCacheMeta(value) {
-	return isRecord(value) && value.kind === "meta" && value.version === 1 && typeof value.generation === "string" && value.generation.trim() !== "" && typeof value.chunkCount === "number" && Number.isSafeInteger(value.chunkCount) && value.chunkCount >= 0 && value.chunkCount <= SYNC_CACHE_MAX_CHUNKS;
-}
-function isSyncCacheChunk(value) {
-	return isRecord(value) && value.kind === "sync-chunk" && typeof value.index === "number" && Number.isSafeInteger(value.index) && value.index >= 0 && typeof value.data === "string";
-}
-function chunkSyncCacheJson(value) {
-	const chunks = [];
-	const pushChunk = (chunk) => {
-		if (chunks.length >= SYNC_CACHE_MAX_CHUNKS) throw new Error("Matrix sync cache exceeds SQLite chunk limit");
-		chunks.push(chunk);
-	};
-	let current = "";
-	let currentBytes = 0;
-	for (const char of value) {
-		const charBytes = Buffer.byteLength(char, "utf8");
-		if (current && currentBytes + charBytes > SYNC_CACHE_CHUNK_BYTES) {
-			pushChunk(current);
-			current = "";
-			currentBytes = 0;
-		}
-		current += char;
-		currentBytes += charBytes;
-	}
-	if (current) pushChunk(current);
-	return chunks;
-}
-function buildSyncCacheRows(stateKey, payload) {
-	const generation = randomUUID().replaceAll("-", "");
-	const syncJson = payload.savedSync ? JSON.stringify(payload.savedSync) : "";
-	const chunks = (syncJson ? chunkSyncCacheJson(syncJson) : []).map((data, index) => ({
-		key: chunkKey(stateKey, generation, index),
-		value: {
-			kind: "sync-chunk",
-			index,
-			data
-		}
-	}));
-	return {
-		chunks,
-		nextChunkKeys: new Set(chunks.map((chunk) => chunk.key)),
-		meta: {
-			key: metaKey(stateKey),
-			value: {
-				kind: "meta",
-				version: 1,
-				generation,
-				chunkCount: chunks.length,
-				...syncJson ? { syncDigest: digestText(syncJson) } : {},
-				...payload.clientOptions ? { clientOptions: payload.clientOptions } : {},
-				cleanShutdown: payload.cleanShutdown === true
-			}
-		}
-	};
-}
-async function readLegacyMatrixSyncCacheState(storageRootDir) {
-	try {
-		const raw = await fs.readFile(resolveLegacySyncCachePath(storageRootDir), "utf8");
-		const persisted = normalizeLegacyPersistedStore(JSON.parse(raw));
-		if (!persisted?.savedSync && !persisted?.clientOptions) return null;
-		return persisted;
-	} catch {
-		return null;
-	}
-}
-async function hasMatrixSyncCacheStateInStore(params) {
-	return Boolean((await readPersistedStoreFromStore(params))?.savedSync);
-}
-async function writeMatrixSyncCacheStateToStore(params) {
-	const { storageRootDir, store, payload } = params;
-	const stateKey = SYNC_CACHE_STATE_KEY;
-	const rows = buildSyncCacheRows(stateKey, payload);
-	return syncCacheOperations.enqueue(path.resolve(storageRootDir), async () => {
-		for (const row of rows.chunks) await store.register(row.key, row.value);
-		await store.register(rows.meta.key, rows.meta.value);
-		for (const row of await store.entries()) if (row.key.startsWith(chunkKeyPrefix(stateKey)) && !rows.nextChunkKeys.has(row.key)) await store.delete(row.key);
-	});
-}
-function openMatrixSyncCacheStoreOptions(storageRootDir) {
-	return {
-		namespace: SYNC_CACHE_NAMESPACE,
-		maxEntries: SYNC_CACHE_MAX_ENTRIES,
-		env: resolveMatrixSqliteStateEnv({ stateDir: storageRootDir })
-	};
-}
-async function deleteMatrixSyncCacheStateFromStore(params) {
-	const { storageRootDir, store } = params;
-	return syncCacheOperations.enqueue(path.resolve(storageRootDir), async () => {
-		await store.delete(metaKey(SYNC_CACHE_STATE_KEY));
-		for (const row of await store.entries()) if (row.key.startsWith(chunkKeyPrefix(SYNC_CACHE_STATE_KEY))) await store.delete(row.key);
-		await fs.rm(resolveLegacySyncCachePath(storageRootDir), { force: true }).catch(() => void 0);
-	});
-}
-//#endregion
-export { readLegacyMatrixSyncCacheState as a, writeMatrixSyncCacheStateToStore as c, openMatrixSyncCacheStoreOptions as i, deleteMatrixSyncCacheStateFromStore as n, readPersistedStoreFromStore as o, hasMatrixSyncCacheStateInStore as r, sync_cache_state_exports as s, MATRIX_SYNC_CACHE_VERSION as t };

package/dist/.setup/thread-bindings-JlnLDfPM.mjs

@@ -1,444 +0,0 @@
-import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
-import { a as listBindingsForAccount, c as resolveEffectiveBindingExpiry, d as setMatrixThreadBindingManagerEntry, l as setBindingRecord, m as toSessionBindingRecord, o as removeBindingRecord, p as toMatrixBindingTargetKind, r as getMatrixThreadBindingManagerEntry, s as resolveBindingKey, t as deleteMatrixThreadBindingManagerEntry } from "./thread-bindings-shared-oNPiyMWY.mjs";
-import { O as resolveMatrixSqliteStateEnv, k as resolveMatrixSqliteStateKey } from "./storage-metadata-fHN6Df2m.mjs";
-import { a as resolveMatrixStateFilePath, t as claimCurrentTokenStorageState } from "./storage-BXaFc0S4.mjs";
-import { r as sendMessageMatrix } from "./send-aVdC5NJO.mjs";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { createHash } from "node:crypto";
-import path from "node:path";
-import { registerSessionBindingAdapter, resolveThreadBindingFarewellText, unregisterSessionBindingAdapter } from "openclaw/plugin-sdk/thread-bindings-session-runtime";
-import fs from "node:fs/promises";
-import { resolveSessionAgentIdStrict } from "openclaw/plugin-sdk/agent-scope-runtime";
-import { readJsonFileWithFallback } from "openclaw/plugin-sdk/json-store";
-import { resolveAgentIdFromSessionKey } from "openclaw/plugin-sdk/session-key-runtime";
-//#region extensions/matrix/src/matrix/thread-bindings.ts
-const STORE_VERSION = 1;
-const THREAD_BINDINGS_NAMESPACE = "thread-bindings";
-const THREAD_BINDINGS_MIGRATIONS_NAMESPACE = "thread-bindings-migrations";
-const THREAD_BINDINGS_MAX_ENTRIES = 1e4;
-const THREAD_BINDINGS_SWEEP_INTERVAL_MS = 6e4;
-const TOUCH_PERSIST_DELAY_MS = 3e4;
-async function resolveBindingsPath(params) {
-	return resolveMatrixStateFilePath({
-		auth: params.auth,
-		accountId: params.accountId,
-		env: params.env,
-		stateDir: params.stateDir,
-		filename: "thread-bindings.json"
-	});
-}
-function createThreadBindingStore(params) {
-	return getMatrixRuntime().state.openKeyedStore({
-		namespace: THREAD_BINDINGS_NAMESPACE,
-		maxEntries: THREAD_BINDINGS_MAX_ENTRIES,
-		env: resolveMatrixSqliteStateEnv(params)
-	});
-}
-function createThreadBindingMigrationStore(params) {
-	return getMatrixRuntime().state.openKeyedStore({
-		namespace: THREAD_BINDINGS_MIGRATIONS_NAMESPACE,
-		maxEntries: 1e3,
-		env: resolveMatrixSqliteStateEnv(params)
-	});
-}
-function buildThreadBindingStoreKey(record) {
-	const digest = createHash("sha256").update(record.accountId).update("\0").update(record.parentConversationId ?? "").update("\0").update(record.conversationId).digest("hex");
-	return `${record.accountId}:${digest}`;
-}
-function buildLegacyThreadBindingsImportKey(params) {
-	const digest = createHash("sha256").update(params.accountId).update("\0").update(params.legacyFilePath).digest("hex");
-	return `${params.accountId}:${digest}`;
-}
-function normalizeBindingRecord(entry, accountId) {
-	if (!entry || typeof entry !== "object" || Array.isArray(entry)) return null;
-	const record = entry;
-	if (record.accountId && record.accountId !== accountId) return null;
-	const conversationId = normalizeOptionalString(record.conversationId);
-	const parentConversationId = normalizeOptionalString(record.parentConversationId);
-	const targetSessionKey = normalizeOptionalString(record.targetSessionKey) ?? "";
-	if (!conversationId || !targetSessionKey) return null;
-	const boundAt = typeof record.boundAt === "number" && Number.isFinite(record.boundAt) ? Math.floor(record.boundAt) : Date.now();
-	const lastActivityAt = typeof record.lastActivityAt === "number" && Number.isFinite(record.lastActivityAt) ? Math.floor(record.lastActivityAt) : boundAt;
-	return {
-		accountId,
-		conversationId,
-		...parentConversationId ? { parentConversationId } : {},
-		targetKind: record.targetKind === "subagent" ? "subagent" : "acp",
-		targetSessionKey,
-		agentId: normalizeOptionalString(record.agentId) || void 0,
-		label: normalizeOptionalString(record.label) || void 0,
-		boundBy: normalizeOptionalString(record.boundBy) || void 0,
-		boundAt,
-		lastActivityAt: Math.max(lastActivityAt, boundAt),
-		idleTimeoutMs: typeof record.idleTimeoutMs === "number" && Number.isFinite(record.idleTimeoutMs) ? Math.max(0, Math.floor(record.idleTimeoutMs)) : void 0,
-		maxAgeMs: typeof record.maxAgeMs === "number" && Number.isFinite(record.maxAgeMs) ? Math.max(0, Math.floor(record.maxAgeMs)) : void 0
-	};
-}
-async function loadBindingsFromLegacyDisk(filePath, accountId) {
-	const { value } = await readJsonFileWithFallback(filePath, null);
-	if (value?.version !== STORE_VERSION || !Array.isArray(value.bindings)) return [];
-	const loaded = [];
-	for (const entry of value.bindings) {
-		const record = normalizeBindingRecord(entry, accountId);
-		if (record) loaded.push(record);
-	}
-	return loaded;
-}
-async function loadBindingsFromPluginState(params) {
-	const store = createThreadBindingStore(params);
-	const loaded = [];
-	for (const entry of await store.entries()) {
-		const record = normalizeBindingRecord(entry.value, params.accountId);
-		if (record) loaded.push(record);
-	}
-	return loaded;
-}
-function toPluginJsonValue(value) {
-	const serialized = JSON.stringify(value);
-	return JSON.parse(serialized);
-}
-async function persistBindingsSnapshot(params) {
-	const store = createThreadBindingStore(params);
-	const liveKeys = new Set(params.bindings.map((record) => buildThreadBindingStoreKey(record)));
-	for (const entry of await store.entries()) if (normalizeBindingRecord(entry.value, params.accountId) && !liveKeys.has(entry.key)) await store.delete(entry.key);
-	for (const record of params.bindings) await store.register(buildThreadBindingStoreKey(record), toPluginJsonValue(record));
-}
-function buildMatrixBindingIntroText(params) {
-	const introText = normalizeOptionalString(params.metadata?.introText);
-	if (introText) return introText;
-	const label = normalizeOptionalString(params.metadata?.label);
-	const agentId = normalizeOptionalString(params.metadata?.agentId) || resolveAgentIdFromSessionKey(params.targetSessionKey);
-	return `⚙️ ${label || agentId || "session"} session active. Messages here go directly to this session.`;
-}
-async function sendBindingMessage(params) {
-	const trimmed = params.text.trim();
-	if (!trimmed) return null;
-	return (await sendMessageMatrix(`room:${params.roomId}`, trimmed, {
-		cfg: params.cfg,
-		client: params.client,
-		accountId: params.accountId,
-		...params.threadId ? { threadId: params.threadId } : {}
-	})).messageId || null;
-}
-async function sendFarewellMessage(params) {
-	const roomId = params.record.parentConversationId ?? params.record.conversationId;
-	const idleTimeoutMs = typeof params.record.idleTimeoutMs === "number" ? params.record.idleTimeoutMs : params.defaultIdleTimeoutMs;
-	const maxAgeMs = typeof params.record.maxAgeMs === "number" ? params.record.maxAgeMs : params.defaultMaxAgeMs;
-	const farewellText = resolveThreadBindingFarewellText({
-		reason: params.reason,
-		idleTimeoutMs,
-		maxAgeMs
-	});
-	await sendBindingMessage({
-		cfg: params.cfg,
-		client: params.client,
-		accountId: params.accountId,
-		roomId,
-		threadId: params.record.parentConversationId && params.record.parentConversationId !== params.record.conversationId ? params.record.conversationId : void 0,
-		text: farewellText
-	}).catch(() => {});
-}
-async function createMatrixThreadBindingManager(params) {
-	if (params.auth.accountId !== params.accountId) throw new Error(`Matrix thread binding account mismatch: requested ${params.accountId}, auth resolved ${params.auth.accountId}`);
-	const legacyFilePath = await resolveBindingsPath({
-		auth: params.auth,
-		accountId: params.accountId,
-		env: params.env,
-		stateDir: params.stateDir
-	});
-	const sqliteStateDir = path.dirname(legacyFilePath);
-	const storageKey = resolveMatrixSqliteStateKey({
-		env: params.env,
-		stateDir: sqliteStateDir
-	});
-	const existingEntry = getMatrixThreadBindingManagerEntry(params.accountId);
-	if (existingEntry) {
-		if (existingEntry.storageKey === storageKey) return existingEntry.manager;
-		await existingEntry.manager.stop();
-	}
-	const pluginLoaded = await loadBindingsFromPluginState({
-		accountId: params.accountId,
-		env: params.env,
-		stateDir: sqliteStateDir
-	});
-	const migrationStore = createThreadBindingMigrationStore({
-		env: params.env,
-		stateDir: sqliteStateDir
-	});
-	const legacyImportKey = buildLegacyThreadBindingsImportKey({
-		accountId: params.accountId,
-		legacyFilePath
-	});
-	const pluginLoadedKeys = new Set(pluginLoaded.map((record) => buildThreadBindingStoreKey(record)));
-	let legacyHadRows = false;
-	let legacyLoaded = [];
-	if (!await migrationStore.lookup(legacyImportKey)) {
-		const legacyCandidates = await loadBindingsFromLegacyDisk(legacyFilePath, params.accountId);
-		legacyHadRows = legacyCandidates.length > 0;
-		legacyLoaded = legacyCandidates.filter((record) => !pluginLoadedKeys.has(buildThreadBindingStoreKey(record)));
-	}
-	const loaded = [...pluginLoaded, ...legacyLoaded];
-	for (const record of loaded) setBindingRecord(record);
-	let persistQueue = Promise.resolve();
-	const enqueuePersist = (bindings) => {
-		const snapshot = bindings ?? listBindingsForAccount(params.accountId);
-		const next = persistQueue.catch(() => {}).then(async () => {
-			await persistBindingsSnapshot({
-				accountId: params.accountId,
-				bindings: snapshot,
-				env: params.env,
-				stateDir: sqliteStateDir
-			});
-			await claimCurrentTokenStorageState({ rootDir: sqliteStateDir });
-		});
-		persistQueue = next;
-		return next;
-	};
-	const persist = async () => await enqueuePersist();
-	const persistSafely = (reason, bindings) => {
-		enqueuePersist(bindings).catch((err) => {
-			params.logVerboseMessage?.(`matrix: failed persisting thread bindings account=${params.accountId} action=${reason}: ${String(err)}`);
-		});
-	};
-	const defaults = {
-		idleTimeoutMs: params.idleTimeoutMs,
-		maxAgeMs: params.maxAgeMs
-	};
-	if (legacyHadRows) {
-		if (legacyLoaded.length > 0) await persist();
-		await migrationStore.register(legacyImportKey, { importedAt: Date.now() });
-		await fs.rm(legacyFilePath, { force: true }).catch((err) => {
-			params.logVerboseMessage?.(`matrix: failed removing migrated legacy thread bindings account=${params.accountId}: ${String(err)}`);
-		});
-	}
-	let persistTimer = null;
-	const schedulePersist = (delayMs) => {
-		if (persistTimer) return;
-		persistTimer = setTimeout(() => {
-			persistTimer = null;
-			persistSafely("delayed-touch");
-		}, delayMs);
-		persistTimer.unref?.();
-	};
-	const updateBindingsBySessionKey = (input) => {
-		const targetSessionKey = input.targetSessionKey.trim();
-		if (!targetSessionKey) return [];
-		const now = Date.now();
-		const nextBindings = listBindingsForAccount(params.accountId).filter((entry) => entry.targetSessionKey === targetSessionKey).map((entry) => input.update(entry, now));
-		if (nextBindings.length === 0) return [];
-		for (const entry of nextBindings) setBindingRecord(entry);
-		persistSafely(input.persistReason);
-		return nextBindings;
-	};
-	const manager = {
-		accountId: params.accountId,
-		getIdleTimeoutMs: () => defaults.idleTimeoutMs,
-		getMaxAgeMs: () => defaults.maxAgeMs,
-		persist,
-		getByConversation: ({ conversationId, parentConversationId }) => listBindingsForAccount(params.accountId).find((entry) => {
-			if (entry.conversationId !== conversationId.trim()) return false;
-			if (!parentConversationId) return true;
-			return (entry.parentConversationId ?? "") === parentConversationId.trim();
-		}),
-		listBySessionKey: (targetSessionKey) => listBindingsForAccount(params.accountId).filter((entry) => entry.targetSessionKey === targetSessionKey.trim()),
-		listBindings: () => listBindingsForAccount(params.accountId),
-		touchBinding: (bindingId, at) => {
-			const record = listBindingsForAccount(params.accountId).find((entry) => resolveBindingKey(entry) === bindingId.trim());
-			if (!record) return null;
-			const nextRecord = {
-				...record,
-				lastActivityAt: typeof at === "number" && Number.isFinite(at) ? Math.max(record.lastActivityAt, Math.floor(at)) : Date.now()
-			};
-			setBindingRecord(nextRecord);
-			schedulePersist(TOUCH_PERSIST_DELAY_MS);
-			return nextRecord;
-		},
-		setIdleTimeoutBySessionKey: ({ targetSessionKey, idleTimeoutMs }) => {
-			return updateBindingsBySessionKey({
-				targetSessionKey,
-				persistReason: "idle-timeout-update",
-				update: (entry, now) => ({
-					...entry,
-					idleTimeoutMs: Math.max(0, Math.floor(idleTimeoutMs)),
-					lastActivityAt: now
-				})
-			});
-		},
-		setMaxAgeBySessionKey: ({ targetSessionKey, maxAgeMs }) => {
-			return updateBindingsBySessionKey({
-				targetSessionKey,
-				persistReason: "max-age-update",
-				update: (entry, now) => ({
-					...entry,
-					maxAgeMs: Math.max(0, Math.floor(maxAgeMs)),
-					lastActivityAt: now
-				})
-			});
-		},
-		stop: async () => {
-			if (sweepTimer) clearInterval(sweepTimer);
-			let finalPersist = persistQueue;
-			if (persistTimer) {
-				clearTimeout(persistTimer);
-				persistTimer = null;
-				finalPersist = enqueuePersist();
-			}
-			unregisterSessionBindingAdapter({
-				channel: "matrix",
-				accountId: params.accountId,
-				adapter: sessionBindingAdapter
-			});
-			if (getMatrixThreadBindingManagerEntry(params.accountId)?.manager === manager) {
-				deleteMatrixThreadBindingManagerEntry(params.accountId);
-				for (const record of listBindingsForAccount(params.accountId)) removeBindingRecord(record);
-			}
-			await finalPersist;
-		}
-	};
-	let sweepTimer = null;
-	const removeRecords = (records) => {
-		if (records.length === 0) return [];
-		return records.map((record) => removeBindingRecord(record)).filter((record) => Boolean(record));
-	};
-	const sendFarewellMessages = async (removed, reason) => {
-		await Promise.all(removed.map(async (record) => {
-			await sendFarewellMessage({
-				cfg: params.cfg,
-				client: params.client,
-				accountId: params.accountId,
-				record,
-				defaultIdleTimeoutMs: defaults.idleTimeoutMs,
-				defaultMaxAgeMs: defaults.maxAgeMs,
-				reason: typeof reason === "function" ? reason(record) : reason
-			});
-		}));
-	};
-	const unbindRecords = async (records, reason) => {
-		const removed = removeRecords(records);
-		if (removed.length === 0) return [];
-		await persist();
-		await sendFarewellMessages(removed, reason);
-		return removed.map((record) => toSessionBindingRecord(record, defaults));
-	};
-	const sessionBindingAdapter = {
-		channel: "matrix",
-		accountId: params.accountId,
-		capabilities: {
-			placements: ["current", "child"],
-			bindSupported: true,
-			unbindSupported: true
-		},
-		bind: async (input) => {
-			const conversationId = input.conversation.conversationId.trim();
-			const parentConversationId = normalizeOptionalString(input.conversation.parentConversationId);
-			const targetSessionKey = input.targetSessionKey.trim();
-			if (!conversationId || !targetSessionKey) return null;
-			let boundConversationId = conversationId;
-			let boundParentConversationId = parentConversationId;
-			const introText = buildMatrixBindingIntroText({
-				metadata: input.metadata,
-				targetSessionKey
-			});
-			if (input.placement === "child") {
-				const roomId = parentConversationId || conversationId;
-				const rootEventId = await sendBindingMessage({
-					cfg: params.cfg,
-					client: params.client,
-					accountId: params.accountId,
-					roomId,
-					text: introText
-				});
-				if (!rootEventId) return null;
-				boundConversationId = rootEventId;
-				boundParentConversationId = roomId;
-			}
-			const now = Date.now();
-			const record = {
-				accountId: params.accountId,
-				conversationId: boundConversationId,
-				...boundParentConversationId ? { parentConversationId: boundParentConversationId } : {},
-				targetKind: toMatrixBindingTargetKind(input.targetKind),
-				targetSessionKey,
-				agentId: normalizeOptionalString(input.metadata?.agentId) ?? resolveSessionAgentIdStrict({
-					config: params.cfg,
-					sessionKey: targetSessionKey
-				}),
-				label: normalizeOptionalString(input.metadata?.label) || void 0,
-				boundBy: normalizeOptionalString(input.metadata?.boundBy) || "system",
-				boundAt: now,
-				lastActivityAt: now,
-				idleTimeoutMs: defaults.idleTimeoutMs,
-				maxAgeMs: defaults.maxAgeMs
-			};
-			setBindingRecord(record);
-			await persist();
-			if (input.placement === "current" && introText) {
-				const roomId = boundParentConversationId || boundConversationId;
-				const threadId = boundParentConversationId && boundParentConversationId !== boundConversationId ? boundConversationId : void 0;
-				await sendBindingMessage({
-					cfg: params.cfg,
-					client: params.client,
-					accountId: params.accountId,
-					roomId,
-					threadId,
-					text: introText
-				}).catch(() => {});
-			}
-			return toSessionBindingRecord(record, defaults);
-		},
-		listBySession: (targetSessionKey) => manager.listBySessionKey(targetSessionKey).map((record) => toSessionBindingRecord(record, defaults)),
-		resolveByConversation: (ref) => {
-			const record = manager.getByConversation({
-				conversationId: ref.conversationId,
-				parentConversationId: ref.parentConversationId
-			});
-			return record ? toSessionBindingRecord(record, defaults) : null;
-		},
-		touch: (bindingId, at) => {
-			manager.touchBinding(bindingId, at);
-		},
-		unbind: async (input) => {
-			return await unbindRecords(listBindingsForAccount(params.accountId).filter((record) => {
-				if (input.bindingId?.trim()) return resolveBindingKey(record) === input.bindingId.trim();
-				if (input.targetSessionKey?.trim()) return record.targetSessionKey === input.targetSessionKey.trim();
-				return false;
-			}), input.reason);
-		}
-	};
-	registerSessionBindingAdapter(sessionBindingAdapter);
-	if (params.enableSweeper !== false) {
-		sweepTimer = setInterval(() => {
-			const now = Date.now();
-			const expired = listBindingsForAccount(params.accountId).map((record) => ({
-				record,
-				lifecycle: resolveEffectiveBindingExpiry({
-					record,
-					defaultIdleTimeoutMs: defaults.idleTimeoutMs,
-					defaultMaxAgeMs: defaults.maxAgeMs
-				})
-			})).filter((entry) => typeof entry.lifecycle.expiresAt === "number" && entry.lifecycle.expiresAt <= now && Boolean(entry.lifecycle.reason));
-			if (expired.length === 0) return;
-			const reasonByBindingKey = new Map(expired.map(({ record, lifecycle }) => [resolveBindingKey(record), lifecycle.reason]));
-			(async () => {
-				const removed = removeRecords(expired.map(({ record }) => record));
-				if (removed.length === 0) return;
-				for (const record of removed) {
-					const reason = reasonByBindingKey.get(resolveBindingKey(record));
-					params.logVerboseMessage?.(`matrix: auto-unbinding ${record.conversationId} due to ${reason}`);
-				}
-				await persist();
-				await sendFarewellMessages(removed, (record) => reasonByBindingKey.get(resolveBindingKey(record)));
-			})().catch((err) => {
-				params.logVerboseMessage?.(`matrix: failed auto-unbinding expired bindings account=${params.accountId}: ${String(err)}`);
-			});
-		}, THREAD_BINDINGS_SWEEP_INTERVAL_MS);
-		sweepTimer.unref?.();
-	}
-	setMatrixThreadBindingManagerEntry(params.accountId, {
-		storageKey,
-		manager
-	});
-	return manager;
-}
-//#endregion
-export { createMatrixThreadBindingManager as t };