@openclaw/matrix 2026.3.13 → 2026.5.10-beta.1

package/dist/account-config-D2W-V1eQ.js

@@ -0,0 +1,96 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input-runtime";
+import { listConfiguredAccountIds, resolveMergedAccountConfig, resolveNormalizedAccountEntry } from "openclaw/plugin-sdk/account-resolution-runtime";
+//#region extensions/matrix/src/matrix/account-config.ts
+function resolveMatrixBaseConfig(cfg) {
+	return cfg.channels?.matrix ?? {};
+}
+function resolveMatrixAccountsMap(cfg) {
+	const accounts = resolveMatrixBaseConfig(cfg).accounts;
+	if (!accounts || typeof accounts !== "object") return {};
+	return accounts;
+}
+function selectInheritedMatrixRoomEntries(params) {
+	const entries = params.entries;
+	if (!entries) return;
+	const selected = Object.fromEntries(Object.entries(entries).filter(([, value]) => {
+		const scopedAccount = typeof value?.account === "string" ? normalizeAccountId(value.account) : void 0;
+		return scopedAccount === void 0 || scopedAccount === params.accountId;
+	}));
+	return Object.keys(selected).length > 0 ? selected : void 0;
+}
+function mergeMatrixRoomEntries(inherited, accountEntries, hasAccountOverride) {
+	if (!inherited && !accountEntries) return;
+	if (hasAccountOverride && Object.keys(accountEntries ?? {}).length === 0) return;
+	const merged = { ...inherited };
+	for (const [key, value] of Object.entries(accountEntries ?? {})) {
+		const inheritedValue = merged[key];
+		merged[key] = inheritedValue && value ? {
+			...inheritedValue,
+			...value
+		} : value ?? inheritedValue;
+	}
+	return Object.keys(merged).length > 0 ? merged : void 0;
+}
+function listNormalizedMatrixAccountIds(cfg) {
+	return listConfiguredAccountIds({
+		accounts: resolveMatrixAccountsMap(cfg),
+		normalizeAccountId
+	});
+}
+function findMatrixAccountConfig(cfg, accountId) {
+	return resolveNormalizedAccountEntry(resolveMatrixAccountsMap(cfg), accountId, normalizeAccountId);
+}
+function hasExplicitMatrixAccountConfig(cfg, accountId) {
+	const normalized = normalizeAccountId(accountId);
+	if (findMatrixAccountConfig(cfg, normalized)) return true;
+	if (normalized !== DEFAULT_ACCOUNT_ID) return false;
+	const matrix = resolveMatrixBaseConfig(cfg);
+	return typeof matrix.enabled === "boolean" || typeof matrix.name === "string" || typeof matrix.homeserver === "string" || typeof matrix.userId === "string" || hasConfiguredSecretInput(matrix.accessToken) || hasConfiguredSecretInput(matrix.password) || typeof matrix.deviceId === "string" || typeof matrix.deviceName === "string" || typeof matrix.avatarUrl === "string";
+}
+function resolveMatrixAccountConfig(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const base = resolveMatrixBaseConfig(params.cfg);
+	const merged = resolveMergedAccountConfig({
+		channelConfig: base,
+		accounts: params.cfg.channels?.matrix?.accounts,
+		accountId,
+		normalizeAccountId,
+		nestedObjectKeys: [
+			"dm",
+			"actions",
+			"execApprovals"
+		]
+	});
+	const accountConfig = findMatrixAccountConfig(params.cfg, accountId);
+	const groups = mergeMatrixRoomEntries(selectInheritedMatrixRoomEntries({
+		entries: base.groups,
+		accountId
+	}), accountConfig?.groups, Boolean(accountConfig && Object.hasOwn(accountConfig, "groups")));
+	const rooms = mergeMatrixRoomEntries(selectInheritedMatrixRoomEntries({
+		entries: base.rooms,
+		accountId
+	}), accountConfig?.rooms, Boolean(accountConfig && Object.hasOwn(accountConfig, "rooms")));
+	const { groups: _ignoredGroups, rooms: _ignoredRooms, ...rest } = merged;
+	return {
+		...rest,
+		...groups ? { groups } : {},
+		...rooms ? { rooms } : {}
+	};
+}
+function resolveMatrixAccountAllowlistConfig(params) {
+	const accountId = normalizeAccountId(params.accountId);
+	const base = resolveMatrixBaseConfig(params.cfg);
+	const accountConfig = findMatrixAccountConfig(params.cfg, accountId);
+	const accountDm = accountConfig?.dm;
+	let dmAllowFrom = base.dm?.allowFrom;
+	if (accountDm && Object.hasOwn(accountDm, "allowFrom")) dmAllowFrom = accountDm.allowFrom;
+	let groupAllowFrom = base.groupAllowFrom;
+	if (accountConfig && Object.hasOwn(accountConfig, "groupAllowFrom")) groupAllowFrom = accountConfig.groupAllowFrom;
+	return {
+		dmAllowFrom,
+		groupAllowFrom
+	};
+}
+//#endregion
+export { resolveMatrixAccountConfig as a, resolveMatrixAccountAllowlistConfig as i, hasExplicitMatrixAccountConfig as n, resolveMatrixBaseConfig as o, listNormalizedMatrixAccountIds as r, findMatrixAccountConfig as t };

