@delta-comic/plugin 3.0.0-next.7 → 3.0.0-next.9

package/dist/lib/index.mjs

@@ -1,70 +1,562 @@
-import { A as pluginI18n, B as require, C as findCyclePaths, D as pluginStore, E as PluginStore, F as declareDepType, G as definePlugin, H as useConfig, I as defaultDependencyRegistry, L as exposeSymbol, M as translatePluginText, N as DependencyRegistry, O as usePluginStore, P as createDependencyRegistry, R as pluginExposes, S as synchronizeBuiltInPlugins, T as planPluginLoadOrder, U as ConfigPointer, V as ConfigStore, W as defineInnerPlugin, _ as runtimeExtensions, a as PluginLoader, b as isBuiltInPlugin, c as filterPluginsBySelection, d as loader_exports, f as booter_exports, g as registerLoader, h as registerInstaller, i as PluginInstaller, j as pluginMessageKey, k as PluginI18nRegistry, l as pluginKind, m as registerBooter, n as install_exports, o as pluginRuntime, p as PluginRuntimeExtensions, r as PluginBooter, s as failedDependencies, t as Global, u as selectPluginsForPhase, v as BUILT_IN_PLUGIN_LOADER, w as formatPluginLoadPlanError, x as isBuiltInPluginName, y as builtInDefinitionToArchive, z as provide } from "../global-BSAsAv3E.mjs";
-import { t as createPluginAssetUrl } from "../storage-DMKDlPzl.mjs";
+import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.mjs";
+import { isFunction } from "es-toolkit";
+import { DELTA_COMIC_PLUGIN_API_VERSION, DELTA_COMIC_PLUGIN_API_VERSION as DELTA_COMIC_PLUGIN_API_VERSION$1, UniComment, UniContentPage, UniItem, UniResource, UniUser } from "@delta-comic/model";
+import { markRaw, ref, shallowReactive } from "vue";
+import { isTauri } from "@tauri-apps/api/core";
 import { logger } from "@delta-comic/logger";
-import semver from "semver";
 import ky from "ky";
