@kodelyth/matrix 2026.5.39 → 2026.5.42

package/dist/doctor-diR5gE7D.js

@@ -0,0 +1,153 @@
+import { t as isRecord } from "./record-shared-DGvSFn5M.js";
+import "./doctor-contract-BLzYHl_9.js";
+import { i as autoPrepareLegacyMatrixCrypto, o as autoMigrateLegacyMatrixState, r as resolveMatrixMigrationStatus } from "./matrix-migration.runtime-BNoT1Prt.js";
+import { t as maybeCreateMatrixMigrationSnapshot } from "./migration-snapshot-backup-BR-xD7Ew.js";
+import { detectPluginInstallPathIssue, formatPluginInstallPathIssue, removePluginFromConfig } from "klaw/plugin-sdk/runtime-doctor";
+//#region extensions/matrix/src/doctor.ts
+function hasConfiguredMatrixChannel(cfg) {
+	const channels = cfg.channels;
+	return isRecord(channels?.matrix);
+}
+function hasConfiguredMatrixPluginSurface(cfg) {
+	return Boolean(cfg.plugins?.installs?.matrix || cfg.plugins?.entries?.matrix || cfg.plugins?.allow?.includes("matrix") || cfg.plugins?.deny?.includes("matrix"));
+}
+function hasConfiguredMatrixEnv(env) {
+	return Object.entries(env).some(([key, value]) => key.startsWith("MATRIX_") && typeof value === "string" && value.trim());
+}
+function configMayNeedMatrixDoctorSequence(cfg, env) {
+	return hasConfiguredMatrixChannel(cfg) || hasConfiguredMatrixPluginSurface(cfg) || hasConfiguredMatrixEnv(env);
+}
+function formatMatrixLegacyStatePreview(detection) {
+	return [
+		"- Matrix plugin upgraded in place.",
+		`- Legacy sync store: ${detection.legacyStoragePath} -> ${detection.targetStoragePath}`,
+		`- Legacy crypto store: ${detection.legacyCryptoPath} -> ${detection.targetCryptoPath}`,
+		...detection.selectionNote ? [`- ${detection.selectionNote}`] : [],
+		"- Run \"klaw doctor --fix\" to migrate this Matrix state now."
+	].join("\n");
+}
+function formatMatrixLegacyCryptoPreview(detection) {
+	const notes = [];
+	for (const warning of detection.warnings) notes.push(`- ${warning}`);
+	for (const plan of detection.plans) notes.push([
+		`- Matrix encrypted-state migration is pending for account "${plan.accountId}".`,
+		`- Legacy crypto store: ${plan.legacyCryptoPath}`,
+		`- New recovery key file: ${plan.recoveryKeyPath}`,
+		`- Migration state file: ${plan.statePath}`,
+		"- Run \"klaw doctor --fix\" to extract any saved backup key now. Backed-up room keys will restore automatically on next gateway start."
+	].join("\n"));
+	return notes;
+}
+async function collectMatrixInstallPathWarnings(cfg) {
+	const issue = await detectPluginInstallPathIssue({
+		pluginId: "matrix",
+		install: cfg.plugins?.installs?.matrix
+	});
+	if (!issue) return [];
+	return formatPluginInstallPathIssue({
+		issue,
+		pluginLabel: "Matrix",
+		defaultInstallCommand: "klaw plugins install @kodelyth/matrix"
+	}).map((entry) => `- ${entry}`);
+}
+async function cleanStaleMatrixPluginConfig(cfg) {
+	const issue = await detectPluginInstallPathIssue({
+		pluginId: "matrix",
+		install: cfg.plugins?.installs?.matrix
+	});
+	if (!issue || issue.kind !== "missing-path") return {
+		config: cfg,
+		changes: []
+	};
+	const { config, actions } = removePluginFromConfig(cfg, "matrix");
+	const removed = [];
+	if (actions.install) removed.push("install record");
+	if (actions.loadPath) removed.push("load path");
+	if (actions.entry) removed.push("plugin entry");
+	if (actions.allowlist) removed.push("allowlist entry");
+	if (removed.length === 0) return {
+		config: cfg,
+		changes: []
+	};
+	return {
+		config,
+		changes: [`Removed stale Matrix plugin references (${removed.join(", ")}). The previous install path no longer exists: ${issue.path}`]
+	};
+}
+async function applyMatrixDoctorRepair(params) {
+	const changes = [];
+	const warnings = [];
+	const migrationStatus = resolveMatrixMigrationStatus({
+		cfg: params.cfg,
+		env: params.env
+	});
+	let matrixSnapshotReady = true;
+	if (migrationStatus.actionable) try {
+		const snapshot = await maybeCreateMatrixMigrationSnapshot({
+			trigger: "doctor-fix",
+			env: params.env
+		});
+		changes.push(`Matrix migration snapshot ${snapshot.created ? "created" : "reused"} before applying Matrix upgrades.\n- ${snapshot.archivePath}`);
+	} catch (error) {
+		matrixSnapshotReady = false;
+		warnings.push(`- Failed creating a Matrix migration snapshot before repair: ${String(error)}`);
+		warnings.push("- Skipping Matrix migration changes for now. Resolve the snapshot failure, then rerun \"klaw doctor --fix\".");
+	}
+	else if (migrationStatus.pending) warnings.push("- Matrix migration warnings are present, but no on-disk Matrix mutation is actionable yet. No pre-migration snapshot was needed.");
+	if (!matrixSnapshotReady) return {
+		changes,
+		warnings
+	};
+	const matrixStateRepair = await autoMigrateLegacyMatrixState({
+		cfg: params.cfg,
+		env: params.env
+	});
+	if (matrixStateRepair.changes.length > 0) changes.push([
+		"Matrix plugin upgraded in place.",
+		...matrixStateRepair.changes.map((entry) => `- ${entry}`),
+		"- No user action required."
+	].join("\n"));
+	if (matrixStateRepair.warnings.length > 0) warnings.push(matrixStateRepair.warnings.map((entry) => `- ${entry}`).join("\n"));
+	const matrixCryptoRepair = await autoPrepareLegacyMatrixCrypto({
+		cfg: params.cfg,
+		env: params.env
+	});
+	if (matrixCryptoRepair.changes.length > 0) changes.push(["Matrix encrypted-state migration prepared.", ...matrixCryptoRepair.changes.map((entry) => `- ${entry}`)].join("\n"));
+	if (matrixCryptoRepair.warnings.length > 0) warnings.push(matrixCryptoRepair.warnings.map((entry) => `- ${entry}`).join("\n"));
+	return {
+		changes,
+		warnings
+	};
+}
+async function runMatrixDoctorSequence(params) {
+	const warningNotes = [];
+	const changeNotes = [];
+	const installWarnings = await collectMatrixInstallPathWarnings(params.cfg);
+	if (installWarnings.length > 0) warningNotes.push(installWarnings.join("\n"));
+	if (!configMayNeedMatrixDoctorSequence(params.cfg, params.env)) return {
+		changeNotes,
+		warningNotes
+	};
+	if (params.shouldRepair) {
+		const repair = await applyMatrixDoctorRepair({
+			cfg: params.cfg,
+			env: params.env
+		});
+		changeNotes.push(...repair.changes);
+		warningNotes.push(...repair.warnings);
+	} else {
+		const migrationStatus = resolveMatrixMigrationStatus({
+			cfg: params.cfg,
+			env: params.env
+		});
+		if (migrationStatus.legacyState) if ("warning" in migrationStatus.legacyState) warningNotes.push(`- ${migrationStatus.legacyState.warning}`);
+		else warningNotes.push(formatMatrixLegacyStatePreview(migrationStatus.legacyState));
+		if (migrationStatus.legacyCrypto.warnings.length > 0 || migrationStatus.legacyCrypto.plans.length > 0) warningNotes.push(...formatMatrixLegacyCryptoPreview(migrationStatus.legacyCrypto));
+	}
+	return {
+		changeNotes,
+		warningNotes
+	};
+}
+//#endregion
+export { cleanStaleMatrixPluginConfig, runMatrixDoctorSequence };

