@openclaw/qqbot 2026.6.11 → 2026.7.1-beta.1

package/dist/api.js

@@ -1,8 +1,8 @@
-import { t as qqbotPlugin } from "./channel-DvWrqcZB.js";
+import { t as qqbotPlugin } from "./channel-Bh0MrYvU.js";
 import { a as resolveQQBotAccount, i as resolveDefaultQQBotAccountId, n as applyQQBotAccountConfig, r as listQQBotAccountIds, t as DEFAULT_ACCOUNT_ID } from "./config-C1qZbh0K.js";
 import { t as qqbotSetupPlugin } from "./channel.setup-CldhUlTO.js";
-import { o as getFrameworkCommands } from "./group-CvVXke_k.js";
-import { n as registerRemindTool, r as registerChannelTool, t as registerQQBotTools } from "./tools-CeUI9pG-.js";
-import { t as registerQQBotFull } from "./channel-entry-BGXFRmbg.js";
-import { C as getMessageReplyConfig, D as OUTBOUND_ERROR_CODES, E as DEFAULT_MEDIA_SEND_ERROR, O as setOutboundAudioPort, S as checkMessageReplyLimit, T as recordMessageReply, _ as sendVideoMsg, a as sendText, b as resolveUserFacingMediaError, f as buildMediaTarget, g as sendPhoto, h as sendDocument, i as sendProactiveMessage, m as resolveOutboundMediaPath, n as sendCronMessage, p as parseTarget, r as sendMedia, v as sendVoice, w as getMessageReplyStats, x as MESSAGE_REPLY_LIMIT } from "./outbound-BQcPCo-z.js";
+import { o as getFrameworkCommands } from "./group-DQQsZ6Y0.js";
+import { C as getMessageReplyConfig, D as OUTBOUND_ERROR_CODES, E as DEFAULT_MEDIA_SEND_ERROR, O as setOutboundAudioPort, S as checkMessageReplyLimit, T as recordMessageReply, _ as sendVideoMsg, a as sendText, b as resolveUserFacingMediaError, f as buildMediaTarget, g as sendPhoto, h as sendDocument, i as sendProactiveMessage, m as resolveOutboundMediaPath, n as sendCronMessage, p as parseTarget, r as sendMedia, v as sendVoice, w as getMessageReplyStats, x as MESSAGE_REPLY_LIMIT } from "./outbound-Dfa2uOEp.js";
+import { n as registerRemindTool, r as registerChannelTool, t as registerQQBotTools } from "./tools-BvXe7bTq.js";
+import { t as registerQQBotFull } from "./channel-entry-LMtNY-J6.js";
 export { DEFAULT_ACCOUNT_ID, DEFAULT_MEDIA_SEND_ERROR, MESSAGE_REPLY_LIMIT, OUTBOUND_ERROR_CODES, applyQQBotAccountConfig, buildMediaTarget, checkMessageReplyLimit, getFrameworkCommands, getMessageReplyConfig, getMessageReplyStats, listQQBotAccountIds, parseTarget, qqbotPlugin, qqbotSetupPlugin, recordMessageReply, registerChannelTool, registerQQBotFull, registerQQBotTools, registerRemindTool, resolveDefaultQQBotAccountId, resolveOutboundMediaPath, resolveQQBotAccount, resolveUserFacingMediaError, sendCronMessage, sendDocument, sendMedia, sendPhoto, sendProactiveMessage, sendText, sendVideoMsg, sendVoice, setOutboundAudioPort };

package/dist/{channel-DvWrqcZB.js → channel-Bh0MrYvU.js}

@@ -1,9 +1,9 @@
 import { t as asOptionalObjectRecord } from "./string-normalize-R_0cKO7Q.js";
 import { a as qqbotSetupAdapterShared, i as qqbotMeta, n as qqbotSetupWizard, o as ensurePlatformAdapter, r as qqbotConfigAdapter, s as getBridgeLogger, t as qqbotChannelConfigSchema } from "./config-schema-gMW9zKvQ.js";
 import { a as resolveQQBotAccount, n as applyQQBotAccountConfig, r as listQQBotAccountIds, t as DEFAULT_ACCOUNT_ID$1 } from "./config-C1qZbh0K.js";