package/dist/account-selection-BWwIruri.js

@@ -0,0 +1,158 @@
+import { n as listMatrixEnvAccountIds, t as getMatrixScopedEnvVarNames } from "./env-vars-C7uQCTKn.js";
+import { t as isRecord } from "./record-shared-CHWJCTWf.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId, normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { listCombinedAccountIds, listConfiguredAccountIds, resolveListedDefaultAccountId, resolveNormalizedAccountEntry } from "openclaw/plugin-sdk/account-core";
+import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input-runtime";
+//#region extensions/matrix/src/auth-precedence.ts
+const MATRIX_DEFAULT_ACCOUNT_AUTH_ONLY_FIELDS = new Set([
+	"userId",
+	"accessToken",
+	"password",
+	"deviceId"
+]);
+function resolveMatrixStringSourceValue(value) {
+	return typeof value === "string" ? value : "";
+}
+function shouldAllowBaseAuthFallback(accountId, field) {
+	return normalizeAccountId(accountId) === DEFAULT_ACCOUNT_ID || !MATRIX_DEFAULT_ACCOUNT_AUTH_ONLY_FIELDS.has(field);
+}
+function resolveMatrixAccountStringValues(params) {
+	const fields = [
+		"homeserver",
+		"userId",
+		"accessToken",
+		"password",
+		"deviceId",
+		"deviceName"
+	];
+	const resolved = {};
+	for (const field of fields) resolved[field] = resolveMatrixStringSourceValue(params.account?.[field]) || resolveMatrixStringSourceValue(params.scopedEnv?.[field]) || (shouldAllowBaseAuthFallback(params.accountId, field) ? resolveMatrixStringSourceValue(params.channel?.[field]) || resolveMatrixStringSourceValue(params.globalEnv?.[field]) : "");
+	return resolved;
+}
+//#endregion
+//#region extensions/matrix/src/account-selection.ts
+function readConfiguredMatrixString(value) {
+	return normalizeOptionalString(value) ?? "";
+}
+function readConfiguredMatrixSecretSource(value) {
+	return hasConfiguredSecretInput(value) ? "configured" : "";
+}
+function resolveMatrixChannelStringSources(entry) {
+	if (!entry) return {};
+	return {
+		homeserver: readConfiguredMatrixString(entry.homeserver),
+		userId: readConfiguredMatrixString(entry.userId),
+		accessToken: readConfiguredMatrixSecretSource(entry.accessToken),
+		password: readConfiguredMatrixSecretSource(entry.password),
+		deviceId: readConfiguredMatrixString(entry.deviceId),
+		deviceName: readConfiguredMatrixString(entry.deviceName)
+	};
+}
+function readEnvMatrixString(env, key) {
+	return normalizeOptionalString(env[key]) ?? "";
+}
+function resolveScopedMatrixEnvStringSources(accountId, env) {
+	const keys = getMatrixScopedEnvVarNames(accountId);
+	return {
+		homeserver: readEnvMatrixString(env, keys.homeserver),
+		userId: readEnvMatrixString(env, keys.userId),
+		accessToken: readEnvMatrixString(env, keys.accessToken),
+		password: readEnvMatrixString(env, keys.password),
+		deviceId: readEnvMatrixString(env, keys.deviceId),
+		deviceName: readEnvMatrixString(env, keys.deviceName)
+	};
+}
+function resolveGlobalMatrixEnvStringSources(env) {
+	return {
+		homeserver: readEnvMatrixString(env, "MATRIX_HOMESERVER"),
+		userId: readEnvMatrixString(env, "MATRIX_USER_ID"),
+		accessToken: readEnvMatrixString(env, "MATRIX_ACCESS_TOKEN"),
+		password: readEnvMatrixString(env, "MATRIX_PASSWORD"),
+		deviceId: readEnvMatrixString(env, "MATRIX_DEVICE_ID"),
+		deviceName: readEnvMatrixString(env, "MATRIX_DEVICE_NAME")
+	};
+}
+function hasUsableResolvedMatrixAuth(values) {
+	return Boolean(values.homeserver && (values.accessToken || values.userId));
+}
+function hasFreshResolvedMatrixAuth(values) {
+	return Boolean(values.homeserver && (values.accessToken || values.userId && values.password));
+}
+function resolveEffectiveMatrixAccountSources(params) {
+	const normalizedAccountId = normalizeAccountId(params.accountId);
+	return resolveMatrixAccountStringValues({
+		accountId: normalizedAccountId,
+		scopedEnv: resolveScopedMatrixEnvStringSources(normalizedAccountId, params.env),
+		channel: resolveMatrixChannelStringSources(params.channel),
+		globalEnv: resolveGlobalMatrixEnvStringSources(params.env)
+	});
+}
+function hasUsableEffectiveMatrixAccountSource(params) {
+	return hasUsableResolvedMatrixAuth(resolveEffectiveMatrixAccountSources(params));
+}
+function hasFreshEffectiveMatrixAccountSource(params) {
+	return hasFreshResolvedMatrixAuth(resolveEffectiveMatrixAccountSources(params));
+}
+function hasConfiguredDefaultMatrixAccountSource(params) {
+	return hasFreshEffectiveMatrixAccountSource({
+		channel: params.channel,
+		accountId: DEFAULT_ACCOUNT_ID,
+		env: params.env
+	});
+}
+function resolveMatrixChannelConfig(cfg) {
+	return isRecord(cfg.channels?.matrix) ? cfg.channels.matrix : null;
+}
+function findMatrixAccountEntry(cfg, accountId) {
+	const channel = resolveMatrixChannelConfig(cfg);
+	if (!channel) return null;
+	const accounts = isRecord(channel.accounts) ? channel.accounts : null;
+	if (!accounts) return null;
+	const entry = resolveNormalizedAccountEntry(accounts, accountId, normalizeAccountId);
+	return isRecord(entry) ? entry : null;
+}
+function resolveConfiguredMatrixAccountIds(cfg, env = process.env) {
+	const channel = resolveMatrixChannelConfig(cfg);
+	const configuredAccountIds = listConfiguredAccountIds({
+		accounts: channel && isRecord(channel.accounts) ? channel.accounts : void 0,
+		normalizeAccountId
+	});
+	if (hasConfiguredDefaultMatrixAccountSource({
+		channel,
+		env
+	})) configuredAccountIds.push(DEFAULT_ACCOUNT_ID);
+	return listCombinedAccountIds({
+		configuredAccountIds,
+		additionalAccountIds: listMatrixEnvAccountIds(env).filter((accountId) => normalizeAccountId(accountId) === DEFAULT_ACCOUNT_ID ? hasConfiguredDefaultMatrixAccountSource({
+			channel,
+			env
+		}) : hasUsableEffectiveMatrixAccountSource({
+			channel,
+			accountId,
+			env
+		})),
+		fallbackAccountIdWhenEmpty: channel ? DEFAULT_ACCOUNT_ID : void 0
+	});
+}
+function resolveMatrixDefaultOrOnlyAccountId(cfg, env = process.env) {
+	const channel = resolveMatrixChannelConfig(cfg);
+	if (!channel) return DEFAULT_ACCOUNT_ID;
+	const configuredDefault = normalizeOptionalAccountId(typeof channel.defaultAccount === "string" ? channel.defaultAccount : void 0);
+	return resolveListedDefaultAccountId({
+		accountIds: resolveConfiguredMatrixAccountIds(cfg, env),
+		configuredDefaultAccountId: configuredDefault,
+		ambiguousFallbackAccountId: DEFAULT_ACCOUNT_ID
+	});
+}
+function requiresExplicitMatrixDefaultAccount(cfg, env = process.env) {
+	const channel = resolveMatrixChannelConfig(cfg);
+	if (!channel) return false;
+	const configuredAccountIds = resolveConfiguredMatrixAccountIds(cfg, env);
+	if (configuredAccountIds.length <= 1) return false;
+	if (configuredAccountIds.includes(DEFAULT_ACCOUNT_ID)) return false;
+	const configuredDefault = normalizeOptionalAccountId(typeof channel.defaultAccount === "string" ? channel.defaultAccount : void 0);
+	return !(configuredDefault && configuredAccountIds.includes(configuredDefault));
+}
+//#endregion
+export { resolveMatrixDefaultOrOnlyAccountId as a, resolveMatrixChannelConfig as i, requiresExplicitMatrixDefaultAccount as n, resolveMatrixAccountStringValues as o, resolveConfiguredMatrixAccountIds as r, findMatrixAccountEntry as t };