package/dist/draft-stream-HpPJ_VJt.js

@@ -0,0 +1,143 @@
+import { n as editMessageMatrix, r as prepareMatrixSingleText, s as sendSingleTextMessageMatrix, y as MsgType } from "./send-CJunc6QM.js";
+import { createDraftStreamLoop } from "klaw/plugin-sdk/channel-lifecycle";
+//#region extensions/matrix/src/matrix/draft-stream.ts
+const DEFAULT_THROTTLE_MS = 1e3;
+function resolveDraftPreviewOptions(mode) {
+	if (mode === "quiet") return {
+		msgtype: MsgType.Notice,
+		includeMentions: false
+	};
+	return { msgtype: MsgType.Text };
+}
+function createMatrixDraftStream(params) {
+	const { roomId, client, cfg, threadId, accountId, log } = params;
+	const preview = resolveDraftPreviewOptions(params.mode ?? "partial");
+	const useLive = params.mode !== "quiet";
+	let currentEventId;
+	let lastSentText = "";
+	let stopped = false;
+	let sendFailed = false;
+	let finalizeInPlaceBlocked = false;
+	let liveFinalized = false;
+	let replyToId = params.replyToId;
+	const sendOrEdit = async (text) => {
+		const trimmed = text.trimEnd();
+		if (!trimmed) return false;
+		const preparedText = prepareMatrixSingleText(trimmed, {
+			cfg,
+			accountId
+		});
+		if (!preparedText.fitsInSingleEvent) {
+			finalizeInPlaceBlocked = true;
+			if (!currentEventId) sendFailed = true;
+			stopped = true;
+			log?.(`draft-stream: preview exceeded single-event limit (${preparedText.convertedText.length} > ${preparedText.singleEventLimit})`);
+			return false;
+		}
+		if (sendFailed) return false;
+		if (preparedText.trimmedText === lastSentText) return true;
+		try {
+			if (!currentEventId) {
+				currentEventId = (await sendSingleTextMessageMatrix(roomId, preparedText.trimmedText, {
+					client,
+					cfg,
+					replyToId,
+					threadId,
+					accountId,
+					msgtype: preview.msgtype,
+					includeMentions: preview.includeMentions,
+					live: useLive
+				})).messageId;
+				lastSentText = preparedText.trimmedText;
+				log?.(`draft-stream: created message ${currentEventId}${useLive ? " (MSC4357 live)" : ""}`);
+			} else {
+				await editMessageMatrix(roomId, currentEventId, preparedText.trimmedText, {
+					client,
+					cfg,
+					threadId,
+					accountId,
+					msgtype: preview.msgtype,
+					includeMentions: preview.includeMentions,
+					live: useLive
+				});
+				lastSentText = preparedText.trimmedText;
+			}
+			return true;
+		} catch (err) {
+			log?.(`draft-stream: send/edit failed: ${String(err)}`);
+			if (err instanceof Error && err.message.startsWith("Matrix single-message text exceeds limit")) finalizeInPlaceBlocked = true;
+			if (!currentEventId) sendFailed = true;
+			stopped = true;
+			return false;
+		}
+	};
+	const loop = createDraftStreamLoop({
+		throttleMs: DEFAULT_THROTTLE_MS,
+		isStopped: () => stopped,
+		sendOrEditStreamMessage: sendOrEdit
+	});
+	log?.(`draft-stream: ready (throttleMs=${DEFAULT_THROTTLE_MS})`);
+	const finalizeLive = async () => {
+		if (useLive && !liveFinalized && currentEventId && lastSentText) {
+			liveFinalized = true;
+			try {
+				await editMessageMatrix(roomId, currentEventId, lastSentText, {
+					client,
+					cfg,
+					threadId,
+					accountId,
+					msgtype: preview.msgtype,
+					includeMentions: preview.includeMentions,
+					live: false
+				});
+				log?.(`draft-stream: finalized ${currentEventId} (MSC4357 stream ended)`);
+				return true;
+			} catch (err) {
+				log?.(`draft-stream: finalize edit failed: ${String(err)}`);
+				finalizeInPlaceBlocked = true;
+				return false;
+			}
+		}
+		return true;
+	};
+	const stop = async () => {
+		await loop.flush();
+		stopped = true;
+		return currentEventId;
+	};
+	const discardPending = async () => {
+		stopped = true;
+		loop.stop();
+		await loop.waitForInFlight();
+	};
+	const reset = () => {
+		replyToId = params.preserveReplyId ? params.replyToId : void 0;
+		currentEventId = void 0;
+		lastSentText = "";
+		stopped = false;
+		sendFailed = false;
+		finalizeInPlaceBlocked = false;
+		liveFinalized = false;
+		loop.resetPending();
+		loop.resetThrottleWindow();
+	};
+	return {
+		update: (text) => {
+			if (stopped) return;
+			loop.update(text);
+		},
+		flush: loop.flush,
+		stop,
+		discardPending,
+		finalizeLive,
+		reset,
+		eventId: () => currentEventId,
+		matchesPreparedText: (text) => prepareMatrixSingleText(text, {
+			cfg,
+			accountId
+		}).trimmedText === lastSentText,
+		mustDeliverFinalNormally: () => sendFailed || finalizeInPlaceBlocked
+	};
+}
+//#endregion
+export { createMatrixDraftStream };

