@kodelyth/matrix 2026.5.39 → 2026.6.1

package/dist/http-client-DoQgbQsU.js

@@ -0,0 +1,331 @@
+import { t as buildTimeoutAbortSignal } from "./timeout-abort-signal-DpSHDHhR.js";
+import { readResponseWithLimit } from "klaw/plugin-sdk/response-limit-runtime";
+import { fetchWithRuntimeDispatcherOrMockedGlobal } from "klaw/plugin-sdk/runtime-fetch";
+import { closeDispatcher, createPinnedDispatcher, resolvePinnedHostnameWithPolicy } from "klaw/plugin-sdk/ssrf-dispatcher";
+//#region extensions/matrix/src/matrix/sdk/event-helpers.ts
+function matrixEventToRaw(event, opts = {}) {
+	const unsigned = event.getUnsigned?.() ?? {};
+	const eventWithOriginalContent = event;
+	const content = opts.contentMode === "original" ? eventWithOriginalContent.getOriginalContent?.() ?? event.getContent?.() ?? {} : event.getContent?.() ?? eventWithOriginalContent.getOriginalContent?.() ?? {};
+	const raw = {
+		event_id: event.getId() ?? "",
+		sender: event.getSender() ?? "",
+		type: event.getType() ?? "",
+		origin_server_ts: event.getTs() ?? 0,
+		content: content || {},
+		unsigned
+	};
+	const stateKey = resolveMatrixStateKey(event);
+	if (typeof stateKey === "string") raw.state_key = stateKey;
+	return raw;
+}
+function parseMxc(url) {
+	const match = /^mxc:\/\/([^/]+)\/(.+)$/.exec(url.trim());
+	if (!match) return null;
+	return {
+		server: match[1],
+		mediaId: match[2]
+	};
+}
+function buildHttpError(statusCode, bodyText) {
+	let message = `Matrix HTTP ${statusCode}`;
+	if (bodyText.trim()) try {
+		const parsed = JSON.parse(bodyText);
+		if (typeof parsed.error === "string" && parsed.error.trim()) message = parsed.error.trim();
+		else message = bodyText.slice(0, 500);
+	} catch {
+		message = bodyText.slice(0, 500);
+	}
+	return Object.assign(new Error(message), { statusCode });
+}
+function resolveMatrixStateKey(event) {
+	const direct = event.getStateKey?.();
+	if (typeof direct === "string") return direct;
+	const wireContent = event.getWireContent?.();
+	if (wireContent && typeof wireContent.state_key === "string") return wireContent.state_key;
+	const rawEvent = event.event;
+	if (rawEvent && typeof rawEvent.state_key === "string") return rawEvent.state_key;
+}
+//#endregion
+//#region extensions/matrix/src/matrix/media-errors.ts
+const MATRIX_MEDIA_SIZE_LIMIT_ERROR_MESSAGE = "Matrix media exceeds configured size limit";
+var MatrixMediaSizeLimitError = class extends Error {
+	constructor(message = MATRIX_MEDIA_SIZE_LIMIT_ERROR_MESSAGE, options) {
+		super(message, options);
+		this.code = "MATRIX_MEDIA_SIZE_LIMIT";
+		this.name = "MatrixMediaSizeLimitError";
+	}
+};
+function isMatrixMediaSizeLimitError(err) {
+	if (err instanceof MatrixMediaSizeLimitError) return true;
+	if (!(err instanceof Error) || err.cause === void 0) return false;
+	return isMatrixMediaSizeLimitError(err.cause);
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/read-response-with-limit.ts
+async function readResponseWithLimit$1(res, maxBytes, opts) {
+	return await readResponseWithLimit(res, maxBytes, {
+		...opts,
+		onIdleTimeout: opts?.onIdleTimeout ?? (({ chunkTimeoutMs }) => /* @__PURE__ */ new Error(`Matrix media download stalled: no data received for ${chunkTimeoutMs}ms`))
+	});
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/transport.ts
+function normalizeEndpoint(endpoint) {
+	if (!endpoint) return "/";
+	return endpoint.startsWith("/") ? endpoint : `/${endpoint}`;
+}
+function applyQuery(url, qs) {
+	if (!qs) return;
+	for (const [key, rawValue] of Object.entries(qs)) {
+		if (rawValue === void 0 || rawValue === null) continue;
+		if (Array.isArray(rawValue)) {
+			for (const item of rawValue) {
+				if (item === void 0 || item === null) continue;
+				url.searchParams.append(key, String(item));
+			}
+			continue;
+		}
+		url.searchParams.set(key, String(rawValue));
+	}
+}
+function isRedirectStatus(statusCode) {
+	return statusCode >= 300 && statusCode < 400;
+}
+function toFetchUrl(resource) {
+	if (resource instanceof URL) return resource.toString();
+	if (typeof resource === "string") return resource;
+	return resource.url;
+}
+const MATRIX_STATE_AFTER_SYNC_PARAM = "org.matrix.msc4222.use_state_after";
+function withoutMatrixStateAfterSyncParam(rawUrl) {
+	let url;
+	try {
+		url = new URL(rawUrl);
+	} catch {
+		return rawUrl;
+	}
+	if (!url.pathname.endsWith("/sync") || !url.searchParams.has(MATRIX_STATE_AFTER_SYNC_PARAM)) return rawUrl;
+	url.searchParams.delete(MATRIX_STATE_AFTER_SYNC_PARAM);
+	return url.toString();
+}
+function buildBufferedResponse(params) {
+	const response = new Response(params.body, {
+		status: params.source.status,
+		statusText: params.source.statusText,
+		headers: new Headers(params.source.headers)
+	});
+	try {
+		Object.defineProperty(response, "url", {
+			value: params.source.url || params.url,
+			configurable: true
+		});
+	} catch {}
+	return response;
+}
+async function fetchWithMatrixDispatcher(params) {
+	return await fetchWithRuntimeDispatcherOrMockedGlobal(params.url, params.init);
+}
+async function fetchWithMatrixGuardedRedirects(params) {
+	let currentUrl = new URL(params.url);
+	let method = (params.init?.method ?? "GET").toUpperCase();
+	let body = params.init?.body;
+	let headers = new Headers(params.init?.headers ?? {});
+	const maxRedirects = 5;
+	const visited = /* @__PURE__ */ new Set();
+	const { signal, cleanup } = buildTimeoutAbortSignal({
+		timeoutMs: params.timeoutMs,
+		signal: params.signal,
+		operation: "matrix.guarded-redirect-fetch",
+		url: params.url
+	});
+	for (let redirectCount = 0; redirectCount <= maxRedirects; redirectCount += 1) {
+		let dispatcher;
+		try {
+			dispatcher = createPinnedDispatcher(await resolvePinnedHostnameWithPolicy(currentUrl.hostname, { policy: params.ssrfPolicy }), params.dispatcherPolicy, params.ssrfPolicy);
+			const response = await fetchWithMatrixDispatcher({
+				url: currentUrl.toString(),
+				init: {
+					...params.init,
+					method,
+					body,
+					headers,
+					redirect: "manual",
+					signal,
+					dispatcher
+				}
+			});
+			if (!isRedirectStatus(response.status)) return {
+				response,
+				release: async () => {
+					cleanup();
+					await closeDispatcher(dispatcher);
+				},
+				finalUrl: currentUrl.toString()
+			};
+			const location = response.headers.get("location");
+			if (!location) {
+				cleanup();
+				await closeDispatcher(dispatcher);
+				throw new Error(`Matrix redirect missing location header (${currentUrl.toString()})`);
+			}
+			const nextUrl = new URL(location, currentUrl);
+			if (nextUrl.protocol !== currentUrl.protocol) {
+				cleanup();
+				await closeDispatcher(dispatcher);
+				throw new Error(`Blocked cross-protocol redirect (${currentUrl.protocol} -> ${nextUrl.protocol})`);
+			}
+			const nextUrlString = nextUrl.toString();
+			if (visited.has(nextUrlString)) {
+				cleanup();
+				await closeDispatcher(dispatcher);
+				throw new Error("Redirect loop detected");
+			}
+			visited.add(nextUrlString);
+			if (nextUrl.origin !== currentUrl.origin) {
+				headers = new Headers(headers);
+				headers.delete("authorization");
+			}
+			if (response.status === 303 || (response.status === 301 || response.status === 302) && method !== "GET" && method !== "HEAD") {
+				method = "GET";
+				body = void 0;
+				headers = new Headers(headers);
+				headers.delete("content-type");
+				headers.delete("content-length");
+			}
+			response.body?.cancel();
+			await closeDispatcher(dispatcher);
+			currentUrl = nextUrl;
+		} catch (error) {
+			cleanup();
+			await closeDispatcher(dispatcher);
+			throw error;
+		}
+	}
+	cleanup();
+	throw new Error(`Too many redirects while requesting ${params.url}`);
+}
+function createMatrixGuardedFetch(params) {
+	return (async (resource, init) => {
+		const url = withoutMatrixStateAfterSyncParam(toFetchUrl(resource));
+		const { signal, ...requestInit } = init ?? {};
+		const { response, release } = await fetchWithMatrixGuardedRedirects({
+			url,
+			init: requestInit,
+			signal: signal ?? void 0,
+			ssrfPolicy: params.ssrfPolicy,
+			dispatcherPolicy: params.dispatcherPolicy
+		});
+		try {
+			return buildBufferedResponse({
+				source: response,
+				body: await response.arrayBuffer(),
+				url
+			});
+		} finally {
+			await release();
+		}
+	});
+}
+async function performMatrixRequest(params) {
+	const isAbsoluteEndpoint = params.endpoint.startsWith("http://") || params.endpoint.startsWith("https://");
+	if (isAbsoluteEndpoint && params.allowAbsoluteEndpoint !== true) throw new Error(`Absolute Matrix endpoint is blocked by default: ${params.endpoint}. Set allowAbsoluteEndpoint=true to opt in.`);
+	const baseUrl = isAbsoluteEndpoint ? new URL(params.endpoint) : new URL(normalizeEndpoint(params.endpoint), params.homeserver);
+	applyQuery(baseUrl, params.qs);
+	const headers = new Headers();
+	headers.set("Accept", params.raw ? "*/*" : "application/json");
+	if (params.accessToken) headers.set("Authorization", `Bearer ${params.accessToken}`);
+	let body;
+	if (params.body !== void 0) if (params.body instanceof Uint8Array || params.body instanceof ArrayBuffer || typeof params.body === "string") body = params.body;
+	else {
+		headers.set("Content-Type", "application/json");
+		body = JSON.stringify(params.body);
+	}
+	const { response, release } = await fetchWithMatrixGuardedRedirects({
+		url: baseUrl.toString(),
+		init: {
+			method: params.method,
+			headers,
+			body
+		},
+		timeoutMs: params.timeoutMs,
+		ssrfPolicy: params.ssrfPolicy,
+		dispatcherPolicy: params.dispatcherPolicy
+	});
+	try {
+		if (params.raw) {
+			const contentLength = response.headers.get("content-length");
+			if (params.maxBytes && contentLength) {
+				const length = Number(contentLength);
+				if (Number.isFinite(length) && length > params.maxBytes) throw new MatrixMediaSizeLimitError(`Matrix media exceeds configured size limit (${length} bytes > ${params.maxBytes} bytes)`);
+			}
+			const bytes = params.maxBytes ? await readResponseWithLimit$1(response, params.maxBytes, {
+				onOverflow: ({ maxBytes, size }) => new MatrixMediaSizeLimitError(`Matrix media exceeds configured size limit (${size} bytes > ${maxBytes} bytes)`),
+				chunkTimeoutMs: params.readIdleTimeoutMs
+			}) : Buffer.from(await response.arrayBuffer());
+			return {
+				response,
+				text: bytes.toString("utf8"),
+				buffer: bytes
+			};
+		}
+		const text = await response.text();
+		return {
+			response,
+			text,
+			buffer: Buffer.from(text, "utf8")
+		};
+	} finally {
+		await release();
+	}
+}
+//#endregion
+//#region extensions/matrix/src/matrix/sdk/http-client.ts
+var MatrixAuthedHttpClient = class {
+	constructor(params) {
+		this.homeserver = params.homeserver;
+		this.accessToken = params.accessToken;
+		this.ssrfPolicy = params.ssrfPolicy;
+		this.dispatcherPolicy = params.dispatcherPolicy;
+	}
+	async requestJson(params) {
+		const { response, text } = await performMatrixRequest({
+			homeserver: this.homeserver,
+			accessToken: this.accessToken,
+			method: params.method,
+			endpoint: params.endpoint,
+			qs: params.qs,
+			body: params.body,
+			timeoutMs: params.timeoutMs,
+			ssrfPolicy: this.ssrfPolicy,
+			dispatcherPolicy: this.dispatcherPolicy,
+			allowAbsoluteEndpoint: params.allowAbsoluteEndpoint
+		});
+		if (!response.ok) throw buildHttpError(response.status, text);
+		if ((response.headers.get("content-type") ?? "").includes("application/json")) {
+			if (!text.trim()) return {};
+			return JSON.parse(text);
+		}
+		return text;
+	}
+	async requestRaw(params) {
+		const { response, buffer } = await performMatrixRequest({
+			homeserver: this.homeserver,
+			accessToken: this.accessToken,
+			method: params.method,
+			endpoint: params.endpoint,
+			qs: params.qs,
+			timeoutMs: params.timeoutMs,
+			raw: true,
+			maxBytes: params.maxBytes,
+			readIdleTimeoutMs: params.readIdleTimeoutMs,
+			ssrfPolicy: this.ssrfPolicy,
+			dispatcherPolicy: this.dispatcherPolicy,
+			allowAbsoluteEndpoint: params.allowAbsoluteEndpoint
+		});
+		if (!response.ok) throw buildHttpError(response.status, buffer.toString("utf8"));
+		return buffer;
+	}
+};
+//#endregion
+export { matrixEventToRaw as a, isMatrixMediaSizeLimitError as i, createMatrixGuardedFetch as n, parseMxc as o, MatrixMediaSizeLimitError as r, MatrixAuthedHttpClient as t };

package/dist/index.js

@@ -0,0 +1,46 @@
+import { n as registerMatrixCliMetadata } from "./cli-metadata-Dkwua7CB.js";
+import { t as registerMatrixSubagentHooks } from "./subagent-hooks-api-Dr_xnMRG.js";
+import { defineBundledChannelEntry } from "klaw/plugin-sdk/channel-entry-contract";
+//#region extensions/matrix/index.ts
+let matrixHandlersRuntimePromise = null;
+function loadMatrixHandlersRuntimeModule() {
+	matrixHandlersRuntimePromise ??= import("./plugin-entry.handlers.runtime.js");
+	return matrixHandlersRuntimePromise;
+}
+function registerMatrixFullRuntime(api) {
+	api.registerGatewayMethod("matrix.verify.recoveryKey", async (ctx) => {
+		const { handleVerifyRecoveryKey } = await loadMatrixHandlersRuntimeModule();
+		await handleVerifyRecoveryKey(ctx);
+	});
+	api.registerGatewayMethod("matrix.verify.bootstrap", async (ctx) => {
+		const { handleVerificationBootstrap } = await loadMatrixHandlersRuntimeModule();
+		await handleVerificationBootstrap(ctx);
+	});
+	api.registerGatewayMethod("matrix.verify.status", async (ctx) => {
+		const { handleVerificationStatus } = await loadMatrixHandlersRuntimeModule();
+		await handleVerificationStatus(ctx);
+	});
+	registerMatrixSubagentHooks(api);
+}
+var matrix_default = defineBundledChannelEntry({
+	id: "matrix",
+	name: "Matrix",
+	description: "Matrix channel plugin (matrix-js-sdk)",
+	importMetaUrl: import.meta.url,
+	plugin: {
+		specifier: "./channel-plugin-api.js",
+		exportName: "matrixPlugin"
+	},
+	secrets: {
+		specifier: "./secret-contract-api.js",
+		exportName: "channelSecrets"
+	},
+	runtime: {
+		specifier: "./runtime-setter-api.js",
+		exportName: "setMatrixRuntime"
+	},
+	registerCliMetadata: registerMatrixCliMetadata,
+	registerFull: registerMatrixFullRuntime
+});
+//#endregion
+export { matrix_default as default, registerMatrixFullRuntime };

package/dist/legacy-crypto-inspector-zK0hDCbt.js

@@ -0,0 +1,41 @@
+import { t as ensureMatrixCryptoRuntime } from "./deps-DVpDS81G.js";
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+//#region extensions/matrix/src/matrix/legacy-crypto-inspector.ts
+function resolveLegacyMachineStorePath(params) {
+	const hashedDir = path.join(params.cryptoRootDir, crypto.createHash("sha256").update(params.deviceId).digest("hex"));
+	if (fs.existsSync(path.join(hashedDir, "matrix-sdk-crypto.sqlite3"))) return hashedDir;
+	if (fs.existsSync(path.join(params.cryptoRootDir, "matrix-sdk-crypto.sqlite3"))) return params.cryptoRootDir;
+	const match = fs.readdirSync(params.cryptoRootDir, { withFileTypes: true }).find((entry) => entry.isDirectory() && fs.existsSync(path.join(params.cryptoRootDir, entry.name, "matrix-sdk-crypto.sqlite3")));
+	return match ? path.join(params.cryptoRootDir, match.name) : null;
+}
+async function inspectLegacyMatrixCryptoStore(params) {
+	const machineStorePath = resolveLegacyMachineStorePath(params);
+	if (!machineStorePath) throw new Error(`Matrix legacy crypto store not found for device ${params.deviceId}`);
+	const requireFn = createRequire(import.meta.url);
+	await ensureMatrixCryptoRuntime({
+		requireFn,
+		resolveFn: requireFn.resolve.bind(requireFn),
+		log: params.log
+	});
+	const { DeviceId, OlmMachine, StoreType, UserId } = requireFn("@matrix-org/matrix-sdk-crypto-nodejs");
+	const machine = await OlmMachine.initialize(new UserId(params.userId), new DeviceId(params.deviceId), machineStorePath, "", StoreType.Sqlite);
+	try {
+		const [backupKeys, roomKeyCounts] = await Promise.all([machine.getBackupKeys(), machine.roomKeyCounts()]);
+		return {
+			deviceId: params.deviceId,
+			roomKeyCounts: roomKeyCounts ? {
+				total: typeof roomKeyCounts.total === "number" ? roomKeyCounts.total : 0,
+				backedUp: typeof roomKeyCounts.backedUp === "number" ? roomKeyCounts.backedUp : 0
+			} : null,
+			backupVersion: typeof backupKeys?.backupVersion === "string" && backupKeys.backupVersion.trim() ? backupKeys.backupVersion : null,
+			decryptionKeyBase64: typeof backupKeys?.decryptionKeyBase64 === "string" && backupKeys.decryptionKeyBase64.trim() ? backupKeys.decryptionKeyBase64 : null
+		};
+	} finally {
+		machine.close();
+	}
+}
+//#endregion
+export { inspectLegacyMatrixCryptoStore };

package/dist/legacy-crypto-restore-DSFIXuDo.js

@@ -0,0 +1,85 @@
+import { t as getMatrixRuntime } from "./runtime-B-Fyrmxo.js";
+import { a as resolveMatrixStoragePaths } from "./storage-nyO0DOFE.js";
+import os from "node:os";
+import path from "node:path";
+import { readJsonFileWithFallback, writeJsonFileAtomically } from "klaw/plugin-sdk/json-store";
+import fs from "node:fs/promises";
+//#region extensions/matrix/src/matrix/monitor/legacy-crypto-restore.ts
+function isMigrationState(value) {
+	return Boolean(value) && typeof value === "object" && value.version === 1;
+}
+async function resolvePendingMigrationStatePath(params) {
+	const { rootDir } = resolveMatrixStoragePaths({
+		homeserver: params.auth.homeserver,
+		userId: params.auth.userId,
+		accessToken: params.auth.accessToken,
+		accountId: params.auth.accountId,
+		deviceId: params.auth.deviceId,
+		stateDir: params.stateDir
+	});
+	const directStatePath = path.join(rootDir, "legacy-crypto-migration.json");
+	const { value: directValue } = await readJsonFileWithFallback(directStatePath, null);
+	if (isMigrationState(directValue) && directValue.restoreStatus === "pending") return {
+		statePath: directStatePath,
+		value: directValue
+	};
+	const accountStorageDir = path.dirname(rootDir);
+	let siblingEntries = [];
+	try {
+		siblingEntries = (await fs.readdir(accountStorageDir, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((entry) => path.join(accountStorageDir, entry) !== rootDir).toSorted((left, right) => left.localeCompare(right));
+	} catch {
+		return {
+			statePath: directStatePath,
+			value: directValue
+		};
+	}
+	for (const sibling of siblingEntries) {
+		const siblingStatePath = path.join(accountStorageDir, sibling, "legacy-crypto-migration.json");
+		const { value } = await readJsonFileWithFallback(siblingStatePath, null);
+		if (isMigrationState(value) && value.restoreStatus === "pending") return {
+			statePath: siblingStatePath,
+			value
+		};
+	}
+	return {
+		statePath: directStatePath,
+		value: directValue
+	};
+}
+async function maybeRestoreLegacyMatrixBackup(params) {
+	const env = params.env ?? process.env;
+	const { statePath, value } = await resolvePendingMigrationStatePath({
+		stateDir: params.stateDir ?? getMatrixRuntime().state.resolveStateDir(env, os.homedir),
+		auth: params.auth
+	});
+	if (!isMigrationState(value) || value.restoreStatus !== "pending") return { kind: "skipped" };
+	const restore = await params.client.restoreRoomKeyBackup();
+	const localOnlyKeys = value.roomKeyCounts && value.roomKeyCounts.total > value.roomKeyCounts.backedUp ? value.roomKeyCounts.total - value.roomKeyCounts.backedUp : 0;
+	if (restore.success) {
+		await writeJsonFileAtomically(statePath, {
+			...value,
+			restoreStatus: "completed",
+			restoredAt: restore.restoredAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+			importedCount: restore.imported,
+			totalCount: restore.total,
+			lastError: null
+		});
+		return {
+			kind: "restored",
+			imported: restore.imported,
+			total: restore.total,
+			localOnlyKeys
+		};
+	}
+	await writeJsonFileAtomically(statePath, {
+		...value,
+		lastError: restore.error ?? "unknown"
+	});
+	return {
+		kind: "failed",
+		error: restore.error ?? "unknown",
+		localOnlyKeys
+	};
+}
+//#endregion
+export { maybeRestoreLegacyMatrixBackup };

package/dist/logging-Df7aPD1z.js

@@ -0,0 +1,99 @@
+import { t as __exportAll } from "./rolldown-runtime-DUslC3ob.js";
+import { a as ConsoleLogger, c as setMatrixConsoleLogging, o as LogService } from "./startup-abort-B2J3MU_h.js";
+import { logger } from "matrix-js-sdk/lib/logger.js";
+//#region extensions/matrix/src/matrix/client/logging.ts
+var logging_exports = /* @__PURE__ */ __exportAll({
+	createMatrixJsSdkClientLogger: () => createMatrixJsSdkClientLogger,
+	ensureMatrixSdkLoggingConfigured: () => ensureMatrixSdkLoggingConfigured,
+	setMatrixSdkConsoleLogging: () => setMatrixSdkConsoleLogging,
+	setMatrixSdkLogMode: () => setMatrixSdkLogMode
+});
+let matrixSdkLoggingConfigured = false;
+let matrixSdkLogMode = "default";
+const matrixSdkBaseLogger = new ConsoleLogger();
+let matrixJsSdkRootLoggerSnapshot = null;
+function shouldSuppressMatrixHttpNotFound(module, messageOrObject) {
+	if (!module.includes("MatrixHttpClient")) return false;
+	return messageOrObject.some((entry) => {
+		if (!entry || typeof entry !== "object") return false;
+		return entry.errcode === "M_NOT_FOUND";
+	});
+}
+function ensureMatrixSdkLoggingConfigured() {
+	if (!matrixSdkLoggingConfigured) matrixSdkLoggingConfigured = true;
+	applyMatrixSdkLogger();
+}
+function setMatrixSdkLogMode(mode) {
+	matrixSdkLogMode = mode;
+	if (!matrixSdkLoggingConfigured) return;
+	applyMatrixSdkLogger();
+}
+function setMatrixSdkConsoleLogging(enabled) {
+	setMatrixConsoleLogging(enabled);
+}
+function createMatrixJsSdkClientLogger(prefix = "matrix") {
+	return createMatrixJsSdkLoggerInstance(prefix);
+}
+function applyMatrixSdkLogger() {
+	if (matrixSdkLogMode === "quiet") {
+		setMatrixJsSdkRootLoggerLevel("silent");
+		LogService.setLogger({
+			trace: () => {},
+			debug: () => {},
+			info: () => {},
+			warn: () => {},
+			error: () => {}
+		});
+		return;
+	}
+	setMatrixJsSdkRootLoggerLevel("debug");
+	LogService.setLogger({
+		trace: (module, ...messageOrObject) => matrixSdkBaseLogger.trace(module, ...messageOrObject),
+		debug: (module, ...messageOrObject) => matrixSdkBaseLogger.debug(module, ...messageOrObject),
+		info: (module, ...messageOrObject) => matrixSdkBaseLogger.info(module, ...messageOrObject),
+		warn: (module, ...messageOrObject) => matrixSdkBaseLogger.warn(module, ...messageOrObject),
+		error: (module, ...messageOrObject) => {
+			if (shouldSuppressMatrixHttpNotFound(module, messageOrObject)) return;
+			matrixSdkBaseLogger.error(module, ...messageOrObject);
+		}
+	});
+}
+function setMatrixJsSdkRootLoggerLevel(level) {
+	const logger$1 = logger;
+	matrixJsSdkRootLoggerSnapshot ??= {
+		level: logger$1.getLevel?.(),
+		methodFactory: logger$1.methodFactory
+	};
+	if (level === "silent") {
+		logger$1.methodFactory = () => () => void 0;
+		logger$1.setLevel?.("silent", false);
+		logger$1.rebuild?.();
+		return;
+	}
+	logger$1.methodFactory = matrixJsSdkRootLoggerSnapshot.methodFactory;
+	const previousLevel = matrixJsSdkRootLoggerSnapshot.level;
+	if (typeof previousLevel === "string" || typeof previousLevel === "number") logger$1.setLevel?.(previousLevel, false);
+	logger$1.rebuild?.();
+}
+function createMatrixJsSdkLoggerInstance(prefix) {
+	const log = (method, ...messageOrObject) => {
+		if (matrixSdkLogMode === "quiet") return;
+		matrixSdkBaseLogger[method](prefix, ...messageOrObject);
+	};
+	return {
+		trace: (...messageOrObject) => log("trace", ...messageOrObject),
+		debug: (...messageOrObject) => log("debug", ...messageOrObject),
+		info: (...messageOrObject) => log("info", ...messageOrObject),
+		warn: (...messageOrObject) => log("warn", ...messageOrObject),
+		error: (...messageOrObject) => {
+			if (shouldSuppressMatrixHttpNotFound(prefix, messageOrObject)) return;
+			log("error", ...messageOrObject);
+		},
+		getChild: (namespace) => {
+			const nextNamespace = namespace.trim();
+			return createMatrixJsSdkLoggerInstance(nextNamespace ? `${prefix}.${nextNamespace}` : prefix);
+		}
+	};
+}
+//#endregion
+export { setMatrixSdkLogMode as i, logging_exports as n, setMatrixSdkConsoleLogging as r, createMatrixJsSdkClientLogger as t };