-//#region lib/manifest.ts
+import semver from "semver";
+import { db, useConfig as useConfig$1 } from "@delta-comic/db";
+import JSZip from "jszip";
+import { Octokit } from "@octokit/rest";
+import { SharedFunction } from "@delta-comic/utils";
+import { compressToEncodedURIComponent, decompressFromEncodedURIComponent } from "lz-string";
+//#region lib/api/config.ts
+var ConfigPointer = class {
+	pluginName;
+	config;
+	configName;
+	key;
+	_type = {};
+	constructor(pluginName, config, configName) {
+		this.pluginName = pluginName;
+		this.config = config;
+		this.configName = configName;
+		this.key = Symbol.for(`config:${pluginName}`);
+	}
+};
+//#endregion
+//#region lib/api/model/content.ts
+var content_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+//#region lib/api/model/expose.ts
+var expose_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+//#region lib/api/model/remote.ts
+var remote_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+//#region lib/api/model/resource.ts
+var resource_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+//#region lib/api/model/social.ts
+var social_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+//#region lib/api/model/special.ts
+var special_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+//#region lib/api/model/user.ts
+var user_exports = /* @__PURE__ */ __exportAll({});
+//#endregion
+//#region lib/api/plugin.ts
+const defineDeltaComicPlugin = (config) => {
+	if (isFunction(config)) return config;
+	return () => config;
+};
+//#endregion
+//#region lib/kernel/candidate.ts
+const defineInternalPlugin = (definition) => definition;
+//#endregion
+//#region lib/kernel/capability.ts
+const defineCapability = (definition) => ({
+	id: definition.id,
+	async activate(plugin, context) {
+		const model = definition.select(plugin);
+		if (model === void 0) return false;
+		await definition.activate(model, context);
+		return true;
+	}
+});
+var ActivationPipeline = class {
+	#modules;
+	constructor(modules) {
+		const ids = /* @__PURE__ */ new Set();
+		for (const module of modules) {
+			if (!module.id) throw new Error("capability id cannot be empty");
+			if (ids.has(module.id)) throw new Error(`duplicate capability "${module.id}"`);
+			ids.add(module.id);
+		}
+		this.#modules = [...modules];
+	}
+	async activate(plugin, context) {
+		const activated = [];
+		for (const module of this.#modules) {
+			if (context.signal.aborted) throw context.signal.reason;
+			context.report({
+				description: "",
+				name: module.id
+			});
+			if (await module.activate(plugin, context)) activated.push(module.id);
+		}
+		return activated;
+	}
+};
+//#endregion
+//#region lib/kernel/contribution.ts
+const defineContributionChannel = (key) => ({ key });
+const contributionKey = (owner, id) => JSON.stringify([owner, id]);
+var ContributionRegistry = class {
+	#entries = shallowReactive(/* @__PURE__ */ new Map());
+	get size() {
+		return this.#entries.size;
+	}
+	get entries() {
+		return this.#entries;
+	}
+	register(owner, id, value) {
+		if (!owner) throw new Error("contribution owner cannot be empty");
+		if (!id) throw new Error("contribution id cannot be empty");
+		const key = contributionKey(owner, id);
+		if (this.#entries.has(key)) throw new Error(`duplicate contribution "${owner}:${id}"`);
+		const contribution = {
+			id,
+			owner,
+			value
+		};
+		this.#entries.set(key, contribution);
+		let active = true;
+		return () => {
+			if (!active) return false;
+			active = false;
+			return this.#entries.delete(key);
+		};
+	}
+	get(owner, id) {
+		return this.#entries.get(contributionKey(owner, id));
+	}
+	byOwner(owner) {
+		return [...this.#entries.values()].filter((entry) => entry.owner === owner);
+	}
+	removeOwner(owner) {
+		for (const [key, entry] of this.#entries) if (entry.owner === owner) this.#entries.delete(key);
+	}
+	values() {
+		return this.#entries.values();
+	}
+};
+var ContributionHub = class {
+	registries = /* @__PURE__ */ new Map();
+	channel(channel) {
+		let registry = this.registries.get(channel.key);
+		if (!registry) {
+			registry = new ContributionRegistry();
+			this.registries.set(channel.key, registry);
+		}
+		return registry;
+	}
+	register(scope, channel, id, value) {
+		const unregister = this.channel(channel).register(scope.owner, id, value);
+		scope.defer(() => void unregister());
+		return unregister;
+	}
+	removeOwner(owner) {
+		for (const registry of this.registries.values()) registry.removeOwner(owner);
+	}
+};
+//#endregion
+//#region lib/kernel/dependency.ts
+const dependenciesOf = (candidate) => candidate.manifest.require.map((dependency) => dependency.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((left, right) => left.join("\0").localeCompare(right.join("\0")));
+	return rotations[0]?.join("\0") ?? "";
+};
+const findPluginDependencyCycles = (candidates) => {
+	const candidateIds = new Set(candidates.map((candidate) => candidate.manifest.name.id));
+	const dependencies = new Map(candidates.map((candidate) => [candidate.manifest.name.id, dependenciesOf(candidate).filter((dependency) => candidateIds.has(dependency))]));
+	const state = /* @__PURE__ */ new Map();
+	const path = [];
+	const keys = /* @__PURE__ */ new Set();
+	const cycles = [];
+	const visit = (plugin) => {
+		state.set(plugin, "visiting");
+		path.push(plugin);
+		for (const dependency of dependencies.get(plugin) ?? []) if (state.get(dependency) === "visiting") {
+			const start = path.lastIndexOf(dependency);
+			if (start < 0) continue;
+			const cycle = path.slice(start).concat(dependency);
+			const key = canonicalCycleKey(cycle);
+			if (!keys.has(key)) {
+				keys.add(key);
+				cycles.push(cycle);
+			}
+		} else if (state.get(dependency) !== "visited") visit(dependency);
+		path.pop();
+		state.set(plugin, "visited");
+	};
+	for (const candidate of candidates) {
+		const id = candidate.manifest.name.id;
+		if (!state.has(id)) visit(id);
+	}
+	return cycles;
+};
+const planPluginDependencies = (candidates) => {
+	const byId = new Map(candidates.map((candidate) => [candidate.manifest.name.id, candidate]));
+	const degree = /* @__PURE__ */ new Map();
+	const dependents = /* @__PURE__ */ new Map();
+	const missing = [];
+	for (const candidate of candidates) {
+		const id = candidate.manifest.name.id;
+		const installed = dependenciesOf(candidate).filter((dependency) => {
+			if (byId.has(dependency)) return true;
+			missing.push({
+				dependency,
+				plugin: id
+			});
+			return false;
+		});
+		degree.set(id, installed.length);
+		for (const dependency of installed) {
+			const entries = dependents.get(dependency) ?? [];
+			entries.push(id);
+			dependents.set(dependency, entries);
+		}
+	}
+	const queue = [...degree].filter(([, value]) => value === 0).map(([id]) => id);
+	const levels = [];
+	while (queue.length > 0) {
+		const current = queue.splice(0);
+		const level = current.flatMap((id) => {
+			const candidate = byId.get(id);
+			return candidate ? [candidate] : [];
+		});
+		if (level.length > 0) levels.push(level);
+		for (const id of current) for (const dependent of dependents.get(id) ?? []) {
+			const next = (degree.get(dependent) ?? 0) - 1;
+			degree.set(dependent, next);
+			if (next === 0) queue.push(dependent);
+		}
+	}
+	const unresolved = candidates.filter((candidate) => (degree.get(candidate.manifest.name.id) ?? 0) > 0);
+	return {
+		cycles: findPluginDependencyCycles(unresolved),
+		levels,
+		missing
+	};
+};
+//#endregion
+//#region lib/kernel/scope.ts
+var PluginScope = class {
+	owner;
+	#controller = new AbortController();
+	#disposers = [];
+	#disposePromise;
+	constructor(owner) {
+		this.owner = owner;
+	}
+	get signal() {
+		return this.#controller.signal;
+	}
+	get disposed() {
+		return this.#disposePromise !== void 0;
+	}
+	defer(disposer) {
+		if (this.disposed) throw new Error(`plugin scope "${this.owner}" is already disposed`);
+		this.#disposers.push(disposer);
+		return disposer;
+	}
+	dispose(reason) {
+		return this.#disposePromise ??= this.#dispose(reason);
+	}
+	async #dispose(reason) {
+		this.#controller.abort(reason);
+		const errors = [];
+		for (const disposer of this.#disposers.reverse()) try {
+			await disposer();
+		} catch (error) {
+			errors.push(error);
+		}
+		this.#disposers.length = 0;
+		if (errors.length > 0) throw new AggregateError(errors, `failed to dispose plugin scope "${this.owner}"`);
+	}
+};
+//#endregion
+//#region lib/capabilities/auth.ts
+const createAuthCapability = (services) => defineCapability({
+	id: "auth",
+	select: (config) => config.model?.user?.auth,
+	async activate(auth, context) {
+		if (services.phase === "preboot") throw new Error("plugin authentication is only available during normal activation");
+		if (!services.auth) throw new Error("plugin authentication requires a host auth gateway");
+		context.report({
+			name: "auth",
+			description: "checking authentication"
+		});
+		await services.auth.authenticate(context.owner, auth, context.signal);
+	}
+});
+//#endregion
+//#region lib/capabilities/config.ts
+const createConfigCapability = (services) => defineCapability({
+	id: "config",
+	select: (config) => config.config,
+	async activate(pointer, context) {
+		if (pointer.pluginName !== context.scope.owner) throw new Error(`plugin config owner mismatch: ${context.scope.owner} / ${pointer.pluginName}`);
+		context.report({ description: pointer.configName });
+		const registered = services.config.register(pointer);
+		context.scope.defer(() => services.config.unregister(pointer));
+		await registered.ready;
+	}
+});
+//#endregion
+//#region lib/capabilities/registryBinding.ts
+/** Bind a host registry entry and restore exactly the value that existed before activation. */
+const bindRegistryValue = (scope, registry, key, value) => {
+	if (value === void 0) return;
+	const hadPrevious = registry.has(key);
+	const previous = registry.get(key);
+	registry.set(key, value);
+	scope.defer(() => {
+		if (hadPrevious) registry.set(key, previous);
+		else registry.delete(key);
+	});
+};
+//#endregion
+//#region lib/capabilities/content.ts
+const createContentCapability = () => defineCapability({
+	id: "content-bindings",
+	select: (config) => config.model?.content?.models,
+	activate(models, context) {
+		const names = /* @__PURE__ */ new Set();
+		for (const model of models) {
+			if (!model.name) throw new Error("content model name cannot be empty");
+			if (names.has(model.name)) throw new Error(`duplicate content model "${model.name}"`);
+			names.add(model.name);
+			const key = [context.owner, model.name];
+			bindRegistryValue(context.scope, UniContentPage.layouts, key, model.Layout);
+			bindRegistryValue(context.scope, UniItem.itemCards, key, model.ItemCard);
+			bindRegistryValue(context.scope, UniContentPage.contentPages, key, model.ContentPage);
+			bindRegistryValue(context.scope, UniContentPage.downloadProviders, key, model.DownloadProvider);
+			bindRegistryValue(context.scope, UniComment.commentRow, key, model.CommentRow);
+			bindRegistryValue(context.scope, UniItem.itemTranslator, key, model.ItemTranslator);
+		}
+	}
+});
+//#endregion
+//#region lib/capabilities/i18n.ts
+const createI18nCapability = (services) => defineCapability({
+	id: "i18n",
+	select: (config) => config.i18n,
+	activate(messages, context) {
+		services.i18n.register(context.scope.owner, messages);
+		context.scope.defer(() => services.i18n.remove(context.scope.owner));
+	}
+});
+//#endregion
+//#region lib/capabilities/lifecycle.ts
+const createLifecycleCapability = (services) => defineCapability({
+	id: "lifecycle",
+	select: (config) => {
+		const hooks = config.hooks;
+		return hooks?.onBooted || hooks?.onPreboot || hooks?.onUnload || hooks?.onUninstall ? hooks : void 0;
+	},
+	async activate(hooks, context) {
+		if (hooks.onUnload) context.scope.defer(() => hooks.onUnload?.());
+		if (services.phase === "preboot") {
+			if (!services.app) throw new Error("preboot activation requires a Vue app");
+			const cleanup = await hooks.onPreboot?.({ app: services.app });
+			if (cleanup) context.scope.defer(cleanup);
+			return;
+		}
+		await hooks.onBooted?.();
+	}
+});
+//#endregion
+//#region lib/capabilities/channels.ts
+const pluginModelChannels = {
+	content: defineContributionChannel("model:content"),
+	expose: defineContributionChannel("model:expose"),
+	remote: defineContributionChannel("model:remote"),
+	resource: defineContributionChannel("model:resource"),
+	social: defineContributionChannel("model:social"),
+	special: defineContributionChannel("model:special"),
+	user: defineContributionChannel("model:user")
+};
+//#endregion
+//#region lib/capabilities/model.ts
+const createModelCapability = (services) => defineCapability({
+	id: "model",
+	select: (config) => config.model,
+	activate(model, context) {
+		const register = (channel, value) => {
+			if (value !== void 0) services.contributions.register(context.scope, channel, "default", value);
+		};
+		register(pluginModelChannels.content, model.content);
+		register(pluginModelChannels.expose, model.expose);
+		register(pluginModelChannels.remote, model.remotes);
+		register(pluginModelChannels.resource, model.resource);
+		register(pluginModelChannels.social, model.social);
+		register(pluginModelChannels.special, model.special);
+		register(pluginModelChannels.user, model.user);
+	}
+});
+//#endregion
+//#region lib/capabilities/endpointProbe.ts
+const probeOne = async (candidate, parentSignal, timeoutMs, controllers) => {
+	const controller = new AbortController();
+	controllers.add(controller);
+	const relayAbort = () => controller.abort(parentSignal.reason);
+	parentSignal.addEventListener("abort", relayAbort, { once: true });
+	const timeout = setTimeout(() => controller.abort(/* @__PURE__ */ new Error("endpoint probe timed out")), timeoutMs);
+	const startedAt = performance.now();
+	try {
+		await candidate.test(candidate.url, controller.signal);
+		return {
+			latencyMs: performance.now() - startedAt,
+			url: candidate.url,
+			value: candidate.value
+		};
+	} finally {
+		clearTimeout(timeout);
+		parentSignal.removeEventListener("abort", relayAbort);
+		controllers.delete(controller);
+	}
+};
+/** Probe independently in parallel and stop remaining attempts after the first reachable endpoint. */
+const selectFastestEndpoint = async (candidates, signal, timeoutMs = 1e4) => {
+	signal.throwIfAborted();
+	const controllers = /* @__PURE__ */ new Set();
+	try {
+		return await Promise.any(candidates.map((candidate) => probeOne(candidate, signal, timeoutMs, controllers)));
+	} catch (error) {
+		signal.throwIfAborted();
+		if (error instanceof AggregateError) return void 0;
+		throw error;
+	} finally {
+		for (const controller of controllers) controller.abort(/* @__PURE__ */ new Error("another endpoint was selected"));
+	}
+};
+//#endregion
+//#region lib/capabilities/remote.ts
+const pluginRemoteSelectionChannel = defineContributionChannel("runtime:remote-selection");
+const createRemoteCapability = (services) => defineCapability({
+	id: "remote",
+	select: (config) => config.model?.remotes ? {
+		hooks: config.hooks,
+		remotes: config.model.remotes
+	} : void 0,
+	async activate({ hooks, remotes }, context) {
+		const groups = /* @__PURE__ */ new Set();
+		for (const group of remotes) {
+			if (!group.name) throw new Error("remote group name cannot be empty");
+			if (groups.has(group.name)) throw new Error(`duplicate remote group "${group.name}"`);
+			groups.add(group.name);
+			context.report({
+				name: "remote",
+				description: `probing ${group.name}`
+			});
+			const selected = await selectFastestEndpoint(group.remotes.map((remote) => ({
+				test: remote.test ?? group.test,
+				url: remote.url,
+				value: remote
+			})), context.signal);
+			if (!selected && !group.allowNoConnected) throw new Error(`no reachable endpoint for remote group "${group.name}"`);
+			const selection = {
+				group,
+				latencyMs: selected?.latencyMs,
+				remote: selected?.value ?? false
+			};
+			services.contributions.register(context.scope, pluginRemoteSelectionChannel, group.name, selection);
+			hooks?.onRemoteTestDone?.(group, selection.remote);
+		}
+	}
+});
+//#endregion
+//#region lib/capabilities/resource.ts
+const createResourceCapability = () => defineCapability({
+	id: "resource",
+	select: (config) => config.model?.resource,
+	async activate(resource, context) {
+		const names = /* @__PURE__ */ new Set();
+		for (const type of resource.types ?? []) {
+			if (!type.type) throw new Error("resource type cannot be empty");
+			if (names.has(type.type)) throw new Error(`duplicate resource type "${type.type}"`);
+			names.add(type.type);
+			const key = [context.owner, type.type];
+			bindRegistryValue(context.scope, UniResource.fork, key, type);
+			context.report({
+				name: "resource",
+				description: `probing ${type.type}`
+			});
+			const selected = await selectFastestEndpoint(type.urls.map((url) => ({
+				test: type.test,
+				url,
+				value: url
+			})), context.signal);
+			if (!selected) throw new Error(`no reachable endpoint for resource "${type.type}"`);
+			bindRegistryValue(context.scope, UniResource.precedenceFork, key, selected.url);
+		}
+		for (const [name, process] of Object.entries(resource.process ?? {})) {
+			if (!name) throw new Error("resource process name cannot be empty");
+			bindRegistryValue(context.scope, UniResource.processInstances, [context.owner, name], process);
+		}
+	}
+});
+//#endregion
+//#region lib/capabilities/special.ts
+const createSpecialCapability = () => defineCapability({
+	id: "special",
+	select: (config) => config.model?.special,
+	async activate(steps, context) {
+		for (const step of steps) {
+			context.signal.throwIfAborted();
+			if (!step.name) throw new Error("special step name cannot be empty");
+			context.report({
+				name: step.name,
+				description: ""
+			});
+			await step.call((description) => context.report({
+				name: step.name,
+				description
+			}));
+		}
+	}
+});
+//#endregion
+//#region lib/capabilities/user.ts
+const createUserCapability = () => defineCapability({
+	id: "user-bindings",
+	select: (config) => config.model?.user,
+	activate(user, context) {
+		bindRegistryValue(context.scope, UniUser.userCards, context.owner, user.card);
+		bindRegistryValue(context.scope, UniUser.userEditorBase, context.owner, user.edit);
+	}
+});
+//#endregion
+//#region lib/capabilities/index.ts
+/** Fixed host-owned activation topology. Third-party plugins only provide data to it. */
+const createDefaultCapabilities = (services) => [
+	createConfigCapability(services),
+	createI18nCapability(services),
+	createModelCapability(services),
+	createContentCapability(),
+	createUserCapability(),
+	createResourceCapability(),
+	createRemoteCapability(services),
+	createAuthCapability(services),
+	createSpecialCapability(),
+	createLifecycleCapability(services)
+];
+//#endregion
+//#region lib/install/manifest.ts
 const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const requiredRecord = (value, path) => {
+const record$1 = (value, path) => {
 	if (!isRecord$1(value)) throw new PluginManifestError(`${path} must be an object`);
 	return value;
 };
-const requiredString = (value, path) => {
+const text = (value, path) => {
 	if (typeof value !== "string" || value.length === 0) throw new PluginManifestError(`${path} must be a non-empty string`);
 	return value;
 };
-const optionalPath = (value, path) => {
-	const text = requiredString(value, path);
-	const normalized = text.replaceAll("\\", "/");
-	if (normalized.startsWith("/") || normalized.split("/").includes("..")) throw new PluginManifestError(`${path} must be a safe relative path`);
-	return text;
+const pluginId = (value, path) => {
+	const id = text(value, path);
+	if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(id)) throw new PluginManifestError(`${path} must be a portable 1-64 character plugin identifier`);
+	return id;
 };
-const decodeLocalIconPath = (value, path) => {
-	let decoded = value;
-	for (let index = 0; index < 5; index += 1) {
-		let next;
-		try {
-			next = decodeURIComponent(decoded);
-		} catch {
-			throw new PluginManifestError(`${path} must be a valid URL path`);
-		}
-		if (next === decoded) break;
-		decoded = next;
-	}
-	const normalized = decoded.replaceAll("\\", "/");
-	const segments = normalized.split("/");
-	if (!normalized || normalized.startsWith("/") || /^[a-z]:($|\/)/i.test(normalized) || normalized.includes("\0") || segments.some((segment) => segment === "..")) throw new PluginManifestError(`${path} must be a safe relative path`);
-	return segments.filter((segment) => segment && segment !== ".").join("/");
-};
-/**
-* Accepts a credential-free HTTP(S) URL or a safe path inside the plugin archive.
-* Query strings and fragments are kept for both forms.
-*/
-const parsePluginIconReference = (value, path = "manifest.icon") => {
-	const text = requiredString(value, path).trim();
-	if (!text) throw new PluginManifestError(`${path} must be a non-empty string`);
-	if (/^[a-z][a-z\d+.-]*:/i.test(text) || text.startsWith("//")) {
-		let url;
-		try {
-			url = new URL(text);
-		} catch {
-			throw new PluginManifestError(`${path} must be an HTTP(S) URL or a safe relative path`);
-		}
-		if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new PluginManifestError(`${path} must be a credential-free HTTP(S) URL or a safe relative path`);
-		return {
-			type: "remote",
-			url: text
-		};
-	}
-	const rawPath = text.split(/[?#]/, 1)[0] ?? "";
-	const resolvedPath = decodeLocalIconPath(rawPath, path);
-	if (!resolvedPath) throw new PluginManifestError(`${path} must be a safe relative path`);
-	const fragmentIndex = text.indexOf("#");
-	return {
-		fragment: fragmentIndex < 0 ? "" : text.slice(fragmentIndex),
-		path: resolvedPath,
-		type: "local"
-	};
+const safePluginPath = (value, path) => {
+	const normalized = text(value, path).replaceAll("\\", "/");
+	if (normalized.startsWith("/") || /^[a-z]:($|\/)/i.test(normalized) || normalized.includes("\0") || normalized.split("/").some((segment) => segment === "..")) throw new PluginManifestError(`${path} must be a safe relative path`);
+	return normalized.split("/").filter((segment) => segment && segment !== ".").join("/");
 };
 var PluginManifestError = class extends Error {
 	constructor(message) {
@@ -72,49 +564,51 @@ var PluginManifestError = class extends Error {
 		this.name = "PluginManifestError";
 	}
 };
-/**
-* Validates the exact manifest format emitted by the `deltaComic` Vite plugin.
-* The returned value is safe to use as the persisted plugin metadata shape.
-*/
+const pluginIcon = (value) => {
+	const icon = text(value, "manifest.icon").trim();
+	if (!/^[a-z][a-z\d+.-]*:/i.test(icon)) return safePluginPath(icon, "manifest.icon");
+	let url;
+	try {
+		url = new URL(icon);
+	} catch {
+		throw new PluginManifestError("manifest.icon must be an HTTP(S) URL or a safe relative path");
+	}
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new PluginManifestError("manifest.icon must be a credential-free HTTP(S) URL or a safe relative path");
+	return icon;
+};
 const parsePluginManifest = (value) => {
-	const manifest = requiredRecord(value, "manifest");
-	const name = requiredRecord(manifest.name, "manifest.name");
-	const version = requiredRecord(manifest.version, "manifest.version");
-	const id = requiredString(name.id, "manifest.name.id");
-	if (id === "." || id === ".." || /[\\/]/.test(id)) throw new PluginManifestError("manifest.name.id contains an unsafe path segment");
-	const requireValue = manifest.require;
-	if (!Array.isArray(requireValue)) throw new PluginManifestError("manifest.require must be an array");
-	const require = requireValue.map((dependency, index) => {
-		const record = requiredRecord(dependency, `manifest.require[${index}]`);
-		const download = record.download;
-		if (download !== void 0 && typeof download !== "string") throw new PluginManifestError(`manifest.require[${index}].download must be a string`);
-		return {
-			id: requiredString(record.id, `manifest.require[${index}].id`),
-			...download === void 0 ? {} : { download }
-		};
-	});
+	const manifest = record$1(value, "manifest");
+	if (manifest.apiVersion !== DELTA_COMIC_PLUGIN_API_VERSION$1) throw new PluginManifestError(`manifest.apiVersion must be ${DELTA_COMIC_PLUGIN_API_VERSION$1}`);
+	const name = record$1(manifest.name, "manifest.name");
+	const version = record$1(manifest.version, "manifest.version");
+	const id = pluginId(name.id, "manifest.name.id");
+	if (!Array.isArray(manifest.require)) throw new PluginManifestError("manifest.require must be an array");
 	const result = {
-		author: requiredString(manifest.author, "manifest.author"),
-		description: requiredString(manifest.description, "manifest.description"),
+		apiVersion: DELTA_COMIC_PLUGIN_API_VERSION$1,
+		author: text(manifest.author, "manifest.author"),
+		description: text(manifest.description, "manifest.description"),
 		name: {
-			display: requiredString(name.display, "manifest.name.display"),
+			display: text(name.display, "manifest.name.display"),
 			id
 		},
-		require,
+		require: manifest.require.map((value, index) => {
+			const dependency = record$1(value, `manifest.require[${index}]`);
+			return {
+				id: pluginId(dependency.id, `manifest.require[${index}].id`),
+				...dependency.download === void 0 ? {} : { download: text(dependency.download, `manifest.require[${index}].download`) }
+			};
+		}),
 		version: {
-			plugin: requiredString(version.plugin, "manifest.version.plugin"),
-			supportCore: requiredString(version.supportCore, "manifest.version.supportCore")
+			plugin: text(version.plugin, "manifest.version.plugin"),
+			supportCore: text(version.supportCore, "manifest.version.supportCore")
 		}
 	};
-	if (manifest.icon !== void 0) {
-		const icon = parsePluginIconReference(manifest.icon);
-		result.icon = icon.type === "remote" ? icon.url : requiredString(manifest.icon, "manifest.icon").trim();
-	}
+	if (manifest.icon !== void 0) result.icon = pluginIcon(manifest.icon);
 	if (manifest.entry !== void 0) {
-		const entry = requiredRecord(manifest.entry, "manifest.entry");
+		const entry = record$1(manifest.entry, "manifest.entry");
 		result.entry = {
-			jsPath: optionalPath(entry.jsPath, "manifest.entry.jsPath"),
-			...entry.cssPath === void 0 ? {} : { cssPath: optionalPath(entry.cssPath, "manifest.entry.cssPath") }
+			jsPath: safePluginPath(entry.jsPath, "manifest.entry.jsPath"),
+			...entry.cssPath === void 0 ? {} : { cssPath: safePluginPath(entry.cssPath, "manifest.entry.cssPath") }
 		};
 	}
 	if (manifest.kind !== void 0) {
@@ -122,23 +616,20 @@ const parsePluginManifest = (value) => {
 		result.kind = manifest.kind;
 	}
 	if (manifest.integrity !== void 0) {
-		const integrity = requiredRecord(manifest.integrity, "manifest.integrity");
+		const integrity = record$1(manifest.integrity, "manifest.integrity");
 		if (integrity.algorithm !== "blake3" && integrity.algorithm !== "sha256") throw new PluginManifestError("manifest.integrity.algorithm is unsupported");
 		result.integrity = {
 			algorithm: integrity.algorithm,
-			digest: requiredString(integrity.digest, "manifest.integrity.digest")
+			digest: text(integrity.digest, "manifest.integrity.digest")
 		};
 	}
 	return result;
 };
 const isPluginManifestCompatible = (manifest, coreVersion) => semver.satisfies(coreVersion, manifest.version.supportCore);
-//#endregion
-//#region lib/marketplace/types.ts
-const AWESOME_REGISTRY_BASE_URL = "https://raw.githubusercontent.com/delta-comic/awesome-plugins/main/";
 const AWESOME_REGISTRY_INDEX_PATH = "registry/index.json";
-const AWESOME_REGISTRY_SCHEMA_VERSION = 1;
 //#endregion
-//#region lib/marketplace/validation.ts
+//#region lib/adapters/awesomeRegistry/schema.ts
+/** Paths are validated before they are resolved against the configured registry origin. */
 const PAGE_PATH_PATTERN = /^registry\/pages\/[1-9][0-9]*\.json$/;
 const PLUGIN_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
 const GITHUB_LOGIN_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/;
@@ -358,7 +849,7 @@ const parseAwesomeRegistryPage = (value) => {
 };
 const assertAwesomeRegistryPagePath = (value) => path(value, "page path");
 //#endregion
-//#region lib/marketplace/cache.ts
+//#region lib/adapters/awesomeRegistry/cache.ts
 const parseEnvelope = (value) => {
 	try {
 		const envelope = JSON.parse(value);
@@ -431,13 +922,14 @@ var AwesomeRegistryCache = class {
 	}
 };
 //#endregion
-//#region lib/marketplace/client.ts
+//#region lib/adapters/awesomeRegistry/client.ts
 const marketplaceLogger = logger.scoped("plugin:marketplace");
-const defaultRequestJson = async (url) => await ky.get(url, {
+const defaultRequestJson = async (url, signal) => await ky.get(url, {
 	retry: 2,
+	signal,
 	timeout: 3e4
 }).json();
-const defaultStorage = () => {
+const defaultStorage$1 = () => {
 	try {
 		return globalThis.localStorage;
 	} catch {
@@ -452,27 +944,56 @@ var AwesomeRegistryNetworkError = class extends Error {
 		this.name = "AwesomeRegistryNetworkError";
 	}
 };
+const catalogIndex = (index) => ({
+	pageSize: index.pageSize,
+	pages: index.pages,
+	totalItems: index.totalItems,
+	totalPages: index.totalPages
+});
+const catalogListing = (listing) => ({
+	authors: listing.authors,
+	id: listing.id,
+	...listing.release ? { release: listing.release } : {},
+	...listing.repository ? { repository: listing.repository } : {},
+	source: listing.download
+});
+const catalogPage = (page) => ({
+	items: page.items.map(catalogListing),
+	pagination: page.pagination
+});
 var AwesomeRegistryClient = class {
 	baseUrl;
 	cache;
 	requestJson;
 	constructor(options = {}) {
 		this.baseUrl = new URL(options.baseUrl ?? "https://raw.githubusercontent.com/delta-comic/awesome-plugins/main/").href;
-		this.cache = options.cache ?? new AwesomeRegistryCache(options.storage ?? defaultStorage());
+		this.cache = options.cache ?? new AwesomeRegistryCache(options.storage ?? defaultStorage$1());
 		this.requestJson = options.requestJson ?? defaultRequestJson;
 	}
-	async loadIndex() {
-		return await this.load(AWESOME_REGISTRY_INDEX_PATH, parseAwesomeRegistryIndex, () => this.cache.readIndex(), (data) => this.cache.writeIndex(data));
+	async loadIndex(signal) {
+		const result = await this.load(AWESOME_REGISTRY_INDEX_PATH, parseAwesomeRegistryIndex, () => this.cache.readIndex(), (data) => this.cache.writeIndex(data), signal);
+		return {
+			...result,
+			data: catalogIndex(result.data)
+		};
 	}
-	async loadPage(path) {
+	async loadPage(path, signal) {
 		const safePath = assertAwesomeRegistryPagePath(path);
-		return await this.load(safePath, parseAwesomeRegistryPage, () => this.cache.readPage(safePath), (data) => this.cache.writePage(safePath, data));
+		const result = await this.load(safePath, parseAwesomeRegistryPage, () => this.cache.readPage(safePath), (data) => this.cache.writePage(safePath, data), signal);
+		return {
+			...result,
+			data: catalogPage(result.data)
+		};
 	}
-	async findListing(id) {
+	async resolveInstallInput(id, signal) {
+		const listing = await this.findListing(id, signal);
+		return listing.source.type === "github" ? `gh:${listing.source.repository}` : listing.source.url;
+	}
+	async findListing(id, signal) {
 		marketplaceLogger.debug("searching marketplace listing", { plugin: id });
-		const { data: index } = await this.loadIndex();
+		const { data: index } = await this.loadIndex(signal);
 		for (const pageReference of index.pages) {
-			const { data: page } = await this.loadPage(pageReference.path);
+			const { data: page } = await this.loadPage(pageReference.path, signal);
 			const listing = page.items.find((item) => item.id === id);
 			if (listing) {
 				marketplaceLogger.debug("marketplace listing found", { plugin: id });
@@ -481,18 +1002,19 @@ var AwesomeRegistryClient = class {
 		}
 		throw new Error(`Plugin "${id}" is not registered in awesome-plugins`);
 	}
-	async loadManifest(listing) {
+	async loadManifest(listing, signal) {
 		const manifestUrl = listing.release?.manifestUrl;
 		if (!manifestUrl) return void 0;
-		const manifest = parsePluginManifest(await this.requestJson(manifestUrl));
+		const manifest = parsePluginManifest(await this.requestJson(manifestUrl, signal));
 		if (manifest.name.id !== listing.id) throw new AwesomeRegistryValidationError(`listing ${listing.id} points to manifest for ${manifest.name.id}`);
 		return manifest;
 	}
-	async load(path, parse, readCache, writeCache) {
+	async load(path, parse, readCache, writeCache, signal) {
 		let payload;
 		try {
-			payload = await this.requestJson(new URL(path, this.baseUrl).href);
+			payload = await this.requestJson(new URL(path, this.baseUrl).href, signal);
 		} catch (error) {
+			if (signal?.aborted) throw signal.reason;
 			if (error instanceof AwesomeRegistryValidationError || error instanceof SyntaxError) throw error;
 			const cached = readCache();
 			if (cached) {
@@ -515,21 +1037,1375 @@ var AwesomeRegistryClient = class {
 	}
 };
 //#endregion
-//#region lib/marketplace/index.ts
-const marketplaceDownloadToInstallInput = (download) => download.type === "github" ? `gh:${download.repository}` : download.url;
-const marketplaceListingInstallId = (listing) => `ap:${listing.id}`;
-const marketplaceListingSource = (listing) => listing.download.type === "github" ? `https://github.com/${listing.download.repository}` : listing.download.url;
+//#region lib/adapters/configStore.ts
+const loadDatabaseConfig = (pointer) => {
+	const store = useConfig$1(pointer.pluginName, pointer.config);
+	return {
+		data: store,
+		form: pointer.config,
+		name: pointer.configName,
+		ready: store.ready
+	};
+};
+var ConfigStore = class {
+	loadConfig;
+	entries = shallowReactive(/* @__PURE__ */ new Map());
+	pointers = /* @__PURE__ */ new Map();
+	isSystemDark = globalThis.matchMedia?.("(prefers-color-scheme: dark)").matches ?? false;
+	constructor(loadConfig = loadDatabaseConfig) {
+		this.loadConfig = loadConfig;
+	}
+	get form() {
+		return this.entries;
+	}
+	get isDark() {
+		const pointer = this.pointers.get("core");
+		if (!pointer) return this.isSystemDark;
+		const mode = this.load(pointer).data.value.darkMode;
+		if (mode === "light") return false;
+		if (mode === "dark") return true;
+		return this.isSystemDark;
+	}
+	load(pointer) {
+		const value = this.entries.get(pointer.key);
+		if (!value) throw new Error(`not found config by plugin "${pointer.pluginName}"`);
+		return value;
+	}
+	has(pointer) {
+		return this.entries.has(pointer.key);
+	}
+	register(pointer) {
+		const registered = this.entries.get(pointer.key);
+		const ownerPointer = this.pointers.get(pointer.pluginName);
+		if (registered && ownerPointer === pointer) return registered;
+		if (ownerPointer) throw new Error(`plugin "${pointer.pluginName}" can only register one config`);
+		const saved = this.loadConfig(pointer);
+		this.entries.set(pointer.key, saved);
+		this.pointers.set(pointer.pluginName, pointer);
+		return saved;
+	}
+	unregister(pointer) {
+		if (this.pointers.get(pointer.pluginName) !== pointer) return;
+		this.pointers.delete(pointer.pluginName);
+		this.entries.delete(pointer.key);
+	}
+};
+//#endregion
+//#region lib/install/candidateProvider.ts
+/** Normalize persisted archives into the same candidate protocol used by internal plugins. */
+var InstalledPluginCandidateProvider = class {
+	repository;
+	reader;
+	id = "installed";
+	constructor(repository, reader) {
+		this.repository = repository;
+		this.reader = reader;
+	}
+	async list(signal) {
+		const archives = await this.repository.list();
+		signal.throwIfAborted();
+		return archives.map((archive) => ({
+			enabled: archive.enable,
+			load: async (loadSignal) => await this.reader.read(archive.pluginName, archive.meta, loadSignal),
+			management: {
+				canDisable: true,
+				canUninstall: true,
+				canUpdate: archive.installInput.length > 0
+			},
+			manifest: archive.meta,
+			origin: "installed"
+		}));
+	}
+};
+//#endregion
+//#region lib/install/catalog.ts
+const catalogInstallInputPattern = /^ap:([A-Za-z0-9][A-Za-z0-9_-]{0,63})$/;
+const pluginCatalogInstallInput = (plugin) => {
+	const input = `ap:${plugin}`;
+	if (!catalogInstallInputPattern.test(input)) throw new TypeError(`invalid plugin catalog id: ${plugin}`);
+	return input;
+};
+const pluginCatalogIdFromInstallInput = (input) => typeof input === "string" ? catalogInstallInputPattern.exec(input)?.[1] : void 0;
 //#endregion
-//#region lib/pluginIcon.ts
-/** Resolves persisted plugin icon metadata into a URL that an `<img>` can consume. */
-const resolvePluginIconUrl = async (pluginId, icon) => {
-	if (icon === void 0) return void 0;
-	const reference = parsePluginIconReference(icon, "plugin icon");
-	if (reference.type === "remote") return reference.url;
-	if (!pluginId) throw new Error("A plugin id is required to resolve a local plugin icon");
-	return `${await createPluginAssetUrl(pluginId, reference.path)}${reference.fragment}`;
+//#region lib/install/codec.ts
+const sha256 = async (bytes) => {
+	const digest = await globalThis.crypto.subtle.digest("SHA-256", Uint8Array.from(bytes).buffer);
+	return [...new Uint8Array(digest)].map((value) => value.toString(16).padStart(2, "0")).join("");
+};
+const withIntegrity = async (manifest, bytes) => ({
+	...manifest,
+	integrity: {
+		algorithm: "sha256",
+		digest: await sha256(bytes)
+	}
+});
+var ZipPackageCodec = class {
+	id = "zip";
+	matches(file) {
+		return file.name.toLowerCase().endsWith(".zip") || file.type === "application/zip";
+	}
+	async decode(file, signal) {
+		const bytes = new Uint8Array(await file.arrayBuffer());
+		if (signal.aborted) throw signal.reason;
+		const archive = await JSZip.loadAsync(bytes);
+		const manifestFile = archive.file("manifest.json");
+		if (!manifestFile) throw new Error("plugin archive does not contain manifest.json");
+		const manifest = await withIntegrity(parsePluginManifest(JSON.parse(await manifestFile.async("text"))), bytes);
+		const files = /* @__PURE__ */ new Map();
+		for (const entry of Object.values(archive.files)) {
+			if (signal.aborted) throw signal.reason;
+			if (entry.dir) continue;
+			const path = safePluginPath(entry.name, `archive entry ${entry.name}`);
+			files.set(path, await entry.async("uint8array"));
+		}
+		return {
+			codecId: this.id,
+			files,
+			manifest
+		};
+	}
+};
+const description = "@description";
+var DevScriptCodec = class {
+	id = "dev-script";
+	matches(file) {
+		return /\.(?:js|mjs|user\.js)$/i.test(file.name);
+	}
+	async decode(file, signal) {
+		const bytes = new Uint8Array(await file.arrayBuffer());
+		if (signal.aborted) throw signal.reason;
+		const code = new TextDecoder().decode(bytes);
+		const start = code.indexOf(description);
+		if (start < 0) throw new Error("development plugin does not contain @description metadata");
+		const [line] = code.slice(start + 12).trimStart().split(/\r?\n/, 1);
+		const manifest = await withIntegrity(parsePluginManifest(JSON.parse(line)), bytes);
+		return {
+			codecId: this.id,
+			files: /* @__PURE__ */ new Map([["index.mjs", bytes]]),
+			manifest: {
+				...manifest,
+				entry: {
+					...manifest.entry,
+					jsPath: "index.mjs"
+				}
+			}
+		};
+	}
+};
+//#endregion
+//#region lib/install/moduleReader.ts
+const asFactory = (value, plugin) => {
+	if (typeof value !== "function") throw new TypeError(`plugin entry has no default factory: ${plugin}`);
+	return value;
+};
+var StoredPluginModuleReader = class {
+	files;
+	constructor(files) {
+		this.files = files;
+	}
+	async read(plugin, manifest, signal) {
+		const entry = manifest.entry?.jsPath ?? "index.mjs";
+		const url = await this.files.createModuleUrl(plugin, entry);
+		if (signal.aborted) {
+			this.files.release(plugin);
+			throw signal.reason;
+		}
+		let style;
+		try {
+			const module = await import(
+				/* @vite-ignore */
+				url
+);
+			signal.throwIfAborted();
+			if (manifest.entry?.cssPath && typeof document !== "undefined") {
+				style = document.createElement("style");
+				style.dataset.plugin = plugin;
+				style.textContent = new TextDecoder().decode(await this.files.read(plugin, manifest.entry.cssPath));
+				signal.throwIfAborted();
+				document.head.append(style);
+			}
+			return {
+				factory: asFactory(module.default, plugin),
+				dispose: () => {
+					style?.remove();
+					this.files.release(plugin);
+				}
+			};
+		} catch (error) {
+			style?.remove();
+			this.files.release(plugin);
+			throw error;
+		}
+	}
+};
+//#endregion
+//#region lib/install/repository.ts
+var DatabasePluginArchiveRepository = class {
+	async find(plugin) {
+		return await db.selectFrom("plugin").selectAll().where("pluginName", "=", plugin).executeTakeFirst();
+	}
+	async list() {
+		return await db.selectFrom("plugin").selectAll().execute();
+	}
+	async remove(plugin) {
+		await db.deleteFrom("plugin").where("pluginName", "=", plugin).execute();
+	}
+	async upsert(archive) {
+		await db.replaceInto("plugin").values({
+			...archive,
+			meta: JSON.stringify(archive.meta)
+		}).execute();
+	}
+};
+//#endregion
+//#region lib/install/service.ts
+var PluginInstallService = class {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	async install(input, signal = new AbortController().signal, report = () => {}) {
+		report({
+			phase: "resolve",
+			progress: 0
+		});
+		const resolver = this.options.resolvers.find((candidate) => candidate.matches(input));
+		if (!resolver) throw new Error("no plugin source resolver accepts this input");
+		const source = await resolver.resolve(input, signal);
+		report({
+			description: source.file.name,
+			phase: "resolve",
+			progress: 100
+		});
+		const codec = this.options.codecs.find((candidate) => candidate.matches(source.file));
+		if (!codec) throw new Error("no plugin package codec accepts this file");
+		report({
+			description: codec.id,
+			phase: "decode",
+			progress: 0
+		});
+		const decoded = await codec.decode(source.file, signal);
+		const plugin = decoded.manifest.name.id;
+		if (this.options.reservedIds?.has(plugin)) throw new Error(`plugin id "${plugin}" is reserved by an internal plugin`);
+		report({
+			description: plugin,
+			phase: "decode",
+			progress: 100
+		});
+		const previous = await this.options.repository.find(plugin);
+		const replacement = await this.options.files.replace(plugin, decoded.files);
+		const archive = {
+			displayName: decoded.manifest.name.display,
+			enable: previous?.enable ?? true,
+			installerName: source.resolverId,
+			installInput: source.installInput,
+			loaderName: decoded.codecId,
+			meta: decoded.manifest,
+			pluginName: plugin
+		};
+		try {
+			report({
+				description: plugin,
+				phase: "persist",
+				progress: 50
+			});
+			await this.options.repository.upsert(archive);
+			await replacement.commit();
+			report({
+				description: plugin,
+				phase: "persist",
+				progress: 100
+			});
+			return archive;
+		} catch (error) {
+			const rollbackErrors = [];
+			try {
+				await replacement.rollback();
+			} catch (rollbackError) {
+				rollbackErrors.push(rollbackError);
+			}
+			try {
+				if (previous) await this.options.repository.upsert(previous);
+				else await this.options.repository.remove(plugin);
+			} catch (rollbackError) {
+				rollbackErrors.push(rollbackError);
+			}
+			if (rollbackErrors.length > 0) throw new AggregateError([error, ...rollbackErrors], `failed to install plugin "${plugin}"`);
+			throw error;
+		}
+	}
+	/** Remove archive metadata and files as one compensating transaction. */
+	async uninstall(plugin) {
+		const previous = await this.options.repository.find(plugin);
+		const replacement = await this.options.files.replace(plugin, /* @__PURE__ */ new Map());
+		try {
+			await this.options.repository.remove(plugin);
+			await replacement.commit();
+		} catch (error) {
+			const rollbackErrors = [];
+			try {
+				await replacement.rollback();
+			} catch (rollbackError) {
+				rollbackErrors.push(rollbackError);
+			}
+			try {
+				if (previous) await this.options.repository.upsert(previous);
+			} catch (rollbackError) {
+				rollbackErrors.push(rollbackError);
+			}
+			if (rollbackErrors.length > 0) throw new AggregateError([error, ...rollbackErrors], `failed to uninstall plugin "${plugin}"`);
+			throw error;
+		}
+	}
+};
+//#endregion
+//#region lib/install/source.ts
+var LocalFileSourceResolver = class {
+	id = "local-file";
+	matches(input) {
+		return typeof input !== "string";
+	}
+	async resolve(input) {
+		if (typeof input === "string") throw new TypeError("local file resolver requires a File");
+		return {
+			file: input,
+			installInput: "",
+			resolverId: this.id
+		};
+	}
+};
+var HttpSourceResolver = class {
+	id = "http";
+	matches(input) {
+		return typeof input === "string" && /^https?:\/\//i.test(input);
+	}
+	async resolve(input, signal) {
+		if (typeof input !== "string") throw new TypeError("HTTP resolver requires a URL");
+		const response = await fetch(input, { signal });
+		if (!response.ok) throw new Error(`plugin download failed: ${response.status}`);
+		const name = new URL(input).pathname.split("/").at(-1) || "plugin.zip";
+		return {
+			file: new File([await response.blob()], name),
+			installInput: input,
+			resolverId: this.id
+		};
+	}
+};
+var GitHubSourceResolver = class {
+	options;
+	id = "github";
+	constructor(options) {
+		this.options = options;
+	}
+	matches(input) {
+		return typeof input === "string" && /^gh:[^/]+\/[^/]+$/.test(input);
+	}
+	async resolve(input, signal) {
+		if (typeof input !== "string") throw new TypeError("GitHub resolver requires a repository");
+		const [owner, repo] = input.slice(3).split("/");
+		const octokit = new Octokit({ auth: this.options.token });
+		const pages = octokit.paginate.iterator(octokit.rest.repos.listReleases, {
+			owner,
+			per_page: 100,
+			repo,
+			request: { signal }
+		});
+		for await (const page of pages) for (const release of page.data) {
+			if (release.draft || release.prerelease) continue;
+			const manifestAsset = release.assets.find((asset) => asset.name === "manifest.json");
+			const packageAsset = release.assets.find((asset) => asset.name === "plugin.zip");
+			if (!manifestAsset || !packageAsset) continue;
+			const manifestResponse = await fetch(manifestAsset.browser_download_url, { signal });
+			if (!manifestResponse.ok) continue;
+			if (!isPluginManifestCompatible(parsePluginManifest(await manifestResponse.json()), this.options.coreVersion)) continue;
+			const packageResponse = await fetch(packageAsset.browser_download_url, { signal });
+			if (!packageResponse.ok) throw new Error(`plugin download failed: ${packageResponse.status}`);
+			return {
+				file: new File([await packageResponse.blob()], packageAsset.name),
+				installInput: input,
+				resolverId: this.id
+			};
+		}
+		throw new Error(`no compatible plugin release found for ${owner}/${repo}`);
+	}
+};
+var MarketplaceSourceResolver = class {
+	catalog;
+	sources;
+	id = "marketplace";
+	constructor(catalog, sources) {
+		this.catalog = catalog;
+		this.sources = sources;
+	}
+	matches(input) {
+		return pluginCatalogIdFromInstallInput(input) !== void 0;
+	}
+	async resolve(input, signal) {
+		if (typeof input !== "string") throw new TypeError("marketplace resolver requires a plugin catalog id");
+		const plugin = pluginCatalogIdFromInstallInput(input);
+		if (!plugin) throw new TypeError("marketplace resolver requires a plugin catalog id");
+		const redirected = await this.catalog.resolveInstallInput(plugin, signal);
+		const resolver = this.sources.find((source) => source.matches(redirected));
+		if (!resolver) throw new Error(`plugin catalog returned an unsupported install source: ${redirected}`);
+		return {
+			...await resolver.resolve(redirected, signal),
+			installInput: input,
+			resolverId: this.id
+		};
+	}
+};
+//#endregion
+//#region lib/adapters/fileStore.ts
+const mimeType = (path) => ({
+	avif: "image/avif",
+	gif: "image/gif",
+	jpeg: "image/jpeg",
+	jpg: "image/jpeg",
+	png: "image/png",
+	svg: "image/svg+xml",
+	webp: "image/webp"
+})[path.split(".").at(-1)?.toLowerCase() ?? ""] ?? "application/octet-stream";
+var IndexedDbPluginFileBackend = class {
+	#database = "delta-comic-plugin-files-v2";
+	#store = "files";
+	async #open() {
+		return await new Promise((resolve, reject) => {
+			const request = indexedDB.open(this.#database, 1);
+			request.onupgradeneeded = () => {
+				if (!request.result.objectStoreNames.contains(this.#store)) request.result.createObjectStore(this.#store);
+			};
+			request.onsuccess = () => resolve(request.result);
+			request.onerror = () => reject(request.error);
+		});
+	}
+	#key(plugin, path) {
+		return `${plugin}/${path}`;
+	}
+	async read(plugin, path) {
+		const database = await this.#open();
+		try {
+			return await new Promise((resolve, reject) => {
+				const request = database.transaction(this.#store, "readonly").objectStore(this.#store).get(this.#key(plugin, path));
+				request.onsuccess = () => {
+					if (!request.result) reject(/* @__PURE__ */ new Error(`plugin file not found: ${plugin}/${path}`));
+					else resolve(Uint8Array.from(request.result));
+				};
+				request.onerror = () => reject(request.error);
+			});
+		} finally {
+			database.close();
+		}
+	}
+	async snapshot(plugin) {
+		const database = await this.#open();
+		try {
+			return await new Promise((resolve, reject) => {
+				const files = /* @__PURE__ */ new Map();
+				const transaction = database.transaction(this.#store, "readonly");
+				const request = transaction.objectStore(this.#store).openCursor();
+				const prefix = `${plugin}/`;
+				request.onsuccess = () => {
+					const cursor = request.result;
+					if (!cursor) return;
+					const key = String(cursor.key);
+					if (key.startsWith(prefix)) files.set(key.slice(prefix.length), Uint8Array.from(cursor.value));
+					cursor.continue();
+				};
+				request.onerror = () => reject(request.error);
+				transaction.oncomplete = () => resolve(files);
+				transaction.onerror = () => reject(transaction.error);
+			});
+		} finally {
+			database.close();
+		}
+	}
+	async replace(plugin, files) {
+		const database = await this.#open();
+		try {
+			await new Promise((resolve, reject) => {
+				const transaction = database.transaction(this.#store, "readwrite");
+				const store = transaction.objectStore(this.#store);
+				const prefix = `${plugin}/`;
+				const cursor = store.openKeyCursor();
+				cursor.onsuccess = () => {
+					if (cursor.result) {
+						if (String(cursor.result.key).startsWith(prefix)) cursor.result.delete();
+						cursor.result.continue();
+						return;
+					}
+					for (const [path, bytes] of files) store.put(bytes, this.#key(plugin, path));
+				};
+				cursor.onerror = () => reject(cursor.error);
+				transaction.oncomplete = () => resolve();
+				transaction.onerror = () => reject(transaction.error);
+				transaction.onabort = () => reject(transaction.error);
+			});
+		} finally {
+			database.close();
+		}
+	}
+};
+var TauriPluginFileBackend = class {
+	async #root(plugin) {
+		const { appLocalDataDir, join } = await import("@tauri-apps/api/path");
+		return await join(await appLocalDataDir(), "plugin", plugin);
+	}
+	async read(plugin, path) {
+		const [{ join }, fs] = await Promise.all([import("@tauri-apps/api/path"), import("@tauri-apps/plugin-fs")]);
+		return await fs.readFile(await join(await this.#root(plugin), path));
+	}
+	async snapshot(plugin) {
+		const [{ join }, fs] = await Promise.all([import("@tauri-apps/api/path"), import("@tauri-apps/plugin-fs")]);
+		const root = await this.#root(plugin);
+		const files = /* @__PURE__ */ new Map();
+		if (!await fs.exists(root)) return files;
+		const visit = async (directory, prefix = "") => {
+			for (const entry of await fs.readDir(directory)) {
+				const path = prefix ? `${prefix}/${entry.name}` : entry.name;
+				const absolute = await join(directory, entry.name);
+				if (entry.isDirectory) await visit(absolute, path);
+				else if (entry.isFile) files.set(path, await fs.readFile(absolute));
+			}
+		};
+		await visit(root);
+		return files;
+	}
+	async replace(plugin, files) {
+		const [{ appLocalDataDir, join }, fs] = await Promise.all([import("@tauri-apps/api/path"), import("@tauri-apps/plugin-fs")]);
+		const appData = await appLocalDataDir();
+		const base = await join(appData, "plugin");
+		const token = crypto.randomUUID();
+		const live = await join(base, plugin);
+		const stagingRoot = await join(appData, "plugin-staging");
+		const backupRoot = await join(appData, "plugin-backup");
+		const staging = await join(stagingRoot, `${plugin}-${token}`);
+		const backup = await join(backupRoot, `${plugin}-${token}`);
+		await fs.mkdir(staging, { recursive: true });
+		try {
+			for (const [path, bytes] of files) {
+				const segments = safePluginPath(path, "plugin file path").split("/");
+				const target = await join(staging, ...segments);
+				const parent = await join(staging, ...segments.slice(0, -1));
+				await fs.mkdir(parent, { recursive: true });
+				await fs.writeFile(target, bytes);
+			}
+			const existed = await fs.exists(live);
+			if (existed) {
+				await fs.mkdir(backupRoot, { recursive: true });
+				await fs.rename(live, backup);
+			}
+			try {
+				await fs.rename(staging, live);
+			} catch (error) {
+				if (existed && await fs.exists(backup)) await fs.rename(backup, live);
+				throw error;
+			}
+			if (await fs.exists(backup)) await fs.remove(backup, { recursive: true }).catch(() => void 0);
+		} catch (error) {
+			if (await fs.exists(staging)) await fs.remove(staging, { recursive: true });
+			throw error;
+		}
+	}
+	async moduleUrl(plugin, path) {
+		const { convertFileSrc } = await import("@tauri-apps/api/core");
+		const { join } = await import("@tauri-apps/api/path");
+		return convertFileSrc(await join(await this.#root(plugin), path));
+	}
+};
+var AtomicPluginFileStore = class {
+	backend;
+	#urls = /* @__PURE__ */ new Map();
+	constructor(backend) {
+		this.backend = backend;
+	}
+	async replace(plugin, files) {
+		const previous = await this.backend.snapshot(plugin);
+		await this.backend.replace(plugin, files);
+		let settled = false;
+		return {
+			commit: async () => {
+				settled = true;
+			},
+			rollback: async () => {
+				if (settled) return;
+				settled = true;
+				await this.backend.replace(plugin, previous);
+			}
+		};
+	}
+	async remove(plugin) {
+		this.release(plugin);
+		await this.backend.replace(plugin, /* @__PURE__ */ new Map());
+	}
+	read(plugin, path) {
+		return this.backend.read(plugin, safePluginPath(path, "plugin file path"));
+	}
+	async createModuleUrl(plugin, path) {
+		const safePath = safePluginPath(path, "plugin module path");
+		if (this.backend.moduleUrl) return await this.backend.moduleUrl(plugin, safePath);
+		const bytes = await this.backend.read(plugin, safePath);
+		const url = URL.createObjectURL(new Blob([Uint8Array.from(bytes)], { type: "text/javascript" }));
+		const urls = this.#urls.get(plugin) ?? /* @__PURE__ */ new Set();
+		urls.add(url);
+		this.#urls.set(plugin, urls);
+		return url;
+	}
+	async createAssetUrl(plugin, path) {
+		const safePath = safePluginPath(path, "plugin asset path");
+		if (this.backend.moduleUrl) return await this.backend.moduleUrl(plugin, safePath);
+		const bytes = await this.backend.read(plugin, safePath);
+		const url = URL.createObjectURL(new Blob([Uint8Array.from(bytes)], { type: mimeType(path) }));
+		const urls = this.#urls.get(plugin) ?? /* @__PURE__ */ new Set();
+		urls.add(url);
+		this.#urls.set(plugin, urls);
+		return url;
+	}
+	release(plugin) {
+		for (const url of this.#urls.get(plugin) ?? []) URL.revokeObjectURL(url);
+		this.#urls.delete(plugin);
+	}
+};
+const createDefaultPluginFileStore = () => new AtomicPluginFileStore(isTauri() ? new TauriPluginFileBackend() : new IndexedDbPluginFileBackend());
+//#endregion
+//#region lib/adapters/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 package.json
+var version = "3.0.0-next.9";
+//#endregion
+//#region lib/core/env.ts
+const pluginName = "core";
+//#endregion
+//#region lib/core/config.ts
+const cfg = new ConfigPointer(pluginName, {
+	recordHistory: {
+		type: "switch",
+		defaultValue: true,
+		info: "plugin.core.config.recordHistory"
+	},
+	showAIProject: {
+		type: "switch",
+		defaultValue: true,
+		info: "plugin.core.config.showAiWorks"
+	},
+	darkMode: {
+		type: "radio",
+		defaultValue: "system",
+		info: "plugin.core.config.theme.title",
+		comp: "select",
+		selects: [
+			{
+				label: "plugin.core.config.theme.light",
+				value: "light"
+			},
+			{
+				label: "plugin.core.config.theme.dark",
+				value: "dark"
+			},
+			{
+				label: "plugin.core.config.systemDefault",
+				value: "system"
+			}
+		]
+	},
+	language: {
+		type: "radio",
+		defaultValue: "system",
+		info: "plugin.core.config.language.title",
+		comp: "select",
+		selects: [
+			{
+				label: "plugin.core.config.language.zhCN",
+				value: "zh-CN"
+			},
+			{
+				label: "plugin.core.config.language.zhTW",
+				value: "zh-TW"
+			},
+			{
+				label: "plugin.core.config.language.enUS",
+				value: "en-US"
+			},
+			{
+				label: "plugin.core.config.systemDefault",
+				value: "system"
+			}
+		]
+	},
+	easilyTitle: {
+		type: "switch",
+		defaultValue: false,
+		info: "plugin.core.config.simplifiedTitle"
+	},
+	githubToken: {
+		type: "string",
+		defaultValue: "",
+		info: "plugin.core.config.githubToken.title",
+		placeholder: "plugin.core.config.githubToken.placeholder"
+	},
+	receivePerReleaseUpdate: {
+		type: "switch",
+		defaultValue: false,
+		info: "plugin.core.config.prereleaseUpdates"
+	},
+	cloudEnabled: {
+		type: "switch",
+		defaultValue: false,
+		info: "plugin.core.config.cloud.enabled"
+	},
+	cloudServerUrl: {
+		type: "string",
+		defaultValue: "",
+		info: "plugin.core.config.cloud.serverUrl",
+		placeholder: "plugin.core.config.cloud.serverUrlPlaceholder"
+	},
+	installOverride: {
+		type: "pairs",
+		defaultValue: [],
+		info: "plugin.core.config.installOverride",
+		required: true
+	}
+}, "plugin.core.config.name");
+//#endregion
+//#region lib/core/share.ts
+const tokenInit = {
+	filter: (page) => !!page.preload,
+	icon: {},
+	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: UniContentPage.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}` };
+	}
+};
+const nativeInit = {
+	filter: (page) => !!page.preload,
+	icon: {},
+	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: UniContentPage.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 };
+	}
+};
+const tokenShare = {
+	key: "token",
+	name: pluginMessageKey("plugin.share.defaultToken"),
+	isMatched(chipboard) {
+		return /^\[.+\]\(复制这条口令，打开Delta Comic\).+/.test(chipboard);
+	},
+	async show(chipboard) {
+		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 }),
+			onNegative() {},
+			onPositive() {
+				return SharedFunction.call("routeToContent", UniContentPage.contentPages.key.toJSON(meta.item.contentType), meta.id, meta.item.ep);
+			}
+		};
+	}
+};
+//#endregion
+//#region lib/core/index.ts
+var core_exports = /* @__PURE__ */ __exportAll({
+	cfg: () => cfg,
+	default: () => core_default
+});
+var core_default = defineDeltaComicPlugin(() => ({
+	config: cfg,
+	name: pluginName,
+	model: { social: { share: {
+		initiative: [tokenInit, nativeInit],
+		tokenListen: [tokenShare]
+	} } }
+}));
+//#endregion
+//#region lib/builtins/core.builtin.ts
+var core_builtin_exports = /* @__PURE__ */ __exportAll({
+	corePluginDefinition: () => corePluginDefinition,
+	default: () => corePluginDefinition
+});
+const corePluginDefinition = defineInternalPlugin({
+	canDisable: false,
+	factory: core_default,
+	manifest: {
+		apiVersion: DELTA_COMIC_PLUGIN_API_VERSION,
+		author: "Delta Comic",
+		description: "Delta Comic host capabilities",
+		kind: "preboot",
+		name: {
+			display: "core",
+			id: "core"
+		},
+		require: [],
+		version: {
+			plugin: version,
+			supportCore: "*"
+		}
+	}
+});
+/** Files are the registration boundary: adding a built-in does not change the composition root. */
+const internalPluginDefinitions = Object.entries(/* @__PURE__ */ Object.assign({ "./core.builtin.ts": core_builtin_exports })).sort(([left], [right]) => left.localeCompare(right)).map(([path, module]) => {
+	if (!module.default) throw new Error(`built-in plugin module has no default definition: ${path}`);
+	return module.default;
+});
+//#endregion
+//#region lib/runtime/store.ts
+var PluginStore = class {
+	translateText;
+	candidateEntries = shallowReactive(/* @__PURE__ */ new Map());
+	loadingEntries = shallowReactive(/* @__PURE__ */ new Map());
+	pluginEntries = shallowReactive(/* @__PURE__ */ new Map());
+	readyEntries = shallowReactive(/* @__PURE__ */ new Set());
+	constructor(translateText = (value) => value) {
+		this.translateText = translateText;
+	}
+	get candidates() {
+		return this.candidateEntries;
+	}
+	get loading() {
+		return this.loadingEntries;
+	}
+	get plugins() {
+		return this.pluginEntries;
+	}
+	get ready() {
+		return this.readyEntries;
+	}
+	replaceCandidates(candidates) {
+		this.candidateEntries.clear();
+		for (const candidate of candidates) this.candidateEntries.set(candidate.manifest.name.id, candidate);
+	}
+	markLoading(plugin, config) {
+		this.readyEntries.delete(plugin);
+		this.loadingEntries.set(plugin, config);
+		this.pluginEntries.delete(plugin);
+	}
+	markReady(plugin) {
+		const config = this.loadingEntries.get(plugin);
+		if (!config) throw new Error(`plugin "${plugin}" was not marked as loading`);
+		this.loadingEntries.delete(plugin);
+		this.pluginEntries.set(plugin, config);
+		this.readyEntries.add(plugin);
+	}
+	markUnloaded(plugin) {
+		this.readyEntries.delete(plugin);
+		this.loadingEntries.delete(plugin);
+		this.pluginEntries.delete(plugin);
+	}
+	isLoaded(plugin) {
+		return this.readyEntries.has(plugin);
+	}
+	displayName(plugin) {
+		return this.translateText(this.candidateEntries.get(plugin)?.manifest.name.display ?? plugin);
+	}
+	modelEntries(key) {
+		return [...this.pluginEntries].flatMap(([plugin, config]) => {
+			const model = config.model?.[key];
+			return model === void 0 ? [] : [[plugin, model]];
+		});
+	}
+};
+//#endregion
+//#region lib/runtime/engine.ts
+const recoveryKey = "delta-comic:preboot-recovery:v2";
+const errorText = (error) => error instanceof Error ? error.message : String(error);
+const loadingInfo = () => ({
+	progress: {
+		status: "wait",
+		stepsIndex: 0
+	},
+	steps: [{
+		description: "",
+		name: "waiting"
+	}]
+});
+var PluginRuntime = class {
+	#active = /* @__PURE__ */ new Map();
+	#options;
+	#normalOperation;
+	#prebootOperation;
+	#prebootReport;
+	store;
+	constructor(options) {
+		this.#options = options;
+		this.store = options.store ?? new PluginStore();
+	}
+	get activeNormalPluginNames() {
+		return [...this.#active].filter(([, value]) => (value.candidate.manifest.kind ?? "normal") === "normal").map(([plugin]) => plugin);
+	}
+	async preparePreboot(app) {
+		if (this.#prebootReport) return this.#prebootReport;
+		if (this.#prebootOperation) return await this.#prebootOperation;
+		const operation = (async () => {
+			const progress = ref({});
+			const report = await this.#load("preboot", progress, void 0, app);
+			this.#prebootReport = report;
+			if (report.failures.length > 0) this.#writeRecovery(report.failures);
+			return report;
+		})();
+		this.#prebootOperation = operation;
+		try {
+			return await operation;
+		} finally {
+			this.#prebootOperation = void 0;
+		}
+	}
+	loadNormal(options = {}) {
+		if (this.#normalOperation) throw new Error("normal plugins are already loading");
+		if (this.activeNormalPluginNames.length > 0) throw new Error("normal plugins are already active; use reloadNormal()");
+		const progress = ref({});
+		const operation = this.#load("normal", progress, options.pluginNames);
+		this.#track(operation);
+		return {
+			operation,
+			progress
+		};
+	}
+	reloadNormal(options = {}) {
+		if (this.#normalOperation) throw new Error("normal plugins are already loading");
+		const progress = ref({});
+		const operation = (async () => {
+			await this.#unload((candidate) => (candidate.manifest.kind ?? "normal") === "normal");
+			return await this.#load("normal", progress, options.pluginNames);
+		})();
+		this.#track(operation);
+		return {
+			operation,
+			progress
+		};
+	}
+	async uninstall(plugin) {
+		const candidate = this.store.candidates.get(plugin);
+		if (!candidate) throw new Error(`plugin "${plugin}" is not a known candidate`);
+		if (!candidate.management.canUninstall) throw new Error(`plugin "${plugin}" cannot be uninstalled`);
+		const active = this.#active.get(plugin);
+		if (active) await this.#deactivate(plugin, active.scope);
+		else {
+			const scope = new PluginScope(plugin);
+			try {
+				const loaded = await candidate.load(scope.signal);
+				if (loaded.dispose) scope.defer(loaded.dispose);
+				await loaded.factory(this.#options.environment()).hooks?.onUninstall?.();
+			} finally {
+				await scope.dispose();
+			}
+		}
+		await this.#options.remove(plugin);
+		await this.refreshCandidates();
+	}
+	async refreshCandidates() {
+		const candidates = await this.#options.provider.list(new AbortController().signal);
+		this.store.replaceCandidates(candidates);
+		return candidates;
+	}
+	readRecovery() {
+		try {
+			const value = globalThis.localStorage?.getItem(recoveryKey);
+			return value ? JSON.parse(value) : null;
+		} catch {
+			return null;
+		}
+	}
+	clearRecovery() {
+		globalThis.localStorage?.removeItem(recoveryKey);
+	}
+	async #load(phase, progress, selected, app) {
+		const candidates = await this.refreshCandidates();
+		const activeDependencies = new Set(this.#active.keys());
+		const phaseCandidates = candidates.filter((candidate) => candidate.enabled && (candidate.manifest.kind ?? "normal") === phase).map((candidate) => ({
+			...candidate,
+			manifest: {
+				...candidate.manifest,
+				require: candidate.manifest.require.filter((value) => !activeDependencies.has(value.id))
+			}
+		}));
+		const plan = planPluginDependencies(selected ? this.#selectWithDependencies(phaseCandidates, selected) : phaseCandidates);
+		if (plan.missing.length > 0 || plan.cycles.length > 0) {
+			const missing = plan.missing.map((value) => `${value.plugin} -> ${value.dependency}`).join(", ");
+			const cycles = plan.cycles.map((value) => value.join(" -> ")).join(", ");
+			throw new Error([missing && `missing: ${missing}`, cycles && `cycles: ${cycles}`].filter(Boolean).join("; "));
+		}
+		const activated = [];
+		const failures = [];
+		const failed = /* @__PURE__ */ new Set();
+		for (const level of plan.levels) for (const candidate of level) {
+			const plugin = candidate.manifest.name.id;
+			const info = progress.value[plugin] = loadingInfo();
+			const blockedBy = candidate.manifest.require.map((value) => value.id).filter((dependency) => failed.has(dependency));
+			if (blockedBy.length > 0) {
+				const error = /* @__PURE__ */ new Error(`dependency activation failed: ${blockedBy.join(", ")}`);
+				info.progress = {
+					errorReason: error.message,
+					status: "error",
+					stepsIndex: 0
+				};
+				failures.push({
+					error,
+					phase,
+					plugin
+				});
+				failed.add(plugin);
+				continue;
+			}
+			const scope = new PluginScope(plugin);
+			try {
+				info.progress.status = "process";
+				info.steps[0] = {
+					description: "",
+					name: "module"
+				};
+				const loaded = await candidate.load(scope.signal);
+				if (loaded.dispose) scope.defer(loaded.dispose);
+				const config = markRaw(loaded.factory(this.#options.environment()));
+				if (config.name !== plugin) throw new Error(`plugin name mismatch: ${plugin} / ${config.name}`);
+				this.store.markLoading(plugin, config);
+				scope.defer(() => this.store.markUnloaded(plugin));
+				await new ActivationPipeline(this.#options.capabilities(phase, app)).activate(config, {
+					owner: plugin,
+					report: (update) => {
+						const value = typeof update === "string" ? { description: update } : update;
+						info.steps[0] = {
+							...info.steps[0],
+							...value
+						};
+					},
+					scope,
+					signal: scope.signal
+				});
+				this.#active.set(plugin, {
+					candidate,
+					scope
+				});
+				this.store.markReady(plugin);
+				info.progress.status = "done";
+				activated.push(plugin);
+			} catch (error) {
+				info.progress = {
+					errorReason: errorText(error),
+					status: "error",
+					stepsIndex: 0
+				};
+				failures.push({
+					error,
+					phase,
+					plugin
+				});
+				failed.add(plugin);
+				await scope.dispose(error).catch((disposeError) => {
+					failures.push({
+						error: disposeError,
+						phase,
+						plugin
+					});
+				});
+			}
+		}
+		return {
+			activated,
+			failures
+		};
+	}
+	#selectWithDependencies(candidates, selected) {
+		const byId = new Map(candidates.map((candidate) => [candidate.manifest.name.id, candidate]));
+		const result = /* @__PURE__ */ new Map();
+		const visit = (plugin) => {
+			const candidate = byId.get(plugin);
+			if (!candidate || result.has(plugin)) return;
+			for (const dependency of candidate.manifest.require) visit(dependency.id);
+			result.set(plugin, candidate);
+		};
+		for (const plugin of selected) visit(plugin);
+		return [...result.values()];
+	}
+	#track(operation) {
+		this.#normalOperation = operation;
+		operation.then(() => this.#normalOperation = void 0, () => this.#normalOperation = void 0);
+	}
+	async #unload(predicate) {
+		const targets = [...this.#active].filter(([, value]) => predicate(value.candidate)).reverse();
+		const errors = [];
+		for (const [plugin, value] of targets) try {
+			await this.#deactivate(plugin, value.scope);
+		} catch (error) {
+			errors.push(error);
+		}
+		if (errors.length > 0) throw new AggregateError(errors, "some plugins failed to unload");
+	}
+	async #deactivate(plugin, scope) {
+		this.#active.delete(plugin);
+		await scope.dispose();
+	}
+	#writeRecovery(failures) {
+		try {
+			globalThis.localStorage?.setItem(recoveryKey, JSON.stringify({
+				failedAt: Date.now(),
+				plugins: failures.map((value) => value.plugin),
+				reason: failures.map((value) => errorText(value.error)).join("\n")
+			}));
+		} catch {}
+	}
+};
+//#endregion
+//#region lib/runtime/providers.ts
+const defaultStorage = () => {
+	try {
+		return globalThis.localStorage;
+	} catch {
+		return;
+	}
+};
+var LocalInternalPluginPreferences = class {
+	storage;
+	prefix;
+	constructor(storage = defaultStorage(), prefix = "delta-comic:internal-plugin:") {
+		this.storage = storage;
+		this.prefix = prefix;
+	}
+	async enabled(plugin, fallback) {
+		try {
+			const value = this.storage?.getItem(`${this.prefix}${plugin}`);
+			return value === null || value === void 0 ? fallback : value === "true";
+		} catch {
+			return fallback;
+		}
+	}
+	async setEnabled(plugin, enabled) {
+		try {
+			this.storage?.setItem(`${this.prefix}${plugin}`, String(enabled));
+		} catch {}
+	}
+};
+var InternalPluginCandidateProvider = class {
+	definitions;
+	preferences;
+	id = "internal";
+	constructor(definitions, preferences = new LocalInternalPluginPreferences()) {
+		this.definitions = definitions;
+		this.preferences = preferences;
+	}
+	async list(signal) {
+		const candidates = [];
+		for (const definition of this.definitions) {
+			if (signal.aborted) throw signal.reason;
+			candidates.push({
+				enabled: definition.canDisable === false ? true : await this.preferences.enabled(definition.manifest.name.id, definition.enabledByDefault ?? true),
+				load: async () => ({ factory: definition.factory }),
+				management: {
+					canDisable: definition.canDisable ?? true,
+					canUninstall: false,
+					canUpdate: false
+				},
+				manifest: definition.manifest,
+				origin: "builtin"
+			});
+		}
+		return candidates;
+	}
+};
+var CompositePluginCandidateProvider = class {
+	providers;
+	id = "composite";
+	constructor(providers) {
+		this.providers = providers;
+	}
+	async list(signal) {
+		const candidates = (await Promise.all(this.providers.map((provider) => provider.list(signal)))).flat();
+		const owners = /* @__PURE__ */ new Map();
+		for (const candidate of candidates) {
+			const id = candidate.manifest.name.id;
+			const previous = owners.get(id);
+			if (previous) throw new Error(`duplicate plugin candidate "${id}" from ${previous.origin} and ${candidate.origin}`);
+			owners.set(id, candidate);
+		}
+		return [...owners.values()];
+	}
+};
+//#endregion
+//#region lib/composition.ts
+const pluginContributions = new ContributionHub();
+const pluginStore = new PluginStore((value) => value.startsWith("i18n:") ? pluginI18n.translate(value.slice(5)) : value);
+const pluginConfigStore = new ConfigStore();
+const useConfig = () => pluginConfigStore;
+const pluginHostServices = {};
+/** Install host-only integrations without exposing UI or platform details to the runtime kernel. */
+const configurePluginHost = (services) => {
+	Object.assign(pluginHostServices, services);
+};
+const pluginFiles = createDefaultPluginFileStore();
+const pluginRepository = new DatabasePluginArchiveRepository();
+const pluginReader = new StoredPluginModuleReader(pluginFiles);
+const internalPreferences = new LocalInternalPluginPreferences();
+const candidateProvider = new CompositePluginCandidateProvider([new InternalPluginCandidateProvider(internalPluginDefinitions, internalPreferences), new InstalledPluginCandidateProvider(pluginRepository, pluginReader)]);
+const httpSource = new HttpSourceResolver();
+const githubSource = new GitHubSourceResolver({ coreVersion: corePluginDefinition.manifest.version.plugin });
+const awesomeRegistry = new AwesomeRegistryClient();
+const marketplaceSource = new MarketplaceSourceResolver(awesomeRegistry, [githubSource, httpSource]);
+const pluginCatalog = awesomeRegistry;
+const pluginInstaller = new PluginInstallService({
+	codecs: [new ZipPackageCodec(), new DevScriptCodec()],
+	files: pluginFiles,
+	repository: pluginRepository,
+	reservedIds: new Set(internalPluginDefinitions.map((definition) => definition.manifest.name.id)),
+	resolvers: [
+		new LocalFileSourceResolver(),
+		marketplaceSource,
+		githubSource,
+		httpSource
+	]
+});
+const pluginRuntime = new PluginRuntime({
+	capabilities: (phase, app) => createDefaultCapabilities({
+		app,
+		auth: pluginHostServices.auth,
+		config: pluginConfigStore,
+		contributions: pluginContributions,
+		i18n: pluginI18n,
+		phase
+	}),
+	environment: () => ({
+		platform: isTauri() ? "tauri" : "web",
+		safe: globalThis.$$safe$$ ?? true
+	}),
+	provider: candidateProvider,
+	remove: (plugin) => pluginInstaller.uninstall(plugin),
+	store: pluginStore
+});
+const installPlugin = async (input) => {
+	const archive = await pluginInstaller.install(input);
+	await pluginRuntime.refreshCandidates();
+	return archive;
+};
+const updatePlugin = async (archive) => {
+	if (!archive.installInput) throw new Error("plugin has no reusable install source");
+	return await installPlugin(archive.installInput);
+};
+const updatePluginByName = async (plugin) => {
+	const archive = await pluginRepository.find(plugin);
+	if (!archive) throw new Error(`installed plugin not found: ${plugin}`);
+	return await updatePlugin(archive);
+};
+const setPluginEnabled = async (plugin, enabled) => {
+	const candidate = pluginStore.candidates.get(plugin);
+	if (!candidate?.management.canDisable) throw new Error(`plugin "${plugin}" cannot be disabled`);
+	if (candidate.origin === "builtin") await internalPreferences.setEnabled(plugin, enabled);
+	else {
+		const archive = await pluginRepository.find(plugin);
+		if (!archive) throw new Error(`installed plugin not found: ${plugin}`);
+		await pluginRepository.upsert({
+			...archive,
+			enable: enabled
+		});
+	}
+	await pluginRuntime.refreshCandidates();
+};
+const setPluginKind = async (plugin, kind) => {
+	const archive = await pluginRepository.find(plugin);
+	if (!archive) throw new Error(`installed plugin not found: ${plugin}`);
+	await pluginRepository.upsert({
+		...archive,
+		meta: {
+			...archive.meta,
+			kind
+		}
+	});
+	await pluginRuntime.refreshCandidates();
+};
+const uninstallPlugin = async (plugin) => await pluginRuntime.uninstall(plugin);
+const resolvePluginIconUrl = async (plugin, icon) => {
+	if (!icon) return void 0;
+	if (/^https?:\/\//i.test(icon)) return icon;
+	if (!plugin) throw new Error("a plugin id is required to resolve a local plugin icon");
+	return await pluginFiles.createAssetUrl(plugin, icon);
 };
+const usePluginStore = () => pluginStore;
 //#endregion
-export { AWESOME_REGISTRY_BASE_URL, AWESOME_REGISTRY_INDEX_PATH, AWESOME_REGISTRY_SCHEMA_VERSION, AwesomeRegistryCache, AwesomeRegistryClient, AwesomeRegistryNetworkError, AwesomeRegistryValidationError, AwesomeRegistryVersionError, BUILT_IN_PLUGIN_LOADER, booter_exports as Booter, ConfigPointer, ConfigStore, DependencyRegistry, Global, install_exports as Install, loader_exports as Loader, PluginBooter, PluginI18nRegistry, PluginInstaller, PluginLoader, PluginManifestError, PluginRuntimeExtensions, PluginStore, assertAwesomeRegistryPagePath, builtInDefinitionToArchive, createDependencyRegistry, declareDepType, defaultDependencyRegistry, defineInnerPlugin, definePlugin, exposeSymbol, failedDependencies, filterPluginsBySelection, findCyclePaths, formatPluginLoadPlanError, isBuiltInPlugin, isBuiltInPluginName, isPluginManifestCompatible, marketplaceDownloadToInstallInput, marketplaceListingInstallId, marketplaceListingSource, parseAwesomePluginListing, parseAwesomeRegistryIndex, parseAwesomeRegistryPage, parsePluginIconReference, parsePluginManifest, planPluginLoadOrder, pluginExposes, pluginI18n, pluginKind, pluginMessageKey, pluginRuntime, pluginStore, provide, registerBooter, registerInstaller, registerLoader, require, resolvePluginIconUrl, runtimeExtensions, selectPluginsForPhase, synchronizeBuiltInPlugins, translatePluginText, useConfig, usePluginStore };
+export { ActivationPipeline, CompositePluginCandidateProvider, ConfigPointer, content_exports as Content, ContributionHub, ContributionRegistry, core_exports as Core, DELTA_COMIC_PLUGIN_API_VERSION, DatabasePluginArchiveRepository, DevScriptCodec, expose_exports as Expose, GitHubSourceResolver, HttpSourceResolver, InstalledPluginCandidateProvider, InternalPluginCandidateProvider, LocalFileSourceResolver, LocalInternalPluginPreferences, MarketplaceSourceResolver, PluginInstallService, PluginManifestError, PluginRuntime, PluginScope, PluginStore, remote_exports as Remote, resource_exports as Resource, social_exports as Social, special_exports as Special, StoredPluginModuleReader, user_exports as User, ZipPackageCodec, configurePluginHost, createAuthCapability, createConfigCapability, createContentCapability, createDefaultCapabilities, createI18nCapability, createLifecycleCapability, createModelCapability, createRemoteCapability, createResourceCapability, createSpecialCapability, createUserCapability, defineCapability, defineContributionChannel, defineDeltaComicPlugin, defineInternalPlugin, findPluginDependencyCycles, installPlugin, isPluginManifestCompatible, parsePluginManifest, planPluginDependencies, pluginCatalog, pluginCatalogIdFromInstallInput, pluginCatalogInstallInput, pluginConfigStore, pluginContributions, pluginI18n, pluginInstaller, pluginMessageKey, pluginModelChannels, pluginRemoteSelectionChannel, pluginRuntime, pluginStore, resolvePluginIconUrl, safePluginPath, setPluginEnabled, setPluginKind, translatePluginText, uninstallPlugin, updatePlugin, updatePluginByName, useConfig, usePluginStore };
 
 //# sourceMappingURL=index.mjs.map