package/dist/encryption-guidance-BNEgckrZ.js

@@ -0,0 +1,15 @@
+import { a as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-Y50DNJ2l.js";
+import { t as resolveMatrixConfigFieldPath } from "./config-paths-DVvt6vM3.js";
+import { normalizeOptionalAccountId } from "klaw/plugin-sdk/account-id";
+//#region extensions/matrix/src/matrix/encryption-guidance.ts
+function resolveMatrixEncryptionConfigPath(cfg, accountId) {
+	return resolveMatrixConfigFieldPath(cfg, normalizeOptionalAccountId(accountId) ?? resolveMatrixDefaultOrOnlyAccountId(cfg), "encryption");
+}
+function formatMatrixEncryptionUnavailableError(cfg, accountId) {
+	return `Matrix encryption is not available (enable ${resolveMatrixEncryptionConfigPath(cfg, accountId)}=true)`;
+}
+function formatMatrixEncryptedEventDisabledWarning(cfg, accountId) {
+	return `matrix: encrypted event received without encryption enabled; set ${resolveMatrixEncryptionConfigPath(cfg, accountId)}=true and verify the device to decrypt`;
+}
+//#endregion
+export { formatMatrixEncryptionUnavailableError as n, formatMatrixEncryptedEventDisabledWarning as t };

package/dist/env-auth-UFiTGkDM.js

@@ -0,0 +1,63 @@
+import { t as getMatrixScopedEnvVarNames } from "./env-vars-EQKQv-FE.js";
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "klaw/plugin-sdk/account-id";
+//#region extensions/matrix/src/matrix/client/env-auth.ts
+function cleanEnv(value) {
+	return typeof value === "string" ? value.trim() : "";
+}
+function resolveGlobalMatrixEnvConfig(env) {
+	return {
+		homeserver: cleanEnv(env.MATRIX_HOMESERVER),
+		userId: cleanEnv(env.MATRIX_USER_ID),
+		accessToken: cleanEnv(env.MATRIX_ACCESS_TOKEN) || void 0,
+		password: cleanEnv(env.MATRIX_PASSWORD) || void 0,
+		deviceId: cleanEnv(env.MATRIX_DEVICE_ID) || void 0,
+		deviceName: cleanEnv(env.MATRIX_DEVICE_NAME) || void 0
+	};
+}
+function hasReadyMatrixEnvAuth(config) {
+	const homeserver = cleanEnv(config.homeserver);
+	const userId = cleanEnv(config.userId);
+	const accessToken = cleanEnv(config.accessToken);
+	const password = cleanEnv(config.password);
+	return Boolean(homeserver && (accessToken || userId && password));
+}
+function resolveScopedMatrixEnvConfig(accountId, env = process.env) {
+	const keys = getMatrixScopedEnvVarNames(accountId);
+	return {
+		homeserver: cleanEnv(env[keys.homeserver]),
+		userId: cleanEnv(env[keys.userId]),
+		accessToken: cleanEnv(env[keys.accessToken]) || void 0,
+		password: cleanEnv(env[keys.password]) || void 0,
+		deviceId: cleanEnv(env[keys.deviceId]) || void 0,
+		deviceName: cleanEnv(env[keys.deviceName]) || void 0
+	};
+}
+function resolveMatrixEnvAuthReadiness(accountId, env = process.env) {
+	const normalizedAccountId = normalizeAccountId(accountId);
+	const scoped = resolveScopedMatrixEnvConfig(normalizedAccountId, env);
+	const scopedReady = hasReadyMatrixEnvAuth(scoped);
+	if (normalizedAccountId !== DEFAULT_ACCOUNT_ID) {
+		const keys = getMatrixScopedEnvVarNames(normalizedAccountId);
+		return {
+			ready: scopedReady,
+			homeserver: scoped.homeserver || void 0,
+			userId: scoped.userId || void 0,
+			sourceHint: `${keys.homeserver} (+ auth vars)`,
+			missingMessage: `Set per-account env vars for "${normalizedAccountId}" (for example ${keys.homeserver} + ${keys.accessToken} or ${keys.userId} + ${keys.password}).`
+		};
+	}
+	const defaultScoped = resolveScopedMatrixEnvConfig(DEFAULT_ACCOUNT_ID, env);
+	const global = resolveGlobalMatrixEnvConfig(env);
+	const defaultScopedReady = hasReadyMatrixEnvAuth(defaultScoped);
+	const globalReady = hasReadyMatrixEnvAuth(global);
+	const defaultKeys = getMatrixScopedEnvVarNames(DEFAULT_ACCOUNT_ID);
+	return {
+		ready: defaultScopedReady || globalReady,
+		homeserver: defaultScoped.homeserver || global.homeserver || void 0,
+		userId: defaultScoped.userId || global.userId || void 0,
+		sourceHint: "MATRIX_* or MATRIX_DEFAULT_*",
+		missingMessage: `Set Matrix env vars for the default account (for example MATRIX_HOMESERVER + MATRIX_ACCESS_TOKEN, MATRIX_USER_ID + MATRIX_PASSWORD, or ${defaultKeys.homeserver} + ${defaultKeys.accessToken}).`
+	};
+}
+//#endregion
+export { resolveScopedMatrixEnvConfig as i, resolveGlobalMatrixEnvConfig as n, resolveMatrixEnvAuthReadiness as r, hasReadyMatrixEnvAuth as t };

package/dist/env-vars-EQKQv-FE.js

@@ -0,0 +1,63 @@
+import { normalizeAccountId, normalizeOptionalAccountId } from "klaw/plugin-sdk/account-id";
+//#region extensions/matrix/src/env-vars.ts
+const MATRIX_SCOPED_ENV_SUFFIXES = [
+	"HOMESERVER",
+	"USER_ID",
+	"ACCESS_TOKEN",
+	"PASSWORD",
+	"DEVICE_ID",
+	"DEVICE_NAME"
+];
+const MATRIX_GLOBAL_ENV_KEYS = MATRIX_SCOPED_ENV_SUFFIXES.map((suffix) => `MATRIX_${suffix}`);
+const MATRIX_SCOPED_ENV_RE = new RegExp(`^MATRIX_(.+)_(${MATRIX_SCOPED_ENV_SUFFIXES.join("|")})$`);
+function resolveMatrixEnvAccountToken(accountId) {
+	return Array.from(normalizeAccountId(accountId)).map((char) => /[a-z0-9]/.test(char) ? char.toUpperCase() : `_X${char.codePointAt(0)?.toString(16).toUpperCase() ?? "00"}_`).join("");
+}
+function getMatrixScopedEnvVarNames(accountId) {
+	const token = resolveMatrixEnvAccountToken(accountId);
+	return {
+		homeserver: `MATRIX_${token}_HOMESERVER`,
+		userId: `MATRIX_${token}_USER_ID`,
+		accessToken: `MATRIX_${token}_ACCESS_TOKEN`,
+		password: `MATRIX_${token}_PASSWORD`,
+		deviceId: `MATRIX_${token}_DEVICE_ID`,
+		deviceName: `MATRIX_${token}_DEVICE_NAME`
+	};
+}
+function decodeMatrixEnvAccountToken(token) {
+	let decoded = "";
+	for (let index = 0; index < token.length;) {
+		const hexEscape = /^_X([0-9A-F]+)_/.exec(token.slice(index));
+		if (hexEscape) {
+			const hex = hexEscape[1];
+			const codePoint = hex ? Number.parseInt(hex, 16) : NaN;
+			if (!Number.isFinite(codePoint)) return;
+			decoded += String.fromCodePoint(codePoint);
+			index += hexEscape[0].length;
+			continue;
+		}
+		const char = token[index];
+		if (!char || !/[A-Z0-9]/.test(char)) return;
+		decoded += char.toLowerCase();
+		index += 1;
+	}
+	const normalized = normalizeOptionalAccountId(decoded);
+	if (!normalized) return;
+	return resolveMatrixEnvAccountToken(normalized) === token ? normalized : void 0;
+}
+function listMatrixEnvAccountIds(env = process.env) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const key of MATRIX_GLOBAL_ENV_KEYS) if (typeof env[key] === "string" && env[key]?.trim()) {
+		ids.add(normalizeAccountId("default"));
+		break;
+	}
+	for (const key of Object.keys(env)) {
+		const match = MATRIX_SCOPED_ENV_RE.exec(key);
+		if (!match) continue;
+		const accountId = decodeMatrixEnvAccountToken(match[1]);
+		if (accountId) ids.add(accountId);
+	}
+	return Array.from(ids).toSorted((a, b) => a.localeCompare(b));
+}
+//#endregion
+export { listMatrixEnvAccountIds as n, resolveMatrixEnvAccountToken as r, getMatrixScopedEnvVarNames as t };

