@openclaw/matrix 2026.10.2 → 2026.10.5-beta.2

package/dist/.setup/setup-core-6DppLENo.mjs

@@ -1,377 +0,0 @@
-import { u as resolveMatrixEnvAuthReadiness } from "./account-selection-BDeeqwwR.mjs";
-import { a as resolveMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
-import { r as resolveDefaultMatrixAccountId } from "./accounts-C_r0UlEm.mjs";
-import { t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.mjs";
-import { n as updateMatrixAccountConfig } from "./config-update-CZndPxNd.mjs";
-import { t as isSupportedMatrixAvatarSource } from "./profile-DS0xdJAi.mjs";
-import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
-import { defineChannelSetupContract } from "openclaw/plugin-sdk/channel-setup";
-import { DEFAULT_ACCOUNT_ID, addWildcardAllowFrom, applyAccountNameToChannelSection, normalizeAccountId, normalizeAllowFromEntries, normalizeSecretInputString, patchTopLevelChannelConfigSection, prepareScopedSetupConfig, setSetupChannelEnabled } from "openclaw/plugin-sdk/setup";
-import { DEFAULT_ACCOUNT_ID as DEFAULT_ACCOUNT_ID$1, normalizeAccountId as normalizeAccountId$1 } from "openclaw/plugin-sdk/routing";
-import { createChannelDmPolicy } from "openclaw/plugin-sdk/channel-dm-policy";
-//#region extensions/matrix/src/setup-contract.ts
-const matrixSingleAccountKeysToMove = [
-	"homeserver",
-	"userId",
-	"accessToken",
-	"password",
-	"deviceId",
-	"deviceName",
-	"avatarUrl",
-	"initialSyncLimit",
-	"encryption",
-	"allowlistOnly",
-	"dangerouslyAllowNameMatching",
-	"allowBots",
-	"streaming",
-	"replyToMode",
-	"threadReplies",
-	"textChunkLimit",
-	"responsePrefix",
-	"ackReaction",
-	"ackReactionScope",
-	"reactionNotifications",
-	"threadBindings",
-	"startupVerification",
-	"startupVerificationCooldownHours",
-	"mediaMaxMb",
-	"autoJoin",
-	"autoJoinAllowlist",
-	"dm",
-	"groups",
-	"rooms",
-	"actions"
-];
-const matrixNamedAccountPromotionKeys = [
-	"name",
-	"homeserver",
-	"userId",
-	"accessToken",
-	"password",
-	"deviceId",
-	"deviceName",
-	"avatarUrl",
-	"initialSyncLimit",
-	"encryption"
-];
-const singleAccountKeysToMove = [...matrixSingleAccountKeysToMove];
-const namedAccountPromotionKeys = [...matrixNamedAccountPromotionKeys];
-function resolveSingleAccountPromotionTarget(params) {
-	const accounts = typeof params.channel.accounts === "object" && params.channel.accounts ? params.channel.accounts : {};
-	const normalizedDefaultAccount = typeof params.channel.defaultAccount === "string" && params.channel.defaultAccount.trim() ? normalizeAccountId$1(params.channel.defaultAccount) : void 0;
-	const matchedAccountId = normalizedDefaultAccount ? Object.entries(accounts).find(([accountId, value]) => accountId && value && typeof value === "object" && normalizeAccountId$1(accountId) === normalizedDefaultAccount)?.[0] : void 0;
-	if (matchedAccountId) return matchedAccountId;
-	if (normalizedDefaultAccount) return DEFAULT_ACCOUNT_ID$1;
-	const namedAccounts = Object.entries(accounts).filter(([accountId, value]) => accountId && typeof value === "object" && value);
-	if (namedAccounts.length === 1) {
-		const onlyAccount = namedAccounts[0];
-		if (onlyAccount) return onlyAccount[0];
-	}
-	return DEFAULT_ACCOUNT_ID$1;
-}
-//#endregion
-//#region extensions/matrix/src/setup-config.ts
-const channel$1 = "matrix";
-const COMMON_SINGLE_ACCOUNT_KEYS_TO_MOVE = /* @__PURE__ */ new Set([
-	"name",
-	"enabled",
-	"httpPort",
-	"webhookPath",
-	"webhookUrl",
-	"webhookSecret",
-	"service",
-	"region",
-	"homeserver",
-	"userId",
-	"accessToken",
-	"password",
-	"deviceName",
-	"url",
-	"code",
-	"dmPolicy",
-	"allowFrom",
-	"groupPolicy",
-	"groupAllowFrom",
-	"defaultTo"
-]);
-const MATRIX_SINGLE_ACCOUNT_KEYS_TO_MOVE = new Set(matrixSingleAccountKeysToMove);
-const MATRIX_NAMED_ACCOUNT_PROMOTION_KEYS = new Set(matrixNamedAccountPromotionKeys);
-function cloneIfObject(value) {
-	if (value && typeof value === "object") return structuredClone(value);
-	return value;
-}
-function resolveExistingMatrixAccountKey(accounts, targetAccountId) {
-	const normalizedTargetAccountId = normalizeAccountId(targetAccountId);
-	return Object.keys(accounts).find((accountId) => normalizeAccountId(accountId) === normalizedTargetAccountId) ?? targetAccountId;
-}
-function moveSingleMatrixAccountConfigToNamedAccount(cfg) {
-	const baseConfig = cfg.channels?.[channel$1];
-	const base = typeof baseConfig === "object" && baseConfig ? baseConfig : void 0;
-	if (!base) return cfg;
-	const accounts = typeof base.accounts === "object" && base.accounts ? base.accounts : {};
-	const hasNamedAccounts = Object.keys(accounts).some(Boolean);
-	const keysToMove = Object.entries(base).filter(([key, value]) => {
-		if (key === "accounts" || key === "enabled" || value === void 0) return false;
-		if (!COMMON_SINGLE_ACCOUNT_KEYS_TO_MOVE.has(key) && !MATRIX_SINGLE_ACCOUNT_KEYS_TO_MOVE.has(key)) return false;
-		if (hasNamedAccounts && !MATRIX_NAMED_ACCOUNT_PROMOTION_KEYS.has(key)) return false;
-		return true;
-	}).map(([key]) => key);
-	if (keysToMove.length === 0) return cfg;
-	const resolvedTargetAccountId = resolveExistingMatrixAccountKey(accounts, resolveSingleAccountPromotionTarget({ channel: base }));
-	const nextAccount = { ...accounts[resolvedTargetAccountId] };
-	for (const key of keysToMove) nextAccount[key] = cloneIfObject(base[key]);
-	return patchTopLevelChannelConfigSection({
-		cfg,
-		channel: channel$1,
-		clearFields: keysToMove,
-		patch: { accounts: {
-			...accounts,
-			[resolvedTargetAccountId]: nextAccount
-		} }
-	});
-}
-function validateMatrixSetupInput(params) {
-	const input = params.input;
-	const avatarUrl = normalizeOptionalString(input.avatarUrl);
-	if (avatarUrl && !isSupportedMatrixAvatarSource(avatarUrl)) return "Matrix avatar URL must be an mxc:// URI or an http(s) URL.";
-	if (input.useEnv) {
-		const envReadiness = resolveMatrixEnvAuthReadiness(params.accountId, process.env);
-		return envReadiness.ready ? null : envReadiness.missingMessage;
-	}
-	if (!input.homeserver?.trim()) return "Matrix requires --homeserver";
-	const accessToken = input.accessToken?.trim();
-	const password = normalizeSecretInputString(input.password);
-	const userId = input.userId?.trim();
-	if (!accessToken && !password) return "Matrix requires --access-token or --password";
-	if (!accessToken && !userId) return "Matrix requires --user-id when using --password";
-	return null;
-}
-function applyMatrixSetupAccountConfig(params) {
-	const input = params.input;
-	const normalizedAccountId = normalizeAccountId(params.accountId);
-	const migratedCfg = normalizedAccountId !== DEFAULT_ACCOUNT_ID ? moveSingleMatrixAccountConfigToNamedAccount(params.cfg) : params.cfg;
-	const next = applyAccountNameToChannelSection({
-		cfg: migratedCfg,
-		channelKey: channel$1,
-		accountId: normalizedAccountId,
-		name: input.name
-	});
-	const avatarUrl = normalizeOptionalString(input.avatarUrl);
-	if (input.useEnv) return updateMatrixAccountConfig(next, normalizedAccountId, {
-		enabled: true,
-		homeserver: null,
-		allowPrivateNetwork: null,
-		proxy: null,
-		userId: null,
-		accessToken: null,
-		password: null,
-		deviceId: null,
-		deviceName: null,
-		avatarUrl
-	});
-	const accessToken = input.accessToken?.trim();
-	const password = normalizeSecretInputString(input.password);
-	const userId = input.userId?.trim();
-	return updateMatrixAccountConfig(next, normalizedAccountId, {
-		enabled: true,
-		homeserver: input.homeserver?.trim(),
-		allowPrivateNetwork: typeof input.dangerouslyAllowPrivateNetwork === "boolean" ? input.dangerouslyAllowPrivateNetwork : typeof input.allowPrivateNetwork === "boolean" ? input.allowPrivateNetwork : void 0,
-		proxy: normalizeOptionalString(input.proxy),
-		userId: password && !userId ? null : userId,
-		accessToken: accessToken || (password ? null : void 0),
-		password: password || (accessToken ? null : void 0),
-		deviceName: input.deviceName?.trim(),
-		avatarUrl,
-		initialSyncLimit: input.initialSyncLimit
-	});
-}
-//#endregion
-//#region extensions/matrix/src/setup-dm-policy.ts
-function resolveMatrixSetupDmAllowFrom(policy, allowFrom) {
-	if (policy === "open") return addWildcardAllowFrom(allowFrom);
-	return normalizeAllowFromEntries(allowFrom ?? []).filter((entry) => entry !== "*");
-}
-function createMatrixSetupDmPolicy(promptAllowFrom) {
-	return createChannelDmPolicy({
-		label: "Matrix",
-		channel: "matrix",
-		policyPath: "dm.policy",
-		allowFromPath: "dm.allowFrom",
-		resolveAccount: (cfg, accountId) => {
-			const resolvedCfg = cfg;
-			const resolvedAccountId = normalizeAccountId(accountId?.trim() || resolveDefaultMatrixAccountId(resolvedCfg) || DEFAULT_ACCOUNT_ID);
-			const config = resolveMatrixAccountConfig({
-				cfg: resolvedCfg,
-				accountId: resolvedAccountId
-			});
-			return {
-				accountId: resolvedAccountId,
-				config: {
-					dmPolicy: config.dm?.policy,
-					allowFrom: config.dm?.allowFrom,
-					dm: config.dm
-				}
-			};
-		},
-		resolveConfigKeys: ({ cfg, account }) => ({
-			policyKey: resolveMatrixConfigFieldPath(cfg, account.accountId, "dm.policy"),
-			allowFromKey: resolveMatrixConfigFieldPath(cfg, account.accountId, "dm.allowFrom")
-		}),
-		resolveAllowFrom: ({ policy, account }) => resolveMatrixSetupDmAllowFrom(policy, account.config.allowFrom),
-		buildPatch: ({ account, policy, allowFrom }) => ({ dm: {
-			...account.config.dm,
-			policy,
-			allowFrom
-		} }),
-		applyPatch: ({ cfg, account, patch }) => updateMatrixAccountConfig(cfg, account.accountId, patch),
-		promptAllowFrom
-	});
-}
-//#endregion
-//#region extensions/matrix/src/setup-core.ts
-const channel = "matrix";
-function resolveMatrixSetupAccountId(params) {
-	return normalizeAccountId(params.accountId?.trim() || params.name?.trim() || DEFAULT_ACCOUNT_ID);
-}
-function createMatrixSetupWizardProxy(loadWizardModule) {
-	let wizardPromise = null;
-	const loadWizard = () => {
-		wizardPromise ??= loadWizardModule().then((module) => module.matrixSetupWizard);
-		return wizardPromise;
-	};
-	return {
-		channel,
-		getStatus: async (ctx) => await (await loadWizard()).getStatus(ctx),
-		configure: async (ctx) => await (await loadWizard()).configure(ctx),
-		configureInteractive: async (ctx) => {
-			const wizard = await loadWizard();
-			return await (wizard.configureInteractive ?? wizard.configure)(ctx);
-		},
-		configureWhenConfigured: async (ctx) => {
-			const wizard = await loadWizard();
-			return await (wizard.configureWhenConfigured ?? wizard.configureInteractive ?? wizard.configure)(ctx);
-		},
-		afterConfigWritten: async (ctx) => await (await loadWizard()).afterConfigWritten?.(ctx),
-		dmPolicy: createMatrixSetupDmPolicy(async (params) => {
-			const promptAllowFrom = (await loadWizard()).dmPolicy?.promptAllowFrom;
-			return promptAllowFrom ? await promptAllowFrom(params) : params.cfg;
-		}),
-		disable: (cfg) => setSetupChannelEnabled(cfg, channel, false)
-	};
-}
-const matrixSetupAdapter = {
-	singleAccountKeysToMove,
-	namedAccountPromotionKeys,
-	resolveSingleAccountPromotionTarget,
-	resolveAccountId: ({ accountId, input }) => resolveMatrixSetupAccountId({
-		accountId,
-		name: input?.name
-	}),
-	resolveBindingAccountId: ({ accountId, agentId }) => resolveMatrixSetupAccountId({
-		accountId,
-		name: agentId
-	}),
-	applyAccountName: ({ cfg, accountId, name }) => prepareScopedSetupConfig({
-		cfg,
-		channelKey: channel,
-		accountId,
-		name
-	}),
-	validateInput: ({ accountId, input }) => validateMatrixSetupInput({
-		accountId,
-		input
-	}),
-	applyAccountConfig: ({ cfg, accountId, input }) => applyMatrixSetupAccountConfig({
-		cfg,
-		accountId,
-		input
-	}),
-	afterAccountConfigWritten: async ({ previousCfg, cfg, accountId, runtime }) => {
-		const { runMatrixSetupBootstrapAfterConfigWrite } = await import("./setup-bootstrap-UNIGyKnk.mjs");
-		await runMatrixSetupBootstrapAfterConfigWrite({
-			previousCfg,
-			cfg,
-			accountId,
-			runtime
-		});
-	}
-};
-const matrixSetupContract = defineChannelSetupContract({
-	fields: {
-		homeserver: {
-			kind: "string",
-			cli: {
-				flags: "--homeserver <url>",
-				description: "Matrix homeserver URL"
-			}
-		},
-		userId: {
-			kind: "string",
-			cli: {
-				flags: "--user-id <id>",
-				description: "Matrix user id"
-			}
-		},
-		accessToken: {
-			kind: "string",
-			sensitive: true,
-			cli: {
-				flags: "--access-token <token>",
-				description: "Matrix access token"
-			}
-		},
-		password: {
-			kind: "string",
-			sensitive: true,
-			cli: {
-				flags: "--password <password>",
-				description: "Matrix password"
-			}
-		},
-		deviceName: {
-			kind: "string",
-			cli: {
-				flags: "--device-name <name>",
-				description: "Matrix device name"
-			}
-		},
-		avatarUrl: {
-			kind: "string",
-			cli: {
-				flags: "--avatar-url <url>",
-				description: "Matrix avatar URL"
-			}
-		},
-		initialSyncLimit: {
-			kind: "integer",
-			cli: {
-				flags: "--initial-sync-limit <n>",
-				description: "Matrix initial sync room limit"
-			}
-		},
-		proxy: {
-			kind: "string",
-			cli: {
-				flags: "--proxy <url>",
-				description: "Matrix proxy URL"
-			}
-		},
-		dangerouslyAllowPrivateNetwork: {
-			kind: "boolean",
-			cli: {
-				flags: "--dangerously-allow-private-network",
-				description: "Allow private-network Matrix homeservers"
-			}
-		},
-		useEnv: {
-			kind: "boolean",
-			cli: {
-				flags: "--use-env",
-				description: "Use Matrix environment credentials"
-			}
-		}
-	},
-	legacyAdapter: matrixSetupAdapter
-});
-//#endregion
-export { moveSingleMatrixAccountConfigToNamedAccount as a, singleAccountKeysToMove as c, createMatrixSetupDmPolicy as i, matrixSetupAdapter as n, namedAccountPromotionKeys as o, matrixSetupContract as r, resolveSingleAccountPromotionTarget as s, createMatrixSetupWizardProxy as t };

package/node_modules/@openclaw/fs-safe/dist/file-lock-sync-root-arbitration.d.ts

@@ -1,17 +0,0 @@
-import { FsSafeError } from "./errors.js";
-import type { FileLockSyncHandle } from "./file-lock-sync.js";
-import { type FileLockSyncRootAuthority, type FileLockSyncRootPath } from "./file-lock-sync-root.js";
-import type { FileLockSyncRootFileReceipt } from "./file-lock-sync-root-io.js";
-import { type RootSyncHeldLock } from "./file-lock-sync-root-held.js";
-export declare class FileLockSyncRootArbitrationCollision extends FsSafeError {
-    constructor();
-}
-export type FileLockSyncRootArbitration = Readonly<{
-    authority: FileLockSyncRootAuthority;
-    heldLocks: Map<string, RootSyncHeldLock>;
-    lockRootPath: FileLockSyncRootPath;
-    normalizedTargetPath: string;
-    reentrantOwner?: string;
-}>;
-export declare function tryReuseCurrentRootSyncHeldLock(arbitration: FileLockSyncRootArbitration): FileLockSyncHandle | undefined;
-export declare function cleanupCreatedRootSyncLock(lockRootPath: FileLockSyncRootPath, fd: number, receipt: FileLockSyncRootFileReceipt, timer?: NodeJS.Timeout): void;

package/node_modules/@openclaw/fs-safe/dist/file-lock-sync-root-arbitration.js

@@ -1,66 +0,0 @@
-import fs from "node:fs";
-import { foreignSyncHeldLock } from "./file-lock-sync-admission.js";
-import path from "node:path";
-import { FsSafeError } from "./errors.js";
-import {} from "./file-lock-sync-root.js";
-import { removeFileLockSyncRootFile } from "./file-lock-sync-root-mutation.js";
-import { createSuppressedError } from "./suppressed-error.js";
-import { createRootSyncHeldLockHandle, verifyRootSyncHeldLock, } from "./file-lock-sync-root-held.js";
-export class FileLockSyncRootArbitrationCollision extends FsSafeError {
-    constructor() {
-        super("path-mismatch", "file lock arbitration changed during local creation");
-    }
-}
-function sameRootLockPath(left, right) {
-    return left.relativePath === right.relativePath && path.relative(left.path, right.path) === "";
-}
-export function tryReuseCurrentRootSyncHeldLock(arbitration) {
-    const held = arbitration.heldLocks.get(arbitration.normalizedTargetPath);
-    const reusable = held && !foreignSyncHeldLock("root", arbitration.normalizedTargetPath) &&
-        arbitration.reentrantOwner !== undefined &&
-        held.reentrantOwner !== undefined &&
-        arbitration.reentrantOwner === held.reentrantOwner &&
-        arbitration.authority.adapter === held.rootAuthority.adapter &&
-        sameRootLockPath(arbitration.lockRootPath, held.rootPath) &&
-        held.releaseState !== "released";
-    if (!reusable)
-        return undefined;
-    if (!verifyRootSyncHeldLock(held)) {
-        throw new FsSafeError("path-mismatch", "held sidecar lock changed before reentrant reuse");
-    }
-    // Verification can invoke a custom parser. Re-fetch the exact entry before
-    // granting a reference, while retaining supported releasing/exit states.
-    if (arbitration.heldLocks.get(arbitration.normalizedTargetPath) !== held ||
-        held.releaseState === "released" || foreignSyncHeldLock("root", arbitration.normalizedTargetPath)) {
-        throw new FsSafeError("path-mismatch", "held sidecar lock changed during reentrant reuse");
-    }
-    held.refCount += 1;
-    held.revision += 1;
-    return createRootSyncHeldLockHandle(held);
-}
-export function cleanupCreatedRootSyncLock(lockRootPath, fd, receipt, timer) {
-    let timerCleanupFailed = false;
-    let timerCleanupError;
-    try {
-        if (timer)
-            clearInterval(timer);
-    }
-    catch (error) {
-        timerCleanupFailed = true;
-        timerCleanupError = error;
-    }
-    try {
-        fs.closeSync(fd);
-        if (!removeFileLockSyncRootFile(lockRootPath, receipt)) {
-            throw new FsSafeError("path-mismatch", "created sidecar lock changed before cleanup");
-        }
-    }
-    catch (fileCleanupError) {
-        if (timerCleanupFailed) {
-            throw createSuppressedError(timerCleanupError, fileCleanupError, "unpublished lock timer and file cleanup both failed");
-        }
-        throw fileCleanupError;
-    }
-    if (timerCleanupFailed)
-        throw timerCleanupError;
-}

package/node_modules/@openclaw/fs-safe/dist/publish-file-native.d.ts

@@ -1,4 +0,0 @@
-import type { BigIntStats } from "node:fs";
-import type { NativeBinding } from "./native-binding.js";
-import { type PublishFailureState } from "./publish-file-failure.js";
-export declare function publishFileNoReplaceNative(binding: NativeBinding, paths: Parameters<NativeBinding["renameNoReplace"]>, expected: BigIntStats, failure: PublishFailureState): "link-unlink" | undefined;

package/node_modules/@openclaw/fs-safe/dist/publish-file-native.js

@@ -1,35 +0,0 @@
-import { FsSafeError } from "./errors.js";
-import { getFsSafeNativeConfig } from "./native-config.js";
-import { nativeMoveNoReplace } from "./native-move-fallback.js";
-import { rememberCreatedTarget } from "./publish-file-failure.js";
-export function publishFileNoReplaceNative(binding, paths, expected, failure) {
-    try {
-        const fallback = nativeMoveNoReplace(binding, paths, expected, getFsSafeNativeConfig().mode === "auto", "file publication");
-        if (fallback) {
-            failure.fallback = fallback;
-            failure.sourceRemoval = "removed";
-        }
-        return fallback;
-    }
-    catch (error) {
-        if (error instanceof FsSafeError && error.details?.publication === "published") {
-            failure.targetCreated = true;
-            failure.preserveTarget = true;
-            failure.phase = "rename-verify";
-            failure.fallback = "link-unlink";
-            failure.sourceRemoval = error.details.sourceRemoval;
-            // Changed/unverified pairs cannot establish which inode was published.
-            if (failure.sourceRemoval === "still-linked")
-                rememberCreatedTarget(failure, expected, "rename-verify");
-        }
-        if (error instanceof FsSafeError)
-            throw error;
-        const code = error?.code;
-        if (code === "path-mismatch" || code === "hardlink") {
-            throw new FsSafeError(code, "publication source changed before fallback", { cause: error });
-        }
-        if (code === "ELOOP")
-            throw new FsSafeError("symlink", "publication source became a symlink", { cause: error });
-        throw error;
-    }
-}

package/node_modules/@openclaw/fs-safe/dist/root-move-preflight.d.ts

@@ -1,7 +0,0 @@
-import { type DenyMutationPolicy } from "./deny-mutations.js";
-import { type RootContext } from "./root-context.js";
-export declare function assertMoveMutationAllowed(root: RootContext, params: {
-    fromRelative: string;
-    toRelative: string;
-    denyMutations?: DenyMutationPolicy;
-}): Promise<void>;

package/node_modules/@openclaw/fs-safe/dist/root-move-preflight.js

@@ -1,16 +0,0 @@
-import { assertMutationNotDenied, } from "./deny-mutations.js";
-import { resolvePathInRoot } from "./root-context.js";
-export async function assertMoveMutationAllowed(root, params) {
-    // Keep this preflight separate from the pinned resolutions in movePathFallback:
-    // mutation denials must take precedence over source alias or identity failures.
-    const source = await resolvePathInRoot(root, params.fromRelative, {
-        aliasErrorCode: "path-alias",
-        allowFinalSymlink: true,
-    });
-    await assertMutationNotDenied(source.resolved, params.denyMutations, { protectAncestors: true });
-    const target = await resolvePathInRoot(root, params.toRelative, {
-        aliasErrorCode: "path-alias",
-        allowFinalSymlink: true,
-    });
-    await assertMutationNotDenied(target.resolved, params.denyMutations, { protectAncestors: true });
-}

package/dist/.setup/{errors-DKVS3_DO.mjs → errors-Bw4EHwKX.mjs}

@@ -1,5 +1,5 @@
-import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 import { formatErrorMessage } from "openclaw/plugin-sdk/error-runtime";
+import { normalizeLowercaseStringOrEmpty } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/matrix/errors.ts
 function formatMatrixErrorReason(err) {
 	return normalizeLowercaseStringOrEmpty(formatErrorMessage(err));