@delta-comic/plugin 2.1.0 → 3.0.0-next.4

package/dist/global-B4SQiBzS.mjs

@@ -0,0 +1,1446 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { l as releasePluginObjectUrls, o as isTauriRuntime, u as removePluginFiles } from "./storage-DMKDlPzl.mjs";
+import { isFunction } from "es-toolkit/compat";
+import { db, useConfig } from "@delta-comic/db";
+import { computed, h, markRaw, ref, shallowReactive, shallowRef } from "vue";
+import { SourcedKeyMap, uni } from "@delta-comic/model";
+import { createDownloadMessage, environmentRegistry } from "@delta-comic/ui";
+import { SharedFunction } from "@delta-comic/utils";
+import { compressToEncodedURIComponent, decompressFromEncodedURIComponent } from "lz-string";
+import { logger } from "@delta-comic/logger";
+import { Mutex, isString } from "es-toolkit";
+//#region lib/plugin/index.ts
+/**
+* 这仅是个辅助定义的函数，没有副作用
+*/
+const definePlugin = (config) => {
+	if (isFunction(config)) return config;
+	return () => config;
+};
+/** Defines a trusted plugin that is bundled with the application. */
+const defineInnerPlugin = (definition) => definition;
+//#endregion
+//#region lib/configPointer.ts
+var ConfigPointer = class {
+	pluginName;
+	config;
+	configName;
+	key;
+	constructor(pluginName, config, configName) {
+		this.pluginName = pluginName;
+		this.config = config;
+		this.configName = configName;
+		this.key = Symbol.for(`config:${pluginName}`);
+	}
+};
+//#endregion
+//#region lib/features/core/config.ts
+const coreConfig = new ConfigPointer("core", {
+	recordHistory: {
+		type: "switch",
+		defaultValue: true,
+		info: "settings.core.recordHistory"
+	},
+	showAIProject: {
+		type: "switch",
+		defaultValue: true,
+		info: "settings.core.showAiWorks"
+	},
+	darkMode: {
+		type: "radio",
+		defaultValue: "system",
+		info: "settings.core.theme.title",
+		comp: "select",
+		selects: [
+			{
+				label: "settings.core.theme.light",
+				value: "light"
+			},
+			{
+				label: "settings.core.theme.dark",
+				value: "dark"
+			},
+			{
+				label: "settings.core.systemDefault",
+				value: "system"
+			}
+		]
+	},
+	language: {
+		type: "radio",
+		defaultValue: "system",
+		info: "settings.core.language.title",
+		comp: "select",
+		selects: [
+			{
+				label: "settings.core.language.zhCN",
+				value: "zh-CN"
+			},
+			{
+				label: "settings.core.language.zhTW",
+				value: "zh-TW"
+			},
+			{
+				label: "settings.core.language.enUS",
+				value: "en-US"
+			},
+			{
+				label: "settings.core.systemDefault",
+				value: "system"
+			}
+		]
+	},
+	easilyTitle: {
+		type: "switch",
+		defaultValue: false,
+		info: "settings.core.simplifiedTitle"
+	},
+	githubToken: {
+		type: "string",
+		defaultValue: "",
+		info: "settings.core.githubToken.title",
+		placeholder: "settings.core.githubToken.placeholder"
+	},
+	receivePerReleaseUpdate: {
+		type: "switch",
+		defaultValue: false,
+		info: "settings.core.prereleaseUpdates"
+	},
+	cloudEnabled: {
+		type: "switch",
+		defaultValue: false,
+		info: "settings.core.cloud.enabled"
+	},
+	cloudServerUrl: {
+		type: "string",
+		defaultValue: "",
+		info: "settings.core.cloud.serverUrl",
+		placeholder: "settings.core.cloud.serverUrlPlaceholder"
+	},
+	installOverride: {
+		type: "pairs",
+		defaultValue: [],
+		info: "settings.core.installOverride",
+		required: true
+	}
+}, "settings.core.title");
+//#endregion
+//#region lib/config.ts
+var ConfigStore = class {
+	form = shallowReactive(/* @__PURE__ */ new Map());
+	darkMode = computed(() => {
+		if (!this.$isExistConfig(coreConfig)) return this.isSystemDark;
+		switch (this.$load(coreConfig).data.value.darkMode) {
+			case "light": return false;
+			case "dark": return true;
+			default: return this.isSystemDark;
+		}
+	});
+	isSystemDark = globalThis.matchMedia?.("(prefers-color-scheme: dark)").matches ?? false;
+	get isDark() {
+		return this.darkMode.value;
+	}
+	constructor() {
+		this.$registerConfig(coreConfig);
+	}
+	$load(pointer) {
+		const value = this.form.get(pointer.key);
+		if (!value) throw new Error(`not found config by plugin "${pointer.pluginName}"`);
+		return value;
+	}
+	$loadApp() {
+		return this.$load(coreConfig);
+	}
+	$isExistConfig(pointer) {
+		return this.form.has(pointer.key);
+	}
+	$registerConfig(pointer) {
+		const registered = this.form.get(pointer.key);
+		if (registered) return registered;
+		const store = useConfig(pointer.pluginName, pointer.config);
+		const saved = {
+			form: pointer.config,
+			data: store,
+			name: pointer.configName,
+			ready: store.ready
+		};
+		this.form.set(pointer.key, saved);
+		return saved;
+	}
+	/** @deprecated Use `$registerConfig`. */
+	$resignerConfig(pointer) {
+		return this.$registerConfig(pointer);
+	}
+	$unregisterConfig(pointer) {
+		this.form.delete(pointer.key);
+	}
+};
+let configStore;
+const useConfig$1 = () => configStore ??= new ConfigStore();
+//#endregion
+//#region lib/depends.ts
+const exposeSymbol = (name) => Symbol.for(`expose:${name}`);
+const declareDepType = (name) => exposeSymbol(name);
+var DependencyRegistry = class {
+	exposes;
+	constructor(exposes = /* @__PURE__ */ new Map()) {
+		this.exposes = exposes;
+	}
+	provide(define, value) {
+		this.exposes.set(define, value);
+		return value;
+	}
+	require(define) {
+		if (!this.exposes.has(define)) {
+			const name = Symbol.keyFor(define) ?? define.description ?? define.toString();
+			throw new Error(`not found plugin expose "${name}"`);
+		}
+		return this.exposes.get(define);
+	}
+	has(define) {
+		return this.exposes.has(define);
+	}
+	delete(define) {
+		return this.exposes.delete(define);
+	}
+	clear() {
+		this.exposes.clear();
+	}
+};
+const pluginExposes = /* @__PURE__ */ new Map();
+const defaultDependencyRegistry = new DependencyRegistry(pluginExposes);
+const createDependencyRegistry = () => new DependencyRegistry();
+const provide = (define, value) => defaultDependencyRegistry.provide(define, value);
+const require = (define) => defaultDependencyRegistry.require(define);
+//#endregion
+//#region lib/i18n.ts
+const messageKeyPrefix = "i18n:";
+const unsafeKeys = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+const mergeMessages = (target, source) => {
+	if (!source) return target;
+	for (const [key, value] of Object.entries(source)) {
+		if (unsafeKeys.has(key)) continue;
+		if (typeof value === "string") {
+			target[key] = value;
+			continue;
+		}
+		const current = target[key];
+		target[key] = mergeMessages(typeof current === "object" ? { ...current } : {}, value);
+	}
+	return target;
+};
+var PluginI18nRegistry = class {
+	adapter;
+	baseMessages = {};
+	pluginMessages = /* @__PURE__ */ new Map();
+	install(adapter, baseMessages) {
+		this.adapter = adapter;
+		this.baseMessages = baseMessages;
+		this.refresh(this.locales());
+	}
+	register(plugin, messages) {
+		const previous = this.pluginMessages.get(plugin);
+		this.pluginMessages.delete(plugin);
+		this.pluginMessages.set(plugin, messages);
+		this.refresh(/* @__PURE__ */ new Set([...Object.keys(previous ?? {}), ...Object.keys(messages)]));
+	}
+	remove(plugin) {
+		const messages = this.pluginMessages.get(plugin);
+		if (!messages) return;
+		this.pluginMessages.delete(plugin);
+		this.refresh(new Set(Object.keys(messages)));
+	}
+	translate(key, params) {
+		return this.adapter?.translate?.(key, params) ?? key;
+	}
+	compose(locale) {
+		const message = mergeMessages({}, this.baseMessages[locale]);
+		for (const messages of this.pluginMessages.values()) mergeMessages(message, messages[locale]);
+		return message;
+	}
+	locales() {
+		const locales = new Set(Object.keys(this.baseMessages));
+		for (const messages of this.pluginMessages.values()) for (const locale of Object.keys(messages)) locales.add(locale);
+		return locales;
+	}
+	refresh(locales) {
+		if (!this.adapter) return;
+		for (const locale of locales) this.adapter.setLocaleMessage(locale, this.compose(locale));
+	}
+};
+const pluginI18n = new PluginI18nRegistry();
+const pluginMessageKey = (key) => `${messageKeyPrefix}${key}`;
+const translatePluginText = (value) => value.startsWith(messageKeyPrefix) ? pluginI18n.translate(value.slice(5)) : value;
+//#endregion
+//#region lib/driver/store.ts
+const pluginStoreLogger = logger.scoped("plugin:store");
+var PluginStore = class {
+	plugins = shallowReactive(/* @__PURE__ */ new Map());
+	/** Plugins whose complete boot pipeline has completed successfully. */
+	ready = shallowReactive(/* @__PURE__ */ new Set());
+	revision = shallowRef(0);
+	pluginNames = shallowReactive(/* @__PURE__ */ new Map());
+	/**
+	* Returns true only when every registered booter has completed successfully.
+	*
+	* `plugins.has()` intentionally is not used here: the config is inserted before
+	* the first booter runs and can therefore describe a partially initialized plugin.
+	*/
+	$isLoaded(plugin) {
+		return this.ready.has(plugin);
+	}
+	/** Starts a new load generation and invalidates the previous readiness state. */
+	$markLoading(plugin) {
+		this.ready.delete(plugin);
+	}
+	/** Marks a plugin ready after all booters have completed. */
+	$markReady(plugin) {
+		this.ready.add(plugin);
+	}
+	/** Removes all lifecycle state for a plugin. */
+	$markUnloaded(plugin) {
+		this.ready.delete(plugin);
+	}
+	async $refreshI18nNames() {
+		const names = await db.selectFrom("plugin").select(["pluginName", "displayName"]).execute();
+		this.pluginNames.clear();
+		for (const plugin of names) this.pluginNames.set(plugin.pluginName, plugin.displayName);
+		pluginStoreLogger.debug("plugin display names refreshed", { count: names.length });
+	}
+	$getI18nName(key) {
+		return translatePluginText(this.pluginNames.get(key) || key);
+	}
+	async $upsertArchives(archives) {
+		if (archives.length === 0) return;
+		await db.replaceInto("plugin").values(archives.map((archive) => ({
+			...archive,
+			meta: JSON.stringify(archive.meta)
+		}))).execute();
+		await this.$refreshI18nNames();
+		this.$touch();
+		pluginStoreLogger.info("plugin archives persisted", { count: archives.length });
+	}
+	$touch() {
+		this.revision.value++;
+	}
+};
+const pluginStore = new PluginStore();
+const usePluginStore = () => pluginStore;
+//#endregion
+//#region lib/driver/loadPlan.ts
+const getDependencyNames = (plugin) => plugin.meta.require.map((dep) => dep.id);
+const canonicalCycleKey = (cycle) => {
+	const nodes = cycle.slice(0, -1);
+	const rotations = nodes.map((_, index) => nodes.slice(index).concat(nodes.slice(0, index)));
+	rotations.sort((a, b) => a.join("\0").localeCompare(b.join("\0")));
+	return rotations[0].join("\0");
+};
+const findCyclePaths = (plugins) => {
+	const pluginNames = new Set(plugins.map((plugin) => plugin.pluginName));
+	const dependencies = new Map(plugins.map((plugin) => [plugin.pluginName, getDependencyNames(plugin).filter((dep) => pluginNames.has(dep))]));
+	const state = /* @__PURE__ */ new Map();
+	const path = [];
+	const cycleKeys = /* @__PURE__ */ new Set();
+	const cycles = [];
+	const visit = (pluginName) => {
+		state.set(pluginName, "visiting");
+		path.push(pluginName);
+		for (const dependencyName of dependencies.get(pluginName) ?? []) {
+			const dependencyState = state.get(dependencyName);
+			if (dependencyState === "visiting") {
+				const cycleStart = path.lastIndexOf(dependencyName);
+				if (cycleStart === -1) continue;
+				const cycle = path.slice(cycleStart).concat(dependencyName);
+				const key = canonicalCycleKey(cycle);
+				if (!cycleKeys.has(key)) {
+					cycleKeys.add(key);
+					cycles.push(cycle);
+				}
+				continue;
+			}
+			if (dependencyState !== "visited") visit(dependencyName);
+		}
+		path.pop();
+		state.set(pluginName, "visited");
+	};
+	for (const plugin of plugins) if (!state.has(plugin.pluginName)) visit(plugin.pluginName);
+	return cycles;
+};
+const planPluginLoadOrder = (plugins) => {
+	const nameToPlugin = new Map(plugins.map((plugin) => [plugin.pluginName, plugin]));
+	const inDegree = /* @__PURE__ */ new Map();
+	const adjacency = /* @__PURE__ */ new Map();
+	const missing = [];
+	for (const plugin of plugins) {
+		const installedDependencies = getDependencyNames(plugin).filter((dependencyName) => {
+			const isInstalled = nameToPlugin.has(dependencyName);
+			if (!isInstalled) missing.push({
+				pluginName: plugin.pluginName,
+				dependencyName
+			});
+			return isInstalled;
+		});
+		inDegree.set(plugin.pluginName, installedDependencies.length);
+		for (const dependencyName of installedDependencies) {
+			const dependents = adjacency.get(dependencyName) ?? [];
+			dependents.push(plugin.pluginName);
+			adjacency.set(dependencyName, dependents);
+		}
+	}
+	const queue = [...inDegree.entries()].filter(([, degree]) => degree === 0).map(([pluginName]) => pluginName);
+	const levels = [];
+	while (queue.length > 0) {
+		const levelSize = queue.length;
+		const level = [];
+		for (let index = 0; index < levelSize; index++) {
+			const pluginName = queue.shift();
+			if (!pluginName) continue;
+			const plugin = nameToPlugin.get(pluginName);
+			if (plugin) level.push(plugin);
+			for (const dependentName of adjacency.get(pluginName) ?? []) {
+				const newDegree = (inDegree.get(dependentName) ?? 0) - 1;
+				inDegree.set(dependentName, newDegree);
+				if (newDegree === 0) queue.push(dependentName);
+			}
+		}
+		if (level.length > 0) levels.push(level);
+	}
+	const unresolved = plugins.filter((plugin) => (inDegree.get(plugin.pluginName) ?? 0) > 0);
+	return {
+		levels,
+		missing,
+		cycles: findCyclePaths(unresolved)
+	};
+};
+const formatPluginLoadPlanError = (plan, translate = (key, params) => pluginI18n.translate(key, params)) => {
+	const sections = [];
+	if (plan.missing.length > 0) {
+		const missing = plan.missing.map(({ pluginName, dependencyName }) => `${pluginName} -> ${dependencyName}`).join("\n");
+		sections.push(translate("plugin.runtime.errors.missingDependencies", { missing }));
+	}
+	if (plan.cycles.length > 0) {
+		const paths = plan.cycles.map((path) => path.join(" -> ")).join("\n");
+		sections.push(translate("plugin.runtime.errors.dependencyCycles", { paths }));
+	}
+	return sections.join("\n\n");
+};
+//#endregion
+//#region lib/features/core/feature.ts
+var feature_default = defineInnerPlugin({
+	meta: {
+		kind: "preboot",
+		author: "Delta Comic",
+		description: pluginMessageKey("plugin.core.description"),
+		require: [],
+		name: {
+			display: pluginMessageKey("settings.core.title"),
+			id: "core"
+		},
+		version: {
+			plugin: "2.3.0",
+			supportCore: "*"
+		}
+	},
+	enabledByDefault: true,
+	config: () => ({
+		name: "core",
+		config: [coreConfig]
+	})
+});
+//#endregion
+//#region lib/features/registry.ts
+const rawDefinitions = /* #__PURE__ */ Object.assign({ "./core/feature.ts": feature_default });
+const createBuiltInPluginRegistry = (definitions) => {
+	const registry = /* @__PURE__ */ new Map();
+	for (const definition of definitions) {
+		const pluginName = definition.meta.name.id;
+		if (!pluginName) throw new Error("built-in plugin id cannot be empty");
+		if (registry.has(pluginName)) throw new Error(`duplicate built-in plugin: ${pluginName}`);
+		registry.set(pluginName, definition);
+	}
+	return registry;
+};
+const builtInPluginRegistry = createBuiltInPluginRegistry(Object.values(rawDefinitions));
+//#endregion
+//#region lib/driver/builtIn.ts
+const builtInLogger = logger.scoped("plugin:builtin");
+const BUILT_IN_PLUGIN_LOADER = "builtin";
+const isBuiltInPluginName = (pluginName) => builtInPluginRegistry.has(pluginName);
+const isBuiltInPlugin = (plugin) => plugin.loaderName === BUILT_IN_PLUGIN_LOADER;
+const builtInDefinitionToArchive = (definition, enable = definition.enabledByDefault ?? true) => ({
+	displayName: definition.meta.name.display,
+	enable,
+	installerName: BUILT_IN_PLUGIN_LOADER,
+	installInput: "",
+	loaderName: BUILT_IN_PLUGIN_LOADER,
+	meta: definition.meta,
+	pluginName: definition.meta.name.id
+});
+/** Mirrors compile-time definitions into the plugin catalog while preserving their enable state. */
+const synchronizeBuiltInPlugins = async () => {
+	builtInLogger.info("built-in plugin synchronization started", { definitionCount: builtInPluginRegistry.size });
+	const { db } = await import("@delta-comic/db");
+	await db.transaction().execute(async (trx) => {
+		const existing = await trx.selectFrom("plugin").selectAll().execute();
+		const existingByName = new Map(existing.map((plugin) => [plugin.pluginName, plugin]));
+		for (const [pluginName, definition] of builtInPluginRegistry) {
+			const current = existingByName.get(pluginName);
+			const archive = builtInDefinitionToArchive(definition, current?.enable);
+			const values = {
+				...archive,
+				meta: JSON.stringify(archive.meta)
+			};
+			if (current) await trx.updateTable("plugin").set(values).where("pluginName", "=", pluginName).execute();
+			else await trx.insertInto("plugin").values(values).execute();
+		}
+		const currentNames = [...builtInPluginRegistry.keys()];
+		let staleQuery = trx.deleteFrom("plugin").where("loaderName", "=", BUILT_IN_PLUGIN_LOADER);
+		if (currentNames.length > 0) staleQuery = staleQuery.where("pluginName", "not in", currentNames);
+		await staleQuery.execute();
+	});
+	builtInLogger.info("built-in plugin synchronization completed");
+};
+//#endregion
+//#region lib/driver/cleanup.ts
+const removeSourcedEntries = (map, plugin) => {
+	for (const key of map.keys()) if (key.split(":", 1)[0] === plugin) map.delete(key);
+};
+const cleanupPlugin = (config) => {
+	const plugin = config.name;
+	const pluginStore = usePluginStore();
+	const errors = [];
+	const attempt = (action) => {
+		try {
+			action();
+		} catch (error) {
+			errors.push(error);
+		}
+	};
+	attempt(() => pluginStore.$markUnloaded(plugin));
+	attempt(() => Global.tabbar.delete(plugin));
+	attempt(() => Global.categories.delete(plugin));
+	attempt(() => Global.barcode.delete(plugin));
+	attempt(() => Global.hotSearch.delete(plugin));
+	attempt(() => Global.levelboard.delete(plugin));
+	attempt(() => Global.topButton.delete(plugin));
+	attempt(() => Global.mainLists.delete(plugin));
+	attempt(() => Global.removeOwnedRegistrations(plugin));
+	attempt(() => pluginI18n.remove(plugin));
+	attempt(() => removeSourcedEntries(Global.share, plugin));
+	attempt(() => removeSourcedEntries(Global.shareToken, plugin));
+	attempt(() => removeSourcedEntries(Global.userActions, plugin));
+	attempt(() => removeSourcedEntries(Global.subscribes, plugin));
+	for (const [contentType, value] of Object.entries(config.content ?? {})) {
+		if (value.layout) attempt(() => uni.content.ContentPage.layouts.delete(contentType));
+		if (value.itemCard) attempt(() => uni.item.Item.itemCards.delete(contentType));
+		if (value.contentPage) attempt(() => uni.content.ContentPage.contentPages.delete(contentType));
+		if (value.downloadProvider) attempt(() => uni.content.ContentPage.downloadProviders.delete(contentType));
+		if (value.commentRow) attempt(() => uni.comment.Comment.commentRow.delete(contentType));
+		if (value.itemTranslator) attempt(() => uni.item.Item.itemTranslator.delete(contentType));
+	}
+	for (const type of config.resource?.types ?? []) {
+		attempt(() => uni.resource.Resource.fork.delete([plugin, type.type]));
+		attempt(() => uni.resource.Resource.precedenceFork.delete([plugin, type.type]));
+	}
+	for (const name of Object.keys(config.resource?.process ?? {})) attempt(() => uni.resource.Resource.processInstances.delete([plugin, name]));
+	if (config.user?.card) attempt(() => uni.user.User.userCards.delete(plugin));
+	if (config.user?.edit) attempt(() => uni.user.User.userEditorBase.delete(plugin));
+	for (const key of Object.keys(config.user?.authorIcon ?? {})) attempt(() => uni.item.Item.authorIcon.delete([plugin, key]));
+	for (const pointer of config.config ?? []) attempt(() => useConfig$1().$unregisterConfig(pointer));
+	attempt(() => defaultDependencyRegistry.delete(declareDepType(plugin)));
+	attempt(() => pluginStore.plugins.delete(plugin));
+	attempt(() => releasePluginObjectUrls(plugin));
+	if (typeof document !== "undefined") {
+		for (const node of document.querySelectorAll("style[data-plugin]")) if (node.dataset.plugin === plugin) attempt(() => node.remove());
+	}
+	if (errors.length > 0) throw new AggregateError(errors, `failed to completely clean plugin "${plugin}"`);
+};
+//#endregion
+//#region lib/driver/extensions.ts
+var OrderedExtensionRegistry = class {
+	direction;
+	values = shallowReactive(new Array());
+	entries = [];
+	sequence = 0;
+	constructor(direction) {
+		this.direction = direction;
+	}
+	register(extension, options = {}, owner) {
+		const entry = {
+			extension,
+			order: options.order ?? 0,
+			owner,
+			sequence: this.sequence++
+		};
+		this.entries.push(entry);
+		this.refresh();
+		return () => {
+			const index = this.entries.indexOf(entry);
+			if (index < 0) return;
+			this.entries.splice(index, 1);
+			this.refresh();
+		};
+	}
+	removeOwner(owner) {
+		let changed = false;
+		for (let index = this.entries.length - 1; index >= 0; index--) {
+			if (this.entries[index].owner !== owner) continue;
+			this.entries.splice(index, 1);
+			changed = true;
+		}
+		if (changed) this.refresh();
+	}
+	refresh() {
+		const activeByName = /* @__PURE__ */ new Map();
+		for (const entry of this.entries) activeByName.set(entry.extension.name, entry);
+		const direction = this.direction === "ascending" ? 1 : -1;
+		const active = [...activeByName.values()].sort((left, right) => (left.order - right.order) * direction || left.sequence - right.sequence).map((entry) => entry.extension);
+		this.values.splice(0, this.values.length, ...active);
+	}
+};
+var PluginRuntimeExtensions = class {
+	booters = new OrderedExtensionRegistry("ascending");
+	installers = new OrderedExtensionRegistry("descending");
+	loaders = new OrderedExtensionRegistry("ascending");
+	owners = [];
+	registerBooter(booter, options) {
+		return this.booters.register(booter, options, this.owners.at(-1));
+	}
+	registerInstaller(installer, options) {
+		return this.installers.register(installer, options, this.owners.at(-1));
+	}
+	registerLoader(loader, options) {
+		return this.loaders.register(loader, options, this.owners.at(-1));
+	}
+	removeOwner(owner) {
+		this.booters.removeOwner(owner);
+		this.installers.removeOwner(owner);
+		this.loaders.removeOwner(owner);
+	}
+	async withOwner(owner, action) {
+		this.owners.push(owner);
+		try {
+			return await action();
+		} finally {
+			this.owners.pop();
+		}
+	}
+};
+const runtimeExtensions = new PluginRuntimeExtensions();
+const registerBooter = runtimeExtensions.registerBooter.bind(runtimeExtensions);
+const registerInstaller = runtimeExtensions.registerInstaller.bind(runtimeExtensions);
+const registerLoader = runtimeExtensions.registerLoader.bind(runtimeExtensions);
+//#endregion
+//#region lib/driver/booter.ts
+var booter_exports = /* @__PURE__ */ __exportAll({
+	bootPlugin: () => bootPlugin,
+	booters: () => booters
+});
+const pluginBooterLogger = logger.scoped("plugin:booter");
+const booters = runtimeExtensions.booters.values;
+const bootPlugin = async (cfg, info) => {
+	const store = usePluginStore();
+	store.$markLoading(cfg.name);
+	try {
+		store.plugins.set(cfg.name, markRaw(cfg));
+		const env = {};
+		for (const booter of booters) {
+			const msIndex = info.value[cfg.name].steps.length;
+			info.value[cfg.name].steps[msIndex] = {
+				name: booter.name,
+				description: ""
+			};
+			info.value[cfg.name].progress = {
+				stepsIndex: msIndex,
+				status: "process"
+			};
+			pluginBooterLogger.debug("plugin boot step started", {
+				plugin: cfg.name,
+				step: msIndex
+			});
+			await booter.call(cfg, (meta) => {
+				if (isString(meta)) info.value[cfg.name].steps[msIndex].description = meta;
+				else {
+					if (meta.description) info.value[cfg.name].steps[msIndex].description = meta.description;
+					if (meta.name) info.value[cfg.name].steps[msIndex].name = meta.name;
+				}
+			}, env);
+		}
+		info.value[cfg.name].progress.status = "done";
+		store.$markReady(cfg.name);
+		pluginBooterLogger.info("plugin boot pipeline completed", { plugin: cfg.name });
+	} catch (error) {
+		store.$markUnloaded(cfg.name);
+		pluginBooterLogger.error("plugin boot pipeline failed", { plugin: cfg.name }, error);
+		throw error;
+	}
+};
+//#endregion
+//#region lib/driver/loader.ts
+var loader_exports = /* @__PURE__ */ __exportAll({
+	bootConfig: () => bootConfig,
+	bootResolvedConfig: () => bootResolvedConfig,
+	createPluginLoadingInfo: () => createPluginLoadingInfo,
+	ensurePluginLoadingInfo: () => ensurePluginLoadingInfo,
+	loadAllPlugins: () => loadAllPlugins,
+	loadPlugin: () => loadPlugin,
+	loadPluginConfig: () => loadPluginConfig,
+	loaders: () => loaders,
+	markPluginLoadError: () => markPluginLoadError
+});
+const pluginLoaderLogger = logger.scoped("plugin:loader");
+const loaders = runtimeExtensions.loaders.values;
+const loadLocks = {};
+const getLoadLock = (pluginName) => loadLocks[pluginName] ??= new Mutex();
+const createPluginLoadingInfo = () => ({
+	progress: {
+		status: "wait",
+		stepsIndex: 0
+	},
+	steps: [{
+		name: pluginMessageKey("plugin.runtime.steps.waiting.title"),
+		description: pluginMessageKey("plugin.runtime.steps.waiting.description")
+	}]
+});
+const ensurePluginLoadingInfo = (info, pluginName) => info.value[pluginName] ??= createPluginLoadingInfo();
+const markPluginLoadError = (info, pluginName, error) => {
+	const loadingInfo = ensurePluginLoadingInfo(info, pluginName);
+	loadingInfo.progress = {
+		...loadingInfo.progress,
+		errorReason: error instanceof Error ? error.message : String(error),
+		status: "error"
+	};
+};
+/** 解析 config factory 并启动插件；任何中途失败都保留原始错误并执行回滚。 */
+const bootConfig = async (configFactory, info, options = {}) => {
+	const { expectedName, rollback } = options;
+	if (expectedName) ensurePluginLoadingInfo(info, expectedName);
+	let cfg;
+	try {
+		cfg = configFactory({
+			safe: true,
+			platform: isTauriRuntime() ? "tauri" : "web"
+		});
+		if (expectedName && cfg.name !== expectedName) throw new Error(`plugin name mismatch: ${expectedName} / ${cfg.name}`);
+		await bootResolvedConfig(cfg, info);
+		return cfg;
+	} catch (error) {
+		const progressName = expectedName ?? cfg?.name;
+		if (progressName) markPluginLoadError(info, progressName, error);
+		if (rollback) try {
+			await rollback(cfg, expectedName);
+		} catch (rollbackError) {
+			pluginLoaderLogger.error("plugin boot rollback failed", { plugin: progressName }, rollbackError);
+		}
+		throw error;
+	}
+};
+const bootResolvedConfig = async (cfg, info) => {
+	ensurePluginLoadingInfo(info, cfg.name);
+	await bootPlugin(cfg, info);
+};
+const loadPluginConfig = async (meta) => {
+	const lock = getLoadLock(meta.pluginName);
+	try {
+		await lock.acquire();
+		pluginLoaderLogger.debug("loading plugin config", {
+			loader: meta.loaderName,
+			plugin: meta.pluginName
+		});
+		if (isBuiltInPlugin(meta)) return builtInPluginRegistry.get(meta.pluginName)?.config;
+		const loader = loaders.find((value) => value.name === meta.loaderName);
+		if (!loader) throw new Error(pluginI18n.translate("plugin.runtime.errors.loaderMissing", {
+			loader: meta.loaderName,
+			plugin: meta.pluginName
+		}));
+		return await loader.load(meta);
+	} finally {
+		lock.release();
+	}
+};
+const loadPlugin = async (meta, info) => {
+	pluginLoaderLogger.info("plugin boot started", { plugin: meta.pluginName });
+	ensurePluginLoadingInfo(info, meta.pluginName);
+	try {
+		const configFactory = await loadPluginConfig(meta);
+		if (!configFactory) throw new Error(pluginI18n.translate("plugin.runtime.errors.defaultExportMissing", { plugin: meta.pluginName }));
+		await bootConfig(configFactory, info, {
+			expectedName: meta.pluginName,
+			rollback: (config) => cleanupPlugin(config ?? { name: meta.pluginName })
+		});
+		pluginLoaderLogger.info("plugin boot completed", { plugin: meta.pluginName });
+	} catch (error) {
+		pluginLoaderLogger.error("plugin boot failed", { plugin: meta.pluginName }, error);
+		markPluginLoadError(info, meta.pluginName, error);
+		throw error;
+	}
+};
+const loadAllPlugins = () => Promise.resolve().then(() => runtime_exports).then(({ pluginRuntime }) => pluginRuntime.loadNormal());
+//#endregion
+//#region lib/driver/runtimePlan.ts
+const pluginKind = (plugin) => plugin.meta.kind ?? "normal";
+const selectPluginsForPhase = (plugins, kind, startupPrebootNames = new Set(plugins.filter((plugin) => pluginKind(plugin) === "preboot").map((plugin) => plugin.pluginName)), activePrebootNames = startupPrebootNames) => {
+	const selected = plugins.filter((plugin) => kind === "preboot" ? startupPrebootNames.has(plugin.pluginName) : !startupPrebootNames.has(plugin.pluginName));
+	if (kind === "preboot") return selected;
+	return selected.map((plugin) => ({
+		...plugin,
+		meta: {
+			...plugin.meta,
+			require: plugin.meta.require.filter((dependency) => !activePrebootNames.has(dependency.id))
+		}
+	}));
+};
+const failedDependencies = (plugin, failedPluginNames) => plugin.meta.require.filter((dependency) => failedPluginNames.has(dependency.id)).map((v) => v.id);
+const filterPluginsBySelection = (plugins, pluginNames) => pluginNames ? plugins.filter((plugin) => pluginNames.has(plugin.pluginName)) : plugins;
+//#endregion
+//#region lib/driver/runtime.ts
+var runtime_exports = /* @__PURE__ */ __exportAll({ pluginRuntime: () => pluginRuntime });
+const pluginRuntimeLogger = logger.scoped("plugin:runtime");
+const recoveryKey = "delta-comic:preboot-recovery";
+const reasonText = (error) => error instanceof Error ? error.message : String(error);
+const createLoadingInfo = () => ({
+	progress: {
+		status: "wait",
+		stepsIndex: 0
+	},
+	steps: [{
+		name: pluginMessageKey("plugin.runtime.steps.waiting.title"),
+		description: pluginMessageKey("plugin.runtime.steps.waiting.description")
+	}]
+});
+var PluginRuntime = class {
+	active = /* @__PURE__ */ new Map();
+	activePrebootNames = /* @__PURE__ */ new Set();
+	prebootCleanups = /* @__PURE__ */ new Map();
+	preparedPreboot = /* @__PURE__ */ new Map();
+	startupPluginNames = /* @__PURE__ */ new Set();
+	startupPrebootNames = /* @__PURE__ */ new Set();
+	builtInSynchronization;
+	enabledPrebootNames = [];
+	normalOperation;
+	startupSnapshotReady = false;
+	prebootActivated = false;
+	get activeNormalPluginNames() {
+		return [...this.active.entries()].filter(([, plugin]) => plugin.kind === "normal").map(([name]) => name);
+	}
+	loadNormal(options = {}) {
+		if (this.normalOperation) throw new Error("normal plugins are already loading");
+		if (this.preparedPreboot.size > 0 && !this.prebootActivated) throw new Error("preboot plugins have not finished activating");
+		if ([...this.active.values()].some((plugin) => plugin.kind === "normal")) throw new Error("normal plugins are already active; use reloadNormal()");
+		const progress = ref({});
+		pluginRuntimeLogger.info("normal plugin load requested", { selectedCount: options.pluginNames?.length });
+		const operation = this.loadKind("normal", progress, options);
+		this.trackNormalOperation(operation);
+		return {
+			operation,
+			progress
+		};
+	}
+	reloadNormal(options = {}) {
+		if (this.normalOperation) throw new Error("normal plugins are already loading");
+		const progress = ref({});
+		pluginRuntimeLogger.info("normal plugin reload requested", { selectedCount: options.pluginNames?.length });
+		const operation = (async () => {
+			const unloadErrors = await this.unloadKind("normal");
+			await this.loadKind("normal", progress, options);
+			if (unloadErrors.length > 0) throw new AggregateError(unloadErrors, "some plugins failed to unload cleanly");
+		})();
+		this.trackNormalOperation(operation);
+		return {
+			operation,
+			progress
+		};
+	}
+	async preparePreboot(app) {
+		pluginRuntimeLogger.info("preboot plugin preparation started");
+		await this.ensureBuiltInPlugins();
+		await pluginStore.$refreshI18nNames();
+		const allPlugins = await db.selectFrom("plugin").selectAll().execute();
+		this.captureStartupSnapshot(allPlugins);
+		const plugins = selectPluginsForPhase(allPlugins.filter((plugin) => plugin.enable), "preboot", this.startupPrebootNames, this.activePrebootNames);
+		this.enabledPrebootNames = plugins.map((plugin) => plugin.pluginName);
+		pluginRuntimeLogger.debug("preboot plugins selected", { count: plugins.length });
+		if (plugins.length === 0) {
+			this.prebootActivated = true;
+			return { reloadRequired: false };
+		}
+		try {
+			const plan = planPluginLoadOrder(plugins);
+			const planError = formatPluginLoadPlanError(plan);
+			if (planError) throw new Error(planError);
+			for (const level of plan.levels) for (const archive of level) await Global.withRegistrationOwner(archive.pluginName, async () => {
+				const platform = isTauriRuntime() ? "tauri" : "web";
+				const factory = await loadPluginConfig(archive);
+				if (!factory) throw new Error(`plugin entry has no default export: ${archive.pluginName}`);
+				const config = factory({
+					safe: true,
+					platform
+				});
+				if (config.name !== archive.pluginName) throw new Error(`plugin name mismatch: ${archive.pluginName} / ${config.name}`);
+				const configStore = useConfig$1();
+				await Promise.all((config.config ?? []).map((pointer) => configStore.$registerConfig(pointer).ready));
+				const cleanup = await config.onPreboot?.({
+					app,
+					platform,
+					safe: true
+				});
+				if (cleanup) this.prebootCleanups.set(config.name, cleanup);
+				this.preparedPreboot.set(config.name, config);
+			});
+			pluginRuntimeLogger.info("preboot plugin preparation completed", { count: plugins.length });
+			return { reloadRequired: false };
+		} catch (error) {
+			pluginRuntimeLogger.error("preboot plugin preparation failed", error);
+			return await this.failPreboot(this.enabledPrebootNames, error);
+		}
+	}
+	async activatePreboot(progress = ref({})) {
+		if (this.prebootActivated) return { reloadRequired: false };
+		try {
+			pluginRuntimeLogger.info("preboot plugin activation started", { count: this.preparedPreboot.size });
+			for (const [name, config] of this.preparedPreboot) {
+				await Global.withRegistrationOwner(name, async () => {
+					await bootResolvedConfig(config, progress);
+				});
+				this.active.set(name, {
+					config,
+					kind: "preboot"
+				});
+				this.activePrebootNames.add(name);
+				this.preparedPreboot.delete(name);
+			}
+			this.preparedPreboot.clear();
+			this.prebootActivated = true;
+			pluginRuntimeLogger.info("preboot plugin activation completed");
+			return { reloadRequired: false };
+		} catch (error) {
+			pluginRuntimeLogger.error("preboot plugin activation failed", error);
+			return await this.failPreboot(this.enabledPrebootNames, error);
+		}
+	}
+	async uninstall(pluginName) {
+		pluginRuntimeLogger.info("plugin uninstall started", { plugin: pluginName });
+		const archive = await db.selectFrom("plugin").selectAll().where("pluginName", "=", pluginName).executeTakeFirst();
+		if (!archive) return;
+		if (isBuiltInPlugin(archive)) throw new Error(`built-in plugin "${pluginName}" cannot be uninstalled`);
+		const errors = [];
+		const active = this.active.get(pluginName);
+		if (active) errors.push(...await this.unloadOne(pluginName, active, true));
+		else {
+			let config;
+			try {
+				await Global.withRegistrationOwner(pluginName, async () => {
+					config = (await loadPluginConfig(archive))?.({
+						safe: true,
+						platform: isTauriRuntime() ? "tauri" : "web"
+					});
+					await config?.onUninstall?.();
+				});
+			} catch (error) {
+				errors.push(error);
+			}
+			if (config) try {
+				cleanupPlugin(config);
+			} catch (error) {
+				errors.push(error);
+			}
+			else Global.removeOwnedRegistrations(pluginName);
+		}
+		await removePluginFiles(pluginName);
+		await db.deleteFrom("plugin").where("pluginName", "=", pluginName).execute();
+		await pluginStore.$refreshI18nNames();
+		pluginStore.$touch();
+		pluginRuntimeLogger.info("plugin uninstall completed", {
+			cleanupErrorCount: errors.length,
+			plugin: pluginName
+		});
+		if (errors.length > 0) throw new AggregateError(errors, `plugin "${pluginName}" was removed with cleanup errors`);
+	}
+	readRecovery() {
+		try {
+			const value = globalThis.localStorage?.getItem(recoveryKey);
+			if (!value) return null;
+			return JSON.parse(value);
+		} catch (error) {
+			pluginRuntimeLogger.warn("failed to read preboot recovery", error);
+			return null;
+		}
+	}
+	clearRecovery() {
+		try {
+			globalThis.localStorage?.removeItem(recoveryKey);
+		} catch (error) {
+			pluginRuntimeLogger.warn("failed to clear preboot recovery", error);
+		}
+	}
+	trackNormalOperation(operation) {
+		this.normalOperation = operation;
+		operation.then(() => {
+			this.normalOperation = void 0;
+			pluginRuntimeLogger.info("normal plugin operation completed");
+		}, (error) => {
+			this.normalOperation = void 0;
+			pluginRuntimeLogger.error("normal plugin operation failed", error);
+		});
+	}
+	ensureBuiltInPlugins() {
+		return this.builtInSynchronization ??= import("./runtime-DQbAfFDr.mjs").then(async ({ registerCoreRuntimeExtensions }) => {
+			registerCoreRuntimeExtensions();
+			await synchronizeBuiltInPlugins();
+		});
+	}
+	captureStartupSnapshot(plugins) {
+		if (!this.startupSnapshotReady) this.startupPrebootNames.clear();
+		for (const plugin of plugins) {
+			if (this.startupPluginNames.has(plugin.pluginName)) continue;
+			this.startupPluginNames.add(plugin.pluginName);
+			if (pluginKind(plugin) === "preboot") this.startupPrebootNames.add(plugin.pluginName);
+		}
+		this.startupSnapshotReady = true;
+	}
+	async loadKind(kind, progress, options) {
+		await this.ensureBuiltInPlugins();
+		await pluginStore.$refreshI18nNames();
+		const allPlugins = await db.selectFrom("plugin").where("enable", "is", true).selectAll().execute();
+		this.captureStartupSnapshot(allPlugins);
+		const plugins = filterPluginsBySelection(selectPluginsForPhase(allPlugins, kind, this.startupPrebootNames, this.activePrebootNames), options.pluginNames ? new Set(options.pluginNames) : void 0);
+		const plan = planPluginLoadOrder(plugins);
+		pluginRuntimeLogger.info("plugin load plan created", {
+			levelCount: plan.levels.length,
+			pluginCount: plugins.length
+		});
+		const planError = formatPluginLoadPlanError(plan);
+		if (planError) throw new Error(planError);
+		const failed = /* @__PURE__ */ new Set();
+		for (const level of plan.levels) for (const archive of level) {
+			const name = archive.pluginName;
+			progress.value[name] ??= createLoadingInfo();
+			const blockedBy = failedDependencies(archive, failed);
+			if (blockedBy.length > 0) {
+				failed.add(name);
+				progress.value[name].progress = {
+					errorReason: pluginI18n.translate("plugin.runtime.errors.blockedDependencies", { plugins: blockedBy.join(", ") }),
+					status: "error",
+					stepsIndex: 0
+				};
+				continue;
+			}
+			let config;
+			try {
+				await Global.withRegistrationOwner(name, async () => {
+					const factory = await loadPluginConfig(archive);
+					if (!factory) throw new Error(`plugin entry has no default export: ${name}`);
+					config = factory({
+						safe: globalThis.window?.$$safe$$ ?? true,
+						platform: isTauriRuntime() ? "tauri" : "web"
+					});
+					if (config.name !== name) throw new Error(`plugin name mismatch: ${name} / ${config.name}`);
+					await bootResolvedConfig(config, progress);
+				});
+				this.active.set(name, {
+					config,
+					kind
+				});
+			} catch (error) {
+				failed.add(name);
+				if (config) try {
+					cleanupPlugin(config);
+				} catch (cleanupError) {
+					pluginRuntimeLogger.error("plugin rollback failed", { plugin: name }, cleanupError);
+				}
+				else Global.removeOwnedRegistrations(name);
+				const current = progress.value[name] ?? createLoadingInfo();
+				progress.value[name] = {
+					...current,
+					progress: {
+						...current.progress,
+						errorReason: reasonText(error),
+						status: "error"
+					}
+				};
+				pluginRuntimeLogger.error("plugin load failed", { plugin: name }, error);
+			}
+		}
+	}
+	async unloadKind(kind) {
+		const entries = [...this.active.entries()].filter(([, active]) => active.kind === kind);
+		const errors = [];
+		pluginRuntimeLogger.info("plugin unload phase started", {
+			count: entries.length,
+			kind
+		});
+		for (const [name, active] of entries.reverse()) errors.push(...await this.unloadOne(name, active, false));
+		pluginRuntimeLogger.info("plugin unload phase completed", {
+			errorCount: errors.length,
+			kind
+		});
+		return errors;
+	}
+	async unloadOne(name, active, uninstall) {
+		const errors = [];
+		const attempt = async (action) => {
+			if (!action) return;
+			try {
+				await action();
+			} catch (error) {
+				errors.push(error);
+			}
+		};
+		await attempt(active.config.onUnload?.bind(active.config));
+		if (uninstall) await attempt(active.config.onUninstall?.bind(active.config));
+		await attempt(this.prebootCleanups.get(name));
+		try {
+			cleanupPlugin(active.config);
+		} catch (error) {
+			errors.push(error);
+		}
+		this.prebootCleanups.delete(name);
+		this.preparedPreboot.delete(name);
+		this.active.delete(name);
+		this.activePrebootNames.delete(name);
+		return errors;
+	}
+	async failPreboot(pluginNames, error) {
+		const cleanupErrors = [];
+		cleanupErrors.push(...await this.unloadKind("preboot"));
+		for (const [name, config] of [...this.preparedPreboot.entries()].reverse()) {
+			try {
+				await this.prebootCleanups.get(name)?.();
+			} catch (cleanupError) {
+				cleanupErrors.push(cleanupError);
+			}
+			try {
+				cleanupPlugin(config);
+			} catch (cleanupError) {
+				cleanupErrors.push(cleanupError);
+			}
+			this.prebootCleanups.delete(name);
+		}
+		this.preparedPreboot.clear();
+		this.activePrebootNames.clear();
+		let disabled = true;
+		try {
+			if (pluginNames.length > 0) await db.updateTable("plugin").set({ enable: false }).where("pluginName", "in", pluginNames).execute();
+		} catch (disableError) {
+			disabled = false;
+			cleanupErrors.push(disableError);
+		}
+		const reasons = [reasonText(error), ...cleanupErrors.map(reasonText)];
+		const recovery = {
+			failedAt: Date.now(),
+			plugins: pluginNames,
+			reason: reasons.join("\n")
+		};
+		try {
+			globalThis.localStorage?.setItem(recoveryKey, JSON.stringify(recovery));
+		} catch (storageError) {
+			pluginRuntimeLogger.warn("failed to persist preboot recovery", storageError);
+		}
+		this.prebootActivated = true;
+		return { reloadRequired: disabled };
+	}
+};
+const pluginRuntime = new PluginRuntime();
+//#endregion
+//#region lib/driver/extensionTypes.ts
+var PluginInstaller = class {};
+var PluginLoader = class {};
+var PluginBooter = class {};
+//#endregion
+//#region lib/driver/install.ts
+var install_exports = /* @__PURE__ */ __exportAll({
+	installDepends: () => installDepends,
+	installFilePlugin: () => installFilePlugin,
+	installPlugin: () => installPlugin,
+	installers: () => installers,
+	uninstallPlugin: () => uninstallPlugin,
+	updatePlugin: () => updatePlugin
+});
+const pluginInstallLogger = logger.scoped("plugin:install");
+const clampProgress = (progress) => Math.min(100, Math.max(0, progress));
+const installers = runtimeExtensions.installers.values;
+const installDepends = (m, meta, installedPlugins) => m.createLoading(pluginI18n.translate("plugin.progress.dependencies.checking"), async (v) => {
+	v.retryable = true;
+	let count = 0;
+	const plugins = installedPlugins ?? new Set((await db.selectFrom("plugin").select("pluginName").execute()).map((v) => v.pluginName));
+	const overrides = useConfig$1().$loadApp().data.value.installOverride;
+	for (const { id, download } of meta.require) {
+		if (plugins.has(id) || !download) continue;
+		pluginInstallLogger.info("installing missing plugin dependency", {
+			dependency: id,
+			plugin: meta.name.id
+		});
+		v.description = pluginI18n.translate("plugin.progress.dependencies.installing", { id });
+		const downloadCommend = overrides.find((c) => c.key == id)?.value ?? download;
+		await installPlugin(downloadCommend);
+		count++;
+	}
+	v.description = pluginI18n.translate("plugin.progress.dependencies.complete", { count });
+});
+const installPluginFile = async (m, file, installerName, installInput, __installedPlugins) => {
+	pluginInstallLogger.info("plugin archive installation started", { installer: installerName });
+	const meta = await m.createProgress(pluginI18n.translate("plugin.progress.installing"), async (v) => {
+		v.retryable = true;
+		const loader = loaders.filter((ins) => ins.canInstall(file)).at(-1);
+		if (!loader) throw new Error(pluginI18n.translate("plugin.install.errors.noInstaller"));
+		v.description = loader.name;
+		v.progress = 0;
+		const meta = await loader.install(file, { report(progress) {
+			if (progress.description) v.description = progress.description;
+			if (typeof progress.progress === "number") v.progress = clampProgress(progress.progress);
+		} });
+		if (isBuiltInPluginName(meta.name.id)) throw new Error(pluginI18n.translate("plugin.install.errors.reservedId", { id: meta.name.id }));
+		v.description = pluginI18n.translate("plugin.progress.persisting");
+		v.progress = 95;
+		await pluginStore.$upsertArchives([{
+			displayName: meta.name.display,
+			enable: true,
+			installerName,
+			installInput,
+			loaderName: loader.name,
+			meta,
+			pluginName: meta.name.id
+		}]);
+		v.progress = 100;
+		return meta;
+	});
+	pluginInstallLogger.info("plugin archive installed", { plugin: meta.name.id });
+	await installDepends(m, meta, __installedPlugins);
+};
+const installPlugin = (input, __installedPlugins) => createDownloadMessage(pluginI18n.translate("plugin.progress.downloadTitle", { input }), async (m) => {
+	const [file, installer] = await m.createLoading(pluginI18n.translate("plugin.progress.downloading"), async (v) => {
+		v.retryable = true;
+		let dlCommend = input;
+		for (;;) {
+			const installer = installers.filter((ins) => ins.isMatched(dlCommend)).at(0);
+			if (!installer) throw new Error(pluginI18n.translate("plugin.install.errors.noDownloader", { input: dlCommend }));
+			v.description = installer.name;
+			const meta = await installer.download(dlCommend);
+			if (isString(meta)) dlCommend = meta;
+			else return [meta, installer];
+		}
+	});
+	await installPluginFile(m, file, installer.name, input, __installedPlugins);
+});
+const installFilePlugin = (file, __installedPlugins) => createDownloadMessage(pluginI18n.translate("plugin.progress.installTitle", { file: file.name }), async (m) => {
+	await installPluginFile(m, file, "", "", __installedPlugins);
+});
+const updatePlugin = async (pluginMeta, __installedPlugins) => {
+	if (isBuiltInPlugin(pluginMeta)) throw new Error(pluginI18n.translate("plugin.install.errors.builtInUpdate"));
+	return createDownloadMessage(pluginI18n.translate("plugin.progress.updateTitle", { plugin: pluginMeta.pluginName }), async (m) => {
+		pluginInstallLogger.info("plugin update started", { plugin: pluginMeta.pluginName });
+		const file = await m.createLoading(pluginI18n.translate("plugin.progress.updating"), async (v) => {
+			v.retryable = true;
+			let installerName = pluginMeta.installerName;
+			for (;;) {
+				const installer = installers.find((v) => v.name == installerName);
+				if (!installer) throw new Error(pluginI18n.translate("plugin.install.errors.noDownloader"));
+				v.description = installer.name;
+				const file = await installer.update(pluginMeta);
+				if (isString(file)) installerName = file;
+				else return file;
+			}
+		});
+		const meta = await m.createProgress(pluginI18n.translate("plugin.progress.installing"), async (v) => {
+			v.retryable = true;
+			const loader = loaders.find((v) => v.name == pluginMeta.loaderName);
+			if (!loader) throw new Error(pluginI18n.translate("plugin.install.errors.noInstaller"));
+			v.description = loader.name;
+			v.progress = 0;
+			const meta = await loader.install(file, { report(progress) {
+				if (progress.description) v.description = progress.description;
+				if (typeof progress.progress === "number") v.progress = clampProgress(progress.progress);
+			} });
+			v.progress = 100;
+			return meta;
+		});
+		await pluginStore.$upsertArchives([{
+			...pluginMeta,
+			meta
+		}]);
+		await installDepends(m, meta, __installedPlugins);
+		pluginInstallLogger.info("plugin update completed", { plugin: pluginMeta.pluginName });
+	});
+};
+const uninstallPlugin = (pluginName) => pluginRuntime.uninstall(pluginName);
+//#endregion
+//#region lib/driver/icon.ts
+const OfflineShareRound = () => h("svg", {
+	"xmlns": "http://www.w3.org/2000/svg",
+	"xmlns:xlink": "http://www.w3.org/1999/xlink",
+	"viewBox": "0 0 24 24"
+}, [
+	h("path", {
+		d: "M5 5c-.55 0-1 .45-1 1v15c0 1.1.9 2 2 2h9c.55 0 1-.45 1-1s-.45-1-1-1H6V6c0-.55-.45-1-1-1z",
+		fill: "currentColor"
+	}),
+	h("path", {
+		d: "M18 1h-8c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h8c1.1 0 2-.9 2-2V3c0-1.1-.9-2-2-2zm0 14h-8V5h8v10z",
+		fill: "currentColor"
+	}),
+	h("path", {
+		d: "M12.5 10.25h2v.54c0 .45.54.67.85.35l1.29-1.29c.2-.2.2-.51 0-.71l-1.29-1.29a.5.5 0 0 0-.85.35v.54H12c-.55 0-1 .45-1 1v1.5c0 .41.34.75.75.75s.75-.34.75-.75v-.99z",
+		fill: "currentColor"
+	})
+]);
+const TagOutlined = () => h("svg", {
+	"xmlns": "http://www.w3.org/2000/svg",
+	"xmlns:xlink": "http://www.w3.org/1999/xlink",
+	"viewBox": "0 0 1024 1024"
+}, [h("path", {
+	d: "M938 458.8l-29.6-312.6c-1.5-16.2-14.4-29-30.6-30.6L565.2 86h-.4c-3.2 0-5.7 1-7.6 2.9L88.9 557.2a9.96 9.96 0 0 0 0 14.1l363.8 363.8c1.9 1.9 4.4 2.9 7.1 2.9s5.2-1 7.1-2.9l468.3-468.3c2-2.1 3-5 2.8-8zM459.7 834.7L189.3 564.3L589 164.6L836 188l23.4 247l-399.7 399.7zM680 256c-48.5 0-88 39.5-88 88s39.5 88 88 88s88-39.5 88-88s-39.5-88-88-88zm0 120c-17.7 0-32-14.3-32-32s14.3-32 32-32s32 14.3 32 32s-14.3 32-32 32z",
+	fill: "currentColor"
+})]);
+//#endregion
+//#region lib/global.ts
+var _Global = class {
+	share = shallowReactive(SourcedKeyMap.createReactive());
+	shareToken = shallowReactive(SourcedKeyMap.createReactive());
+	userActions = shallowReactive(SourcedKeyMap.createReactive());
+	subscribes = shallowReactive(SourcedKeyMap.createReactive());
+	globalNodes = shallowReactive(new Array());
+	globalNodeOwners = /* @__PURE__ */ new Map();
+	registrationOwners = [];
+	/**
+	* Associates global registrations made by a plugin with that plugin. The runtime
+	* deliberately loads plugins serially while this ambient scope is active.
+	*/
+	async withRegistrationOwner(plugin, action) {
+		this.registrationOwners.push(plugin);
+		try {
+			return await runtimeExtensions.withOwner(plugin, () => environmentRegistry.withOwner(plugin, action));
+		} finally {
+			this.registrationOwners.pop();
+		}
+	}
+	get registrationOwner() {
+		return this.registrationOwners.at(-1);
+	}
+	addGlobalNode(component, plugin = this.registrationOwner) {
+		this.globalNodes.push(component);
+		if (plugin) this.globalNodeOwners.set(component, plugin);
+		return component;
+	}
+	/** Removes only registrations owned by the requested plugin. */
+	removeOwnedRegistrations(plugin) {
+		for (let index = this.globalNodes.length - 1; index >= 0; index--) {
+			const component = this.globalNodes[index];
+			if (this.globalNodeOwners.get(component) !== plugin) continue;
+			this.globalNodes.splice(index, 1);
+			this.globalNodeOwners.delete(component);
+		}
+		environmentRegistry.removeOwner(plugin);
+		runtimeExtensions.removeOwner(plugin);
+	}
+	tabbar = shallowReactive(/* @__PURE__ */ new Map());
+	addTabbar(plugin, ...tabbar) {
+		const old = this.tabbar.get(plugin) ?? [];
+		this.tabbar.set(plugin, old.concat(tabbar));
+	}
+	categories = shallowReactive(/* @__PURE__ */ new Map());
+	addCategories(plugin, ...categories) {
+		const old = this.categories.get(plugin) ?? [];
+		this.categories.set(plugin, old.concat(categories));
+	}
+	barcode = shallowReactive(/* @__PURE__ */ new Map());
+	addBarcode(plugin, ...barcode) {
+		const old = this.barcode.get(plugin) ?? [];
+		this.barcode.set(plugin, old.concat(barcode));
+	}
+	hotSearch = shallowReactive(/* @__PURE__ */ new Map());
+	addHotSearch(plugin, ...providers) {
+		const old = this.hotSearch.get(plugin) ?? [];
+		this.hotSearch.set(plugin, old.concat(providers));
+	}
+	levelboard = shallowReactive(/* @__PURE__ */ new Map());
+	addLevelboard(plugin, ...levelboard) {
+		const old = this.levelboard.get(plugin) ?? [];
+		this.levelboard.set(plugin, old.concat(levelboard));
+	}
+	topButton = shallowReactive(/* @__PURE__ */ new Map());
+	addTopButton(plugin, ...topButton) {
+		const old = this.topButton.get(plugin) ?? [];
+		this.topButton.set(plugin, old.concat(topButton));
+	}
+	mainLists = shallowReactive(/* @__PURE__ */ new Map());
+	addMainList(plugin, ...mainLists) {
+		const old = this.mainLists.get(plugin) ?? [];
+		this.mainLists.set(plugin, old.concat(mainLists));
+	}
+};
+const Global = new _Global();
+Global.share.set(["core", "token"], {
+	filter: (page) => !!page.preload,
+	icon: TagOutlined,
+	key: "token",
+	name: pluginMessageKey("plugin.share.copyToken"),
+	async call(page) {
+		const item = page.preload?.toJSON();
+		if (!item) throw new Error("Not found preload in content. Maybe not fetch detail?");
+		const compressed = compressToEncodedURIComponent(JSON.stringify({
+			item: {
+				contentType: uni.content.ContentPage.contentPages.key.toString(item.contentType),
+				ep: item.thisEp.id,
+				name: item.title
+			},
+			plugin: page.plugin,
+			id: page.id
+		}));
+		return { token: `[${item.title}](复制这条口令，打开Delta Comic)${compressed}` };
+	}
+});
+Global.share.set(["core", "native"], {
+	filter: (page) => !!page.preload,
+	icon: OfflineShareRound,
+	key: "native",
+	name: pluginMessageKey("plugin.share.native"),
+	async call(page) {
+		const item = page.preload?.toJSON();
+		if (!item) throw new Error("Not found preload in content. Maybe not fetch detail?");
+		const compressed = compressToEncodedURIComponent(JSON.stringify({
+			item: {
+				contentType: uni.content.ContentPage.contentPages.key.toString(item.contentType),
+				ep: item.thisEp.id,
+				name: item.title
+			},
+			plugin: page.plugin,
+			id: page.id
+		}));
+		const token = `[${item.title}](复制这条口令，打开Delta Comic)${compressed}`;
+		await navigator.share({
+			title: pluginI18n.translate("plugin.share.nativeTitle"),
+			text: token
+		});
+		return { token };
+	}
+});
+Global.shareToken.set(["core", "token"], {
+	key: "token",
+	name: pluginMessageKey("plugin.share.defaultToken"),
+	patten(chipboard) {
+		return /^\[.+\]\(复制这条口令，打开Delta Comic\).+/.test(chipboard);
+	},
+	show(chipboard) {
+		const pluginStore = usePluginStore();
+		const meta = JSON.parse(decompressFromEncodedURIComponent(chipboard.replace(/^\[.+\]/, "").replaceAll("(复制这条口令，打开Delta Comic)", "")));
+		return {
+			title: pluginI18n.translate("plugin.share.tokenTitle"),
+			detail: pluginI18n.translate("plugin.share.tokenDetail", {
+				item: meta.item.name,
+				plugin: pluginStore.$getI18nName(meta.plugin)
+			}),
+			onNegative() {},
+			onPositive() {
+				return SharedFunction.call("routeToContent", uni.content.ContentPage.contentPages.key.toJSON(meta.item.contentType), meta.id, meta.item.ep);
+			}
+		};
+	}
+});
+//#endregion
+export { pluginI18n as A, require as B, findCyclePaths as C, pluginStore as D, PluginStore as E, declareDepType as F, definePlugin as G, useConfig$1 as H, defaultDependencyRegistry as I, exposeSymbol as L, translatePluginText as M, DependencyRegistry as N, usePluginStore as O, createDependencyRegistry as P, pluginExposes as R, synchronizeBuiltInPlugins as S, planPluginLoadOrder as T, ConfigPointer as U, ConfigStore as V, defineInnerPlugin as W, runtimeExtensions as _, PluginLoader as a, isBuiltInPlugin as b, filterPluginsBySelection as c, loader_exports as d, booter_exports as f, registerLoader as g, registerInstaller as h, PluginInstaller as i, pluginMessageKey as j, PluginI18nRegistry as k, pluginKind as l, registerBooter as m, install_exports as n, pluginRuntime as o, PluginRuntimeExtensions as p, PluginBooter as r, failedDependencies as s, Global as t, selectPluginsForPhase as u, BUILT_IN_PLUGIN_LOADER as v, formatPluginLoadPlanError as w, isBuiltInPluginName as x, builtInDefinitionToArchive as y, provide as z };
+
+//# sourceMappingURL=global-B4SQiBzS.mjs.map