package/dist/errors-BETj3zr9.js

@@ -0,0 +1,17 @@
+import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
+import { formatErrorMessage } from "klaw/plugin-sdk/error-runtime";
+//#region extensions/matrix/src/matrix/errors.ts
+function formatMatrixErrorMessage(err) {
+	return formatErrorMessage(err);
+}
+function formatMatrixErrorReason(err) {
+	return normalizeLowercaseStringOrEmpty(formatMatrixErrorMessage(err));
+}
+function isMatrixNotFoundError(err) {
+	const errObj = err;
+	if (errObj?.statusCode === 404 || errObj?.body?.errcode === "M_NOT_FOUND") return true;
+	const message = formatMatrixErrorReason(err);
+	return message.includes("m_not_found") || message.includes("[404]") || message.includes("not found");
+}
+//#endregion
+export { formatMatrixErrorReason as n, isMatrixNotFoundError as r, formatMatrixErrorMessage as t };

package/dist/exec-approval-resolver-BxPorU_t.js

@@ -0,0 +1,15 @@
+import { isApprovalNotFoundError } from "klaw/plugin-sdk/error-runtime";
+import { resolveApprovalOverGateway } from "klaw/plugin-sdk/approval-gateway-runtime";
+//#region extensions/matrix/src/exec-approval-resolver.ts
+async function resolveMatrixApproval(params) {
+	await resolveApprovalOverGateway({
+		cfg: params.cfg,
+		approvalId: params.approvalId,
+		decision: params.decision,
+		senderId: params.senderId,
+		gatewayUrl: params.gatewayUrl,
+		clientDisplayName: `Matrix approval (${params.senderId?.trim() || "unknown"})`
+	});
+}
+//#endregion
+export { isApprovalNotFoundError, resolveMatrixApproval };

