@kodelyth/matrix 2026.5.39 → 2026.5.42

package/dist/deps-DVpDS81G.js

@@ -0,0 +1,208 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import { formatErrorMessage } from "klaw/plugin-sdk/error-runtime";
+import { spawn } from "node:child_process";
+//#region extensions/matrix/src/matrix/deps.ts
+const REQUIRED_MATRIX_PACKAGES = [
+	"matrix-js-sdk",
+	"@matrix-org/matrix-sdk-crypto-nodejs",
+	"@matrix-org/matrix-sdk-crypto-wasm"
+];
+const MIN_MATRIX_CRYPTO_NATIVE_BINDING_BYTES = 1e6;
+function resolveMissingMatrixPackages(resolveFn) {
+	const resolve = resolveFn ?? defaultResolveFn;
+	return REQUIRED_MATRIX_PACKAGES.filter((pkg) => {
+		try {
+			resolve(pkg);
+			return false;
+		} catch {
+			return true;
+		}
+	});
+}
+function isMatrixSdkAvailable() {
+	return resolveMissingMatrixPackages().length === 0;
+}
+function buildMatrixDepsMissingMessage(missing) {
+	return [`Matrix plugin dependencies are missing: ${missing.join(", ")}.`, "Repair this plugin with `klaw plugins update matrix` or run `klaw doctor --fix`."].join(" ");
+}
+let defaultMatrixCryptoRuntimeEnsurePromise = null;
+async function runFixedCommandWithTimeout(params) {
+	return await new Promise((resolve) => {
+		const [command, ...args] = params.argv;
+		if (!command) {
+			resolve({
+				code: 1,
+				stdout: "",
+				stderr: "command is required"
+			});
+			return;
+		}
+		const proc = spawn(command, args, {
+			cwd: params.cwd,
+			env: {
+				...process.env,
+				...params.env
+			},
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		let stdout = "";
+		let stderr = "";
+		let settled = false;
+		let timer = null;
+		const killChildOnExit = () => {
+			if (!settled && proc.exitCode === null) proc.kill("SIGTERM");
+		};
+		const finalize = (result) => {
+			if (settled) return;
+			settled = true;
+			if (timer) clearTimeout(timer);
+			process.off("exit", killChildOnExit);
+			resolve(result);
+		};
+		process.once("exit", killChildOnExit);
+		proc.stdout?.on("data", (chunk) => {
+			stdout += chunk.toString();
+		});
+		proc.stderr?.on("data", (chunk) => {
+			stderr += chunk.toString();
+		});
+		timer = setTimeout(() => {
+			proc.kill("SIGKILL");
+			finalize({
+				code: 124,
+				stdout,
+				stderr: stderr || `command timed out after ${params.timeoutMs}ms`
+			});
+		}, params.timeoutMs);
+		proc.on("error", (err) => {
+			finalize({
+				code: 1,
+				stdout,
+				stderr: err.message
+			});
+		});
+		proc.on("close", (code) => {
+			finalize({
+				code: code ?? 1,
+				stdout,
+				stderr
+			});
+		});
+	});
+}
+function defaultRequireFn(id) {
+	return createRequire(import.meta.url)(id);
+}
+function defaultResolveFn(id) {
+	return createRequire(import.meta.url).resolve(id);
+}
+function isMissingMatrixCryptoRuntimeError(error) {
+	const message = formatErrorMessage(error);
+	return message.includes("@matrix-org/matrix-sdk-crypto-nodejs-") || message.includes("matrix-sdk-crypto-nodejs") || message.includes("download-lib.js");
+}
+function isMuslRuntime() {
+	try {
+		return !(process.report?.getReport?.())?.header?.glibcVersionRuntime;
+	} catch {
+		return true;
+	}
+}
+function resolveMatrixCryptoNativeBindingFilename() {
+	switch (process.platform) {
+		case "darwin": return process.arch === "arm64" ? "matrix-sdk-crypto.darwin-arm64.node" : process.arch === "x64" ? "matrix-sdk-crypto.darwin-x64.node" : null;
+		case "linux":
+			if (process.arch === "x64") return isMuslRuntime() ? "matrix-sdk-crypto.linux-x64-musl.node" : "matrix-sdk-crypto.linux-x64-gnu.node";
+			if (process.arch === "arm64" && !isMuslRuntime()) return "matrix-sdk-crypto.linux-arm64-gnu.node";
+			if (process.arch === "arm") return "matrix-sdk-crypto.linux-arm-gnueabihf.node";
+			if (process.arch === "s390x") return "matrix-sdk-crypto.linux-s390x-gnu.node";
+			return null;
+		case "win32": return process.arch === "x64" ? "matrix-sdk-crypto.win32-x64-msvc.node" : process.arch === "ia32" ? "matrix-sdk-crypto.win32-ia32-msvc.node" : process.arch === "arm64" ? "matrix-sdk-crypto.win32-arm64-msvc.node" : null;
+		default: return null;
+	}
+}
+function resolveMatrixCryptoNativeBindingPath(resolveFn) {
+	const filename = resolveMatrixCryptoNativeBindingFilename();
+	if (!filename) return null;
+	try {
+		return path.join(path.dirname(resolveFn("@matrix-org/matrix-sdk-crypto-nodejs/download-lib.js")), filename);
+	} catch {
+		return null;
+	}
+}
+function removeIncompleteMatrixCryptoNativeBinding(params) {
+	const bindingPath = params.bindingPath;
+	if (!bindingPath) return;
+	try {
+		const stat = fs.statSync(bindingPath);
+		if (!stat.isFile() || stat.size >= MIN_MATRIX_CRYPTO_NATIVE_BINDING_BYTES) return;
+		fs.unlinkSync(bindingPath);
+		params.log?.(`matrix: removed incomplete native crypto runtime (${stat.size} bytes); it will be downloaded again`);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+async function ensureMatrixCryptoRuntime(params = {}) {
+	const usesDefaultRuntime = !params.requireFn && !params.runCommand && !params.resolveFn && !params.nodeExecutable;
+	if (usesDefaultRuntime && defaultMatrixCryptoRuntimeEnsurePromise) {
+		await defaultMatrixCryptoRuntimeEnsurePromise;
+		return;
+	}
+	const ensurePromise = ensureMatrixCryptoRuntimeOnce(params);
+	if (!usesDefaultRuntime) {
+		await ensurePromise;
+		return;
+	}
+	defaultMatrixCryptoRuntimeEnsurePromise = ensurePromise.catch((error) => {
+		defaultMatrixCryptoRuntimeEnsurePromise = null;
+		throw error;
+	});
+	await defaultMatrixCryptoRuntimeEnsurePromise;
+}
+async function ensureMatrixCryptoRuntimeOnce(params) {
+	const resolveFn = params.resolveFn ?? defaultResolveFn;
+	const nativeBindingPath = resolveMatrixCryptoNativeBindingPath(resolveFn);
+	removeIncompleteMatrixCryptoNativeBinding({
+		bindingPath: nativeBindingPath,
+		log: params.log
+	});
+	const requireFn = params.requireFn ?? defaultRequireFn;
+	try {
+		requireFn("@matrix-org/matrix-sdk-crypto-nodejs");
+		return;
+	} catch (err) {
+		if (!isMissingMatrixCryptoRuntimeError(err)) throw err;
+	}
+	const scriptPath = resolveFn("@matrix-org/matrix-sdk-crypto-nodejs/download-lib.js");
+	params.log?.("matrix: bootstrapping native crypto runtime");
+	const result = await (params.runCommand ?? runFixedCommandWithTimeout)({
+		argv: [params.nodeExecutable ?? process.execPath, scriptPath],
+		cwd: path.dirname(scriptPath),
+		timeoutMs: 3e5,
+		env: { COREPACK_ENABLE_DOWNLOAD_PROMPT: "0" }
+	});
+	if (result.code !== 0) {
+		removeIncompleteMatrixCryptoNativeBinding({
+			bindingPath: nativeBindingPath,
+			log: params.log
+		});
+		throw new Error(result.stderr.trim() || result.stdout.trim() || "Matrix crypto runtime bootstrap failed.");
+	}
+	removeIncompleteMatrixCryptoNativeBinding({
+		bindingPath: nativeBindingPath,
+		log: params.log
+	});
+	requireFn("@matrix-org/matrix-sdk-crypto-nodejs");
+}
+async function ensureMatrixSdkInstalled(params) {
+	const missing = resolveMissingMatrixPackages(params?.resolveFn);
+	if (missing.length === 0) return;
+	throw new Error(buildMatrixDepsMissingMessage(missing));
+}
+//#endregion
+export { ensureMatrixSdkInstalled as n, isMatrixSdkAvailable as r, ensureMatrixCryptoRuntime as t };

package/dist/device-health-Ct2wDSPG.js

@@ -0,0 +1,16 @@
+//#region extensions/matrix/src/matrix/device-health.ts
+const KLAW_DEVICE_NAME_PREFIX = "Klaw ";
+function isKlawManagedMatrixDevice(displayName) {
+	return displayName?.startsWith(KLAW_DEVICE_NAME_PREFIX) === true;
+}
+function summarizeMatrixDeviceHealth(devices) {
+	const currentDeviceId = devices.find((device) => device.current)?.deviceId ?? null;
+	const openClawDevices = devices.filter((device) => isKlawManagedMatrixDevice(device.displayName));
+	return {
+		currentDeviceId,
+		staleKlawDevices: openClawDevices.filter((device) => !device.current),
+		currentKlawDevices: openClawDevices.filter((device) => device.current)
+	};
+}
+//#endregion
+export { isKlawManagedMatrixDevice, summarizeMatrixDeviceHealth };

package/dist/directory-live-i3T8uORc.js

@@ -0,0 +1,150 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { n as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-Bsazo8si.js";
+import { t as MatrixAuthedHttpClient } from "./http-client-DoQgbQsU.js";
+import { l as resolveMatrixAuth } from "./shared-D6MFMnpG.js";
+import "./client-PhrTwuC4.js";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "klaw/plugin-sdk/string-coerce-runtime";
+//#region extensions/matrix/src/directory-live.ts
+var directory_live_exports = /* @__PURE__ */ __exportAll({
+	listMatrixDirectoryGroupsLive: () => listMatrixDirectoryGroupsLive,
+	listMatrixDirectoryPeersLive: () => listMatrixDirectoryPeersLive
+});
+const MATRIX_DIRECTORY_TIMEOUT_MS = 1e4;
+function resolveMatrixDirectoryLimit(limit) {
+	return typeof limit === "number" && Number.isFinite(limit) && limit > 0 ? Math.max(1, Math.floor(limit)) : 20;
+}
+function createMatrixDirectoryClient(auth) {
+	return new MatrixAuthedHttpClient({
+		homeserver: auth.homeserver,
+		accessToken: auth.accessToken,
+		ssrfPolicy: auth.ssrfPolicy,
+		dispatcherPolicy: auth.dispatcherPolicy
+	});
+}
+async function resolveMatrixDirectoryContext(params) {
+	const query = normalizeOptionalString(params.query) ?? "";
+	if (!query) return null;
+	const auth = await resolveMatrixAuth({
+		cfg: params.cfg,
+		accountId: params.accountId
+	});
+	return {
+		auth,
+		client: createMatrixDirectoryClient(auth),
+		query,
+		queryLower: normalizeLowercaseStringOrEmpty(query)
+	};
+}
+function createGroupDirectoryEntry(params) {
+	return {
+		kind: "group",
+		id: params.id,
+		name: params.name,
+		handle: params.handle
+	};
+}
+async function requestMatrixJson(client, params) {
+	return await client.requestJson({
+		method: params.method,
+		endpoint: params.endpoint,
+		body: params.body,
+		timeoutMs: MATRIX_DIRECTORY_TIMEOUT_MS
+	});
+}
+async function listMatrixDirectoryPeersLive(params) {
+	const query = normalizeOptionalString(params.query) ?? "";
+	if (!query) return [];
+	const directUserId = normalizeMatrixMessagingTarget(query);
+	if (directUserId && isMatrixQualifiedUserId(directUserId)) return [{
+		kind: "user",
+		id: directUserId
+	}];
+	const context = await resolveMatrixDirectoryContext({
+		...params,
+		query
+	});
+	if (!context) return [];
+	return ((await requestMatrixJson(context.client, {
+		method: "POST",
+		endpoint: "/_matrix/client/v3/user_directory/search",
+		body: {
+			search_term: context.query,
+			limit: resolveMatrixDirectoryLimit(params.limit)
+		}
+	})).results ?? []).map((entry) => {
+		const userId = normalizeOptionalString(entry.user_id);
+		if (!userId) return null;
+		const displayName = normalizeOptionalString(entry.display_name);
+		return {
+			kind: "user",
+			id: userId,
+			name: displayName,
+			handle: displayName ? `@${displayName}` : void 0,
+			raw: entry
+		};
+	}).filter(Boolean);
+}
+async function resolveMatrixRoomAlias(client, alias) {
+	try {
+		return normalizeOptionalString((await requestMatrixJson(client, {
+			method: "GET",
+			endpoint: `/_matrix/client/v3/directory/room/${encodeURIComponent(alias)}`
+		})).room_id) ?? null;
+	} catch {
+		return null;
+	}
+}
+async function fetchMatrixRoomName(client, roomId) {
+	try {
+		return normalizeOptionalString((await requestMatrixJson(client, {
+			method: "GET",
+			endpoint: `/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/state/m.room.name`
+		})).name) ?? null;
+	} catch {
+		return null;
+	}
+}
+async function listMatrixDirectoryGroupsLive(params) {
+	const query = normalizeOptionalString(params.query) ?? "";
+	if (!query) return [];
+	const directTarget = normalizeMatrixMessagingTarget(query);
+	if (directTarget?.startsWith("!")) return [createGroupDirectoryEntry({
+		id: directTarget,
+		name: directTarget
+	})];
+	const context = await resolveMatrixDirectoryContext({
+		...params,
+		query
+	});
+	if (!context) return [];
+	const { client, queryLower } = context;
+	const limit = resolveMatrixDirectoryLimit(params.limit);
+	if (directTarget?.startsWith("#")) {
+		const roomId = await resolveMatrixRoomAlias(client, directTarget);
+		if (!roomId) return [];
+		return [createGroupDirectoryEntry({
+			id: roomId,
+			name: directTarget,
+			handle: directTarget
+		})];
+	}
+	const rooms = ((await requestMatrixJson(client, {
+		method: "GET",
+		endpoint: "/_matrix/client/v3/joined_rooms"
+	})).joined_rooms ?? []).map((roomId) => normalizeOptionalString(roomId)).filter((roomId) => Boolean(roomId));
+	const results = [];
+	for (const roomId of rooms) {
+		const name = await fetchMatrixRoomName(client, roomId);
+		if (!name || !normalizeLowercaseStringOrEmpty(name).includes(queryLower)) continue;
+		results.push({
+			kind: "group",
+			id: roomId,
+			name,
+			handle: `#${name}`
+		});
+		if (results.length >= limit) break;
+	}
+	return results;
+}
+//#endregion
+export { listMatrixDirectoryGroupsLive as n, listMatrixDirectoryPeersLive as r, directory_live_exports as t };

package/dist/doctor-contract-BLzYHl_9.js

@@ -0,0 +1,246 @@
+import { t as isRecord } from "./record-shared-DGvSFn5M.js";
+import { hasLegacyFlatAllowPrivateNetworkAlias, migrateLegacyFlatAllowPrivateNetworkAlias } from "klaw/plugin-sdk/ssrf-runtime";
+//#region extensions/matrix/src/doctor-contract.ts
+function hasLegacyMatrixRoomAllowAlias(value) {
+	const room = isRecord(value) ? value : null;
+	return Boolean(room && typeof room.allow === "boolean");
+}
+function hasLegacyMatrixRoomMapAllowAliases(value) {
+	const rooms = isRecord(value) ? value : null;
+	return Boolean(rooms && Object.values(rooms).some((room) => hasLegacyMatrixRoomAllowAlias(room)));
+}
+function hasLegacyMatrixAccountRoomAllowAliases(value) {
+	const accounts = isRecord(value) ? value : null;
+	if (!accounts) return false;
+	return Object.values(accounts).some((account) => {
+		if (!isRecord(account)) return false;
+		return hasLegacyMatrixRoomMapAllowAliases(account.groups) || hasLegacyMatrixRoomMapAllowAliases(account.rooms);
+	});
+}
+function hasLegacyMatrixAccountPrivateNetworkAliases(value) {
+	const accounts = isRecord(value) ? value : null;
+	if (!accounts) return false;
+	return Object.values(accounts).some((account) => hasLegacyFlatAllowPrivateNetworkAlias(isRecord(account) ? account : {}));
+}
+function hasLegacyTrustedDmPolicy(value) {
+	const root = isRecord(value) ? value : null;
+	if (!root) return false;
+	return (isRecord(root.dm) ? root.dm : null)?.policy === "trusted";
+}
+function hasLegacyMatrixAccountTrustedDmPolicies(value) {
+	const accounts = isRecord(value) ? value : null;
+	if (!accounts) return false;
+	return Object.values(accounts).some((account) => hasLegacyTrustedDmPolicy(account));
+}
+function migrateLegacyTrustedDmPolicy(params) {
+	const dm = isRecord(params.entry.dm) ? params.entry.dm : null;
+	if (!dm || dm.policy !== "trusted") return {
+		entry: params.entry,
+		changed: false
+	};
+	const allowFromRaw = dm.allowFrom;
+	const allowFromEntries = Array.isArray(allowFromRaw) ? allowFromRaw.filter((entry) => typeof entry === "string" && entry.trim().length > 0).length : 0;
+	const nextPolicy = allowFromEntries > 0 ? "allowlist" : "pairing";
+	const nextDm = {
+		...dm,
+		policy: nextPolicy
+	};
+	params.changes.push(`Migrated ${params.pathPrefix}.dm.policy "trusted" → "${nextPolicy}" (legacy alias removed; ${allowFromEntries > 0 ? `preserved ${allowFromEntries} ${params.pathPrefix}.dm.allowFrom ${allowFromEntries === 1 ? "entry" : "entries"}` : "no allowFrom entries present, defaulting to pairing for safety"}).`);
+	return {
+		entry: {
+			...params.entry,
+			dm: nextDm
+		},
+		changed: true
+	};
+}
+function normalizeMatrixRoomAllowAliases(params) {
+	let changed = false;
+	const nextRooms = { ...params.rooms };
+	for (const [roomId, roomValue] of Object.entries(params.rooms)) {
+		const room = isRecord(roomValue) ? roomValue : null;
+		if (!room || typeof room.allow !== "boolean") continue;
+		const nextRoom = { ...room };
+		if (typeof nextRoom.enabled !== "boolean") nextRoom.enabled = room.allow;
+		delete nextRoom.allow;
+		nextRooms[roomId] = nextRoom;
+		changed = true;
+		params.changes.push(`Moved ${params.pathPrefix}.${roomId}.allow → ${params.pathPrefix}.${roomId}.enabled (${String(nextRoom.enabled)}).`);
+	}
+	return {
+		rooms: nextRooms,
+		changed
+	};
+}
+const legacyConfigRules = [
+	{
+		path: ["channels", "matrix"],
+		message: "channels.matrix.allowPrivateNetwork is legacy; use channels.matrix.network.dangerouslyAllowPrivateNetwork instead. Run \"klaw doctor --fix\".",
+		match: (value) => hasLegacyFlatAllowPrivateNetworkAlias(isRecord(value) ? value : {})
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"accounts"
+		],
+		message: "channels.matrix.accounts.<id>.allowPrivateNetwork is legacy; use channels.matrix.accounts.<id>.network.dangerouslyAllowPrivateNetwork instead. Run \"klaw doctor --fix\".",
+		match: hasLegacyMatrixAccountPrivateNetworkAliases
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"groups"
+		],
+		message: "channels.matrix.groups.<room>.allow is legacy; use channels.matrix.groups.<room>.enabled instead. Run \"klaw doctor --fix\".",
+		match: hasLegacyMatrixRoomMapAllowAliases
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"rooms"
+		],
+		message: "channels.matrix.rooms.<room>.allow is legacy; use channels.matrix.rooms.<room>.enabled instead. Run \"klaw doctor --fix\".",
+		match: hasLegacyMatrixRoomMapAllowAliases
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"accounts"
+		],
+		message: "channels.matrix.accounts.<id>.{groups,rooms}.<room>.allow is legacy; use channels.matrix.accounts.<id>.{groups,rooms}.<room>.enabled instead. Run \"klaw doctor --fix\".",
+		match: hasLegacyMatrixAccountRoomAllowAliases
+	},
+	{
+		path: ["channels", "matrix"],
+		message: "channels.matrix.dm.policy \"trusted\" is legacy; use \"allowlist\" (with allowFrom entries) or \"pairing\" instead. Run \"klaw doctor --fix\".",
+		match: hasLegacyTrustedDmPolicy
+	},
+	{
+		path: [
+			"channels",
+			"matrix",
+			"accounts"
+		],
+		message: "channels.matrix.accounts.<id>.dm.policy \"trusted\" is legacy; use \"allowlist\" (with allowFrom entries) or \"pairing\" instead. Run \"klaw doctor --fix\".",
+		match: hasLegacyMatrixAccountTrustedDmPolicies
+	}
+];
+function normalizeCompatibilityConfig({ cfg }) {
+	const channels = isRecord(cfg.channels) ? cfg.channels : null;
+	const matrix = isRecord(channels?.matrix) ? channels.matrix : null;
+	if (!matrix) return {
+		config: cfg,
+		changes: []
+	};
+	const changes = [];
+	let updatedMatrix = matrix;
+	let changed = false;
+	const topLevelPrivateNetwork = migrateLegacyFlatAllowPrivateNetworkAlias({
+		entry: updatedMatrix,
+		pathPrefix: "channels.matrix",
+		changes
+	});
+	updatedMatrix = topLevelPrivateNetwork.entry;
+	changed = changed || topLevelPrivateNetwork.changed;
+	const topLevelTrustedDmPolicy = migrateLegacyTrustedDmPolicy({
+		entry: updatedMatrix,
+		pathPrefix: "channels.matrix",
+		changes
+	});
+	updatedMatrix = topLevelTrustedDmPolicy.entry;
+	changed = changed || topLevelTrustedDmPolicy.changed;
+	const normalizeTopLevelRoomScope = (key) => {
+		const rooms = isRecord(updatedMatrix[key]) ? updatedMatrix[key] : null;
+		if (!rooms) return;
+		const normalized = normalizeMatrixRoomAllowAliases({
+			rooms,
+			pathPrefix: `channels.matrix.${key}`,
+			changes
+		});
+		if (normalized.changed) {
+			updatedMatrix = {
+				...updatedMatrix,
+				[key]: normalized.rooms
+			};
+			changed = true;
+		}
+	};
+	normalizeTopLevelRoomScope("groups");
+	normalizeTopLevelRoomScope("rooms");
+	const accounts = isRecord(updatedMatrix.accounts) ? updatedMatrix.accounts : null;
+	if (accounts) {
+		let accountsChanged = false;
+		const nextAccounts = { ...accounts };
+		for (const [accountId, accountValue] of Object.entries(accounts)) {
+			const account = isRecord(accountValue) ? accountValue : null;
+			if (!account) continue;
+			let nextAccount = account;
+			let accountChanged = false;
+			const privateNetworkMigration = migrateLegacyFlatAllowPrivateNetworkAlias({
+				entry: nextAccount,
+				pathPrefix: `channels.matrix.accounts.${accountId}`,
+				changes
+			});
+			if (privateNetworkMigration.changed) {
+				nextAccount = privateNetworkMigration.entry;
+				accountChanged = true;
+			}
+			const accountTrustedDmPolicy = migrateLegacyTrustedDmPolicy({
+				entry: nextAccount,
+				pathPrefix: `channels.matrix.accounts.${accountId}`,
+				changes
+			});
+			if (accountTrustedDmPolicy.changed) {
+				nextAccount = accountTrustedDmPolicy.entry;
+				accountChanged = true;
+			}
+			for (const key of ["groups", "rooms"]) {
+				const rooms = isRecord(nextAccount[key]) ? nextAccount[key] : null;
+				if (!rooms) continue;
+				const normalized = normalizeMatrixRoomAllowAliases({
+					rooms,
+					pathPrefix: `channels.matrix.accounts.${accountId}.${key}`,
+					changes
+				});
+				if (normalized.changed) {
+					nextAccount = {
+						...nextAccount,
+						[key]: normalized.rooms
+					};
+					accountChanged = true;
+				}
+			}
+			if (accountChanged) {
+				nextAccounts[accountId] = nextAccount;
+				accountsChanged = true;
+			}
+		}
+		if (accountsChanged) {
+			updatedMatrix = {
+				...updatedMatrix,
+				accounts: nextAccounts
+			};
+			changed = true;
+		}
+	}
+	if (!changed) return {
+		config: cfg,
+		changes: []
+	};
+	return {
+		config: {
+			...cfg,
+			channels: {
+				...cfg.channels,
+				matrix: updatedMatrix
+			}
+		},
+		changes
+	};
+}
+//#endregion
+export { normalizeCompatibilityConfig as n, legacyConfigRules as t };

package/dist/doctor-contract-api.js

@@ -0,0 +1,2 @@
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BLzYHl_9.js";
+export { legacyConfigRules, normalizeCompatibilityConfig };