package/dist/accounts-Bm90Rzvp.js

@@ -0,0 +1,130 @@
+import { a as resolveMatrixDefaultOrOnlyAccountId, o as resolveMatrixAccountStringValues, r as resolveConfiguredMatrixAccountIds } from "./account-selection-BWwIruri.js";
+import { a as resolveMatrixAccountConfig, o as resolveMatrixBaseConfig, t as findMatrixAccountConfig } from "./account-config-D2W-V1eQ.js";
+import { i as resolveScopedMatrixEnvConfig, n as resolveGlobalMatrixEnvConfig } from "./env-auth-BJqGI8M6.js";
+import { i as loadMatrixCredentials, n as credentialsMatchConfig } from "./credentials-read-cmHgousK.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { hasConfiguredSecretInput } from "openclaw/plugin-sdk/secret-input-runtime";
+//#region extensions/matrix/src/matrix/accounts.ts
+function clean(value) {
+	return normalizeOptionalString(value) ?? "";
+}
+function resolveMatrixAccountAuthView(params) {
+	const normalizedAccountId = normalizeAccountId(params.accountId);
+	const matrix = resolveMatrixBaseConfig(params.cfg);
+	const account = findMatrixAccountConfig(params.cfg, normalizedAccountId) ?? {};
+	const resolvedStrings = resolveMatrixAccountStringValues({
+		accountId: normalizedAccountId,
+		account: {
+			homeserver: clean(account.homeserver),
+			userId: clean(account.userId),
+			accessToken: typeof account.accessToken === "string" ? clean(account.accessToken) : "",
+			password: typeof account.password === "string" ? clean(account.password) : "",
+			deviceId: clean(account.deviceId),
+			deviceName: clean(account.deviceName)
+		},
+		scopedEnv: resolveScopedMatrixEnvConfig(normalizedAccountId, params.env),
+		channel: {
+			homeserver: clean(matrix.homeserver),
+			userId: clean(matrix.userId),
+			accessToken: typeof matrix.accessToken === "string" ? clean(matrix.accessToken) : "",
+			password: typeof matrix.password === "string" ? clean(matrix.password) : "",
+			deviceId: clean(matrix.deviceId),
+			deviceName: clean(matrix.deviceName)
+		},
+		globalEnv: resolveGlobalMatrixEnvConfig(params.env)
+	});
+	return {
+		homeserver: resolvedStrings.homeserver,
+		userId: resolvedStrings.userId,
+		accessToken: resolvedStrings.accessToken || void 0,
+		password: resolvedStrings.password || void 0
+	};
+}
+function resolveMatrixAccountUserId(params) {
+	const env = params.env ?? process.env;
+	const authView = resolveMatrixAccountAuthView({
+		cfg: params.cfg,
+		accountId: params.accountId,
+		env
+	});
+	const configuredUserId = authView.userId.trim();
+	if (configuredUserId) return configuredUserId;
+	const stored = loadMatrixCredentials(env, params.accountId);
+	if (!stored) return null;
+	if (authView.homeserver && stored.homeserver !== authView.homeserver) return null;
+	if (authView.accessToken && stored.accessToken !== authView.accessToken) return null;
+	return stored.userId.trim() || null;
+}
+function listMatrixAccountIds(cfg) {
+	const ids = resolveConfiguredMatrixAccountIds(cfg, process.env);
+	return ids.length > 0 ? ids : [DEFAULT_ACCOUNT_ID];
+}
+function resolveDefaultMatrixAccountId(cfg) {
+	return normalizeAccountId(resolveMatrixDefaultOrOnlyAccountId(cfg));
+}
+function resolveConfiguredMatrixBotUserIds(params) {
+	const env = params.env ?? process.env;
+	const currentAccountId = normalizeAccountId(params.accountId);
+	const accountIds = new Set(resolveConfiguredMatrixAccountIds(params.cfg, env));
+	if (resolveMatrixAccount({
+		cfg: params.cfg,
+		accountId: DEFAULT_ACCOUNT_ID,
+		env
+	}).configured) accountIds.add(DEFAULT_ACCOUNT_ID);
+	const ids = /* @__PURE__ */ new Set();
+	for (const accountId of accountIds) {
+		if (normalizeAccountId(accountId) === currentAccountId) continue;
+		if (!resolveMatrixAccount({
+			cfg: params.cfg,
+			accountId,
+			env
+		}).configured) continue;
+		const userId = resolveMatrixAccountUserId({
+			cfg: params.cfg,
+			accountId,
+			env
+		});
+		if (userId) ids.add(userId);
+	}
+	return ids;
+}
+function resolveMatrixAccount(params) {
+	const env = params.env ?? process.env;
+	const accountId = normalizeAccountId(params.accountId ?? resolveDefaultMatrixAccountId(params.cfg));
+	const matrixBase = resolveMatrixBaseConfig(params.cfg);
+	const base = resolveMatrixAccountConfig({
+		cfg: params.cfg,
+		accountId,
+		env
+	});
+	const explicitAuthConfig = accountId === DEFAULT_ACCOUNT_ID ? base : findMatrixAccountConfig(params.cfg, accountId) ?? {};
+	const enabled = base.enabled !== false && matrixBase.enabled !== false;
+	const authView = resolveMatrixAccountAuthView({
+		cfg: params.cfg,
+		accountId,
+		env
+	});
+	const hasHomeserver = Boolean(authView.homeserver);
+	const hasUserId = Boolean(authView.userId);
+	const hasAccessToken = Boolean(authView.accessToken) || hasConfiguredSecretInput(explicitAuthConfig.accessToken);
+	const hasPassword = Boolean(authView.password);
+	const hasPasswordAuth = hasUserId && (hasPassword || hasConfiguredSecretInput(explicitAuthConfig.password));
+	const stored = loadMatrixCredentials(env, accountId);
+	const hasStored = stored && authView.homeserver ? credentialsMatchConfig(stored, {
+		homeserver: authView.homeserver,
+		userId: authView.userId || ""
+	}) : false;
+	const configured = hasHomeserver && (hasAccessToken || hasPasswordAuth || hasStored);
+	return {
+		accountId,
+		enabled,
+		name: normalizeOptionalString(base.name),
+		configured,
+		homeserver: authView.homeserver || void 0,
+		userId: authView.userId || void 0,
+		config: base
+	};
+}
+//#endregion
+export { resolveMatrixAccount as i, resolveConfiguredMatrixBotUserIds as n, resolveDefaultMatrixAccountId as r, listMatrixAccountIds as t };