-import { t as getQQBotRuntime } from "./runtime-D1hn91-s.js";
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BYTS8-ia.js";
-import { n as normalizeTarget, s as getQQBotDataPath, t as looksLikeQQBotTarget } from "./target-parser-BdCUmxK7.js";
+import { t as getQQBotRuntime } from "./runtime-BL0xZzWe.js";
+import { n as legacyConfigRules, r as normalizeCompatibilityConfig, t as buildQQBotStateKey } from "./state-keys-CQKlAFyo.js";
+import { n as normalizeTarget, t as looksLikeQQBotTarget } from "./target-parser-DagYRQkP.js";
 import { getExecApprovalReplyMetadata } from "openclaw/plugin-sdk/approval-runtime";
 import { createMessageReceiptFromOutboundResults, defineChannelMessageAdapter } from "openclaw/plugin-sdk/channel-outbound";
 import { sanitizeAssistantVisibleText } from "openclaw/plugin-sdk/text-chunking";
@@ -14,11 +14,6 @@ import { normalizeLowercaseStringOrEmpty, normalizeOptionalString } from "opencl
 import { markImplicitSameChatApprovalAuthorization, resolveApprovalApprovers } from "openclaw/plugin-sdk/approval-auth-runtime";
 import { createChannelExecApprovalProfile, isChannelExecApprovalClientEnabledFromConfig, matchesApprovalRequestFilters } from "openclaw/plugin-sdk/approval-client-runtime";
 import { normalizeAccountId } from "openclaw/plugin-sdk/routing";
-import fs from "node:fs";
-import crypto from "node:crypto";
-import path from "node:path";
-import { loadJsonFile } from "openclaw/plugin-sdk/json-store";
-import { resolveStateDir } from "openclaw/plugin-sdk/state-paths";
 import { resolveChannelGroupToolsPolicy } from "openclaw/plugin-sdk/channel-policy";
 //#region extensions/qqbot/src/engine/approval/index.ts
 function buildExecApprovalText(request) {
@@ -370,7 +365,7 @@ function createQQBotApprovalCapability() {
 			},
 			load: async () => {
 				ensurePlatformAdapter();
-				return (await import("./handler-runtime--OTMkFWa.js")).qqbotApprovalNativeRuntime;
+				return (await import("./handler-runtime-BQ72YPsH.js")).qqbotApprovalNativeRuntime;
 			}
 		})
 	});
@@ -412,41 +407,6 @@ const qqbotDoctor = {
 	normalizeCompatibilityConfig
 };
 //#endregion
-//#region extensions/qqbot/src/engine/utils/data-paths.ts
-/**
-* Centralised filename helpers for persisted QQBot state.
-*
-* Every persistence module routes file paths through these helpers so the
-* naming convention stays in sync and legacy migrations are handled
-* consistently.
-*
-* Key design decisions:
-* - Credential backup is keyed only by `accountId` because recovery runs
-*   exactly when the appId is missing from config.
-*/
-/**
-* Normalise an identifier so it is safe to embed in a filename.
-* Keeps alphanumerics, dot, underscore, dash; everything else becomes `_`.
-*/
-function safeName$1(id) {
-	return id.replace(/[^a-zA-Z0-9._-]/g, "_");
-}
-function getCredentialBackupRoot() {
-	return path.join(resolveStateDir(process.env), "qqbot", "data");
-}
-/**
-* Per-accountId credential backup file. Not keyed by appId because the
-* whole point of this file is to recover credentials when appId is
-* missing from the live config.
-*/
-function getCredentialBackupFile(accountId) {
-	return path.join(getCredentialBackupRoot(), `credential-backup-${safeName$1(accountId)}.json`);
-}
-/** Legacy single-file credential backup (pre-multi-account-isolation). */
-function getLegacyCredentialBackupFile() {
-	return path.join(getCredentialBackupRoot(), "credential-backup.json");
-}
-//#endregion
 //#region extensions/qqbot/src/engine/utils/sqlite-state.ts
 function resolveStoreEnv(options) {
 	if (!options.stateDir) return options.env;
@@ -463,9 +423,6 @@ function openQQBotSyncKeyedStore(options) {
 		...resolveStoreEnv(options) ? { env: resolveStoreEnv(options) } : {}
 	});
 }
