@openclaw/matrix 2026.9.4 → 2026.9.6

package/dist/.setup/direct-management-B2Bno2xL.mjs

@@ -0,0 +1,346 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
+import { a as MATRIX_REACTION_EVENT_TYPE, i as MATRIX_ANNOTATION_RELATION_TYPE } from "./send-currentness-BrGXL7b8.mjs";
+import { asOptionalRecord, normalizeNullableString, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
+//#region extensions/matrix/src/matrix/send/types.ts
+const MsgType = {
+	Text: "m.text",
+	Image: "m.image",
+	Audio: "m.audio",
+	Video: "m.video",
+	File: "m.file",
+	Notice: "m.notice"
+};
+const RelationType = {
+	Annotation: MATRIX_ANNOTATION_RELATION_TYPE,
+	Replace: "m.replace",
+	Thread: "m.thread"
+};
+const EventType = {
+	Direct: "m.direct",
+	Reaction: MATRIX_REACTION_EVENT_TYPE,
+	RoomMessage: "m.room.message"
+};
+const MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY = "com.openclaw.finalized_preview";
+/**
+* MSC4357 live marker key.
+* When present on event content, signals that the message is still being
+* streamed (e.g. an LLM generating a response). Supporting clients render
+* the message with a streaming animation until an edit without this marker
+* arrives, indicating the stream is complete.
+* @see https://github.com/matrix-org/matrix-spec-proposals/pull/4357
+*/
+const MSC4357_LIVE_KEY = "org.matrix.msc4357.live";
+//#endregion
+//#region extensions/matrix/src/matrix/relations.ts
+function relatedReplyEventId(relation) {
+	const reply = asOptionalRecord(relation?.["m.in_reply_to"]);
+	return typeof reply?.event_id === "string" ? reply.event_id : void 0;
+}
+function buildMatrixMessageRelation(params) {
+	const threadId = params.threadId?.trim();
+	const replyToId = params.replyToId?.trim();
+	const relatedId = replyToId || (threadId ? params.fallbackReplyToId?.trim() : void 0);
+	const reply = relatedId ? { "m.in_reply_to": { event_id: relatedId } } : void 0;
+	if (!threadId) return reply;
+	return {
+		rel_type: RelationType.Thread,
+		event_id: threadId,
+		...reply,
+		...relatedId && !replyToId ? { is_falling_back: true } : {}
+	};
+}
+function resolveMatrixReplyToEventId(content) {
+	const relation = asOptionalRecord(content["m.relates_to"]);
+	return relation?.rel_type === RelationType.Thread && relation.is_falling_back === true ? void 0 : relatedReplyEventId(relation);
+}
+function resolveMatrixThreadRootId(content) {
+	const relation = asOptionalRecord(content["m.relates_to"]);
+	if (relation?.rel_type !== RelationType.Thread) return;
+	return typeof relation.event_id === "string" ? relation.event_id : relatedReplyEventId(relation);
+}
+//#endregion
+//#region extensions/matrix/src/matrix/direct-room.ts
+var direct_room_exports = /* @__PURE__ */ __exportAll({
+	hasDirectMatrixMemberFlag: () => hasDirectMatrixMemberFlag,
+	inspectMatrixDirectRoomEvidence: () => inspectMatrixDirectRoomEvidence,
+	isStrictDirectMembership: () => isStrictDirectMembership,
+	isStrictDirectRoom: () => isStrictDirectRoom,
+	readJoinedMatrixMembers: () => readJoinedMatrixMembers
+});
+function normalizeJoinedMatrixMembers(joinedMembers) {
+	if (!Array.isArray(joinedMembers)) return [];
+	return joinedMembers.map((entry) => normalizeNullableString(entry)).filter((entry) => Boolean(entry));
+}
+function isStrictDirectMembership(params) {
+	const selfUserId = normalizeNullableString(params.selfUserId);
+	const remoteUserId = normalizeNullableString(params.remoteUserId);
+	const joinedMembers = params.joinedMembers ?? [];
+	return Boolean(selfUserId && remoteUserId && joinedMembers.length === 2 && joinedMembers.includes(selfUserId) && joinedMembers.includes(remoteUserId));
+}
+async function readJoinedMatrixMembers(client, roomId) {
+	try {
+		return normalizeJoinedMatrixMembers(await client.getJoinedRoomMembers(roomId));
+	} catch {
+		return null;
+	}
+}
+async function hasDirectMatrixMemberFlag(client, roomId, userId) {
+	const normalizedUserId = normalizeNullableString(userId);
+	if (!normalizedUserId) return null;
+	try {
+		const state = await client.getRoomStateEvent(roomId, "m.room.member", normalizedUserId);
+		if (state?.is_direct === true) return true;
+		if (state?.is_direct === false) return false;
+		return null;
+	} catch {
+		return null;
+	}
+}
+async function inspectMatrixDirectRoomEvidence(params) {
+	const selfUserId = params.selfUserId !== void 0 ? normalizeNullableString(params.selfUserId) : normalizeNullableString(await params.client.getUserId().catch(() => null));
+	const joinedMembers = await readJoinedMatrixMembers(params.client, params.roomId);
+	const strict = isStrictDirectMembership({
+		selfUserId,
+		remoteUserId: params.remoteUserId,
+		joinedMembers
+	});
+	if (!strict) return {
+		joinedMembers,
+		strict: false,
+		viaMemberState: false,
+		memberStateFlag: null
+	};
+	const memberStateFlag = await hasDirectMatrixMemberFlag(params.client, params.roomId, selfUserId);
+	return {
+		joinedMembers,
+		strict,
+		viaMemberState: memberStateFlag === true,
+		memberStateFlag
+	};
+}
+async function isStrictDirectRoom(params) {
+	return (await inspectMatrixDirectRoomEvidence({
+		client: params.client,
+		roomId: params.roomId,
+		remoteUserId: params.remoteUserId,
+		selfUserId: params.selfUserId
+	})).strict;
+}
+//#endregion
+//#region extensions/matrix/src/matrix/direct-management.ts
+var direct_management_exports = /* @__PURE__ */ __exportAll({
+	inspectMatrixDirectRooms: () => inspectMatrixDirectRooms,
+	persistMatrixDirectRoomMapping: () => persistMatrixDirectRoomMapping,
+	promoteMatrixDirectRoomCandidate: () => promoteMatrixDirectRoomCandidate,
+	repairMatrixDirectRooms: () => repairMatrixDirectRooms
+});
+const DIRECT_ACCOUNT_DATA_QUEUE_KEY = EventType.Direct;
+const directAccountDataWriteQueues = /* @__PURE__ */ new WeakMap();
+async function readMatrixDirectAccountData(client) {
+	try {
+		const direct = await client.getAccountData(EventType.Direct);
+		return direct && typeof direct === "object" && !Array.isArray(direct) ? direct : {};
+	} catch {
+		return {};
+	}
+}
+function normalizeRemoteUserId(remoteUserId) {
+	const normalized = normalizeOptionalString(remoteUserId) ?? "";
+	if (!isMatrixQualifiedUserId(normalized)) throw new Error(`Matrix user IDs must be fully qualified (got "${remoteUserId}")`);
+	return normalized;
+}
+function normalizeMappedRoomIds(direct, remoteUserId) {
+	const current = direct[remoteUserId];
+	if (!Array.isArray(current)) return [];
+	const seen = /* @__PURE__ */ new Set();
+	const normalized = [];
+	for (const value of current) {
+		const roomId = normalizeOptionalString(value) ?? "";
+		if (!roomId || seen.has(roomId)) continue;
+		seen.add(roomId);
+		normalized.push(roomId);
+	}
+	return normalized;
+}
+function normalizeRoomIdList(values) {
+	const seen = /* @__PURE__ */ new Set();
+	const normalized = [];
+	for (const value of values) {
+		const roomId = value.trim();
+		if (!roomId || seen.has(roomId)) continue;
+		seen.add(roomId);
+		normalized.push(roomId);
+	}
+	return normalized;
+}
+function hasMatrixDirectRoomMappings(params) {
+	const current = normalizeMappedRoomIds(params.directContent, params.remoteUserId);
+	const next = normalizeRoomIdList([...params.roomIds, ...current]);
+	return current.length === next.length && current.every((roomId, index) => roomId === next[index]);
+}
+function resolveDirectAccountDataWriteQueue(client) {
+	const existing = directAccountDataWriteQueues.get(client);
+	if (existing) return existing;
+	const created = new KeyedAsyncQueue();
+	directAccountDataWriteQueues.set(client, created);
+	return created;
+}
+async function writeMatrixDirectRoomMappings(params) {
+	return await resolveDirectAccountDataWriteQueue(params.client).enqueue(DIRECT_ACCOUNT_DATA_QUEUE_KEY, async () => {
+		const directContentBefore = await readMatrixDirectAccountData(params.client);
+		const directContentAfter = buildNextDirectContent({
+			directContent: directContentBefore,
+			remoteUserId: params.remoteUserId,
+			roomIds: params.roomIds
+		});
+		const changed = !hasMatrixDirectRoomMappings({
+			directContent: directContentBefore,
+			remoteUserId: params.remoteUserId,
+			roomIds: params.roomIds
+		});
+		if (changed) await params.client.setAccountData(EventType.Direct, directContentAfter);
+		return {
+			changed,
+			directContentBefore,
+			directContentAfter
+		};
+	});
+}
+async function classifyDirectRoomCandidate(params) {
+	const evidence = await inspectMatrixDirectRoomEvidence({
+		client: params.client,
+		roomId: params.roomId,
+		remoteUserId: params.remoteUserId,
+		selfUserId: params.selfUserId
+	});
+	return {
+		roomId: params.roomId,
+		joinedMembers: evidence.joinedMembers,
+		strict: evidence.strict && (params.source === "account-data" || evidence.memberStateFlag !== false),
+		explicit: evidence.strict && (params.source === "account-data" || evidence.memberStateFlag !== false) && (params.source === "account-data" || evidence.viaMemberState),
+		source: params.source
+	};
+}
+function buildNextDirectContent(params) {
+	const current = normalizeMappedRoomIds(params.directContent, params.remoteUserId);
+	const nextRooms = normalizeRoomIdList([...params.roomIds, ...current]);
+	return {
+		...params.directContent,
+		[params.remoteUserId]: nextRooms
+	};
+}
+async function persistMatrixDirectRoomMapping(params) {
+	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
+	return (await writeMatrixDirectRoomMappings({
+		client: params.client,
+		remoteUserId,
+		roomIds: [params.roomId]
+	})).changed;
+}
+async function promoteMatrixDirectRoomCandidate(params) {
+	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
+	const evidence = await inspectMatrixDirectRoomEvidence({
+		client: params.client,
+		roomId: params.roomId,
+		remoteUserId,
+		selfUserId: params.selfUserId
+	});
+	if (!evidence.strict) return {
+		classifyAsDirect: false,
+		repaired: false,
+		reason: "not-strict"
+	};
+	if (evidence.memberStateFlag === false) return {
+		classifyAsDirect: false,
+		repaired: false,
+		reason: "local-explicit-false"
+	};
+	try {
+		const repaired = await persistMatrixDirectRoomMapping({
+			client: params.client,
+			remoteUserId,
+			roomId: params.roomId
+		});
+		return {
+			classifyAsDirect: true,
+			repaired,
+			roomId: params.roomId,
+			reason: repaired ? "promoted" : "already-mapped"
+		};
+	} catch {
+		return {
+			classifyAsDirect: true,
+			repaired: false,
+			roomId: params.roomId,
+			reason: "repair-failed"
+		};
+	}
+}
+async function inspectMatrixDirectRooms(params) {
+	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
+	const selfUserId = normalizeOptionalString(await params.client.getUserId().catch(() => null)) ?? null;
+	const mappedRoomIds = normalizeMappedRoomIds(await readMatrixDirectAccountData(params.client), remoteUserId);
+	const mappedRooms = await Promise.all(mappedRoomIds.map(async (roomId) => await classifyDirectRoomCandidate({
+		client: params.client,
+		roomId,
+		remoteUserId,
+		selfUserId,
+		source: "account-data"
+	})));
+	const mappedStrict = mappedRooms.find((room) => room.strict);
+	let joinedRooms = [];
+	if (typeof params.client.getJoinedRooms === "function") try {
+		const resolved = await params.client.getJoinedRooms();
+		joinedRooms = Array.isArray(resolved) ? resolved : [];
+	} catch {
+		joinedRooms = [];
+	}
+	const discoveredStrictRooms = [];
+	for (const roomId of normalizeRoomIdList(joinedRooms)) {
+		if (mappedRoomIds.includes(roomId)) continue;
+		const candidate = await classifyDirectRoomCandidate({
+			client: params.client,
+			roomId,
+			remoteUserId,
+			selfUserId,
+			source: "joined"
+		});
+		if (candidate.strict) discoveredStrictRooms.push(candidate);
+	}
+	const discoveredStrictRoomIds = discoveredStrictRooms.map((room) => room.roomId);
+	const discoveredExplicit = discoveredStrictRooms.find((room) => room.explicit);
+	return {
+		selfUserId,
+		remoteUserId,
+		mappedRoomIds,
+		mappedRooms,
+		discoveredStrictRoomIds,
+		activeRoomId: mappedStrict?.roomId ?? discoveredExplicit?.roomId ?? discoveredStrictRoomIds[0] ?? null
+	};
+}
+async function repairMatrixDirectRooms(params) {
+	const remoteUserId = normalizeRemoteUserId(params.remoteUserId);
+	const inspected = await inspectMatrixDirectRooms({
+		client: params.client,
+		remoteUserId
+	});
+	const activeRoomId = inspected.activeRoomId ?? await params.client.createDirectRoom(remoteUserId, { encrypted: params.encrypted === true });
+	const createdRoomId = inspected.activeRoomId ? null : activeRoomId;
+	const mappingWrite = await writeMatrixDirectRoomMappings({
+		client: params.client,
+		remoteUserId,
+		roomIds: [activeRoomId, ...inspected.discoveredStrictRoomIds]
+	});
+	return {
+		...inspected,
+		activeRoomId,
+		createdRoomId,
+		changed: mappingWrite.changed,
+		directContentBefore: mappingWrite.directContentBefore,
+		directContentAfter: mappingWrite.directContentAfter
+	};
+}
+//#endregion
+export { MsgType as _, repairMatrixDirectRooms as a, isStrictDirectMembership as c, buildMatrixMessageRelation as d, resolveMatrixReplyToEventId as f, MSC4357_LIVE_KEY as g, MATRIX_OPENCLAW_FINALIZED_PREVIEW_KEY as h, promoteMatrixDirectRoomCandidate as i, isStrictDirectRoom as l, EventType as m, inspectMatrixDirectRooms as n, direct_room_exports as o, resolveMatrixThreadRootId as p, persistMatrixDirectRoomMapping as r, hasDirectMatrixMemberFlag as s, direct_management_exports as t, readJoinedMatrixMembers as u, RelationType as v };

package/dist/{directory-live-B8-GAVcc.js → .setup/directory-live-CxqkcYbT.mjs}

@@ -1,8 +1,8 @@
-import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
-import { r as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.js";
-import { l as resolveMatrixAuth } from "./client-CPcRv6ab.js";
-import { t as MatrixAuthedHttpClient } from "./http-client-BfPeF4CE.js";
-import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.mjs";
+import { r as normalizeMatrixMessagingTarget, t as isMatrixQualifiedUserId } from "./target-ids-Nwx7cMVE.mjs";
+import { d as resolveMatrixAuth } from "./client-ChrXpxos.mjs";
+import { t as MatrixAuthedHttpClient } from "./http-client-Bi6uKmzh.mjs";
+import { isRecord, normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "openclaw/plugin-sdk/string-coerce-runtime";
 //#region extensions/matrix/src/directory-live.ts
 var directory_live_exports = /* @__PURE__ */ __exportAll({
 	listMatrixDirectoryGroupsLive: () => listMatrixDirectoryGroupsLive,
@@ -43,12 +43,14 @@ function createGroupDirectoryEntry(params) {
 	};
 }
 async function requestMatrixJson(client, params) {
-	return await client.requestJson({
+	const result = await client.requestJson({
 		method: params.method,
 		endpoint: params.endpoint,
 		body: params.body,
 		timeoutMs: MATRIX_DIRECTORY_TIMEOUT_MS
 	});
+	if (!isRecord(result)) throw new Error(`Matrix homeserver returned a non-object JSON response for ${params.endpoint}`);
+	return result;
 }
 async function listMatrixDirectoryPeersLive(params) {
 	const query = normalizeOptionalString(params.query) ?? "";

package/dist/{doctor-CJE8wO6y.js → .setup/doctor-BLCvdOFo.mjs}

@@ -1,4 +1,4 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-HyWFZQVG.js";
+import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-HyWFZQVG.mjs";
 import { detectPluginInstallPathIssue, formatPluginInstallPathIssue, removePluginFromConfig } from "openclaw/plugin-sdk/doctor-repair-runtime";
 //#region extensions/matrix/src/doctor.ts
 async function collectMatrixInstallPathWarnings(cfg) {

package/dist/{draft-stream--NdEtnZ8.js → .setup/draft-stream-y0Vq5f38.mjs}

@@ -1,6 +1,6 @@
-import { a as sendSingleTextMessageMatrix, m as prepareMatrixSingleText, t as editMessageMatrix } from "./send-UWLIQ0bG.js";
-import { i as MsgType } from "./types-DzSc7Sqm.js";
-import { createFinalizableDraftStreamControlsForState } from "openclaw/plugin-sdk/channel-outbound";
+import { _ as MsgType } from "./direct-management-B2Bno2xL.mjs";
+import { a as sendSingleTextMessageMatrix, m as prepareMatrixSingleText, t as editMessageMatrix } from "./send-aVdC5NJO.mjs";
+import { createFinalizableDraftLifecycle } from "openclaw/plugin-sdk/channel-outbound";
 //#region extensions/matrix/src/matrix/draft-stream.ts
 const DEFAULT_THROTTLE_MS = 1e3;
 function resolveDraftPreviewOptions(mode) {
@@ -82,10 +82,22 @@ function createMatrixDraftStream(params) {
 			return false;
 		}
 	};
-	const { loop, update, stop: stopDraft, discardPending } = createFinalizableDraftStreamControlsForState({
+	const { loop, update, stop: stopDraft, discardPending, seal, clear, retire, cleanupPending } = createFinalizableDraftLifecycle({
 		throttleMs: DEFAULT_THROTTLE_MS,
 		state: streamState,
-		sendOrEditStreamMessage: sendOrEdit
+		sendOrEditStreamMessage: sendOrEdit,
+		readMessageId: () => currentEventId,
+		clearMessageId: () => {
+			currentEventId = void 0;
+			lastSentText = "";
+			lastSentContent = "";
+		},
+		isValidMessageId: (id) => typeof id === "string" && id.length > 0,
+		deleteMessage: async (id) => {
+			await client.redactEvent(roomId, id);
+		},
+		warn: log,
+		warnPrefix: "matrix draft preview cleanup failed"
 	});
 	log?.(`draft-stream: ready (throttleMs=${DEFAULT_THROTTLE_MS})`);
 	const finalizeLive = async () => {
@@ -134,14 +146,18 @@ function createMatrixDraftStream(params) {
 	const deleteCurrentMessage = async () => {
 		loop.resetPending();
 		await loop.waitForInFlight();
-		if (currentEventId) await client.redactEvent(roomId, currentEventId);
+		const retiredEventId = currentEventId;
 		resetCurrentMessage();
+		if (retiredEventId) await retire(retiredEventId);
 	};
 	return {
 		update,
 		flush: loop.flush,
 		stop,
 		discardPending,
+		seal,
+		clear,
+		cleanupPending,
 		deleteCurrentMessage,
 		finalizeLive,
 		reset,

package/dist/{encryption-guidance-mDyxJV9U.js → .setup/encryption-guidance-CMWXiBzJ.mjs}

@@ -1,5 +1,5 @@
-import { o as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-Bbtc483D.js";
-import { t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.js";
+import { s as resolveMatrixDefaultOrOnlyAccountId } from "./account-selection-BHkfU1eC.mjs";
+import { t as resolveMatrixConfigFieldPath } from "./config-paths-CnREYb1Y.mjs";
 import { normalizeOptionalAccountId } from "openclaw/plugin-sdk/account-id";
 //#region extensions/matrix/src/matrix/encryption-guidance.ts
 function resolveMatrixEncryptionConfigPath(cfg, accountId) {

package/dist/.setup/file-sync-store-CsalA4yI.mjs

@@ -0,0 +1,213 @@
+import { t as getMatrixRuntime } from "./runtime-1kn1P6io.mjs";
+import { t as claimCurrentTokenStorageState } from "./storage-BXaFc0S4.mjs";
+import { c as writeMatrixSyncCacheStateToStore, i as openMatrixSyncCacheStoreOptions, n as deleteMatrixSyncCacheStateFromStore, o as readPersistedStoreFromStore } from "./sync-cache-state-BMtGMxU1.mjs";
+import { n as LogService } from "./logger-xBjiRIp1.mjs";
+import { MemoryStore, SyncAccumulator } from "matrix-js-sdk/lib/matrix.js";
+//#region extensions/matrix/src/matrix/async-lock.ts
+function createAsyncLock() {
+	let lock = Promise.resolve();
+	return async function withLock(fn) {
+		const previous = lock;
+		let release;
+		lock = new Promise((resolve) => {
+			release = resolve;
+		});
+		await previous;
+		try {
+			return await fn();
+		} finally {
+			release?.();
+		}
+	};
+}
+//#endregion
+//#region extensions/matrix/src/matrix/client/file-sync-store.ts
+const PERSIST_DEBOUNCE_MS = 250;
+function cloneJson(value) {
+	return structuredClone(value);
+}
+function syncDataToSyncResponse(syncData) {
+	return {
+		next_batch: syncData.nextBatch,
+		rooms: syncData.roomsData,
+		account_data: { events: syncData.accountData }
+	};
+}
+var SqliteBackedMatrixSyncStore = class SqliteBackedMatrixSyncStore extends MemoryStore {
+	static async create(storageRootDir) {
+		let store;
+		let persisted = null;
+		let unavailableError;
+		try {
+			store = getMatrixRuntime().state.openKeyedStore(openMatrixSyncCacheStoreOptions(storageRootDir));
+			persisted = await readPersistedStoreFromStore({
+				storageRootDir,
+				store
+			});
+		} catch (error) {
+			unavailableError = error;
+			LogService.warn("MatrixSyncCacheStore", "Failed to load Matrix sync cache:", error);
+		}
+		return new SqliteBackedMatrixSyncStore(storageRootDir, store, persisted, unavailableError);
+	}
+	constructor(storageRootDir, store, persisted, storeUnavailableError) {
+		super();
+		this.storageRootDir = storageRootDir;
+		this.store = store;
+		this.storeUnavailableError = storeUnavailableError;
+		this.persistLock = createAsyncLock();
+		this.accumulator = new SyncAccumulator();
+		this.savedSync = null;
+		this.cleanShutdown = false;
+		this.dirty = false;
+		this.frozen = false;
+		this.persistTimer = null;
+		this.persistPromise = null;
+		const restoredSavedSync = persisted?.savedSync ?? null;
+		const restoredClientOptions = persisted?.clientOptions;
+		const restoredCleanShutdown = persisted?.cleanShutdown === true;
+		this.savedSync = restoredSavedSync;
+		this.savedClientOptions = restoredClientOptions;
+		this.hadSavedSyncOnLoad = restoredSavedSync !== null;
+		this.hadCleanShutdownOnLoad = this.hadSavedSyncOnLoad && restoredCleanShutdown;
+		this.cleanShutdown = this.hadCleanShutdownOnLoad;
+		if (this.savedSync) {
+			this.accumulator.accumulate(syncDataToSyncResponse(this.savedSync), true);
+			super.setSyncToken(this.savedSync.nextBatch);
+		}
+		if (this.savedClientOptions) super.storeClientOptions(this.savedClientOptions);
+	}
+	hasSavedSync() {
+		return this.hadSavedSyncOnLoad;
+	}
+	hasSavedSyncFromCleanShutdown() {
+		return this.hadCleanShutdownOnLoad;
+	}
+	getSavedSync() {
+		return Promise.resolve(this.savedSync ? cloneJson(this.savedSync) : null);
+	}
+	getSavedSyncToken() {
+		return Promise.resolve(this.savedSync?.nextBatch ?? null);
+	}
+	setSyncData(syncData) {
+		if (this.frozen) return Promise.resolve();
+		this.accumulator.accumulate(syncData);
+		this.savedSync = this.accumulator.getJSON();
+		this.markDirtyAndSchedulePersist();
+		return Promise.resolve();
+	}
+	getClientOptions() {
+		return Promise.resolve(this.savedClientOptions ? cloneJson(this.savedClientOptions) : void 0);
+	}
+	storeClientOptions(options) {
+		if (this.frozen) return Promise.resolve();
+		this.savedClientOptions = cloneJson(options);
+		super.storeClientOptions(options);
+		this.markDirtyAndSchedulePersist();
+		return Promise.resolve();
+	}
+	save(force = false) {
+		if (force) return this.flush();
+		return Promise.resolve();
+	}
+	wantsSave() {
+		return false;
+	}
+	async deleteAllData() {
+		const store = this.requireStore();
+		if (this.persistTimer) {
+			clearTimeout(this.persistTimer);
+			this.persistTimer = null;
+		}
+		this.dirty = false;
+		await this.enqueuePersistence(async () => {
+			await super.deleteAllData();
+			this.savedSync = null;
+			this.savedClientOptions = void 0;
+			this.cleanShutdown = false;
+			this.dirty = false;
+			await deleteMatrixSyncCacheStateFromStore({
+				storageRootDir: this.storageRootDir,
+				store
+			});
+		});
+	}
+	markCleanShutdown() {
+		this.cleanShutdown = true;
+		this.dirty = true;
+	}
+	async freezeSyncCursorPersistence() {
+		this.frozen = true;
+		if (this.persistTimer) {
+			clearTimeout(this.persistTimer);
+			this.persistTimer = null;
+		}
+		while (this.persistPromise) await this.persistPromise;
+	}
+	discardPendingSyncCursorPersistence() {
+		this.frozen = true;
+		if (this.persistTimer) {
+			clearTimeout(this.persistTimer);
+			this.persistTimer = null;
+		}
+		this.cleanShutdown = false;
+		this.dirty = false;
+	}
+	async flush() {
+		if (this.persistTimer) {
+			clearTimeout(this.persistTimer);
+			this.persistTimer = null;
+		}
+		while (this.dirty || this.persistPromise) {
+			if (this.dirty && !this.persistPromise) this.enqueuePersistence(() => this.persist());
+			await this.persistPromise;
+		}
+	}
+	markDirtyAndSchedulePersist() {
+		if (this.frozen) return;
+		this.cleanShutdown = false;
+		this.dirty = true;
+		if (this.persistTimer) return;
+		this.persistTimer = setTimeout(() => {
+			this.persistTimer = null;
+			this.flush().catch((err) => {
+				LogService.warn("MatrixSyncCacheStore", "Failed to persist Matrix sync store:", err);
+			});
+		}, PERSIST_DEBOUNCE_MS);
+		this.persistTimer.unref?.();
+	}
+	async persist() {
+		const store = this.requireStore();
+		this.dirty = false;
+		const payload = {
+			version: 1,
+			savedSync: this.savedSync ? cloneJson(this.savedSync) : null,
+			cleanShutdown: this.cleanShutdown,
+			...this.savedClientOptions ? { clientOptions: cloneJson(this.savedClientOptions) } : {}
+		};
+		try {
+			await writeMatrixSyncCacheStateToStore({
+				storageRootDir: this.storageRootDir,
+				payload,
+				store
+			});
+			await claimCurrentTokenStorageState({ rootDir: this.storageRootDir });
+		} catch (err) {
+			this.dirty = true;
+			throw err;
+		}
+	}
+	enqueuePersistence(operation) {
+		const pending = this.persistLock(operation).finally(() => {
+			if (this.persistPromise === pending) this.persistPromise = null;
+		});
+		this.persistPromise = pending;
+		return pending;
+	}
+	requireStore() {
+		if (this.store && this.storeUnavailableError == null) return this.store;
+		throw new Error("Matrix sync cache SQLite store is unavailable; cannot persist sync state", { cause: this.storeUnavailableError });
+	}
+};
+//#endregion
+export { SqliteBackedMatrixSyncStore };