package/dist/active-client-uhlxdhEy.js

@@ -0,0 +1,20 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+//#region extensions/matrix/src/matrix/active-client.ts
+const activeClients = /* @__PURE__ */ new Map();
+function resolveAccountKey(accountId) {
+	return normalizeAccountId(accountId) || DEFAULT_ACCOUNT_ID;
+}
+function setActiveMatrixClient(client, accountId) {
+	const key = resolveAccountKey(accountId);
+	if (!client) {
+		activeClients.delete(key);
+		return;
+	}
+	activeClients.set(key, client);
+}
+function getActiveMatrixClient(accountId) {
+	const key = resolveAccountKey(accountId);
+	return activeClients.get(key) ?? null;
+}
+//#endregion
+export { setActiveMatrixClient as n, getActiveMatrixClient as t };

package/dist/allowlist-sTzpCn5d.js

@@ -0,0 +1,68 @@
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { resolveAllowlistMatchByCandidates } from "openclaw/plugin-sdk/allow-from";
+import { normalizeStringEntries } from "openclaw/plugin-sdk/string-normalization-runtime";
+//#region extensions/matrix/src/matrix/monitor/allowlist.ts
+function normalizeAllowList(list) {
+	return normalizeStringEntries(list);
+}
+function normalizeMatrixUser(raw) {
+	const value = (raw ?? "").trim();
+	if (!value) return "";
+	if (!value.startsWith("@") || !value.includes(":")) return normalizeLowercaseStringOrEmpty(value);
+	const withoutAt = value.slice(1);
+	const splitIndex = withoutAt.indexOf(":");
+	if (splitIndex === -1) return normalizeLowercaseStringOrEmpty(value);
+	const localpart = normalizeLowercaseStringOrEmpty(withoutAt.slice(0, splitIndex));
+	const server = normalizeLowercaseStringOrEmpty(withoutAt.slice(splitIndex + 1));
+	if (!server) return normalizeLowercaseStringOrEmpty(value);
+	return `@${localpart}:${server}`;
+}
+function normalizeMatrixUserId(raw) {
+	const trimmed = (raw ?? "").trim();
+	if (!trimmed) return "";
+	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lowered.startsWith("matrix:")) return normalizeMatrixUser(trimmed.slice(7));
+	if (lowered.startsWith("user:")) return normalizeMatrixUser(trimmed.slice(5));
+	return normalizeMatrixUser(trimmed);
+}
+function normalizeMatrixAllowListEntry(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed) return "";
+	if (trimmed === "*") return trimmed;
+	const lowered = normalizeLowercaseStringOrEmpty(trimmed);
+	if (lowered.startsWith("matrix:")) return `matrix:${normalizeMatrixUser(trimmed.slice(7))}`;
+	if (lowered.startsWith("user:")) return `user:${normalizeMatrixUser(trimmed.slice(5))}`;
+	return normalizeMatrixUser(trimmed);
+}
+function normalizeMatrixAllowList(list) {
+	return normalizeAllowList(list).map((entry) => normalizeMatrixAllowListEntry(entry));
+}
+function resolveMatrixAllowListMatch(params) {
+	const allowList = params.allowList;
+	if (allowList.length === 0) return { allowed: false };
+	if (allowList.includes("*")) return {
+		allowed: true,
+		matchKey: "*",
+		matchSource: "wildcard"
+	};
+	const userId = normalizeMatrixUser(params.userId);
+	return resolveAllowlistMatchByCandidates({
+		allowList,
+		candidates: [
+			{
+				value: userId,
+				source: "id"
+			},
+			{
+				value: userId ? `matrix:${userId}` : "",
+				source: "prefixed-id"
+			},
+			{
+				value: userId ? `user:${userId}` : "",
+				source: "prefixed-user"
+			}
+		]
+	});
+}
+//#endregion
+export { normalizeMatrixUserId as n, resolveMatrixAllowListMatch as r, normalizeMatrixAllowList as t };

