@openclaw/matrix 2026.7.2-beta.7 → 2026.8.1-beta.2

package/dist/{client-bootstrap-XsIkHNt0.js → client-bootstrap-BFwT_2VT.js}

@@ -1,5 +1,4 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { t as getActiveMatrixClient } from "./active-client-DXvz2gCo.js";
 import { t as isBunRuntime } from "./runtime-BefyhPWv.js";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
@@ -8,14 +7,14 @@ var client_bootstrap_exports = /* @__PURE__ */ __exportAll({
 	resolveRuntimeMatrixClientWithReadiness: () => resolveRuntimeMatrixClientWithReadiness,
 	withResolvedRuntimeMatrixClient: () => withResolvedRuntimeMatrixClient
 });
-const loadMatrixSharedClientRuntimeDeps = createLazyRuntimeModule(() => Promise.all([import("./client-Dbso3-0V.js").then((n) => n.t), import("./shared-CUMWxcMz.js").then((n) => n.a)]).then(([clientModule, sharedModule]) => ({
+const loadMatrixSharedClientRuntimeDeps = createLazyRuntimeModule(() => import("./client-CeGw0G5S.js").then((n) => n.t).then((clientModule) => ({
 	acquireSharedMatrixClient: clientModule.acquireSharedMatrixClient,
-	resolveMatrixAuthContext: clientModule.resolveMatrixAuthContext,
-	releaseSharedClientInstance: sharedModule.releaseSharedClientInstance
+	resolveMatrixAuthContext: clientModule.resolveMatrixAuthContext
 })));
 async function ensureResolvedClientReadiness(params) {
 	if (params.readiness === "started") {
-		await params.client.start();
+		if (params.lease) await params.lease.start();
+		else await params.client.start();
 		return;
 	}
 	if (params.readiness === "prepared" || !params.readiness && params.preparedByDefault) await params.client.prepareForOneOff();
@@ -23,87 +22,52 @@ async function ensureResolvedClientReadiness(params) {
 function ensureMatrixNodeRuntime() {
 	if (isBunRuntime()) throw new Error("Matrix support requires Node (bun runtime not supported)");
 }
-async function resolveRuntimeMatrixClient(opts) {
+async function resolveRuntimeMatrixClientWithReadiness(opts) {
 	ensureMatrixNodeRuntime();
 	if (opts.client) {
-		await opts.onResolved?.(opts.client, { preparedByDefault: false });
-		return {
+		await ensureResolvedClientReadiness({
 			client: opts.client,
-			stopOnDone: false
-		};
+			readiness: opts.readiness,
+			preparedByDefault: false
+		});
+		return { client: opts.client };
 	}
 	if (!opts.cfg) throw new Error("Matrix runtime client requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
 	const cfg = requireRuntimeConfig(opts.cfg, "Matrix runtime client");
-	const { acquireSharedMatrixClient, releaseSharedClientInstance, resolveMatrixAuthContext } = await loadMatrixSharedClientRuntimeDeps();
+	const { acquireSharedMatrixClient, resolveMatrixAuthContext } = await loadMatrixSharedClientRuntimeDeps();
 	const authContext = resolveMatrixAuthContext({
 		cfg,
 		accountId: opts.accountId
 	});
-	const active = getActiveMatrixClient(authContext.accountId);
-	if (active) {
-		await opts.onResolved?.(active, { preparedByDefault: false });
-		return {
-			client: active,
-			stopOnDone: false
-		};
-	}
-	const client = await acquireSharedMatrixClient({
+	const lease = await acquireSharedMatrixClient({
 		cfg,
 		timeoutMs: opts.timeoutMs,
 		accountId: authContext.accountId,
-		startClient: false
+		startClient: false,
+		role: "transient"
 	});
 	try {
-		await opts.onResolved?.(client, { preparedByDefault: true });
+		await ensureResolvedClientReadiness({
+			client: lease.client,
+			lease,
+			readiness: opts.readiness,
+			preparedByDefault: true
+		});
 	} catch (err) {
-		await releaseSharedClientInstance(client, "stop");
+		await lease.release({ mode: "stop" });
 		throw err;
 	}
 	return {
-		client,
-		stopOnDone: true,
-		cleanup: async (mode) => {
-			await releaseSharedClientInstance(client, mode);
-		}
+		client: lease.client,
+		lease
 	};
 }
-async function resolveRuntimeMatrixClientWithReadiness(opts) {
-	return await resolveRuntimeMatrixClient({
-		client: opts.client,
-		cfg: opts.cfg,
-		timeoutMs: opts.timeoutMs,
-		accountId: opts.accountId,
-		onResolved: async (client, context) => {
-			await ensureResolvedClientReadiness({
-				client,
-				readiness: opts.readiness,
-				preparedByDefault: context.preparedByDefault
-			});
-		}
-	});
-}
-async function stopResolvedRuntimeMatrixClient(resolved, mode = "stop") {
-	if (!resolved.stopOnDone) return;
-	if (resolved.cleanup) {
-		await resolved.cleanup(mode);
-		return;
-	}
-	if (mode === "persist") {
-		await resolved.client.stopAndPersist();
-		return;
-	}
-	if (mode === "discard") {
-		resolved.client.stopWithoutPersist();
-		return;
-	}
-	resolved.client.stop();
-}
 async function withResolvedRuntimeMatrixClient(opts, run, stopMode = "stop") {
 	const resolved = await resolveRuntimeMatrixClientWithReadiness(opts);
 	try {
-		return await run(resolved.client);
+		return await run(resolved.client, resolved.lease?.abortSignal);
 	} finally {
-		await stopResolvedRuntimeMatrixClient(resolved, stopMode);
+		await resolved.lease?.release({ mode: stopMode });
 	}
 }
 //#endregion

package/dist/{client-6eRENr7k.js → client-sJesKQmp.js}

@@ -1,6 +1,6 @@
 import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { c as resolveMatrixRoomId } from "./send-BldGYG8g.js";
-import { n as withResolvedRuntimeMatrixClient } from "./client-bootstrap-XsIkHNt0.js";
+import { x as resolveMatrixRoomId } from "./send-ZDLU4JTk.js";
+import { n as withResolvedRuntimeMatrixClient } from "./client-bootstrap-BFwT_2VT.js";
 //#region extensions/matrix/src/matrix/actions/client.ts
 var client_exports = /* @__PURE__ */ __exportAll({
 	withResolvedActionClient: () => withResolvedActionClient,
@@ -17,8 +17,8 @@ async function withStartedActionClient(opts, run) {
 	}, run, "persist");
 }
 async function withResolvedRoomAction(roomId, opts, run) {
-	return await withResolvedActionClient(opts, async (client) => {
-		return await run(client, await resolveMatrixRoomId(client, roomId));
+	return await withResolvedActionClient(opts, async (client, abortSignal) => {
+		return await run(client, await resolveMatrixRoomId(client, roomId), abortSignal);
 	});
 }
 //#endregion

package/dist/client-support-DLj4vDeu.js

@@ -0,0 +1,93 @@
+import { t as formatMatrixErrorReason } from "./errors-DKVS3_DO.js";
+//#region extensions/matrix/src/matrix/sync-state.ts
+function isMatrixReadySyncState(state) {
+	return state === "PREPARED" || state === "SYNCING" || state === "CATCHUP";
+}
+function isMatrixDisconnectedSyncState(state) {
+	return state === "RECONNECTING" || state === "ERROR" || state === "STOPPED";
+}
+function isMatrixTerminalSyncState(state) {
+	return state === "STOPPED";
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/client-support.ts
+const MATRIX_STATUS_DIAGNOSTIC_TIMEOUT_MS = 1e4;
+const DEFAULT_MATRIX_LOCAL_TIMEOUT_MS = 6e4;
+function resolveMatrixLocalTimeoutMs(raw) {
+	if (typeof raw !== "number" || !Number.isFinite(raw)) return DEFAULT_MATRIX_LOCAL_TIMEOUT_MS;
+	return Math.max(1, Math.floor(raw));
+}
+function unresolvedMatrixRoomKeyBackupStatus() {
+	return {
+		serverVersion: null,
+		activeVersion: null,
+		trusted: null,
+		matchesDecryptionKey: null,
+		decryptionKeyCached: null,
+		keyLoadAttempted: false,
+		keyLoadError: null
+	};
+}
+function unresolvedMatrixDeviceVerificationStatus(params) {
+	return {
+		encryptionEnabled: true,
+		userId: params.userId,
+		deviceId: params.deviceId,
+		verified: false,
+		localVerified: false,
+		crossSigningVerified: false,
+		signedByOwner: false
+	};
+}
+async function resolveMatrixDiagnostic(promise, timeoutMs) {
+	return (await resolveMatrixDiagnosticResult(promise, timeoutMs)).value;
+}
+async function resolveMatrixDiagnosticResult(promise, timeoutMs) {
+	let timeoutId;
+	try {
+		const guarded = promise.then((value) => ({
+			error: null,
+			timedOut: false,
+			value
+		})).catch((error) => ({
+			error,
+			timedOut: false,
+			value: null
+		}));
+		const timeout = new Promise((resolve) => {
+			timeoutId = setTimeout(() => resolve({
+				error: null,
+				timedOut: true,
+				value: null
+			}), timeoutMs);
+			timeoutId.unref?.();
+		});
+		return await Promise.race([guarded, timeout]);
+	} finally {
+		if (timeoutId) clearTimeout(timeoutId);
+	}
+}
+function isMatrixAccessTokenInvalidatedError(error) {
+	if (!error || typeof error !== "object") return false;
+	const err = error;
+	const errcode = err.body?.errcode ?? err.data?.errcode;
+	if (err.statusCode === 401 && errcode === "M_UNKNOWN_TOKEN") return true;
+	const reason = formatMatrixErrorReason(error);
+	return reason.includes("m_unknown_token") || reason.includes("unknown token") || reason.includes("access token") && (reason.includes("invalid") || reason.includes("unrecognized") || reason.includes("unknown"));
+}
+const MATRIX_INITIAL_CRYPTO_BOOTSTRAP_OPTIONS = { allowAutomaticCrossSigningReset: false };
+const MATRIX_AUTOMATIC_REPAIR_BOOTSTRAP_OPTIONS = {
+	forceResetCrossSigning: true,
+	allowSecretStorageRecreateWithoutRecoveryKey: true,
+	strict: true
+};
+function createMatrixExplicitBootstrapOptions(params) {
+	return {
+		forceResetCrossSigning: params?.forceResetCrossSigning === true,
+		allowAutomaticCrossSigningReset: params?.allowAutomaticCrossSigningReset !== false,
+		allowSecretStorageRecreateWithoutRecoveryKey: true,
+		strict: params?.strict !== false
+	};
+}
+//#endregion
+export { isMatrixAccessTokenInvalidatedError as a, resolveMatrixLocalTimeoutMs as c, isMatrixDisconnectedSyncState as d, isMatrixReadySyncState as f, createMatrixExplicitBootstrapOptions as i, unresolvedMatrixDeviceVerificationStatus as l, MATRIX_INITIAL_CRYPTO_BOOTSTRAP_OPTIONS as n, resolveMatrixDiagnostic as o, isMatrixTerminalSyncState as p, MATRIX_STATUS_DIAGNOSTIC_TIMEOUT_MS as r, resolveMatrixDiagnosticResult as s, MATRIX_AUTOMATIC_REPAIR_BOOTSTRAP_OPTIONS as t, unresolvedMatrixRoomKeyBackupStatus as u };

package/dist/config-update-Bor_Pjsv.js

@@ -0,0 +1,150 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { t as findMatrixAccountConfig } from "./account-config-BZWN9tGS.js";
+import { n as resolveMatrixConfigPath$1, r as shouldStoreMatrixAccountAtTopLevel, t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { normalizeSecretInputString } from "openclaw/plugin-sdk/setup";
+import { resolveOptionalIntegerOption } from "openclaw/plugin-sdk/number-runtime";
+import { coerceSecretRef } from "openclaw/plugin-sdk/secret-ref-runtime";
+//#region extensions/matrix/src/matrix/config-update.ts
+var config_update_exports = /* @__PURE__ */ __exportAll({
+	resolveMatrixConfigFieldPath: () => resolveMatrixConfigFieldPath,
+	resolveMatrixConfigPath: () => resolveMatrixConfigPath,
+	shouldStoreMatrixAccountAtTopLevel: () => shouldStoreMatrixAccountAtTopLevel,
+	updateMatrixAccountConfig: () => updateMatrixAccountConfig
+});
+const resolveMatrixConfigPath = resolveMatrixConfigPath$1;
+function applyNullableStringField(target, key, value) {
+	if (value === void 0) return;
+	if (value === null) {
+		delete target[key];
+		return;
+	}
+	const trimmed = value.trim();
+	if (!trimmed) {
+		delete target[key];
+		return;
+	}
+	target[key] = trimmed;
+}
+function applyNullableSecretInputField(target, key, value, defaults) {
+	if (value === void 0) return;
+	if (value === null) {
+		delete target[key];
+		return;
+	}
+	if (typeof value === "string") {
+		const normalized = normalizeSecretInputString(value);
+		if (normalized) target[key] = normalized;
+		else delete target[key];
+		return;
+	}
+	const ref = coerceSecretRef(value, defaults);
+	if (!ref) throw new Error(`Invalid Matrix ${key} SecretInput.`);
+	target[key] = ref;
+}
+function cloneMatrixDmConfig(dm) {
+	if (!dm) return dm;
+	return {
+		...dm,
+		...dm.allowFrom ? { allowFrom: [...dm.allowFrom] } : {}
+	};
+}
+function cloneMatrixRoomMap(rooms) {
+	if (!rooms) return rooms;
+	const clonedRoomEntries = [];
+	for (const [roomId, roomCfg] of Object.entries(rooms)) clonedRoomEntries.push([roomId, roomCfg ? { ...roomCfg } : roomCfg]);
+	return Object.fromEntries(clonedRoomEntries);
+}
+function applyNullableArrayField(target, key, value) {
+	if (value === void 0) return;
+	if (value === null) {
+		delete target[key];
+		return;
+	}
+	target[key] = [...value];
+}
+function updateMatrixAccountConfig(cfg, accountId, patch) {
+	const matrix = cfg.channels?.matrix ?? {};
+	const normalizedAccountId = normalizeAccountId(accountId);
+	const nextAccount = { ...findMatrixAccountConfig(cfg, normalizedAccountId) ?? (normalizedAccountId === DEFAULT_ACCOUNT_ID ? matrix : {}) };
+	if (patch.name !== void 0) if (patch.name === null) delete nextAccount.name;
+	else {
+		const trimmed = patch.name.trim();
+		if (trimmed) nextAccount.name = trimmed;
+		else delete nextAccount.name;
+	}
+	if (typeof patch.enabled === "boolean") nextAccount.enabled = patch.enabled;
+	else if (typeof nextAccount.enabled !== "boolean") nextAccount.enabled = true;
+	applyNullableStringField(nextAccount, "homeserver", patch.homeserver);
+	applyNullableStringField(nextAccount, "proxy", patch.proxy);
+	applyNullableStringField(nextAccount, "userId", patch.userId);
+	applyNullableSecretInputField(nextAccount, "accessToken", patch.accessToken, cfg.secrets?.defaults);
+	applyNullableSecretInputField(nextAccount, "password", patch.password, cfg.secrets?.defaults);
+	applyNullableStringField(nextAccount, "deviceId", patch.deviceId);
+	applyNullableStringField(nextAccount, "deviceName", patch.deviceName);
+	applyNullableStringField(nextAccount, "avatarUrl", patch.avatarUrl);
+	if (patch.allowPrivateNetwork !== void 0) {
+		const nextNetwork = nextAccount.network && typeof nextAccount.network === "object" ? { ...nextAccount.network } : {};
+		if (patch.allowPrivateNetwork === null) delete nextNetwork.dangerouslyAllowPrivateNetwork;
+		else nextNetwork.dangerouslyAllowPrivateNetwork = patch.allowPrivateNetwork;
+		if (Object.keys(nextNetwork).length > 0) nextAccount.network = nextNetwork;
+		else delete nextAccount.network;
+	}
+	if (patch.initialSyncLimit !== void 0) if (patch.initialSyncLimit === null) delete nextAccount.initialSyncLimit;
+	else {
+		const initialSyncLimit = resolveOptionalIntegerOption(patch.initialSyncLimit, { min: 0 });
+		if (initialSyncLimit === void 0) delete nextAccount.initialSyncLimit;
+		else nextAccount.initialSyncLimit = initialSyncLimit;
+	}
+	if (patch.encryption !== void 0) if (patch.encryption === null) delete nextAccount.encryption;
+	else nextAccount.encryption = patch.encryption;
+	if (patch.allowBots !== void 0) if (patch.allowBots === null) delete nextAccount.allowBots;
+	else nextAccount.allowBots = patch.allowBots;
+	if (patch.autoJoin !== void 0) if (patch.autoJoin === null) delete nextAccount.autoJoin;
+	else nextAccount.autoJoin = patch.autoJoin;
+	applyNullableArrayField(nextAccount, "autoJoinAllowlist", patch.autoJoinAllowlist);
+	if (patch.dm !== void 0) if (patch.dm === null) delete nextAccount.dm;
+	else nextAccount.dm = cloneMatrixDmConfig({
+		...nextAccount.dm,
+		...patch.dm
+	});
+	if (patch.groupPolicy !== void 0) if (patch.groupPolicy === null) delete nextAccount.groupPolicy;
+	else nextAccount.groupPolicy = patch.groupPolicy;
+	applyNullableArrayField(nextAccount, "groupAllowFrom", patch.groupAllowFrom);
+	if (patch.groups !== void 0) if (patch.groups === null) delete nextAccount.groups;
+	else nextAccount.groups = cloneMatrixRoomMap(patch.groups);
+	if (patch.rooms !== void 0) if (patch.rooms === null) delete nextAccount.rooms;
+	else nextAccount.rooms = cloneMatrixRoomMap(patch.rooms);
+	const nextAccounts = Object.fromEntries(Object.entries(matrix.accounts ?? {}).filter(([rawAccountId]) => rawAccountId === normalizedAccountId || normalizeAccountId(rawAccountId) !== normalizedAccountId));
+	if (shouldStoreMatrixAccountAtTopLevel(cfg, normalizedAccountId)) {
+		const { accounts: _ignoredAccounts, defaultAccount } = matrix;
+		const { accounts: _ignoredNextAccounts, defaultAccount: _ignoredNextDefaultAccount, ...topLevelAccount } = nextAccount;
+		return {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				matrix: {
+					...defaultAccount ? { defaultAccount } : {},
+					enabled: true,
+					...topLevelAccount
+				}
+			}
+		};
+	}
+	return {
+		...cfg,
+		channels: {
+			...cfg.channels,
+			matrix: {
+				...matrix,
+				enabled: true,
+				accounts: {
+					...nextAccounts,
+					[normalizedAccountId]: nextAccount
+				}
+			}
+		}
+	};
+}
+//#endregion
+export { resolveMatrixConfigPath as n, updateMatrixAccountConfig as r, config_update_exports as t };

package/dist/contract-api.js

@@ -1,3 +1,3 @@
-import { d as namedAccountPromotionKeys, f as resolveSingleAccountPromotionTarget, n as matrixSetupAdapter, p as singleAccountKeysToMove } from "./setup-core-BVfBv2ai.js";
-import { n as matrixOnboardingAdapter } from "./setup-surface-BBq3WeqX.js";
+import { c as singleAccountKeysToMove, n as matrixSetupAdapter, o as namedAccountPromotionKeys, s as resolveSingleAccountPromotionTarget } from "./setup-core-DQn6b5vi.js";
+import { n as matrixOnboardingAdapter } from "./setup-surface-DlhJdrNI.js";
 export { matrixSetupAdapter, matrixOnboardingAdapter as matrixSetupWizard, namedAccountPromotionKeys, resolveSingleAccountPromotionTarget, singleAccountKeysToMove };

package/dist/{credentials-W2EmwRhu.js → credentials-BdAaWuiR.js}

@@ -1,5 +1,6 @@
+import { i as normalizeMatrixStoredCredentials, n as isMatrixCredentialRevocation, r as matrixCredentialsStoreKey } from "./credentials-state-B3cuUFwZ.js";
 import { a as resolveMatrixCredentialsPath, r as resolveMatrixCredentialsDir } from "./storage-paths-gUmSydsW.js";
-import { a as isMatrixCredentialRevocation, c as normalizeMatrixStoredCredentials, l as openMatrixCredentialsStore, n as clearMatrixCredentials, o as loadMatrixCredentials, r as credentialsMatchConfig, s as matrixCredentialsStoreKey } from "./credentials-read-DVmFCm7X.js";
+import { a as openMatrixCredentialsStore, i as loadMatrixCredentials, n as credentialsMatchConfig, t as clearMatrixCredentials } from "./credentials-read-B37cQknZ.js";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/credentials.ts
 function requireCredentialStoreUpdate(store) {

package/dist/credentials-read-B37cQknZ.js

@@ -0,0 +1,51 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { n as getOptionalMatrixRuntime } from "./runtime-6S3DNFNv.js";
+import { i as normalizeMatrixStoredCredentials, r as matrixCredentialsStoreKey, t as MATRIX_CREDENTIALS_NAMESPACE } from "./credentials-state-B3cuUFwZ.js";
+import { a as resolveMatrixCredentialsPath, r as resolveMatrixCredentialsDir } from "./storage-paths-gUmSydsW.js";
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { createPluginStateSyncKeyedStore } from "openclaw/plugin-sdk/plugin-state-store-runtime";
+//#region extensions/matrix/src/matrix/credentials-read.ts
+var credentials_read_exports = /* @__PURE__ */ __exportAll({
+	clearMatrixCredentials: () => clearMatrixCredentials,
+	credentialsMatchConfig: () => credentialsMatchConfig,
+	loadMatrixCredentials: () => loadMatrixCredentials,
+	openMatrixCredentialsStore: () => openMatrixCredentialsStore,
+	resolveMatrixCredentialsDir: () => resolveMatrixCredentialsDir,
+	resolveMatrixCredentialsPath: () => resolveMatrixCredentialsPath
+});
+function openMatrixCredentialsStore(env = process.env) {
+	const runtime = getOptionalMatrixRuntime();
+	return createPluginStateSyncKeyedStore("matrix", {
+		namespace: MATRIX_CREDENTIALS_NAMESPACE,
+		maxEntries: 256,
+		overflowPolicy: "reject-new",
+		env: env.OPENCLAW_STATE_DIR?.trim() || !runtime ? env : {
+			...env,
+			OPENCLAW_STATE_DIR: runtime.state.resolveStateDir(env)
+		}
+	});
+}
+function loadMatrixCredentials(env = process.env, accountId) {
+	const normalizedAccountId = normalizeAccountId(accountId);
+	const parsed = normalizeMatrixStoredCredentials(openMatrixCredentialsStore(env).lookup(matrixCredentialsStoreKey(accountId)), normalizedAccountId);
+	if (!parsed || parsed.accountId !== normalizedAccountId) return null;
+	const { accountId: _accountId, ...credentials } = parsed;
+	return credentials;
+}
+function clearMatrixCredentials(env = process.env, accountId) {
+	const normalizedAccountId = normalizeAccountId(accountId);
+	openMatrixCredentialsStore(env).register(matrixCredentialsStoreKey(normalizedAccountId), {
+		accountId: normalizedAccountId,
+		kind: "revoked",
+		revokedAt: (/* @__PURE__ */ new Date()).toISOString()
+	});
+}
+function credentialsMatchConfig(stored, config) {
+	if (!config.userId) {
+		if (!config.accessToken) return false;
+		return stored.homeserver === config.homeserver && stored.accessToken === config.accessToken;
+	}
+	return stored.homeserver === config.homeserver && stored.userId === config.userId;
+}
+//#endregion
+export { openMatrixCredentialsStore as a, loadMatrixCredentials as i, credentialsMatchConfig as n, credentials_read_exports as r, clearMatrixCredentials as t };

package/dist/credentials-state-B3cuUFwZ.js

@@ -0,0 +1,27 @@
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+//#region extensions/matrix/src/matrix/credentials-state.ts
+const MATRIX_CREDENTIALS_NAMESPACE = "credentials";
+function matrixCredentialsStoreKey(accountId) {
+	return `account:${normalizeAccountId(accountId)}`;
+}
+function normalizeMatrixStoredCredentials(value, accountId) {
+	if (!value || typeof value !== "object") return null;
+	const parsed = value;
+	if (typeof parsed.homeserver !== "string" || !parsed.homeserver || typeof parsed.userId !== "string" || !parsed.userId || typeof parsed.accessToken !== "string" || !parsed.accessToken || typeof parsed.createdAt !== "string" || !parsed.createdAt) return null;
+	return {
+		accountId: normalizeAccountId(accountId ?? parsed.accountId),
+		homeserver: parsed.homeserver,
+		userId: parsed.userId,
+		accessToken: parsed.accessToken,
+		...typeof parsed.deviceId === "string" ? { deviceId: parsed.deviceId } : {},
+		createdAt: parsed.createdAt,
+		...typeof parsed.lastUsedAt === "string" ? { lastUsedAt: parsed.lastUsedAt } : {}
+	};
+}
+function isMatrixCredentialRevocation(value, accountId) {
+	if (!value || typeof value !== "object") return false;
+	const parsed = value;
+	return parsed.kind === "revoked" && typeof parsed.revokedAt === "string" && parsed.revokedAt.length > 0 && normalizeAccountId(parsed.accountId) === normalizeAccountId(accountId ?? parsed.accountId);
+}
+//#endregion
+export { normalizeMatrixStoredCredentials as i, isMatrixCredentialRevocation as n, matrixCredentialsStoreKey as r, MATRIX_CREDENTIALS_NAMESPACE as t };

package/dist/{credentials-write.runtime-Be9zNSUw.js → credentials-write.runtime-nAV2-5uR.js}

@@ -1,6 +1,6 @@
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/matrix/src/matrix/credentials-write.runtime.ts
-const loadMatrixCredentialsRuntime = createLazyRuntimeModule(() => import("./credentials-W2EmwRhu.js"));
+const loadMatrixCredentialsRuntime = createLazyRuntimeModule(() => import("./credentials-BdAaWuiR.js"));
 async function saveMatrixCredentials(...args) {
 	return (await loadMatrixCredentialsRuntime()).saveMatrixCredentials(...args);
 }