-function buildQQBotStateKey(...parts) {
-	return crypto.createHash("sha256").update(JSON.stringify(parts)).digest("hex");
-}
 //#endregion
 //#region extensions/qqbot/src/engine/config/credential-backup.ts
 /**
@@ -481,8 +438,8 @@ function buildQQBotStateKey(...parts) {
 *   - During plugin startup, if the live config has an empty appId or
 *     secret, the gateway consults the backup and restores the values
 *     via the config mutation API.
-*   - Legacy JSON backups are imported on first read, then removed after
-*     SQLite has the canonical copy.
+*   - Legacy JSON backups are imported by `openclaw doctor --fix`, not by
+*     runtime startup.
 *
 * Safety notes:
 *   - Only restore when credentials are **actually empty** — never
@@ -498,53 +455,16 @@ function createCredentialBackupStore() {
 		maxEntries: MAX_CREDENTIAL_BACKUPS
 	});
 }
-function safeName(id) {
-	return id.replace(/[^a-zA-Z0-9._-]/g, "_");
-}
-function getLegacyOsHomeCredentialBackupFile(accountId) {
-	return path.join(getQQBotDataPath("data"), `credential-backup-${safeName(accountId)}.json`);
-}
-function getLegacyOsHomeCredentialBackupFileWithoutAccount() {
-	return path.join(getQQBotDataPath("data"), "credential-backup.json");
-}
 function credentialBackupKey(accountId) {
 	return buildQQBotStateKey("credential-backup", accountId);
 }
 function isUsableBackup(data) {
 	return Boolean(data?.accountId && data.appId && data.clientSecret);
 }
-function loadUsableBackupFromFile(filePath) {
-	const data = loadJsonFile(filePath);
-	return isUsableBackup(data) ? data : null;
-}
-function removeFileQuietly(filePath) {
-	try {
-		fs.unlinkSync(filePath);
-	} catch {}
-}
-function findLegacyBackup(accountId) {
-	const candidates = accountId ? [
-		getCredentialBackupFile(accountId),
-		getLegacyCredentialBackupFile(),
-		getLegacyOsHomeCredentialBackupFile(accountId),
-		getLegacyOsHomeCredentialBackupFileWithoutAccount()
-	] : [getLegacyCredentialBackupFile(), getLegacyOsHomeCredentialBackupFileWithoutAccount()];
-	for (const filePath of candidates) {
-		const data = loadUsableBackupFromFile(filePath);
-		if (!data) continue;
-		if (accountId && data.accountId !== accountId) continue;
-		return {
-			data,
-			filePath
-		};
-	}
-	return null;
-}
 /** Persist a credential snapshot (called once gateway reaches READY). */
 function saveCredentialBackup(accountId, appId, clientSecret) {
 	if (!appId || !clientSecret) return;
 	try {
-		const backupPath = getCredentialBackupFile(accountId);
 		const data = {
 			accountId,
 			appId,
@@ -552,14 +472,13 @@ function saveCredentialBackup(accountId, appId, clientSecret) {
 			savedAt: (/* @__PURE__ */ new Date()).toISOString()
 		};
 		createCredentialBackupStore().register(credentialBackupKey(accountId), data);
-		removeFileQuietly(backupPath);
 	} catch {}
 }
 /**
 * Load a credential snapshot for `accountId`.
 *
-* Consults SQLite first; falls back to shipped JSON backups and imports
-* them when the embedded `accountId` matches the request.
+* Reads SQLite only. Legacy JSON backup import is owned by doctor/setup
+* migration so runtime startup stays canonical-state-only.
 */
 function loadCredentialBackup(accountId) {
 	try {
@@ -567,12 +486,6 @@ function loadCredentialBackup(accountId) {
 			const data = createCredentialBackupStore().lookup(credentialBackupKey(accountId));
 			if (isUsableBackup(data)) return data;
 		}
-		const legacy = findLegacyBackup(accountId);
-		if (legacy) {
-			createCredentialBackupStore().register(credentialBackupKey(legacy.data.accountId), legacy.data);
-			removeFileQuietly(legacy.filePath);
-			return legacy.data;
-		}
 	} catch {}
 	return null;
 }
@@ -934,11 +847,32 @@ function isTableSeparatorLine(line) {
 	const cells = splitTableCells(line);
 	return cells.length > 0 && cells.every((cell) => /^:?-+:?$/.test(cell.trim()));
 }
+function splitTableRowCells(inner) {
+	const cells = [];
+	let current = "";
+	for (let i = 0; i < inner.length; i++) {
+		const char = inner[i];
+		if (char === "\\" && i + 1 < inner.length) {
+			const next = inner[i + 1];
+			current += next === "|" || next === "\\" ? next : `\\${next}`;
+			i++;
+			continue;
+		}
+		if (char === "|") {
+			cells.push(current);
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	cells.push(current);
+	return cells;
+}
 function splitTableCells(line) {
-	return line.trim().slice(1, -1).split("|").map((cell) => cell.trim());
+	return splitTableRowCells(line.trim().slice(1, -1)).map((cell) => cell.trim());
 }
 function splitPartialTableCells(line) {
-	return line.trim().replace(/^\|/, "").split("|").map((cell) => cell.trim()).filter((cell) => cell.length > 0);
+	return splitTableRowCells(line.trim().replace(/^\|/, "")).map((cell) => cell.trim()).filter((cell) => cell.length > 0);
 }
 function mergeRowFragments(pending, next) {
 	return pending ? `${pending}${next}` : next;
@@ -1066,12 +1000,12 @@ function resolveQQBotGroupToolPolicy(params) {
 //#region extensions/qqbot/src/channel.ts
 let gatewayModulePromise;
 function loadGatewayModule() {
-	gatewayModulePromise ??= import("./gateway-CCkrdgaK.js");
+	gatewayModulePromise ??= import("./gateway-BgfQAYxB.js");
 	return gatewayModulePromise;
 }
 let outboundMessagingModulePromise;
 function loadOutboundMessagingModule() {
-	outboundMessagingModulePromise ??= import("./outbound-BQcPCo-z.js").then((n) => n.t);
+	outboundMessagingModulePromise ??= import("./outbound-Dfa2uOEp.js").then((n) => n.t);
 	return outboundMessagingModulePromise;
 }
 function createQQBotSendReceipt(params) {
@@ -1349,4 +1283,4 @@ const qqbotPlugin = {
 	}
 };
 //#endregion
-export { toGatewayAccount as a, matchesQQBotApprovalAccount as c, buildApprovalKeyboard as d, buildExecApprovalText as f, resolveApprovalTarget as h, openQQBotSyncKeyedStore as i, resolveQQBotExecApprovalConfig as l, parseApprovalButtonData as m, createQQBotMarkdownChunker as n, authorizeQQBotApprovalAction as o, buildPluginApprovalText as p, buildQQBotStateKey as r, isQQBotExecApprovalClientEnabled as s, qqbotPlugin as t, shouldHandleQQBotExecApprovalRequest as u };
+export { authorizeQQBotApprovalAction as a, resolveQQBotExecApprovalConfig as c, buildExecApprovalText as d, buildPluginApprovalText as f, toGatewayAccount as i, shouldHandleQQBotExecApprovalRequest as l, resolveApprovalTarget as m, createQQBotMarkdownChunker as n, isQQBotExecApprovalClientEnabled as o, parseApprovalButtonData as p, openQQBotSyncKeyedStore as r, matchesQQBotApprovalAccount as s, qqbotPlugin as t, buildApprovalKeyboard as u };

package/dist/{channel-entry-BGXFRmbg.js → channel-entry-LMtNY-J6.js}

@@ -1,7 +1,7 @@
 import { a as resolveQQBotAccount } from "./config-C1qZbh0K.js";
-import { d as PRIVATE_CHAT_ONLY_TEXT, n as resolveGroupCommandLevelFromAccountConfig, o as getFrameworkCommands } from "./group-CvVXke_k.js";
-import { t as registerQQBotTools } from "./tools-CeUI9pG-.js";
-import { h as sendDocument } from "./outbound-BQcPCo-z.js";
+import { d as PRIVATE_CHAT_ONLY_TEXT, n as resolveGroupCommandLevelFromAccountConfig, o as getFrameworkCommands } from "./group-DQQsZ6Y0.js";
+import { h as sendDocument } from "./outbound-Dfa2uOEp.js";
+import { t as registerQQBotTools } from "./tools-BvXe7bTq.js";
 //#region extensions/qqbot/src/bridge/commands/framework-context-adapter.ts
 /**
 * Default queue snapshot used for framework-registered commands.

package/dist/channel-entry-api.js

@@ -1,2 +1,2 @@
-import { t as registerQQBotFull } from "./channel-entry-BGXFRmbg.js";
+import { t as registerQQBotFull } from "./channel-entry-LMtNY-J6.js";
 export { registerQQBotFull };

package/dist/channel-plugin-api.js

@@ -1,2 +1,2 @@
-import { t as qqbotPlugin } from "./channel-DvWrqcZB.js";
+import { t as qqbotPlugin } from "./channel-Bh0MrYvU.js";
 export { qqbotPlugin };

package/dist/doctor-contract-api.js

@@ -1,2 +1,168 @@
-import { n as normalizeCompatibilityConfig, t as legacyConfigRules } from "./doctor-contract-BYTS8-ia.js";
-export { legacyConfigRules, normalizeCompatibilityConfig };
+import { n as legacyConfigRules, r as normalizeCompatibilityConfig, t as buildQQBotStateKey } from "./state-keys-CQKlAFyo.js";
+import path from "node:path";
+import fs from "node:fs/promises";
+//#region extensions/qqbot/src/state-migrations.ts
+const CREDENTIAL_BACKUPS_NAMESPACE = "credential-backups";
+const MAX_CREDENTIAL_BACKUPS = 1e3;
+function safeName(id) {
+	return id.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+async function fileExists(filePath) {
+	try {
+		return (await fs.lstat(filePath)).isFile();
+	} catch {
+		return false;
+	}
+}
+async function readCredentialBackup(filePath) {
+	try {
+		const parsed = JSON.parse(await fs.readFile(filePath, "utf8"));
+		if (typeof parsed.accountId !== "string" || typeof parsed.appId !== "string" || typeof parsed.clientSecret !== "string" || !parsed.accountId || !parsed.appId || !parsed.clientSecret) return null;
+		return {
+			accountId: parsed.accountId,
+			appId: parsed.appId,
+			clientSecret: parsed.clientSecret,
+			savedAt: typeof parsed.savedAt === "string" && parsed.savedAt ? parsed.savedAt : (/* @__PURE__ */ new Date(0)).toISOString()
+		};
+	} catch {
+		return null;
+	}
+}
+function credentialBackupKey(accountId) {
+	return buildQQBotStateKey("credential-backup", accountId);
+}
+async function credentialBackupCandidates(stateDir) {
+	const dataDir = path.join(stateDir, "qqbot", "data");
+	const accountFiles = [];
+	try {
+		for (const entry of await fs.readdir(dataDir, { withFileTypes: true })) if (entry.isFile() && entry.name.startsWith("credential-backup-") && entry.name.endsWith(".json")) accountFiles.push({
+			sourcePath: path.join(dataDir, entry.name),
+			expectedSafeAccountId: entry.name.slice(18, -5)
+		});
+	} catch {}
+	accountFiles.sort((left, right) => left.sourcePath.localeCompare(right.sourcePath));
+	const singlePath = path.join(dataDir, "credential-backup.json");
+	return await fileExists(singlePath) ? [...accountFiles, { sourcePath: singlePath }] : accountFiles;
+}
+async function readLegacyCredentialBackups(stateDir) {
+	const backups = [];
+	for (const candidate of await credentialBackupCandidates(stateDir)) {
+		const value = await readCredentialBackup(candidate.sourcePath);
+		if (!value || candidate.expectedSafeAccountId !== void 0 && safeName(value.accountId) !== candidate.expectedSafeAccountId) continue;
+		backups.push({
+			sourcePath: candidate.sourcePath,
+			key: credentialBackupKey(value.accountId),
+			value
+		});
+	}
+	return backups;
+}
+async function archiveLegacySource(params) {
+	const archivedPath = `${params.sourcePath}.migrated`;
+	if (await fileExists(archivedPath)) {
+		params.warnings.push(`Left QQBot credential backup in place because ${archivedPath} already exists`);
+		return;
+	}
+	try {
+		await fs.chmod(params.sourcePath, 384);
+	} catch (err) {
+		params.warnings.push(`Failed securing QQBot credential backup legacy source: ${String(err)}`);
+		return;
+	}
+	try {
+		await fs.rename(params.sourcePath, archivedPath);
+		try {
+			await fs.chmod(archivedPath, 384);
+		} catch (err) {
+			params.warnings.push(`Failed securing archived QQBot credential backup legacy source: ${String(err)}`);
+		}
+		params.changes.push(`Archived QQBot credential backup legacy source -> ${archivedPath}`);
+	} catch (err) {
+		params.warnings.push(`Failed archiving QQBot credential backup: ${String(err)}`);
+	}
+}
+function sameCredentialBackup(left, right) {
+	return left?.accountId === right.accountId && left.appId === right.appId && left.clientSecret === right.clientSecret && left.savedAt === right.savedAt;
+}
+async function rollbackCredentialImports(store, inserted, existing) {
+	for (const [key, value] of [...inserted].toReversed()) if (sameCredentialBackup(await store.lookup(key), value)) await store.delete(key);
+	for (const [key, value] of existing) if (await store.lookup(key) === void 0) await store.registerIfAbsent(key, value);
+}
+function findMissingKey(expected, actual) {
+	for (const key of expected) if (!actual.has(key)) return key;
+	return null;
+}
+const stateMigrations = [{
+	id: "qqbot-credential-backups-json-to-plugin-state",
+	label: "QQBot credential backups",
+	async detectLegacyState(params) {
+		const backups = await readLegacyCredentialBackups(params.stateDir);
+		if (backups.length === 0) return null;
+		return { preview: [`- QQBot credential backups: ${backups.length} ${backups.length === 1 ? "file" : "files"} -> plugin state (${CREDENTIAL_BACKUPS_NAMESPACE})`] };
+	},
+	async migrateLegacyState(params) {
+		const changes = [];
+		const warnings = [];
+		const backups = await readLegacyCredentialBackups(params.stateDir);
+		if (backups.length === 0) return {
+			changes,
+			warnings
+		};
+		const selectedByKey = /* @__PURE__ */ new Map();
+		for (const backup of backups) if (!selectedByKey.has(backup.key)) selectedByKey.set(backup.key, backup);
+		const store = params.context.openPluginStateKeyedStore({
+			namespace: CREDENTIAL_BACKUPS_NAMESPACE,
+			maxEntries: MAX_CREDENTIAL_BACKUPS
+		});
+		const existingEntries = await store.entries();
+		const existingValues = new Map(existingEntries.map((entry) => [entry.key, entry.value]));
+		const existingKeys = new Set(existingValues.keys());
+		const missing = [...selectedByKey.values()].filter((backup) => !existingKeys.has(backup.key));
+		const available = MAX_CREDENTIAL_BACKUPS - existingKeys.size;
+		if (missing.length > available) {
+			warnings.push(`Skipped QQBot credential backup migration because plugin state has room for ${available} of ${missing.length} missing entries; left legacy sources in place`);
+			return {
+				changes,
+				warnings
+			};
+		}
+		const expectedKeys = new Set(existingKeys);
+		const inserted = /* @__PURE__ */ new Map();
+		for (const backup of missing) try {
+			if (await store.registerIfAbsent(backup.key, backup.value)) inserted.set(backup.key, backup.value);
+			const missingKey = findMissingKey(new Set(expectedKeys).add(backup.key), new Set((await store.entries()).map((entry) => entry.key)));
+			if (missingKey) {
+				await rollbackCredentialImports(store, inserted, existingValues);
+				warnings.push(`Stopped QQBot credential backup migration because plugin state capacity evicted ${missingKey}; restored credential state and left legacy sources in place`);
+				return {
+					changes,
+					warnings
+				};
+			}
+			expectedKeys.add(backup.key);
+		} catch (err) {
+			try {
+				await rollbackCredentialImports(store, inserted, existingValues);
+			} catch (rollbackErr) {
+				warnings.push(`Failed restoring QQBot credential state after migration error: ${String(rollbackErr)}`);
+			}
+			warnings.push(`Failed migrating QQBot credential backup: ${String(err)}; left legacy sources in place`);
+			return {
+				changes,
+				warnings
+			};
+		}
+		if (inserted.size > 0) changes.push(`Migrated ${inserted.size} QQBot credential ${inserted.size === 1 ? "backup" : "backups"} -> plugin state`);
+		for (const backup of backups) await archiveLegacySource({
+			sourcePath: backup.sourcePath,
+			changes,
+			warnings
+		});
+		return {
+			changes,
+			warnings
+		};
+	}
+}];
+//#endregion
+export { legacyConfigRules, normalizeCompatibilityConfig, stateMigrations };