package/dist/api.js

@@ -0,0 +1,12 @@
+import { d as setMatrixThreadBindingIdleTimeoutBySessionKey, n as getMatrixThreadBindingManager, p as setMatrixThreadBindingMaxAgeBySessionKey, s as resetMatrixThreadBindingsForTests } from "./thread-bindings-shared-DK-d-oYX.js";
+import { a as resolveMatrixDefaultOrOnlyAccountId, i as resolveMatrixChannelConfig, n as requiresExplicitMatrixDefaultAccount, r as resolveConfiguredMatrixAccountIds, t as findMatrixAccountEntry } from "./account-selection-BWwIruri.js";
+import { n as listMatrixEnvAccountIds, r as resolveMatrixEnvAccountToken, t as getMatrixScopedEnvVarNames } from "./env-vars-C7uQCTKn.js";
+import { a as resolveMatrixCredentialsPath, c as resolveMatrixLegacyFlatStoreRoot, i as resolveMatrixCredentialsFilename, l as sanitizeMatrixPathSegment, n as resolveMatrixAccountStorageRoot, o as resolveMatrixHomeserverKey, r as resolveMatrixCredentialsDir, s as resolveMatrixLegacyFlatStoragePaths, t as hashMatrixAccessToken } from "./storage-paths-BJLdnCjV.js";
+import { t as matrixPlugin } from "./channel-H_6lMgwf.js";
+import { n as matrixSetupAdapter, t as createMatrixSetupWizardProxy } from "./setup-core-CfZy05oW.js";
+import { n as matrixOnboardingAdapter } from "./setup-surface-CqT_o61M.js";
+import { t as createMatrixThreadBindingManager } from "./thread-bindings-B9mesxXk.js";
+//#region extensions/matrix/api.ts
+const matrixSessionBindingAdapterChannels = ["matrix"];
+//#endregion
+export { createMatrixSetupWizardProxy, createMatrixThreadBindingManager, findMatrixAccountEntry, getMatrixScopedEnvVarNames, getMatrixThreadBindingManager, hashMatrixAccessToken, listMatrixEnvAccountIds, matrixOnboardingAdapter, matrixOnboardingAdapter as matrixSetupWizard, matrixPlugin, matrixSessionBindingAdapterChannels, matrixSetupAdapter, requiresExplicitMatrixDefaultAccount, resetMatrixThreadBindingsForTests, resolveConfiguredMatrixAccountIds, resolveMatrixAccountStorageRoot, resolveMatrixChannelConfig, resolveMatrixCredentialsDir, resolveMatrixCredentialsFilename, resolveMatrixCredentialsPath, resolveMatrixDefaultOrOnlyAccountId, resolveMatrixEnvAccountToken, resolveMatrixHomeserverKey, resolveMatrixLegacyFlatStoragePaths, resolveMatrixLegacyFlatStoreRoot, sanitizeMatrixPathSegment, setMatrixThreadBindingIdleTimeoutBySessionKey, setMatrixThreadBindingMaxAgeBySessionKey };