@openclaw/matrix 2026.9.4 → 2026.9.6

package/dist/{client-bootstrap-DLN-K8Xb.js → .setup/client-bootstrap-BSnUAoz1.mjs}

@@ -1,12 +1,8 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { requireRuntimeConfig } from "openclaw/plugin-sdk/plugin-config-runtime";
+import { captureChannelReadAuthority } from "openclaw/plugin-sdk/fetch-runtime";
 //#region extensions/matrix/src/matrix/client-bootstrap.ts
-var client_bootstrap_exports = /* @__PURE__ */ __exportAll({
-	resolveRuntimeMatrixClientWithReadiness: () => resolveRuntimeMatrixClientWithReadiness,
-	withResolvedRuntimeMatrixClient: () => withResolvedRuntimeMatrixClient
-});
-const loadMatrixSharedClientRuntimeDeps = createLazyRuntimeModule(() => import("./client-CPcRv6ab.js").then((n) => n.t).then((clientModule) => ({
+const loadMatrixSharedClientRuntimeDeps = createLazyRuntimeModule(() => import("./client-ChrXpxos.mjs").then((n) => n.t).then((clientModule) => ({
 	acquireSharedMatrixClient: clientModule.acquireSharedMatrixClient,
 	resolveMatrixAuthContext: clientModule.resolveMatrixAuthContext
 })));
@@ -19,17 +15,21 @@ async function ensureResolvedClientReadiness(params) {
 	if (params.readiness === "prepared" || !params.readiness && params.preparedByDefault) await params.client.prepareForOneOff();
 }
 async function resolveRuntimeMatrixClientWithReadiness(opts) {
+	const assertCurrent = captureChannelReadAuthority();
+	assertCurrent?.();
 	if (opts.client) {
 		await ensureResolvedClientReadiness({
 			client: opts.client,
 			readiness: opts.readiness,
 			preparedByDefault: false
 		});
+		assertCurrent?.();
 		return { client: opts.client };
 	}
 	if (!opts.cfg) throw new Error("Matrix runtime client requires a resolved runtime config. Load and resolve config at the command or gateway boundary, then pass cfg through the runtime path.");
 	const cfg = requireRuntimeConfig(opts.cfg, "Matrix runtime client");
 	const { acquireSharedMatrixClient, resolveMatrixAuthContext } = await loadMatrixSharedClientRuntimeDeps();
+	assertCurrent?.();
 	const authContext = resolveMatrixAuthContext({
 		cfg,
 		accountId: opts.accountId
@@ -42,12 +42,14 @@ async function resolveRuntimeMatrixClientWithReadiness(opts) {
 		role: "transient"
 	});
 	try {
+		assertCurrent?.();
 		await ensureResolvedClientReadiness({
 			client: lease.client,
 			lease,
 			readiness: opts.readiness,
 			preparedByDefault: true
 		});
+		assertCurrent?.();
 	} catch (err) {
 		await lease.release({ mode: "stop" });
 		throw err;
@@ -58,12 +60,19 @@ async function resolveRuntimeMatrixClientWithReadiness(opts) {
 	};
 }
 async function withResolvedRuntimeMatrixClient(opts, run, stopMode = "stop") {
+	const assertCurrent = captureChannelReadAuthority();
+	assertCurrent?.();
 	const resolved = await resolveRuntimeMatrixClientWithReadiness(opts);
 	try {
+		assertCurrent?.();
 		return await run(resolved.client, resolved.lease?.abortSignal);
 	} finally {
-		await resolved.lease?.release({ mode: stopMode });
+		try {
+			await resolved.lease?.release({ mode: stopMode });
+		} finally {
+			assertCurrent?.();
+		}
 	}
 }
 //#endregion
-export { withResolvedRuntimeMatrixClient as n, client_bootstrap_exports as t };
+export { resolveRuntimeMatrixClientWithReadiness, withResolvedRuntimeMatrixClient };

package/dist/{client-support-DLj4vDeu.js → .setup/client-support-Bn9Bk0-H.mjs}

@@ -1,4 +1,4 @@
-import { t as formatMatrixErrorReason } from "./errors-DKVS3_DO.js";
+import { t as formatMatrixErrorReason } from "./errors-DKVS3_DO.mjs";
 //#region extensions/matrix/src/matrix/sync-state.ts
 function isMatrixReadySyncState(state) {
 	return state === "PREPARED" || state === "SYNCING" || state === "CATCHUP";

package/dist/{config-update-BnX26jCO.js → .setup/config-update-B_4qZ5bV.mjs}

@@ -1,6 +1,6 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { t as findMatrixAccountConfig } from "./account-config-CRsKoMqJ.js";
-import { n as resolveMatrixConfigPath$1, r as shouldStoreMatrixAccountAtTopLevel, t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { t as findMatrixAccountConfig } from "./account-config-CRsKoMqJ.mjs";
+import { n as resolveMatrixConfigPath$1, r as shouldStoreMatrixAccountAtTopLevel, t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.mjs";
 import { DEFAULT_ACCOUNT_ID, normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { coerceSecretRef, normalizeSecretInputString } from "openclaw/plugin-sdk/secret-input";
 import { resolveOptionalIntegerOption } from "openclaw/plugin-sdk/number-runtime";

package/dist/.setup/create-client-CHxcron_.mjs

@@ -0,0 +1,67 @@
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { t as resolveValidatedMatrixHomeserverUrl } from "./url-validation-GRHde6lq.mjs";
+import { n as maybeMigrateLegacyStorage, o as resolveMatrixStoragePaths, s as writeStorageMeta } from "./storage-BXaFc0S4.mjs";
+import "./client-ChrXpxos.mjs";
+import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
+import { normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { ssrfPolicyFromDangerouslyAllowPrivateNetwork } from "openclaw/plugin-sdk/ssrf-runtime";
+import fs from "node:fs";
+//#region extensions/matrix/src/matrix/client/create-client.ts
+const loadMatrixCreateClientRuntimeDeps = createLazyRuntimeModule(() => Promise.all([
+	import("./sdk-rqFjgltR.mjs").then((n) => n.t),
+	import("./logging-rgm8ep9H.mjs").then((n) => n.n),
+	import("./file-sync-store-CsalA4yI.mjs")
+]).then(([sdkModule, loggingModule, syncStoreModule]) => ({
+	MatrixClient: sdkModule.MatrixClient,
+	SqliteBackedMatrixSyncStore: syncStoreModule.SqliteBackedMatrixSyncStore,
+	ensureMatrixSdkLoggingConfigured: loggingModule.ensureMatrixSdkLoggingConfigured
+})));
+async function createMatrixClient(params) {
+	const { MatrixClient, SqliteBackedMatrixSyncStore, ensureMatrixSdkLoggingConfigured } = await loadMatrixCreateClientRuntimeDeps();
+	ensureMatrixSdkLoggingConfigured();
+	const homeserver = await resolveValidatedMatrixHomeserverUrl(params.homeserver, { dangerouslyAllowPrivateNetwork: params.allowPrivateNetwork });
+	const matrixClientUserId = normalizeOptionalString(params.userId);
+	const userId = matrixClientUserId ?? "unknown";
+	const storagePaths = params.persistStorage !== false ? await resolveMatrixStoragePaths({
+		homeserver,
+		userId,
+		accessToken: params.accessToken,
+		accountId: params.accountId,
+		deviceId: params.deviceId,
+		env: process.env
+	}) : null;
+	if (storagePaths) {
+		await maybeMigrateLegacyStorage({
+			storagePaths,
+			env: process.env
+		});
+		fs.mkdirSync(storagePaths.rootDir, { recursive: true });
+		await writeStorageMeta({
+			storagePaths,
+			homeserver,
+			userId,
+			accountId: params.accountId,
+			deviceId: params.deviceId
+		});
+	}
+	const cryptoDatabasePrefix = storagePaths ? `openclaw-matrix-${storagePaths.accountKey}-${storagePaths.tokenHash}` : void 0;
+	const syncStore = storagePaths ? await SqliteBackedMatrixSyncStore.create(storagePaths.rootDir) : void 0;
+	return new MatrixClient(homeserver, params.accessToken, {
+		userId: matrixClientUserId,
+		password: params.password,
+		deviceId: params.deviceId,
+		encryption: params.encryption,
+		localTimeoutMs: params.localTimeoutMs,
+		initialSyncLimit: params.initialSyncLimit,
+		syncStore,
+		recoveryKeyPath: storagePaths?.recoveryKeyPath,
+		idbSnapshotPath: storagePaths?.idbSnapshotPath,
+		cryptoDatabasePrefix,
+		autoBootstrapCrypto: params.autoBootstrapCrypto,
+		ssrfPolicy: params.ssrfPolicy ?? ssrfPolicyFromDangerouslyAllowPrivateNetwork(params.allowPrivateNetwork),
+		dispatcherPolicy: params.dispatcherPolicy,
+		stateRuntime: getMatrixRuntime().state
+	});
+}
+//#endregion
+export { createMatrixClient };

package/dist/{credentials-DysXbkv2.js → .setup/credentials-BGKfiaJW.mjs}

@@ -1,20 +1,20 @@
-import { i as normalizeMatrixStoredCredentials, n as isMatrixCredentialRevocation, r as matrixCredentialsStoreKey } from "./credentials-state-B3cuUFwZ.js";
-import { i as resolveMatrixCredentialsDir, o as resolveMatrixCredentialsPath } from "./storage-paths-DVCANXTc.js";
-import { a as openMatrixCredentialsStore, i as loadMatrixCredentials, n as credentialsMatchConfig, t as clearMatrixCredentials } from "./credentials-read-WWpqi88V.js";
+import { i as normalizeMatrixStoredCredentials, n as isMatrixCredentialRevocation, r as matrixCredentialsStoreKey } from "./credentials-state-B3cuUFwZ.mjs";
+import { i as resolveMatrixCredentialsDir, o as resolveMatrixCredentialsPath } from "./storage-paths-DVCANXTc.mjs";
+import { a as loadMatrixCredentials, c as openMatrixCredentialsStore, n as clearMatrixCredentials, r as credentialsMatchConfig, s as openMatrixCredentialsAsyncStore } from "./credentials-read-Q5sHkkHv.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/credentials.ts
 async function saveMatrixCredentials(credentials, env = process.env, accountId) {
 	const normalizedAccountId = normalizeAccountId(accountId);
-	const store = openMatrixCredentialsStore(env);
+	const preparedCredentials = { ...credentials };
 	const now = (/* @__PURE__ */ new Date()).toISOString();
-	store.update(matrixCredentialsStoreKey(normalizedAccountId), (current) => {
+	await updateMatrixCredentials(env, normalizedAccountId, (current) => {
 		const existing = normalizeMatrixStoredCredentials(current, normalizedAccountId);
 		return {
 			accountId: normalizedAccountId,
-			homeserver: credentials.homeserver,
-			userId: credentials.userId,
-			accessToken: credentials.accessToken,
-			...typeof credentials.deviceId === "string" ? { deviceId: credentials.deviceId } : {},
+			homeserver: preparedCredentials.homeserver,
+			userId: preparedCredentials.userId,
+			accessToken: preparedCredentials.accessToken,
+			...typeof preparedCredentials.deviceId === "string" ? { deviceId: preparedCredentials.deviceId } : {},
 			createdAt: existing?.createdAt ?? now,
 			lastUsedAt: now
 		};
@@ -22,25 +22,26 @@ async function saveMatrixCredentials(credentials, env = process.env, accountId)
 }
 async function saveBackfilledMatrixDeviceId(credentials, env = process.env, accountId) {
 	const normalizedAccountId = normalizeAccountId(accountId);
-	const store = openMatrixCredentialsStore(env);
+	const preparedCredentials = { ...credentials };
 	const now = (/* @__PURE__ */ new Date()).toISOString();
 	let result = "saved";
-	store.update(matrixCredentialsStoreKey(normalizedAccountId), (current) => {
+	await updateMatrixCredentials(env, normalizedAccountId, (current) => {
+		result = "saved";
 		if (isMatrixCredentialRevocation(current, normalizedAccountId)) {
 			result = "skipped";
 			return current;
 		}
 		const existing = normalizeMatrixStoredCredentials(current, normalizedAccountId);
-		if (existing && (existing.homeserver !== credentials.homeserver || existing.userId !== credentials.userId || existing.accessToken !== credentials.accessToken)) {
+		if (existing && (existing.homeserver !== preparedCredentials.homeserver || existing.userId !== preparedCredentials.userId || existing.accessToken !== preparedCredentials.accessToken)) {
 			result = "skipped";
 			return existing;
 		}
 		return {
 			accountId: normalizedAccountId,
-			homeserver: credentials.homeserver,
-			userId: credentials.userId,
-			accessToken: credentials.accessToken,
-			...typeof credentials.deviceId === "string" ? { deviceId: credentials.deviceId } : {},
+			homeserver: preparedCredentials.homeserver,
+			userId: preparedCredentials.userId,
+			accessToken: preparedCredentials.accessToken,
+			...typeof preparedCredentials.deviceId === "string" ? { deviceId: preparedCredentials.deviceId } : {},
 			createdAt: existing?.createdAt ?? now,
 			lastUsedAt: now
 		};
@@ -49,7 +50,7 @@ async function saveBackfilledMatrixDeviceId(credentials, env = process.env, acco
 }
 async function touchMatrixCredentials(env = process.env, accountId) {
 	const normalizedAccountId = normalizeAccountId(accountId);
-	openMatrixCredentialsStore(env).update(matrixCredentialsStoreKey(normalizedAccountId), (current) => {
+	await updateMatrixCredentials(env, normalizedAccountId, (current) => {
 		if (isMatrixCredentialRevocation(current, normalizedAccountId)) return current;
 		const existing = normalizeMatrixStoredCredentials(current, normalizedAccountId);
 		return existing ? {
@@ -58,5 +59,27 @@ async function touchMatrixCredentials(env = process.env, accountId) {
 		} : void 0;
 	});
 }
+async function updateMatrixCredentials(env, accountId, update) {
+	const store = openMatrixCredentialsAsyncStore(env);
+	const key = matrixCredentialsStoreKey(accountId);
+	if (!store.observe || !store.compareAndApply) {
+		openMatrixCredentialsStore(env).update(key, update);
+		return;
+	}
+	let observation = await store.observe(key);
+	for (;;) {
+		const value = update(observation.value);
+		const result = await store.compareAndApply(key, observation.comparison, value === void 0 ? {
+			operation: "update",
+			action: "keep"
+		} : {
+			operation: "update",
+			action: "set",
+			value
+		});
+		if (result.status !== "conflict") return;
+		observation = result.current;
+	}
+}
 //#endregion
 export { clearMatrixCredentials, credentialsMatchConfig, loadMatrixCredentials, resolveMatrixCredentialsDir, resolveMatrixCredentialsPath, saveBackfilledMatrixDeviceId, saveMatrixCredentials, touchMatrixCredentials };

package/dist/{credentials-read-WWpqi88V.js → .setup/credentials-read-Q5sHkkHv.mjs}

@@ -1,34 +1,55 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { n as getOptionalMatrixRuntime } from "./runtime-6S3DNFNv.js";
-import { i as normalizeMatrixStoredCredentials, r as matrixCredentialsStoreKey, t as MATRIX_CREDENTIALS_NAMESPACE } from "./credentials-state-B3cuUFwZ.js";
-import { i as resolveMatrixCredentialsDir, o as resolveMatrixCredentialsPath } from "./storage-paths-DVCANXTc.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { r as getOptionalMatrixRuntime, t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { i as normalizeMatrixStoredCredentials, r as matrixCredentialsStoreKey, t as MATRIX_CREDENTIALS_NAMESPACE } from "./credentials-state-B3cuUFwZ.mjs";
+import { i as resolveMatrixCredentialsDir, o as resolveMatrixCredentialsPath } from "./storage-paths-DVCANXTc.mjs";
 import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
 import { createPluginStateSyncKeyedStore } from "openclaw/plugin-sdk/plugin-state-store-runtime";
 //#region extensions/matrix/src/matrix/credentials-read.ts
 var credentials_read_exports = /* @__PURE__ */ __exportAll({
+	captureMatrixCredentialsEnv: () => captureMatrixCredentialsEnv,
 	clearMatrixCredentials: () => clearMatrixCredentials,
 	credentialsMatchConfig: () => credentialsMatchConfig,
 	loadMatrixCredentials: () => loadMatrixCredentials,
+	loadMatrixCredentialsAsync: () => loadMatrixCredentialsAsync,
+	openMatrixCredentialsAsyncStore: () => openMatrixCredentialsAsyncStore,
 	openMatrixCredentialsStore: () => openMatrixCredentialsStore,
 	resolveMatrixCredentialsDir: () => resolveMatrixCredentialsDir,
 	resolveMatrixCredentialsPath: () => resolveMatrixCredentialsPath
 });
-function openMatrixCredentialsStore(env = process.env) {
+function matrixCredentialsStoreOptions(env) {
 	const runtime = getOptionalMatrixRuntime();
 	const resolvedEnv = env.OPENCLAW_STATE_DIR?.trim() || !runtime ? env : {
 		...env,
 		OPENCLAW_STATE_DIR: runtime.state.resolveStateDir(env)
 	};
-	return createPluginStateSyncKeyedStore("matrix", {
+	return {
 		namespace: MATRIX_CREDENTIALS_NAMESPACE,
 		maxEntries: 256,
 		overflowPolicy: "reject-new",
 		env: resolvedEnv
-	});
+	};
+}
+function openMatrixCredentialsStore(env = process.env) {
+	return createPluginStateSyncKeyedStore("matrix", matrixCredentialsStoreOptions(env));
+}
+function openMatrixCredentialsAsyncStore(env = process.env) {
+	return getMatrixRuntime().state.openKeyedStore(matrixCredentialsStoreOptions(env));
+}
+function captureMatrixCredentialsEnv(env) {
+	return {
+		...env,
+		OPENCLAW_STATE_DIR: getMatrixRuntime().state.resolveStateDir(env),
+		OPENCLAW_SUPERVISOR_MODE: env.OPENCLAW_SUPERVISOR_MODE
+	};
+}
+async function loadMatrixCredentialsAsync(env = process.env, accountId) {
+	return decodeMatrixCredentials(await openMatrixCredentialsAsyncStore(env).lookup(matrixCredentialsStoreKey(accountId)), accountId);
 }
 function loadMatrixCredentials(env = process.env, accountId) {
+	return decodeMatrixCredentials(openMatrixCredentialsStore(env).lookup(matrixCredentialsStoreKey(accountId)), accountId);
+}
+function decodeMatrixCredentials(stored, accountId) {
 	const normalizedAccountId = normalizeAccountId(accountId);
-	const stored = openMatrixCredentialsStore(env).lookup(matrixCredentialsStoreKey(accountId));
 	const parsed = normalizeMatrixStoredCredentials(stored, normalizedAccountId);
 	if (!parsed || parsed.accountId !== normalizedAccountId) return null;
 	const { accountId: _accountId, ...credentials } = parsed;
@@ -50,4 +71,4 @@ function credentialsMatchConfig(stored, config) {
 	return stored.homeserver === config.homeserver && stored.userId === config.userId;
 }
 //#endregion
-export { openMatrixCredentialsStore as a, loadMatrixCredentials as i, credentialsMatchConfig as n, credentials_read_exports as r, clearMatrixCredentials as t };
+export { loadMatrixCredentials as a, openMatrixCredentialsStore as c, credentials_read_exports as i, clearMatrixCredentials as n, loadMatrixCredentialsAsync as o, credentialsMatchConfig as r, openMatrixCredentialsAsyncStore as s, captureMatrixCredentialsEnv as t };

package/dist/{credentials-write.runtime-D22lPwRO.js → .setup/credentials-write.runtime-DxbXh-pK.mjs}

@@ -1,6 +1,6 @@
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 //#region extensions/matrix/src/matrix/credentials-write.runtime.ts
-const loadMatrixCredentialsRuntime = createLazyRuntimeModule(() => import("./credentials-DysXbkv2.js"));
+const loadMatrixCredentialsRuntime = createLazyRuntimeModule(() => import("./credentials-BGKfiaJW.mjs"));
 async function saveMatrixCredentials(...args) {
 	return (await loadMatrixCredentialsRuntime()).saveMatrixCredentials(...args);
 }

package/dist/{crypto-runtime-DiyH4R3D.js → .setup/crypto-runtime-D9qn_Pbj.mjs}

@@ -1,13 +1,13 @@
-import { t as ensureMatrixCryptoRuntime } from "./deps-mtxF2mHI.js";
-import { n as LogService, r as noop } from "./logger-B_71hN6W.js";
-import { i as restoreIdbFromDisk, n as persistIdbToDisk } from "./idb-persistence-DBdwHSWg.js";
-import { n as isRepairableSecretStorageAccessError } from "./sdk-B4By16Bt.js";
+import { t as ensureMatrixCryptoRuntime } from "./deps-mtxF2mHI.mjs";
+import { n as LogService, r as noop } from "./logger-xBjiRIp1.mjs";
+import { i as restoreIdbFromDisk, n as persistIdbToDisk } from "./idb-persistence-c8uxcofH.mjs";
+import { n as isRepairableSecretStorageAccessError } from "./sdk-rqFjgltR.mjs";
 import { createLazyRuntimeModule } from "openclaw/plugin-sdk/lazy-runtime";
 import { formatErrorMessage, toStringifiedError } from "openclaw/plugin-sdk/error-runtime";
 import { resolveDateTimestampMs, resolveTimestampMsToIsoString } from "openclaw/plugin-sdk/number-runtime";
 import { setTimeout as setTimeout$1 } from "node:timers/promises";
-import { IDBDatabase } from "fake-indexeddb";
 import { MatrixEventEvent } from "matrix-js-sdk/lib/matrix.js";
+import { IDBDatabase } from "fake-indexeddb";
 import { VerificationMethod } from "matrix-js-sdk/lib/types.js";
 import "fake-indexeddb/auto";
 import { CryptoEvent } from "matrix-js-sdk/lib/crypto-api/CryptoEvent.js";
@@ -309,7 +309,7 @@ var MatrixCryptoBootstrapper = class {
 };
 //#endregion
 //#region extensions/matrix/src/matrix/sdk/crypto-facade.ts
-const matrixCryptoNodeRuntimeLoader = createLazyRuntimeModule(() => import("./crypto-node.runtime-6Aj_ltHQ.js"));
+const matrixCryptoNodeRuntimeLoader = createLazyRuntimeModule(() => import("./crypto-node.runtime-6Aj_ltHQ.mjs"));
 async function loadMatrixCryptoNodeRuntime() {
 	try {
 		return await matrixCryptoNodeRuntimeLoader();
@@ -330,7 +330,6 @@ function trackInProgressToDeviceVerifications(deps) {
 }
 function createMatrixCryptoFacade(deps) {
 	return {
-		prepare: async (_joinedRooms) => {},
 		updateSyncData: async (_toDeviceMessages, _otkCounts, _unusedFallbackKeyAlgs, _changedDeviceLists, _leftDeviceLists) => {},
 		isRoomEncrypted: deps.isRoomEncrypted,
 		requestOwnUserVerification: async () => {

package/dist/{crypto-snapshot-doctor.runtime-DxgUMXUy.js → .setup/crypto-snapshot-doctor.runtime-CMWa1d9Y.mjs}

@@ -1,6 +1,6 @@
-import { T as writeMatrixIdbSnapshotJsonToStore, m as openMatrixIdbSnapshotStoreOptions, o as MATRIX_IDB_SNAPSHOT_FILENAME, x as readMatrixIdbSnapshotJsonFromStore } from "./storage-metadata-DYArLcq1.js";
-import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-B3fZXyF_.js";
-import { r as readLegacyMatrixIdbSnapshotStateUnlocked, t as isValidMatrixIdbSnapshotJson } from "./idb-persistence-DBdwHSWg.js";
+import { b as readMatrixIdbSnapshotJsonFromStore, o as MATRIX_IDB_SNAPSHOT_FILENAME, p as openMatrixIdbSnapshotStoreOptions, w as writeMatrixIdbSnapshotJsonToStore } from "./storage-metadata-fHN6Df2m.mjs";
+import { n as MATRIX_IDB_SNAPSHOT_LOCK_OPTIONS } from "./idb-persistence-lock-B3fZXyF_.mjs";
+import { r as readLegacyMatrixIdbSnapshotStateUnlocked, t as isValidMatrixIdbSnapshotJson } from "./idb-persistence-c8uxcofH.mjs";
 import { randomUUID } from "node:crypto";
 import path from "node:path";
 import fs from "node:fs";

package/dist/{device-health-B4-YXtJR.js → .setup/device-health-CWOuIirq.mjs}

@@ -1,4 +1,4 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
 //#region extensions/matrix/src/matrix/device-health.ts
 var device_health_exports = /* @__PURE__ */ __exportAll({
 	isOpenClawManagedMatrixDevice: () => isOpenClawManagedMatrixDevice,