package/dist/helper-api.js

@@ -0,0 +1,4 @@
+import { a as resolveMatrixDefaultOrOnlyAccountId, i as resolveMatrixChannelConfig, n as requiresExplicitMatrixDefaultAccount, r as resolveConfiguredMatrixAccountIds, t as findMatrixAccountEntry } from "./account-selection-Y50DNJ2l.js";
+import { n as listMatrixEnvAccountIds, r as resolveMatrixEnvAccountToken, t as getMatrixScopedEnvVarNames } from "./env-vars-EQKQv-FE.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-BTAketfg.js";
+export { findMatrixAccountEntry, getMatrixScopedEnvVarNames, hashMatrixAccessToken, listMatrixEnvAccountIds, requiresExplicitMatrixDefaultAccount, resolveConfiguredMatrixAccountIds, resolveMatrixAccountStorageRoot, resolveMatrixChannelConfig, resolveMatrixCredentialsDir, resolveMatrixCredentialsFilename, resolveMatrixCredentialsPath, resolveMatrixDefaultOrOnlyAccountId, resolveMatrixEnvAccountToken, resolveMatrixHomeserverKey, resolveMatrixLegacyFlatStoragePaths, resolveMatrixLegacyFlatStoreRoot, sanitizeMatrixPathSegment };