@elementspanel/epanel-plugin-config 0.0.0-stage → 1.0.0

package/daemon/backend/index.cjs

@@ -0,0 +1,2465 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "../common/src/array.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.arrayUnique = arrayUnique;
+function arrayUnique(arr, felidName) {
+    if (!felidName)
+        return Array.from(new Set(arr));
+    const map = new Map();
+    return arr.filter((v) => !map.has(v[felidName]) && map.set(v[felidName], v));
+}
+
+
+/***/ },
+
+/***/ "../common/src/docker_utils.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.normalizeDockerArchitecture = normalizeDockerArchitecture;
+exports.normalizeDockerOS = normalizeDockerOS;
+exports.normalizeDockerPlatform = normalizeDockerPlatform;
+/**
+ * Normalizes Docker platform architecture names to standard format
+ * @param architecture The architecture string from Docker manifest
+ * @returns Normalized architecture string (amd64, arm64, arm, or original if not recognized)
+ */
+function normalizeDockerArchitecture(architecture) {
+    if (!architecture) {
+        return "amd64"; // default fallback
+    }
+    // Return original if not one of the standard architectures
+    return architecture;
+}
+/**
+ * Normalizes Docker platform OS name
+ * @param os The OS string from Docker manifest
+ * @returns Normalized OS string (defaults to "linux" if not provided)
+ */
+function normalizeDockerOS(os) {
+    return os || "linux";
+}
+/**
+ * Normalizes a Docker platform from manifest format to standard platform string
+ * @param platform Platform object from Docker manifest with os and architecture
+ * @returns Normalized platform string in format "os/arch" (e.g., "linux/amd64")
+ */
+function normalizeDockerPlatform(platform) {
+    const os = normalizeDockerOS(platform.os);
+    const arch = normalizeDockerArchitecture(platform.architecture);
+    return `${os}/${arch}`;
+}
+
+
+/***/ },
+
+/***/ "../common/src/global_variable.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+class GlobalVariable {
+    static map = new Map();
+    static set(k, v) {
+        GlobalVariable.map.set(k, v);
+    }
+    static get(k, def) {
+        if (GlobalVariable.map.has(k)) {
+            return GlobalVariable.map.get(k);
+        }
+        else {
+            return def;
+        }
+    }
+    static del(k) {
+        return GlobalVariable.map.delete(k);
+    }
+}
+exports["default"] = GlobalVariable;
+
+
+/***/ },
+
+/***/ "../common/src/index.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.StorageSubsystem = exports.MCServerStatus = exports.InstanceStreamListener = exports.GlobalVariable = exports.normalizeDockerPlatform = exports.normalizeDockerOS = exports.normalizeDockerArchitecture = exports.removeTrail = exports.uninstallNpmPlugin = exports.npmPluginRoots = exports.listNpmPlugins = exports.installNpmPlugin = exports.currentProjectRoot = exports.currentPackageRoot = exports.sortPlugins = exports.resolvePluginEntry = exports.readPluginManifest = exports.createFrontendPluginMetadata = exports.discoverPluginsFromRoots = exports.discoverPlugins = exports.arrayUnique = exports.toText = exports.toNumber = exports.toBoolean = exports.supposeValue = exports.isEmpty = exports.configureEntityParams = exports.systemInfo = exports.QueryWrapper = exports.QueryMapWrapper = exports.MySqlSource = exports.LocalFileSource = exports.killProcess = exports.ProcessWrapper = void 0;
+const global_variable_1 = __importDefault(__webpack_require__("../common/src/global_variable.ts"));
+exports.GlobalVariable = global_variable_1.default;
+const instance_stream_1 = __importDefault(__webpack_require__("../common/src/instance_stream.ts"));
+exports.InstanceStreamListener = instance_stream_1.default;
+const system_storage_1 = __importDefault(__webpack_require__("../common/src/system_storage.ts"));
+exports.StorageSubsystem = system_storage_1.default;
+const mcping_1 = __importDefault(__webpack_require__("../common/src/mcping.ts"));
+exports.MCServerStatus = mcping_1.default;
+var process_tools_1 = __webpack_require__("../common/src/process_tools.ts");
+Object.defineProperty(exports, "ProcessWrapper", ({ enumerable: true, get: function () { return process_tools_1.ProcessWrapper; } }));
+Object.defineProperty(exports, "killProcess", ({ enumerable: true, get: function () { return process_tools_1.killProcess; } }));
+var query_wrapper_1 = __webpack_require__("../common/src/query_wrapper.ts");
+Object.defineProperty(exports, "LocalFileSource", ({ enumerable: true, get: function () { return query_wrapper_1.LocalFileSource; } }));
+Object.defineProperty(exports, "MySqlSource", ({ enumerable: true, get: function () { return query_wrapper_1.MySqlSource; } }));
+Object.defineProperty(exports, "QueryMapWrapper", ({ enumerable: true, get: function () { return query_wrapper_1.QueryMapWrapper; } }));
+Object.defineProperty(exports, "QueryWrapper", ({ enumerable: true, get: function () { return query_wrapper_1.QueryWrapper; } }));
+var system_info_1 = __webpack_require__("../common/src/system_info.ts");
+Object.defineProperty(exports, "systemInfo", ({ enumerable: true, get: function () { return system_info_1.systemInfo; } }));
+var typecheck_1 = __webpack_require__("../common/src/typecheck.ts");
+Object.defineProperty(exports, "configureEntityParams", ({ enumerable: true, get: function () { return typecheck_1.configureEntityParams; } }));
+Object.defineProperty(exports, "isEmpty", ({ enumerable: true, get: function () { return typecheck_1.isEmpty; } }));
+Object.defineProperty(exports, "supposeValue", ({ enumerable: true, get: function () { return typecheck_1.supposeValue; } }));
+Object.defineProperty(exports, "toBoolean", ({ enumerable: true, get: function () { return typecheck_1.toBoolean; } }));
+Object.defineProperty(exports, "toNumber", ({ enumerable: true, get: function () { return typecheck_1.toNumber; } }));
+Object.defineProperty(exports, "toText", ({ enumerable: true, get: function () { return typecheck_1.toText; } }));
+var array_1 = __webpack_require__("../common/src/array.ts");
+Object.defineProperty(exports, "arrayUnique", ({ enumerable: true, get: function () { return array_1.arrayUnique; } }));
+__exportStar(__webpack_require__("../common/src/plugin_contract.ts"), exports);
+__exportStar(__webpack_require__("../common/src/plugin_overrides.ts"), exports);
+__exportStar(__webpack_require__("../common/src/plugin_lifecycle.ts"), exports);
+__exportStar(__webpack_require__("../common/src/plugin_revision.ts"), exports);
+__exportStar(__webpack_require__("../common/src/runtime_paths.ts"), exports);
+var plugin_manifest_1 = __webpack_require__("../common/src/plugin_manifest.ts");
+Object.defineProperty(exports, "discoverPlugins", ({ enumerable: true, get: function () { return plugin_manifest_1.discoverPlugins; } }));
+Object.defineProperty(exports, "discoverPluginsFromRoots", ({ enumerable: true, get: function () { return plugin_manifest_1.discoverPluginsFromRoots; } }));
+Object.defineProperty(exports, "createFrontendPluginMetadata", ({ enumerable: true, get: function () { return plugin_manifest_1.createFrontendPluginMetadata; } }));
+Object.defineProperty(exports, "readPluginManifest", ({ enumerable: true, get: function () { return plugin_manifest_1.readPluginManifest; } }));
+Object.defineProperty(exports, "resolvePluginEntry", ({ enumerable: true, get: function () { return plugin_manifest_1.resolvePluginEntry; } }));
+Object.defineProperty(exports, "sortPlugins", ({ enumerable: true, get: function () { return plugin_manifest_1.sortPlugins; } }));
+var plugin_npm_1 = __webpack_require__("../common/src/plugin_npm.ts");
+Object.defineProperty(exports, "currentPackageRoot", ({ enumerable: true, get: function () { return plugin_npm_1.currentPackageRoot; } }));
+Object.defineProperty(exports, "currentProjectRoot", ({ enumerable: true, get: function () { return plugin_npm_1.currentProjectRoot; } }));
+Object.defineProperty(exports, "installNpmPlugin", ({ enumerable: true, get: function () { return plugin_npm_1.installNpmPlugin; } }));
+Object.defineProperty(exports, "listNpmPlugins", ({ enumerable: true, get: function () { return plugin_npm_1.listNpmPlugins; } }));
+Object.defineProperty(exports, "npmPluginRoots", ({ enumerable: true, get: function () { return plugin_npm_1.npmPluginRoots; } }));
+Object.defineProperty(exports, "uninstallNpmPlugin", ({ enumerable: true, get: function () { return plugin_npm_1.uninstallNpmPlugin; } }));
+var string_utils_1 = __webpack_require__("../common/src/string_utils.ts");
+Object.defineProperty(exports, "removeTrail", ({ enumerable: true, get: function () { return string_utils_1.removeTrail; } }));
+var docker_utils_1 = __webpack_require__("../common/src/docker_utils.ts");
+Object.defineProperty(exports, "normalizeDockerArchitecture", ({ enumerable: true, get: function () { return docker_utils_1.normalizeDockerArchitecture; } }));
+Object.defineProperty(exports, "normalizeDockerOS", ({ enumerable: true, get: function () { return docker_utils_1.normalizeDockerOS; } }));
+Object.defineProperty(exports, "normalizeDockerPlatform", ({ enumerable: true, get: function () { return docker_utils_1.normalizeDockerPlatform; } }));
+
+
+/***/ },
+
+/***/ "../common/src/instance_stream.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+// Application instance data stream forwarding adapter
+class InstanceStreamListener {
+    listenMap = new Map();
+    disconnectHandlers = new Map();
+    requestForward(socket, instanceUuid) {
+        const sockets = this.listenMap.get(instanceUuid) ?? [];
+        if (sockets.some((listener) => listener.id === socket.id))
+            return;
+        sockets.push(socket);
+        this.listenMap.set(instanceUuid, sockets);
+        if (!this.disconnectHandlers.has(socket)) {
+            const disconnect = () => {
+                for (const uuid of this.listenMap.keys())
+                    this.cannelForward(socket, uuid);
+            };
+            this.disconnectHandlers.set(socket, disconnect);
+            socket.once("disconnect", disconnect);
+        }
+    }
+    cannelForward(socket, instanceUuid) {
+        const remaining = this.listenMap
+            .get(instanceUuid)
+            ?.filter((listener) => listener.id !== socket.id);
+        if (remaining?.length)
+            this.listenMap.set(instanceUuid, remaining);
+        else
+            this.listenMap.delete(instanceUuid);
+        if (![...this.listenMap.values()].some((sockets) => sockets.includes(socket))) {
+            const disconnect = this.disconnectHandlers.get(socket);
+            if (disconnect)
+                socket.off("disconnect", disconnect);
+            this.disconnectHandlers.delete(socket);
+        }
+    }
+    forward(instanceUuid, data) {
+        this.forwardViaCallback(instanceUuid, (socket) => socket.emit("instance/stdout", data));
+    }
+    forwardViaCallback(instanceUuid, callback) {
+        for (const socket of this.listenMap.get(instanceUuid) ?? []) {
+            if (socket.connected)
+                callback(socket);
+            else
+                this.cannelForward(socket, instanceUuid);
+        }
+    }
+    hasListenInstance(instanceUuid) {
+        return this.listenMap.get(instanceUuid)?.some((socket) => socket.connected) ?? false;
+    }
+}
+exports["default"] = InstanceStreamListener;
+
+
+/***/ },
+
+/***/ "../common/src/mcping.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const net_1 = __importDefault(__webpack_require__("net"));
+class PingMinecraftServer {
+    port;
+    host;
+    status;
+    client;
+    pending;
+    constructor(port, host) {
+        this.port = port;
+        this.host = host;
+        this.status = this.offlineStatus();
+    }
+    offlineStatus() {
+        return {
+            online: false,
+            host: this.host,
+            port: this.port,
+            version: "",
+            motd: "",
+            current_players: 0,
+            max_players: 0,
+            latency: 0
+        };
+    }
+    getStatus() {
+        if (this.pending)
+            return this.pending;
+        this.status = this.offlineStatus();
+        this.pending = new Promise((resolve, reject) => {
+            const startedAt = Date.now();
+            const client = net_1.default.connect({ host: this.host, port: this.port });
+            this.client = client;
+            let received = Buffer.alloc(0);
+            let settled = false;
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                client.destroy();
+                this.client = undefined;
+                if (error)
+                    reject(error);
+                else
+                    resolve(this.status);
+            };
+            const timeout = setTimeout(() => finish(new Error("Minecraft status request timed out")), 15000);
+            client.once("connect", () => client.write(Buffer.from([0xfe, 0x01])));
+            client.on("data", (chunk) => {
+                if (settled)
+                    return;
+                try {
+                    received = Buffer.concat([received, chunk]);
+                    // Legacy status packets contain an unsigned UTF-16 character count.
+                    if (received.length > 3 + 0xffff * 2)
+                        throw new Error("Minecraft status response is too large");
+                    if (received.length < 3)
+                        return;
+                    if (received[0] !== 0xff)
+                        throw new Error("Invalid Minecraft status packet");
+                    const length = 3 + received.readUInt16BE(1) * 2;
+                    if (received.length < length)
+                        return;
+                    const fields = Buffer.from(received.subarray(3, length))
+                        .swap16()
+                        .toString("utf16le")
+                        .split("\0");
+                    if (fields.length !== 6 ||
+                        fields[0] !== "§1" ||
+                        !/^\d+$/.test(fields[4]) ||
+                        !/^\d+$/.test(fields[5])) {
+                        throw new Error("Invalid Minecraft status response");
+                    }
+                    const currentPlayers = Number(fields[4]);
+                    const maxPlayers = Number(fields[5]);
+                    if (!Number.isSafeInteger(currentPlayers) || !Number.isSafeInteger(maxPlayers)) {
+                        throw new Error("Invalid Minecraft player count");
+                    }
+                    this.status = {
+                        host: this.host,
+                        port: this.port,
+                        online: true,
+                        version: fields[2],
+                        motd: fields[3],
+                        current_players: currentPlayers,
+                        max_players: maxPlayers,
+                        latency: Date.now() - startedAt
+                    };
+                    finish();
+                }
+                catch (error) {
+                    finish(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+            client.once("error", finish);
+            client.once("close", () => finish(received.length ? new Error("Incomplete Minecraft status response") : undefined));
+        }).finally(() => {
+            this.pending = undefined;
+        });
+        return this.pending;
+    }
+    asyncStatus() {
+        return this.getStatus();
+    }
+}
+exports["default"] = PingMinecraftServer;
+
+
+/***/ },
+
+/***/ "../common/src/plugin_contract.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.PLUGIN_SDK_VERSION = exports.PLUGIN_API_VERSION = void 0;
+exports.validatePluginCompatibility = validatePluginCompatibility;
+exports.resolvePluginDependencyOrder = resolvePluginDependencyOrder;
+exports.createPluginQueue = createPluginQueue;
+exports.validatePluginSettings = validatePluginSettings;
+/** Versioned contract shared by the host, plugin compiler and package registry. */
+exports.PLUGIN_API_VERSION = 1;
+exports.PLUGIN_SDK_VERSION = "1.0.0";
+/** Omitted metadata denotes a legacy package. Unknown versions never execute. */
+function validatePluginCompatibility(value) {
+    if (value === undefined)
+        return;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid ElementsPanel plugin compatibility metadata.");
+    const contract = value;
+    if (contract.api !== exports.PLUGIN_API_VERSION || (contract.sdk !== undefined && contract.sdk !== 1))
+        throw new Error(`Unsupported ElementsPanel plugin API/SDK: ${JSON.stringify(value)}`);
+}
+/**
+ * Stable topological ordering shared by plugin hosts.
+ *
+ * Invalid nodes are kept out of `ordered`: direct missing dependencies are
+ * reported first, then anything depending on an invalid node, and finally
+ * cycles (plus nodes blocked behind a cycle). Independent nodes retain the
+ * caller's priority/id comparator.
+ */
+function resolvePluginDependencyOrder(items, options) {
+    const sorted = [...items].sort(options.compare);
+    const byId = new Map(sorted.map((item) => [options.id(item), item]));
+    const dependencies = new Map(sorted.map((item) => [
+        options.id(item),
+        [...new Set(options.dependencies(item) || [])].filter(Boolean)
+    ]));
+    const issues = new Map();
+    for (const item of sorted) {
+        const id = options.id(item);
+        const missing = dependencies.get(id).filter((dependency) => !byId.has(dependency));
+        if (!missing.length)
+            continue;
+        issues.set(id, {
+            type: "missing-dependency",
+            dependencies: missing,
+            message: `Missing frontend plugin dependencies: ${missing.join(", ")}`
+        });
+    }
+    const markUnavailable = () => {
+        let changed = false;
+        for (const item of sorted) {
+            const id = options.id(item);
+            if (issues.has(id))
+                continue;
+            const unavailable = dependencies.get(id).filter((dependency) => issues.has(dependency));
+            if (!unavailable.length)
+                continue;
+            issues.set(id, {
+                type: "dependency-unavailable",
+                dependencies: unavailable,
+                message: `Frontend plugin dependencies are unavailable: ${unavailable.join(", ")}`
+            });
+            changed = true;
+        }
+        return changed;
+    };
+    while (markUnavailable()) {
+        // Propagate direct graph failures before sorting the remaining nodes.
+    }
+    const candidates = sorted.filter((item) => !issues.has(options.id(item)));
+    const candidateIds = new Set(candidates.map(options.id));
+    const indegree = new Map(candidates.map((item) => [options.id(item), 0]));
+    const dependents = new Map();
+    for (const item of candidates) {
+        const id = options.id(item);
+        for (const dependency of dependencies.get(id)) {
+            if (!candidateIds.has(dependency))
+                continue;
+            indegree.set(id, indegree.get(id) + 1);
+            const bucket = dependents.get(dependency) || [];
+            bucket.push(item);
+            dependents.set(dependency, bucket);
+        }
+    }
+    const ready = candidates.filter((item) => indegree.get(options.id(item)) === 0);
+    ready.sort(options.compare);
+    const ordered = [];
+    while (ready.length) {
+        const item = ready.shift();
+        const id = options.id(item);
+        ordered.push(item);
+        for (const dependent of dependents.get(id) || []) {
+            const dependentId = options.id(dependent);
+            const next = indegree.get(dependentId) - 1;
+            indegree.set(dependentId, next);
+            if (next === 0) {
+                ready.push(dependent);
+                ready.sort(options.compare);
+            }
+        }
+    }
+    const unresolved = candidates.filter((item) => !ordered.includes(item));
+    if (unresolved.length) {
+        const unresolvedIds = new Set(unresolved.map(options.id));
+        for (const item of unresolved) {
+            const id = options.id(item);
+            const blockedBy = dependencies.get(id).filter((dependency) => unresolvedIds.has(dependency));
+            issues.set(id, {
+                type: "dependency-cycle",
+                dependencies: blockedBy,
+                message: `Frontend plugin dependency cycle: ${[id, ...blockedBy].join(" -> ")}`
+            });
+        }
+    }
+    return { ordered, issues };
+}
+/** A queue survives failures, so a failed change cannot block subsequent repairs. */
+function createPluginQueue() {
+    let tail = Promise.resolve();
+    return (operation) => {
+        const next = tail.then(operation);
+        tail = next.catch(() => undefined);
+        return next;
+    };
+}
+/** Validate the form contract on the server before invoking plugin-owned validation. */
+function validatePluginSettings(fields, values) {
+    if (!values || typeof values !== "object" || Array.isArray(values))
+        throw new Error("Invalid plugin settings.");
+    const input = values;
+    for (const field of fields) {
+        if (!field.key || field.type === "link")
+            continue;
+        const value = input[field.key];
+        if (value === undefined || value === null) {
+            if (field.required)
+                throw new Error(`${field.title || field.key}: required`);
+            continue;
+        }
+        if (field.type === "list") {
+            if (!Array.isArray(value) || value.length > (field.maxItems ?? 100))
+                throw new Error(`${field.title || field.key}: invalid list`);
+            for (const item of value)
+                validatePluginSettings(field.fields || [], item);
+            continue;
+        }
+        const valid = field.type === "number"
+            ? typeof value === "number" &&
+                Number.isFinite(value) &&
+                (field.min === undefined || value >= field.min) &&
+                (field.max === undefined || value <= field.max)
+            : field.type === "boolean"
+                ? typeof value === "boolean"
+                : field.type === "select"
+                    ? field.options?.some((option) => option.value === value)
+                    : typeof value === "string";
+        if (!valid)
+            throw new Error(`${field.title || field.key}: invalid value`);
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_lifecycle.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.trackPluginDisposal = trackPluginDisposal;
+/** Cordis 3 starts async disposers without awaiting them. Track them per host. */
+function trackPluginDisposal(ctx) {
+    const pending = new Set();
+    const failures = [];
+    const tracked = new WeakSet();
+    const scopes = new WeakSet();
+    const observe = (scope) => {
+        if (scopes.has(scope))
+            return;
+        scopes.add(scope);
+        const reset = scope.reset;
+        scope.reset = function () {
+            this.disposables = this.disposables.map((dispose) => {
+                if (tracked.has(dispose))
+                    return dispose;
+                const wrapper = (...args) => {
+                    let result;
+                    try {
+                        result = dispose(...args);
+                    }
+                    catch (error) {
+                        failures.push(error);
+                        throw error;
+                    }
+                    if (result && typeof result.then === "function") {
+                        const task = Promise.resolve(result)
+                            .catch((error) => {
+                            failures.push(error);
+                        })
+                            .finally(() => pending.delete(task));
+                        pending.add(task);
+                    }
+                    return result;
+                };
+                // Cordis marks persistent disposers with a symbol; preserve its semantics.
+                for (const key of Object.getOwnPropertySymbols(dispose))
+                    Object.defineProperty(wrapper, key, Object.getOwnPropertyDescriptor(dispose, key));
+                tracked.add(wrapper);
+                return wrapper;
+            });
+            return reset.call(this);
+        };
+    };
+    ctx.on("internal/runtime", observe);
+    ctx.on("internal/fork", observe);
+    return async () => {
+        do {
+            await ctx.events.flush();
+            await Promise.all([...pending]);
+        } while (pending.size);
+        if (failures.length) {
+            const errors = failures.splice(0);
+            throw new Error(`Plugin cleanup failed: ${errors.map(String).join("; ")}`);
+        }
+    };
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_manifest.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createFrontendPluginMetadata = createFrontendPluginMetadata;
+exports.readPluginManifest = readPluginManifest;
+exports.resolvePluginEntry = resolvePluginEntry;
+exports.discoverPlugins = discoverPlugins;
+exports.discoverPluginsFromRoots = discoverPluginsFromRoots;
+exports.sortPlugins = sortPlugins;
+const node_fs_1 = __importDefault(__webpack_require__("node:fs"));
+const node_path_1 = __importDefault(__webpack_require__("node:path"));
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const result = value.filter((item) => typeof item === "string" && !!item.trim());
+    return result.length ? [...new Set(result.map((item) => item.trim()))] : undefined;
+}
+/**
+ * Redacts a full plugin manifest to the fields a browser is allowed to see.
+ * Backend `config` may contain credentials, so only `frontendConfig` crosses
+ * this boundary.
+ */
+function createFrontendPluginMetadata(manifest, extras = {}) {
+    const frontendInject = stringArray(manifest.frontendInject);
+    return {
+        id: manifest.id,
+        ...(manifest.version === undefined ? {} : { version: manifest.version }),
+        ...(manifest.description === undefined ? {} : { description: manifest.description }),
+        ...(manifest.priority === undefined ? {} : { priority: manifest.priority }),
+        ...(manifest.elements === undefined ? {} : { elements: manifest.elements }),
+        ...(frontendInject === undefined ? {} : { frontendInject }),
+        ...(manifest.frontendImmediate === undefined
+            ? {}
+            : { frontendImmediate: Boolean(manifest.frontendImmediate) }),
+        ...(manifest.frontendRequired === undefined
+            ? {}
+            : { frontendRequired: Boolean(manifest.frontendRequired) }),
+        ...(manifest.frontendConfig === undefined ? {} : { config: manifest.frontendConfig }),
+        ...(extras.restartRequired === undefined ? {} : extras)
+    };
+}
+const MANIFEST_FILES = ["plugin.json", "manifest.json", "package.json"];
+/** Reads the manifest of one plugin directory, or null if it has none. */
+function readPluginManifest(directory, onWarning, fallbackId = node_path_1.default.basename(directory)) {
+    for (const file of MANIFEST_FILES) {
+        const filePath = node_path_1.default.join(directory, file);
+        if (!node_fs_1.default.existsSync(filePath))
+            continue;
+        try {
+            const value = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                return null;
+            const id = typeof value.id === "string" ? value.id : fallbackId;
+            if (!id.trim())
+                return null;
+            return { ...value, id: id.trim() };
+        }
+        catch (error) {
+            onWarning?.(`Failed to read plugin manifest: ${filePath}`, error);
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Resolves one plugin's entry module. Returns null when the manifest names an
+ * entry that does not exist, or when none of the fallback candidates is present.
+ * Paths that would escape the plugin directory are rejected.
+ */
+function resolvePluginEntry(directory, manifest, options) {
+    const configured = options.entryFields
+        .map((field) => manifest[field])
+        .find((entry) => typeof entry === "string" && entry.length > 0);
+    const candidates = configured ? [configured] : options.entryCandidates ?? [];
+    const root = node_path_1.default.resolve(directory);
+    for (const candidate of candidates) {
+        const entry = node_path_1.default.resolve(directory, candidate);
+        if (entry.startsWith(`${root}${node_path_1.default.sep}`) && node_fs_1.default.existsSync(entry))
+            return entry;
+    }
+    return null;
+}
+function discoverPluginDirectory(directory, options, folder = node_path_1.default.basename(directory)) {
+    // Npm packages expose a side directory; its name is not the public plugin id.
+    const manifest = readPluginManifest(directory, options.onWarning, folder);
+    if (!manifest)
+        return null;
+    if (manifest.enabled === false && !options.includeDisabled)
+        return null;
+    const entry = resolvePluginEntry(directory, manifest, options);
+    if (!entry && options.entryFields.some((field) => typeof manifest[field] === "string")) {
+        options.onWarning?.(`Plugin "${manifest.id}" has no valid entry module.`);
+        return null;
+    }
+    return { manifest, directory, folder, entry: entry ?? undefined };
+}
+/**
+ * Lists the usable plugins below `root`, in load order: ascending `priority`,
+ * then by id so the order is stable. Duplicate ids are dropped, and disabled
+ * ones too unless `includeDisabled` says otherwise. A plugin whose manifest names an entry that cannot be resolved is
+ * dropped too; one that names none keeps `entry` undefined, because a plugin may
+ * legitimately contribute to only one side of the panel.
+ */
+function discoverPlugins(root, options) {
+    if (!node_fs_1.default.existsSync(root))
+        return [];
+    const plugins = [];
+    const seenIds = new Set();
+    for (const item of node_fs_1.default.readdirSync(root, { withFileTypes: true })) {
+        if (!item.isDirectory())
+            continue;
+        const directory = node_path_1.default.join(root, item.name);
+        const plugin = discoverPluginDirectory(directory, options, item.name);
+        if (!plugin || seenIds.has(plugin.manifest.id)) {
+            if (plugin && seenIds.has(plugin.manifest.id)) {
+                options.onWarning?.(`Ignoring duplicate plugin id: ${plugin.manifest.id}`);
+            }
+            continue;
+        }
+        seenIds.add(plugin.manifest.id);
+        plugins.push(plugin);
+    }
+    return sortPlugins(plugins);
+}
+/**
+ * Discovers plugins from several roots while keeping the first root's plugin
+ * when ids collide. The built-in root is intentionally passed first by the
+ * panel and daemon loaders, so an installed market plugin cannot shadow a
+ * built-in npm dependency. A root can also force an installed project plugin
+ * into the disabled state; the user-owned override layer may enable it later.
+ */
+function discoverPluginsFromRoots(roots, options) {
+    const discovered = [];
+    const seenIds = new Set();
+    for (const root of roots) {
+        const isDirectPlugin = MANIFEST_FILES.some((file) => node_fs_1.default.existsSync(node_path_1.default.join(root.directory, file)));
+        const plugins = isDirectPlugin
+            ? [discoverPluginDirectory(root.directory, options, root.folder)]
+            : discoverPlugins(root.directory, options);
+        for (const plugin of plugins) {
+            if (!plugin)
+                continue;
+            const manifest = root.defaultEnabled === false ? { ...plugin.manifest, enabled: false } : plugin.manifest;
+            if (manifest.enabled === false && !options.includeDisabled)
+                continue;
+            if (seenIds.has(plugin.manifest.id)) {
+                options.onWarning?.(`Ignoring duplicate plugin id: ${plugin.manifest.id}`);
+                continue;
+            }
+            seenIds.add(plugin.manifest.id);
+            discovered.push({
+                ...plugin,
+                manifest,
+                ...(root.folder ? { folder: root.folder } : {})
+            });
+        }
+    }
+    return sortPlugins(discovered);
+}
+/** Load order: ascending `priority`, then by id so it never depends on the filesystem. */
+function sortPlugins(plugins) {
+    return plugins.sort((a, b) => (Number(a.manifest.priority) || 0) - (Number(b.manifest.priority) || 0) ||
+        a.manifest.id.localeCompare(b.manifest.id));
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_npm.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.currentPackageRoot = currentPackageRoot;
+exports.currentProjectRoot = currentProjectRoot;
+exports.npmPluginRoots = npmPluginRoots;
+exports.listNpmPlugins = listNpmPlugins;
+exports.installNpmPlugin = installNpmPlugin;
+exports.uninstallNpmPlugin = uninstallNpmPlugin;
+const child_process_1 = __webpack_require__("child_process");
+const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+const path_1 = __importDefault(__webpack_require__("path"));
+const module_1 = __webpack_require__("module");
+const PLUGIN_ID = /^[a-z][a-z0-9_-]{1,63}$/;
+const PACKAGE_NAME = /^(?:@[a-z0-9_.-]+\/)?epanel-plugin-[a-z0-9_.-]+$/;
+const VERSION = /^[0-9][^\s/]{0,63}$/;
+function readJson(filename) {
+    try {
+        const parsed = JSON.parse(fs_extra_1.default.readFileSync(filename, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch (error) {
+        if (error?.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function currentPackageRoot() {
+    return path_1.default.resolve(process.env.EPANEL_PACKAGE_ROOT || process.cwd());
+}
+function currentProjectRoot(packageRoot = currentPackageRoot()) {
+    // The npm worker sets EPANEL_PROJECT_ROOT to the installation directory. In a
+    // development checkout the runtime package sits directly under the project.
+    if (process.env.EPANEL_PROJECT_ROOT)
+        return path_1.default.resolve(process.env.EPANEL_PROJECT_ROOT);
+    const scope = path_1.default.resolve(packageRoot, "..");
+    const nodeModules = path_1.default.dirname(scope);
+    if (path_1.default.basename(nodeModules) === "node_modules" && path_1.default.basename(scope).startsWith("@"))
+        return path_1.default.dirname(nodeModules);
+    return scope;
+}
+function npmPluginRoots(options = {}) {
+    const packageRoot = path_1.default.resolve(options.packageRoot ?? currentPackageRoot());
+    return {
+        packageRoot,
+        projectRoot: path_1.default.resolve(options.projectRoot ?? currentProjectRoot(packageRoot))
+    };
+}
+function projectManifestFile(projectRoot) {
+    return path_1.default.join(projectRoot, "package.json");
+}
+function readProjectManifest(projectRoot) {
+    return (readJson(projectManifestFile(projectRoot)) ?? {
+        private: true,
+        dependencies: {},
+        elementspanel: { plugins: {} }
+    });
+}
+function writeProjectManifest(projectRoot, manifest) {
+    fs_extra_1.default.writeFileSync(projectManifestFile(projectRoot), `${JSON.stringify(manifest, null, 2)}\n`);
+}
+function dependenciesOf(manifest) {
+    return objectValue(manifest?.dependencies) ?? {};
+}
+function mappingsOf(manifest) {
+    return objectValue(objectValue(manifest?.elementspanel)?.plugins) ?? {};
+}
+function pluginRecord(pluginId, name, source, packageRoot, directory, folder, version) {
+    return { pluginId, name, version, sides: [], directory, folder, packageRoot, source };
+}
+function readPackageEntry(packageRoot, name) {
+    const hostRequire = (0, module_1.createRequire)(path_1.default.join(packageRoot, "package.json"));
+    const manifestPath = hostRequire.resolve(`${name}/package.json`);
+    const metadata = readJson(manifestPath);
+    if (!metadata)
+        throw new Error(`Missing package metadata for ${name}.`);
+    return { root: path_1.default.dirname(manifestPath), metadata };
+}
+function sideDirectory(packageRoot, metadata, side) {
+    const elements = objectValue(metadata.elementspanel);
+    const definition = objectValue(elements?.[side]);
+    const directory = stringValue(definition?.directory);
+    if (!definition || !directory)
+        return undefined;
+    const target = path_1.default.resolve(packageRoot, directory);
+    const relative = path_1.default.relative(packageRoot, target);
+    if (relative === "" || relative.startsWith(`..${path_1.default.sep}`) || path_1.default.isAbsolute(relative))
+        return undefined;
+    return target;
+}
+function recordFromPackage(pluginId, name, source, packageRoot, metadata, side) {
+    const elements = objectValue(metadata.elementspanel);
+    if (!elements || elements.id !== pluginId)
+        return undefined;
+    const version = stringValue(metadata.version);
+    const sides = ["panel", "daemon"].filter((item) => Boolean(sideDirectory(packageRoot, metadata, item)));
+    if (!sides.length)
+        return undefined;
+    const target = side ?? sides[0];
+    if (!sides.includes(target))
+        return undefined;
+    const directory = sideDirectory(packageRoot, metadata, target);
+    const folder = stringValue(objectValue(elements[target])?.folder);
+    if (!directory || !folder)
+        return undefined;
+    return {
+        ...pluginRecord(pluginId, name, source, packageRoot, directory, folder, version),
+        sides
+    };
+}
+/**
+ * Every npm plugin the runtime can load for a side, built-in and project-installed.
+ *
+ * Built-in mappings win over a project mapping for the same id: a third-party
+ * package must not shadow a plugin that ships with the runtime. A project package
+ * that does not describe the requested side is skipped instead of failing, which
+ * is what lets a two-sided project share one dependency list between sides.
+ */
+function listNpmPlugins(side, options = {}) {
+    const { packageRoot, projectRoot } = npmPluginRoots(options);
+    const host = readJson(path_1.default.join(packageRoot, "package.json"));
+    if (!host)
+        throw new Error(`Missing runtime package metadata: ${packageRoot}`);
+    const project = path_1.default.resolve(projectRoot) === path_1.default.resolve(packageRoot) ? null : readProjectManifest(projectRoot);
+    const hostMappings = mappingsOf(host);
+    const projectMappings = mappingsOf(project);
+    const mappings = new Map();
+    for (const [pluginId, name] of Object.entries(projectMappings)) {
+        if (!PLUGIN_ID.test(pluginId) || typeof name !== "string" || !PACKAGE_NAME.test(name))
+            continue;
+        mappings.set(pluginId, { name, source: "project" });
+    }
+    for (const [pluginId, name] of Object.entries(hostMappings)) {
+        if (!PLUGIN_ID.test(pluginId) || typeof name !== "string" || !PACKAGE_NAME.test(name))
+            continue;
+        mappings.set(pluginId, { name, source: "bundled" });
+    }
+    const hostDependencies = dependenciesOf(host);
+    const projectDependencies = dependenciesOf(project);
+    const folders = new Set();
+    const records = [];
+    for (const [pluginId, mapping] of mappings) {
+        const declared = hostDependencies[mapping.name] ?? projectDependencies[mapping.name];
+        if (declared === undefined) {
+            if (options.skipInvalid)
+                continue;
+            throw new Error(`Missing npm plugin dependency: ${mapping.name}. Run npm install in the project directory.`);
+        }
+        let entry;
+        try {
+            entry = readPackageEntry(packageRoot, mapping.name);
+        }
+        catch (error) {
+            if (options.skipInvalid)
+                continue;
+            throw error;
+        }
+        const record = recordFromPackage(pluginId, mapping.name, mapping.source, entry.root, entry.metadata, side);
+        if (!record) {
+            if (options.skipInvalid || mapping.source === "project")
+                continue;
+            throw new Error(`Invalid ${side ?? "plugin"} entry in npm plugin ${mapping.name}.`);
+        }
+        const folder = record.folder;
+        if (folders.has(folder)) {
+            if (options.skipInvalid)
+                continue;
+            throw new Error(`Duplicate npm plugin asset directory: ${folder}.`);
+        }
+        folders.add(folder);
+        records.push(record);
+    }
+    return records;
+}
+function runNpm(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const npmCLI = process.env.npm_execpath;
+        const invocation = npmCLI && /npm(?:-cli)?\.(?:c?js|mjs)$/.test(npmCLI)
+            ? { command: process.execPath, args: [npmCLI, ...args], shell: false }
+            : process.platform === "win32"
+                ? {
+                    command: process.env.ComSpec || "cmd.exe",
+                    args: ["/d", "/s", "/c", `npm ${args.map((item) => `"${item.replace(/"/g, '""')}"`).join(" ")}`],
+                    shell: false
+                }
+                : { command: "npm", args, shell: false };
+        const child = (0, child_process_1.spawn)(invocation.command, invocation.args, {
+            cwd,
+            shell: invocation.shell,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...process.env, npm_config_update_notifier: "false" }
+        });
+        let output = "";
+        const append = (data) => {
+            output += data.toString();
+            if (output.length > 16000)
+                output = output.slice(-16000);
+        };
+        child.stdout?.on("data", append);
+        child.stderr?.on("data", append);
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            reject(new Error(`npm ${args[0] ?? ""} timed out.`));
+        }, 10 * 60 * 1000);
+        timer.unref?.();
+        child.once("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.once("close", (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+                return resolve(output);
+            reject(new Error(`npm ${args[0] ?? ""} failed (${code}): ${output.trim()}`));
+        });
+    });
+}
+const operations = new Map();
+function withProjectLock(projectRoot, operation) {
+    const key = process.platform === "win32" ? projectRoot.toLowerCase() : projectRoot;
+    const previous = operations.get(key) ?? Promise.resolve();
+    const result = previous.then(operation);
+    const settled = result.then(() => { }, () => { });
+    operations.set(key, settled);
+    return result.finally(() => {
+        if (operations.get(key) === settled)
+            operations.delete(key);
+    });
+}
+/**
+ * Installs (or updates) one npm plugin as a project dependency.
+ *
+ * The version is pinned with `--save-exact`: the panel performs updates, so a
+ * later bare `npm install` must not silently move the plugin to another release.
+ */
+async function installNpmPlugin(options) {
+    const { name, pluginId, version, side } = options;
+    if (!PLUGIN_ID.test(pluginId))
+        throw new Error(`Invalid plugin id: ${pluginId}`);
+    if (!PACKAGE_NAME.test(name))
+        throw new Error(`Invalid npm plugin package: ${name}`);
+    if (!VERSION.test(version))
+        throw new Error(`Invalid plugin version: ${version}`);
+    const { packageRoot, projectRoot } = npmPluginRoots(options);
+    return withProjectLock(projectRoot, async () => {
+        const host = readJson(path_1.default.join(packageRoot, "package.json"));
+        if (!host)
+            throw new Error(`Missing runtime package metadata: ${packageRoot}`);
+        if (mappingsOf(host)[pluginId] !== undefined)
+            throw new Error(`BUNDLED:${pluginId}`);
+        const existing = mappingsOf(readProjectManifest(projectRoot))[pluginId];
+        if (existing !== undefined && existing !== name)
+            throw new Error(`Plugin id ${pluginId} is already installed as ${String(existing)}.`);
+        await fs_extra_1.default.ensureDir(projectRoot);
+        await runNpm(["install", `${name}@${version}`, "--save", "--save-exact", "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot);
+        let entry;
+        try {
+            entry = readPackageEntry(packageRoot, name);
+        }
+        catch (error) {
+            await runNpm(["uninstall", name, "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot).catch(() => { });
+            throw error;
+        }
+        const record = recordFromPackage(pluginId, name, "project", entry.root, entry.metadata, side);
+        if (!record) {
+            await runNpm(["uninstall", name, "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot).catch(() => { });
+            throw new Error(`The package ${name} does not provide a ${side} plugin named ${pluginId}.`);
+        }
+        if (record.version !== version) {
+            await runNpm(["uninstall", name, "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot).catch(() => { });
+            throw new Error(`The installed package ${name} is ${record.version}, expected ${version}.`);
+        }
+        const manifest = readProjectManifest(projectRoot);
+        const dependencies = { ...dependenciesOf(manifest), [name]: version };
+        const elementspanel = { ...(objectValue(manifest.elementspanel) ?? {}) };
+        const plugins = { ...mappingsOf(manifest), [pluginId]: name };
+        manifest.dependencies = dependencies;
+        manifest.elementspanel = { ...elementspanel, plugins };
+        writeProjectManifest(projectRoot, manifest);
+        return record;
+    });
+}
+/** Removes one project-installed npm plugin. Built-in packages are left alone. */
+async function uninstallNpmPlugin(pluginId, options = {}) {
+    if (!PLUGIN_ID.test(pluginId))
+        throw new Error(`Invalid plugin id: ${pluginId}`);
+    const { packageRoot, projectRoot } = npmPluginRoots(options);
+    return withProjectLock(projectRoot, async () => {
+        const host = readJson(path_1.default.join(packageRoot, "package.json"));
+        if (host && mappingsOf(host)[pluginId] !== undefined)
+            throw new Error(`BUNDLED:${pluginId}`);
+        const manifest = readProjectManifest(projectRoot);
+        const name = mappingsOf(manifest)[pluginId];
+        if (typeof name !== "string" || !PACKAGE_NAME.test(name))
+            return null;
+        const record = listNpmPlugins(undefined, { packageRoot, projectRoot, skipInvalid: true }).find((item) => item.pluginId === pluginId);
+        await runNpm(["uninstall", name, "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot);
+        const plugins = { ...mappingsOf(manifest) };
+        delete plugins[pluginId];
+        const elementspanel = { ...(objectValue(manifest.elementspanel) ?? {}) };
+        if (Object.keys(plugins).length)
+            elementspanel.plugins = plugins;
+        else
+            delete elementspanel.plugins;
+        manifest.elementspanel = elementspanel;
+        writeProjectManifest(projectRoot, manifest);
+        return record ?? null;
+    });
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_overrides.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.pluginOverridesPath = pluginOverridesPath;
+exports.readPluginOverrides = readPluginOverrides;
+exports.validatePluginOverride = validatePluginOverride;
+exports.applyPluginOverrides = applyPluginOverrides;
+exports.writePluginOverride = writePluginOverride;
+const node_fs_1 = __importDefault(__webpack_require__("node:fs"));
+const node_path_1 = __importDefault(__webpack_require__("node:path"));
+const node_crypto_1 = __webpack_require__("node:crypto");
+function pluginOverridesPath() {
+    return node_path_1.default.resolve(process.cwd(), "data", "plugin-overrides.json");
+}
+/** Package defaults stay immutable; only the user's last layer lives in data. */
+function readPluginOverrides(filename = pluginOverridesPath()) {
+    let raw;
+    try {
+        raw = node_fs_1.default.readFileSync(filename, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { version: 1, plugins: {} };
+        throw error;
+    }
+    const data = JSON.parse(raw);
+    if (data?.version !== 1 ||
+        !data.plugins ||
+        typeof data.plugins !== "object" ||
+        Array.isArray(data.plugins))
+        throw new Error("Invalid plugin-overrides.json");
+    for (const entry of Object.values(data.plugins))
+        validatePluginOverride(entry);
+    return data;
+}
+function validatePluginOverride(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid plugin override.");
+    const entry = value;
+    if (entry.enabled !== undefined && typeof entry.enabled !== "boolean")
+        throw new Error("Invalid plugin enablement.");
+    if (entry.config !== undefined &&
+        (!entry.config || typeof entry.config !== "object" || Array.isArray(entry.config)))
+        throw new Error("Plugin config must be an object.");
+    if (Object.keys(value).some((key) => !["enabled", "config"].includes(key)))
+        throw new Error("Unknown plugin override field.");
+}
+function applyPluginOverrides(plugins, filename = pluginOverridesPath()) {
+    const overrides = readPluginOverrides(filename).plugins;
+    return plugins.map((plugin) => ({
+        ...plugin,
+        manifest: {
+            ...plugin.manifest,
+            ...(Object.prototype.hasOwnProperty.call(overrides, plugin.manifest.id)
+                ? overrides[plugin.manifest.id]
+                : {})
+        }
+    }));
+}
+/** Call inside the host's change queue; rename keeps readers off partial JSON. */
+function writePluginOverride(id, patch, filename = pluginOverridesPath()) {
+    validatePluginOverride(patch);
+    if (!id || ["__proto__", "constructor", "prototype"].includes(id))
+        throw new Error("Invalid plugin id.");
+    const data = readPluginOverrides(filename);
+    data.plugins[id] = {
+        ...(Object.prototype.hasOwnProperty.call(data.plugins, id) ? data.plugins[id] : {}),
+        ...patch
+    };
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(filename), { recursive: true });
+    const temporary = `${filename}.${(0, node_crypto_1.randomBytes)(8).toString("hex")}.tmp`;
+    try {
+        node_fs_1.default.writeFileSync(temporary, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        node_fs_1.default.renameSync(temporary, filename);
+    }
+    finally {
+        node_fs_1.default.rmSync(temporary, { force: true });
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_revision.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.pluginDirectoryRevision = pluginDirectoryRevision;
+const node_fs_1 = __importDefault(__webpack_require__("node:fs"));
+const node_path_1 = __importDefault(__webpack_require__("node:path"));
+const node_crypto_1 = __webpack_require__("node:crypto");
+const cache = new Map();
+/** One revision addresses the complete module graph, including CSS and nested chunks. */
+function pluginDirectoryRevision(directory) {
+    const files = [];
+    const walk = (root) => {
+        if (!node_fs_1.default.existsSync(root))
+            return;
+        for (const item of node_fs_1.default
+            .readdirSync(root, { withFileTypes: true })
+            .sort((a, b) => a.name.localeCompare(b.name))) {
+            const absolute = node_path_1.default.join(root, item.name);
+            if (item.isDirectory())
+                walk(absolute);
+            else if (item.isFile())
+                files.push({
+                    relative: node_path_1.default.relative(directory, absolute),
+                    absolute,
+                    stat: node_fs_1.default.statSync(absolute)
+                });
+        }
+    };
+    walk(directory);
+    const signature = JSON.stringify(files.map(({ relative, stat }) => [relative, stat.size, stat.mtimeMs, stat.ctimeMs]));
+    const previous = cache.get(directory);
+    if (previous?.signature === signature)
+        return previous.revision;
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    for (const file of files)
+        hash
+            .update(file.relative)
+            .update("\0")
+            .update(new Uint8Array(node_fs_1.default.readFileSync(file.absolute)))
+            .update("\0");
+    const revision = hash.digest("hex").slice(0, 24);
+    if (cache.size > 1024)
+        cache.clear();
+    cache.set(directory, { signature, revision });
+    return revision;
+}
+
+
+/***/ },
+
+/***/ "../common/src/process_tools.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ProcessWrapper = exports.StartError = void 0;
+exports.killProcess = killProcess;
+const child_process_1 = __webpack_require__("child_process");
+const os_1 = __importDefault(__webpack_require__("os"));
+const child_process_2 = __importDefault(__webpack_require__("child_process"));
+const path_1 = __importDefault(__webpack_require__("path"));
+const events_1 = __importDefault(__webpack_require__("events"));
+const iconv_lite_1 = __importDefault(__webpack_require__("iconv-lite"));
+const process_1 = __importDefault(__webpack_require__("process"));
+class StartError extends Error {
+}
+exports.StartError = StartError;
+class ProcessWrapper extends events_1.default {
+    file;
+    args;
+    cwd;
+    timeout;
+    code;
+    option;
+    process;
+    pid;
+    lastExitCode;
+    completed = false;
+    errMsg = {
+        timeoutErr: "task timeout!",
+        exitErr: "task error!",
+        startErr: "task start error!"
+    };
+    constructor(file, args, cwd, timeout = 0, code = "utf-8", option = {}) {
+        super();
+        this.file = file;
+        this.args = args;
+        this.cwd = cwd;
+        this.timeout = timeout;
+        this.code = code;
+        this.option = option;
+    }
+    setErrMsg(errMsg) {
+        this.errMsg = errMsg;
+    }
+    start() {
+        if (this.process)
+            return Promise.reject(new Error("The process is already running"));
+        return new Promise((resolve, reject) => {
+            const stdoutDecoder = iconv_lite_1.default.decodeStream(this.code);
+            const stderrDecoder = iconv_lite_1.default.decodeStream(this.code);
+            let timeTask;
+            let settled = false;
+            let spawned = false;
+            const settle = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeTask)
+                    clearTimeout(timeTask);
+                if (error)
+                    reject(error);
+                else
+                    resolve(true);
+            };
+            const subProcess = child_process_2.default.spawn(this.file, this.args, {
+                stdio: "pipe",
+                windowsHide: true,
+                cwd: path_1.default.normalize(this.cwd),
+                ...this.option
+            });
+            this.process = subProcess;
+            this.pid = subProcess.pid;
+            this.lastExitCode = undefined;
+            this.completed = false;
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settle(error);
+                if (subProcess.pid && subProcess.exitCode === null && subProcess.signalCode === null) {
+                    try {
+                        killProcess(subProcess.pid, subProcess);
+                    }
+                    catch (error) {
+                        console.error("[ProcessWrapper kill error]", error);
+                    }
+                }
+            };
+            subProcess.once("spawn", () => {
+                spawned = true;
+                this.emit("start", subProcess.pid);
+            });
+            for (const [source, decoder] of [
+                [subProcess.stdout, stdoutDecoder],
+                [subProcess.stderr, stderrDecoder]
+            ]) {
+                decoder.on("data", (text) => this.emit("data", text));
+                decoder.on("error", fail);
+                source.on("error", fail);
+                source.pipe(decoder);
+            }
+            subProcess.stdin.on("error", fail);
+            subProcess.once("error", (error) => {
+                fail(new Error(`${spawned ? this.errMsg.exitErr : this.errMsg.startErr} ${error.message}`));
+            });
+            subProcess.once("exit", (code) => {
+                this.lastExitCode = code;
+                this.emit("exit", code);
+            });
+            // `close` follows the final stdout/stderr data and also follows a failed spawn.
+            subProcess.once("close", (code) => {
+                this.lastExitCode = code;
+                this.completed = true;
+                this.process = undefined;
+                settle(code === 0 ? undefined : new Error(this.errMsg.exitErr));
+            });
+            if (this.timeout > 0) {
+                timeTask = setTimeout(() => {
+                    fail(new Error(this.errMsg.timeoutErr));
+                }, 1000 * this.timeout);
+            }
+        });
+    }
+    getPid() {
+        return this.process?.pid;
+    }
+    write(data) {
+        return this.process?.stdin?.write(iconv_lite_1.default.encode(data, this.code));
+    }
+    kill() {
+        if (this.process?.pid)
+            killProcess(this.process?.pid, this.process);
+    }
+    status() {
+        return this.completed;
+    }
+    exitCode() {
+        return this.process?.exitCode ?? this.lastExitCode;
+    }
+}
+exports.ProcessWrapper = ProcessWrapper;
+function killProcess(pid, process, signal) {
+    const numericPid = Number(pid);
+    if (!Number.isSafeInteger(numericPid) || numericPid <= 0) {
+        throw new Error("Invalid process ID");
+    }
+    try {
+        if (os_1.default.platform() === "win32") {
+            (0, child_process_1.execFileSync)("taskkill", ["/PID", String(numericPid), "/T", "/F"], { windowsHide: true });
+            return true;
+        }
+        return process_1.default.kill(numericPid, signal || "SIGKILL");
+    }
+    catch (err) {
+        return signal ? process.kill(signal) : process.kill("SIGKILL");
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/query_wrapper.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.QueryWrapper = exports.LocalFileSource = exports.MySqlSource = exports.QueryMapWrapper = void 0;
+function paginate(data, page, pageSize) {
+    if (!Number.isSafeInteger(page) || page < 1 || !Number.isSafeInteger(pageSize) || pageSize < 1) {
+        throw new RangeError("page and pageSize must be positive integers");
+    }
+    const start = (page - 1) * pageSize;
+    return {
+        page,
+        pageSize,
+        maxPage: Math.ceil(data.length / pageSize),
+        total: data.length,
+        data: data.slice(start, start + pageSize)
+    };
+}
+// Provide the MAP query interface used by the routing layer
+class QueryMapWrapper {
+    map;
+    constructor(map) {
+        this.map = map;
+    }
+    select(condition) {
+        const result = [];
+        this.map.forEach((v) => {
+            if (condition(v))
+                result.push(v);
+        });
+        return result;
+    }
+    page(data, page = 1, pageSize = 10) {
+        return paginate(data, page, pageSize);
+    }
+}
+exports.QueryMapWrapper = QueryMapWrapper;
+// MYSQL data source
+class MySqlSource {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    selectPage(condition, page, pageSize) {
+        return {
+            page,
+            pageSize,
+            maxPage: 0,
+            total: 0,
+            data: []
+        };
+    }
+    select(condition) {
+        return [];
+    }
+    update(condition, data) { }
+    delete(condition) { }
+    insert(data) { }
+}
+exports.MySqlSource = MySqlSource;
+// local file data source (embedded microdatabase)
+class LocalFileSource {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    selectPage(condition, page = 1, pageSize = 10) {
+        return this.page(this.select(condition), page, pageSize);
+    }
+    page(data, page = 1, pageSize = 10) {
+        return paginate(data, page, pageSize);
+    }
+    select(condition = {}) {
+        const result = [];
+        const entries = Object.entries(condition);
+        this.data.forEach((v) => {
+            for (const [key, targetValue] of entries) {
+                const dataValue = v[key];
+                if (typeof targetValue === "string" &&
+                    targetValue.startsWith("%") &&
+                    targetValue.endsWith("%")) {
+                    if (typeof dataValue !== "string" || !dataValue.includes(targetValue.slice(1, -1)))
+                        return;
+                }
+                else if (targetValue !== dataValue) {
+                    return;
+                }
+            }
+            result.push(v);
+        });
+        return result;
+    }
+    update(condition, data) { }
+    delete(condition) { }
+    insert(data) { }
+}
+exports.LocalFileSource = LocalFileSource;
+// Provide the unified data query interface used by the routing layer
+class QueryWrapper {
+    dataSource;
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+    }
+    selectPage(condition, page = 1, pageSize = 10) {
+        return this.dataSource.selectPage(condition, page, pageSize);
+    }
+}
+exports.QueryWrapper = QueryWrapper;
+
+
+/***/ },
+
+/***/ "../common/src/runtime_paths.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.isPackagedRuntime = isPackagedRuntime;
+exports.packagePath = packagePath;
+exports.packagePluginRoots = packagePluginRoots;
+exports.isPackagePlugin = isPackagePlugin;
+exports.bundledToolPath = bundledToolPath;
+exports.ensureExecutable = ensureExecutable;
+const node_fs_1 = __importDefault(__webpack_require__("node:fs"));
+const node_os_1 = __importDefault(__webpack_require__("node:os"));
+const node_path_1 = __importDefault(__webpack_require__("node:path"));
+/** Set by the npm worker before any application module is loaded. */
+function isPackagedRuntime() {
+    return Boolean(process.env.EPANEL_PACKAGE_ROOT);
+}
+/** Code and bundled assets belong to the package; cwd always belongs to the user. */
+function packagePath(...parts) {
+    return node_path_1.default.resolve(process.env.EPANEL_PACKAGE_ROOT || process.cwd(), ...parts);
+}
+function npmPluginRoots(side) {
+    // The same resolver is used by the CLI before the bundled application starts.
+    // A development checkout keeps it in the repository, beside the side packages,
+    // so project-installed npm plugins work there as well.
+    const runtimeRequire = eval("require");
+    const resolver = isPackagedRuntime()
+        ? packagePath("runtime/npm-plugins.cjs")
+        : node_path_1.default.resolve(packagePath(), "..", "scripts", "runtime", "npm-plugins.cjs");
+    // A development process may run from a fixture directory without a runtime
+    // package; there is nothing to resolve in that case.
+    if (!node_fs_1.default.existsSync(node_path_1.default.join(packagePath(), "package.json")))
+        return [];
+    if (!isPackagedRuntime() && !node_fs_1.default.existsSync(resolver))
+        return [];
+    const { resolveNpmPlugins } = runtimeRequire(resolver);
+    return resolveNpmPlugins(packagePath(), side, { skipInvalid: true }).map((record) => ({
+        directory: record.directory,
+        ...(record.folder ? { folder: record.folder } : {}),
+        // Built-in packages are part of the runtime's default configuration. A
+        // project dependency is installed but remains dormant until the user
+        // enables it through the plugin configuration service.
+        defaultEnabled: record.defaultEnabled !== false
+    }));
+}
+function packagePluginRoots(side) {
+    const roots = isPackagedRuntime()
+        ? []
+        : [{ directory: packagePath("plugins"), defaultEnabled: true }];
+    // Project-installed npm plugins load in development too: they are dependencies
+    // of the development project, not of the published runtime package.
+    roots.push(...npmPluginRoots(side));
+    return roots;
+}
+function isPackagePlugin(directory) {
+    return npmPluginRoots().some((root) => {
+        const relative = node_path_1.default.relative(root.directory, node_path_1.default.resolve(directory));
+        return (relative === "" ||
+            (!relative.startsWith(`..${node_path_1.default.sep}`) && relative !== ".." && !node_path_1.default.isAbsolute(relative)));
+    });
+}
+function bundledToolPath(name) {
+    const platform = node_os_1.default.platform();
+    const arch = node_os_1.default.arch();
+    const suffix = platform === "win32" ? ".exe" : "";
+    const filename = `${name}_${platform}_${arch}${suffix}`;
+    // Published daemon packages download native tools into the installation's
+    // writable lib directory on first start. Development checkouts use the same
+    // repository-local sibling of data and logs.
+    const root = isPackagedRuntime() ? node_path_1.default.resolve(process.cwd(), "lib") : packagePath("lib");
+    const primary = node_path_1.default.join(root, filename);
+    // Zip-Tools names its Intel macOS binary "amd64", while Node reports "x64".
+    if (!node_fs_1.default.existsSync(primary) && name === "file_zip" && platform === "darwin" && arch === "x64") {
+        const alternate = node_path_1.default.join(root, "file_zip_darwin_amd64");
+        if (node_fs_1.default.existsSync(alternate))
+            return alternate;
+    }
+    return primary;
+}
+/** Published binaries already carry executable permissions, including in read-only installs. */
+function ensureExecutable(filename) {
+    if (node_os_1.default.platform() === "win32")
+        return;
+    try {
+        node_fs_1.default.accessSync(filename, node_fs_1.default.constants.X_OK);
+    }
+    catch {
+        node_fs_1.default.chmodSync(filename, 0o755);
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/string_utils.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.removeTrail = removeTrail;
+function removeTrail(origin, trail) {
+    if (origin.endsWith(trail)) {
+        return origin.slice(0, origin.length - trail.length);
+    }
+    else {
+        return origin;
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/system_info.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.systemInfo = systemInfo;
+const os_1 = __importDefault(__webpack_require__("os"));
+const os_utils_1 = __importDefault(__webpack_require__("os-utils"));
+const fs_1 = __importDefault(__webpack_require__("fs"));
+// System details are updated every time
+const info = {
+    type: os_1.default.type(),
+    hostname: os_1.default.hostname(),
+    platform: os_1.default.platform(),
+    release: os_1.default.release(),
+    uptime: os_1.default.uptime(),
+    cwd: process.cwd(),
+    loadavg: os_1.default.loadavg(),
+    freemem: 0,
+    cpuUsage: 0,
+    memUsage: 0,
+    totalmem: 0,
+    processCpu: 0,
+    processMem: 0
+};
+let previousCpu = process.cpuUsage();
+let previousTime = process.hrtime.bigint();
+// periodically refresh the cache
+function refresh() {
+    const now = process.hrtime.bigint();
+    const cpu = process.cpuUsage();
+    const elapsed = Number(now - previousTime) / 1000;
+    info.processCpu =
+        elapsed > 0 ? (cpu.user - previousCpu.user + cpu.system - previousCpu.system) / elapsed : 0;
+    previousCpu = cpu;
+    previousTime = now;
+    info.uptime = os_1.default.uptime();
+    info.loadavg = os_1.default.loadavg();
+    info.processMem = process.memoryUsage().rss;
+    if (os_1.default.platform() === "linux") {
+        return setLinuxSystemInfo();
+    }
+    return otherSystemInfo();
+}
+refresh();
+setInterval(refresh, 3000).unref();
+function otherSystemInfo() {
+    info.freemem = os_1.default.freemem();
+    info.totalmem = os_1.default.totalmem();
+    info.memUsage = (os_1.default.totalmem() - os_1.default.freemem()) / os_1.default.totalmem();
+    os_utils_1.default.cpuUsage((p) => (info.cpuUsage = p));
+}
+function setLinuxSystemInfo() {
+    try {
+        // read memory data based on /proc/meminfo
+        const data = fs_1.default.readFileSync("/proc/meminfo", { encoding: "utf-8" });
+        const list = data.split("\n");
+        const infoTable = {};
+        list.forEach((line) => {
+            const kv = line.split(":");
+            if (kv.length === 2) {
+                const k = kv[0].replace(/ /gim, "").replace(/\t/gim, "").trim().toLowerCase();
+                let v = kv[1].replace(/ /gim, "").replace(/\t/gim, "").trim().toLowerCase();
+                v = v.replace(/kb/gim, "").replace(/mb/gim, "").replace(/gb/gim, "");
+                let vNumber = parseInt(v);
+                if (isNaN(vNumber))
+                    vNumber = 0;
+                infoTable[k] = vNumber;
+            }
+        });
+        const memAvailable = infoTable["memavailable"] ?? infoTable["memfree"];
+        const memTotal = infoTable["memtotal"];
+        info.freemem = memAvailable * 1024;
+        info.totalmem = memTotal * 1024;
+        info.memUsage = (info.totalmem - info.freemem) / info.totalmem;
+        os_utils_1.default.cpuUsage((p) => (info.cpuUsage = p));
+    }
+    catch (error) {
+        // If the reading is wrong, the default general reading method is automatically used
+        otherSystemInfo();
+    }
+}
+function systemInfo() {
+    return info;
+}
+
+
+/***/ },
+
+/***/ "../common/src/system_storage.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const crypto_1 = __webpack_require__("crypto");
+const path_1 = __importDefault(__webpack_require__("path"));
+const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+class StorageSubsystem {
+    static DATA_PATH = path_1.default.resolve(process.cwd(), "data");
+    static INDEX_PATH = path_1.default.join(StorageSubsystem.DATA_PATH, "Index");
+    resolvePath(name) {
+        if (typeof name !== "string" ||
+            !name ||
+            /[\0:]/.test(name) ||
+            path_1.default.isAbsolute(name) ||
+            path_1.default.win32.isAbsolute(name)) {
+            throw new Error(`Invalid storage path: ${name}`);
+        }
+        const target = path_1.default.resolve(StorageSubsystem.DATA_PATH, name);
+        const relative = path_1.default.relative(StorageSubsystem.DATA_PATH, target);
+        if (!relative ||
+            relative === ".." ||
+            relative.startsWith(`..${path_1.default.sep}`) ||
+            path_1.default.isAbsolute(relative)) {
+            throw new Error(`Invalid storage path: ${name}`);
+        }
+        const realRelative = path_1.default.relative(this.realPath(StorageSubsystem.DATA_PATH), this.realPath(target));
+        if (realRelative === ".." ||
+            realRelative.startsWith(`..${path_1.default.sep}`) ||
+            path_1.default.isAbsolute(realRelative)) {
+            throw new Error(`Invalid storage path: ${name}`);
+        }
+        return target;
+    }
+    realPath(target) {
+        if (fs_extra_1.default.existsSync(target))
+            return fs_extra_1.default.realpathSync(target);
+        const parent = path_1.default.dirname(target);
+        return parent === target ? target : path_1.default.join(this.realPath(parent), path_1.default.basename(target));
+    }
+    entityPath(category, uuid) {
+        if (typeof uuid !== "string" || !uuid || /[\\/\0:]/.test(uuid) || uuid.includes("..")) {
+            throw new Error(`UUID ${uuid} does not conform to specification`);
+        }
+        this.resolvePath(category);
+        return path_1.default.join(category, `${uuid}.json`);
+    }
+    writeFile(name, data) {
+        const targetPath = this.resolvePath(name);
+        fs_extra_1.default.ensureDirSync(path_1.default.dirname(targetPath));
+        const temporaryPath = `${targetPath}.${(0, crypto_1.randomUUID)()}.tmp`;
+        const mode = fs_extra_1.default.existsSync(targetPath) ? fs_extra_1.default.statSync(targetPath).mode : 0o600;
+        try {
+            fs_extra_1.default.writeFileSync(temporaryPath, data, { encoding: "utf8", flag: "wx", mode });
+            fs_extra_1.default.renameSync(temporaryPath, targetPath);
+        }
+        finally {
+            if (fs_extra_1.default.existsSync(temporaryPath))
+                fs_extra_1.default.unlinkSync(temporaryPath);
+        }
+    }
+    readFile(name) {
+        return fs_extra_1.default.readFileSync(this.resolvePath(name), "utf8");
+    }
+    readDir(dirName) {
+        const targetPath = this.resolvePath(dirName);
+        if (!fs_extra_1.default.existsSync(targetPath))
+            return [];
+        return fs_extra_1.default.readdirSync(targetPath).map((name) => path_1.default.join(dirName, name));
+    }
+    deleteFile(name) {
+        fs_extra_1.default.removeSync(this.resolvePath(name));
+    }
+    fileExists(name) {
+        return fs_extra_1.default.existsSync(this.resolvePath(name));
+    }
+    store(category, uuid, object) {
+        this.writeFile(this.entityPath(category, uuid), JSON.stringify(object, null, 4));
+    }
+    // Restore declared fields while keeping defaults for fields absent in older data.
+    defineAttr(target, object) {
+        for (const key of Object.keys(target)) {
+            if (!Object.prototype.hasOwnProperty.call(object, key) || object[key] === undefined)
+                continue;
+            const value = object[key];
+            if (value !== null &&
+                typeof value === "object" &&
+                !Array.isArray(value) &&
+                target[key] !== null &&
+                typeof target[key] === "object" &&
+                !Array.isArray(target[key])) {
+                this.defineAttr(target[key], value);
+            }
+            else {
+                target[key] = value;
+            }
+        }
+        return target;
+    }
+    load(category, classz, uuid) {
+        const file = this.entityPath(category, uuid);
+        if (!this.fileExists(file))
+            return null;
+        const object = JSON.parse(this.readFile(file));
+        if (!object || typeof object !== "object" || Array.isArray(object)) {
+            throw new Error(`Invalid stored entity: ${file}`);
+        }
+        return this.defineAttr(new classz(), object);
+    }
+    list(category) {
+        const directory = this.resolvePath(category);
+        if (!fs_extra_1.default.existsSync(directory))
+            return [];
+        return fs_extra_1.default
+            .readdirSync(directory, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => entry.name.slice(0, -5));
+    }
+    delete(category, uuid) {
+        this.deleteFile(this.entityPath(category, uuid));
+    }
+}
+exports["default"] = StorageSubsystem;
+
+
+/***/ },
+
+/***/ "../common/src/typecheck.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.configureEntityParams = configureEntityParams;
+exports.toText = toText;
+exports.toNumber = toNumber;
+exports.toBoolean = toBoolean;
+exports.isEmpty = isEmpty;
+exports.supposeValue = supposeValue;
+function configureEntityParams(self, args, key, typeFn) {
+    const selfDefaultValue = self[key] ?? null;
+    const v = args[key] != null ? args[key] : selfDefaultValue;
+    if (typeFn === Number) {
+        if (v === "" || v == null) {
+            self[key] = null;
+        }
+        else {
+            if (isNaN(Number(v)))
+                throw new Error(`ConfigureEntityParams Error: Expected type to be Number, but got ${typeof v}`);
+            self[key] = Number(v);
+        }
+        return;
+    }
+    if (typeFn === String) {
+        if (v == null) {
+            self[key] = null;
+        }
+        else {
+            self[key] = String(v);
+        }
+        return;
+    }
+    if (typeFn === Boolean) {
+        if (v == null) {
+            self[key] = false;
+        }
+        else {
+            self[key] = Boolean(v);
+        }
+        return;
+    }
+    if (typeFn) {
+        self[key] = typeFn(v);
+    }
+    else {
+        self[key] = v;
+    }
+}
+function toText(v) {
+    if (isEmpty(v))
+        return null;
+    return String(v);
+}
+function toNumber(v) {
+    if (isEmpty(v))
+        return null;
+    if (isNaN(Number(v)))
+        return null;
+    return Number(v);
+}
+function toBoolean(v) {
+    if (isEmpty(v))
+        return null;
+    return Boolean(v);
+}
+function isEmpty(v) {
+    return v === null || v === undefined;
+}
+function supposeValue(v, def) {
+    if (isEmpty(v))
+        return def;
+    return v;
+}
+
+
+/***/ },
+
+/***/ "./plugins/config/src/backend/settings.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SettingsFormService = void 0;
+const mcsmanager_common_1 = __webpack_require__("../common/src/index.ts");
+const cordis_1 = __webpack_require__("cordis");
+const cosmokit_1 = __webpack_require__("cosmokit");
+/** Configuration declarations are owned by the daemon config plugin. */
+class SettingsFormService extends cordis_1.Service {
+    declarations = [];
+    constructor(ctx) {
+        super(ctx, "settingsForm", true);
+    }
+    declare(declaration) {
+        const entry = { id: this.ctx.name, declaration };
+        return this.ctx.effect(() => {
+            this.declarations.push(entry);
+            return () => (0, cosmokit_1.remove)(this.declarations, entry);
+        });
+    }
+    declared() {
+        return this.declarations.map((entry) => entry.id);
+    }
+    async read(id) {
+        const entry = this.declarations.find((item) => item.id === id);
+        if (!entry) {
+            const schema = this.ctx.plugins.configuration(id);
+            return schema.fields.length ? schema : null;
+        }
+        return { id, fields: entry.declaration.fields(), values: await entry.declaration.read() };
+    }
+    async write(id, values) {
+        const entry = this.declarations.find((item) => item.id === id);
+        if (!entry)
+            return (await this.ctx.plugins.configure(id, values)).result;
+        return this.ctx.plugins.runExclusive(async () => {
+            (0, mcsmanager_common_1.validatePluginSettings)(entry.declaration.fields(), values);
+            await entry.declaration.write(values);
+            return {
+                saved: true,
+                application: entry.declaration.restartRequired ? "restart-required" : "applied"
+            };
+        });
+    }
+}
+exports.SettingsFormService = SettingsFormService;
+
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/index.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.localeMessages = void 0;
+const de_DE_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/de_DE.json"));
+const en_US_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/en_US.json"));
+const es_ES_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/es_ES.json"));
+const fr_FR_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/fr_FR.json"));
+const ja_JP_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/ja_JP.json"));
+const ko_KR_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/ko_KR.json"));
+const pt_BR_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/pt_BR.json"));
+const ru_RU_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/ru_RU.json"));
+const th_TH_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/th_TH.json"));
+const tr_TR_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/tr_TR.json"));
+const zh_CN_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/zh_CN.json"));
+const zh_TW_json_1 = __importDefault(__webpack_require__("./plugins/config/src/i18n/zh_TW.json"));
+// The refusals this plugin's protocol handlers throw. The panel surfaces them
+// verbatim on its plugin manager page, so they are translated here rather than
+// in the panel: this daemon knows which of its own plugins may not be switched
+// off remotely, and it answers in the language it was told to speak.
+exports.localeMessages = {
+    de_de: de_DE_json_1.default,
+    en_us: en_US_json_1.default,
+    es_es: es_ES_json_1.default,
+    fr_fr: fr_FR_json_1.default,
+    ja_jp: ja_JP_json_1.default,
+    ko_kr: ko_KR_json_1.default,
+    pt_br: pt_BR_json_1.default,
+    ru_ru: ru_RU_json_1.default,
+    th_th: th_TH_json_1.default,
+    tr_tr: tr_TR_json_1.default,
+    zh_cn: zh_CN_json_1.default,
+    zh_tw: zh_TW_json_1.default
+};
+
+
+/***/ },
+
+/***/ "events"
+(module) {
+
+module.exports = require("events");
+
+/***/ },
+
+/***/ "fs-extra"
+(module) {
+
+module.exports = require("fs-extra");
+
+/***/ },
+
+/***/ "iconv-lite"
+(module) {
+
+module.exports = require("iconv-lite");
+
+/***/ },
+
+/***/ "os-utils"
+(module) {
+
+module.exports = require("os-utils");
+
+/***/ },
+
+/***/ "cordis"
+(module) {
+
+module.exports = require("cordis");
+
+/***/ },
+
+/***/ "cosmokit"
+(module) {
+
+module.exports = require("cosmokit");
+
+/***/ },
+
+/***/ "child_process"
+(module) {
+
+module.exports = require("child_process");
+
+/***/ },
+
+/***/ "crypto"
+(module) {
+
+module.exports = require("crypto");
+
+/***/ },
+
+/***/ "fs"
+(module) {
+
+module.exports = require("fs");
+
+/***/ },
+
+/***/ "module"
+(module) {
+
+module.exports = require("module");
+
+/***/ },
+
+/***/ "net"
+(module) {
+
+module.exports = require("net");
+
+/***/ },
+
+/***/ "node:crypto"
+(module) {
+
+module.exports = require("node:crypto");
+
+/***/ },
+
+/***/ "node:fs"
+(module) {
+
+module.exports = require("node:fs");
+
+/***/ },
+
+/***/ "node:os"
+(module) {
+
+module.exports = require("node:os");
+
+/***/ },
+
+/***/ "node:path"
+(module) {
+
+module.exports = require("node:path");
+
+/***/ },
+
+/***/ "os"
+(module) {
+
+module.exports = require("os");
+
+/***/ },
+
+/***/ "path"
+(module) {
+
+module.exports = require("path");
+
+/***/ },
+
+/***/ "process"
+(module) {
+
+module.exports = require("process");
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/de_DE.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE":"Der Webserver kann nicht aus der Ferne deaktiviert werden: Das Panel würde die Verbindung verlieren, über die es diesen Daemon verwaltet. Setze enabled auf dem Host in seiner plugin.json auf false.","TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED":"Eine Plugin-ID ist erforderlich.","TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE":"Die Plugin-Verwaltung kann sich nicht selbst deaktivieren: Das Panel würde die Events verlieren, mit denen es diesen Daemon verwaltet. Setze enabled auf dem Host in seiner plugin.json auf false."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/en_US.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE":"The web server cannot be disabled remotely: the panel would lose the connection it manages this daemon over. Set enabled to false in its plugin.json on the host instead.","TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED":"A plugin id is required.","TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE":"Plugin management cannot disable itself: the panel would lose the events it administers this daemon with. Set enabled to false in its plugin.json on the host instead."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/es_ES.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE":"El servidor web no puede desactivarse de forma remota: el panel perdería la conexión con la que administra este demonio. Establece enabled en false en su plugin.json en el host.","TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED":"Se requiere un id de complemento.","TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE":"La gestión de complementos no puede desactivarse a sí misma: el panel perdería los eventos con los que administra este demonio. Establece enabled en false en su plugin.json en el host."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/fr_FR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE":"Le serveur web ne peut pas être désactivé à distance : le panneau perdrait la connexion par laquelle il administre ce démon. Définissez enabled à false dans son plugin.json sur l hôte.","TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED":"Un identifiant d extension est requis.","TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE":"Le gestionnaire d extensions ne peut pas se désactiver lui-même : le panneau perdrait les événements par lesquels il administre ce démon. Définissez enabled à false dans son plugin.json sur l hôte."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/ja_JP.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE":"Web サーバーはリモートから無効にできません。パネルがこのデーモンを管理している接続を失います。ホスト上で plugin.json の enabled を false に設定してください。","TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED":"プラグイン ID を指定してください。","TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE":"プラグイン管理は自身を無効にできません。パネルがこのデーモンを管理しているイベントを失います。ホスト上で plugin.json の enabled を false に設定してください。"}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/ko_KR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE":"웹 서버는 원격으로 비활성화할 수 없습니다. 패널이 이 데몬을 관리하는 연결을 잃게 됩니다. 호스트에서 plugin.json의 enabled 를 false 로 설정하세요.","TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED":"플러그인 ID가 필요합니다.","TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE":"플러그인 관리는 자신을 비활성화할 수 없습니다. 패널이 이 데몬을 관리하는 이벤트를 잃게 됩니다. 호스트에서 plugin.json의 enabled 를 false 로 설정하세요."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/pt_BR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE":"O servidor web não pode ser desativado remotamente: o painel perderia a conexão pela qual administra este daemon. Defina enabled como false no plugin.json dele no host.","TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED":"É necessário informar o id do plugin.","TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE":"O gerenciador de plugins não pode desativar a si mesmo: o painel perderia os eventos pelos quais administra este daemon. Defina enabled como false no plugin.json dele no host."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/ru_RU.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE":"Веб-сервер нельзя отключить удалённо: панель потеряет соединение, через которое управляет этим демоном. Укажите enabled: false в его plugin.json на хосте.","TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED":"Требуется идентификатор плагина.","TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE":"Менеджер плагинов не может отключить сам себя: панель потеряет события, через которые управляет этим демоном. Укажите enabled: false в его plugin.json на хосте."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/th_TH.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE":"ไม่สามารถปิดใช้งานเว็บเซิร์ฟเวอร์จากระยะไกลได้ แผงควบคุมจะเสียการเชื่อมต่อที่ใช้จัดการดีมอนนี้ กรุณาตั้ง enabled เป็น false ใน plugin.json ของมันบนเครื่องโฮสต์","TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED":"ต้องระบุรหัสปลั๊กอิน","TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE":"ตัวจัดการปลั๊กอินปิดใช้งานตัวเองไม่ได้ แผงควบคุมจะเสียอีเวนต์ที่ใช้จัดการดีมอนนี้ กรุณาตั้ง enabled เป็น false ใน plugin.json ของมันบนเครื่องโฮสต์"}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/tr_TR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE":"Web sunucusu uzaktan devre dışı bırakılamaz: panel bu daemon u yönettiği bağlantıyı kaybeder. Bunun yerine ana makinede plugin.json dosyasında enabled değerini false yapın.","TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED":"Bir eklenti kimliği gerekli.","TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE":"Eklenti yöneticisi kendisini devre dışı bırakamaz: panel bu daemon u yönettiği olayları kaybeder. Bunun yerine ana makinede plugin.json dosyasında enabled değerini false yapın."}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/zh_CN.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE":"Web 服务器不能远程禁用：面板会失去用来管理这个守护进程的连接。请在宿主机上把它的 plugin.json 里的 enabled 设为 false。","TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED":"必须提供插件 ID。","TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE":"插件管理无法禁用自己：面板会失去用来管理这个守护进程的事件。请在宿主机上把它的 plugin.json 里的 enabled 设为 false。"}');
+
+/***/ },
+
+/***/ "./plugins/config/src/i18n/zh_TW.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE":"Web 伺服器不能遠端停用：面板會失去用來管理這個守護行程的連線。請在主機上把它的 plugin.json 裡的 enabled 設為 false。","TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED":"必須提供外掛 ID。","TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE":"外掛管理無法停用自己：面板會失去用來管理這個守護行程的事件。請在主機上把它的 plugin.json 裡的 enabled 設為 false。"}');
+
+/***/ }
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry needs to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.inject = void 0;
+exports.apply = apply;
+const mcsmanager_common_1 = __webpack_require__("../common/src/index.ts");
+const i18n_1 = __webpack_require__("./plugins/config/src/i18n/index.ts");
+const settings_1 = __webpack_require__("./plugins/config/src/backend/settings.ts");
+// Daemon side of the plugin manager. The daemon core owns the mechanism —
+// `ctx.plugins` lists what is installed and persists the enable switch — and
+// this plugin only exposes it over the protocol, because the panel's plugin
+// manager page is what drives it.
+//
+// Every event is reachable only over an authenticated top-level session: the
+// daemon's auth middleware rejects every event other than "auth" and "stream"
+// until the panel has presented the daemon key.
+/** Turning this plugin off would remove the events the request came in over. */
+const SELF = "config";
+/**
+ * Turning the web server off would drop the connection the request arrived on,
+ * and with it every event that could turn it back on.
+ */
+const ESSENTIAL = new Set(["i18n", "storage", "runtime", "server"]);
+const PLUGIN_GROUPS_CATEGORY = "PluginGroups";
+const PLUGIN_GROUPS_ID = "config";
+class StoredPluginGroups {
+    groups = [];
+}
+function normalizePluginGroups(input) {
+    if (!Array.isArray(input))
+        throw new Error("Plugin groups must be an array.");
+    if (input.length > 100)
+        throw new Error("Too many plugin groups.");
+    return input.map((value) => {
+        if (!value || typeof value !== "object")
+            throw new Error("Invalid plugin group.");
+        const group = value;
+        const id = String(group.id ?? "").trim();
+        const name = String(group.name ?? "").trim();
+        if (!id || id.length > 128 || !name || name.length > 200) {
+            throw new Error("Invalid plugin group.");
+        }
+        if (!Array.isArray(group.pluginIds) ||
+            group.pluginIds.length > 2000 ||
+            group.pluginIds.some((pluginId) => typeof pluginId !== "string")) {
+            throw new Error("Invalid plugin group plugins.");
+        }
+        return {
+            id,
+            name,
+            pluginIds: [...new Set(group.pluginIds.map((pluginId) => pluginId.trim()).filter(Boolean))]
+        };
+    });
+}
+exports.inject = ["protocol", "i18n", "plugins", "storage", "overview"];
+function apply(ctx) {
+    ctx.i18n.define(i18n_1.localeMessages);
+    ctx.plugin(settings_1.SettingsFormService);
+    const settingsForm = ctx.get("settingsForm");
+    if (!settingsForm)
+        throw new Error("Daemon settings form service is unavailable.");
+    // The panel's node page compares daemon plugins against its own inventory, so
+    // the id/version pairs ride along on the overview payload it already polls.
+    // `dual` marks a two-sided plugin: if its panel half is absent there, the node
+    // page reports the plugin as missing rather than daemon-only by design.
+    // Best-effort: hosts without an overview service (tests, minimal daemons)
+    // keep loading this plugin without the extra payload.
+    ctx.overview?.provide(() => ({
+        plugins: ctx.plugins
+            .inventory()
+            .map((record) => ({ id: record.id, version: record.version, dual: record.dual }))
+    }));
+    // Unloads and deletes one installed plugin package. What may be removed —
+    // essential plugins, development sources — is the loader's own decision; its
+    // refusal arrives as a protocol error the panel's page reports.
+    ctx.protocol.on("plugin/remove", async (routerCtx, data) => {
+        try {
+            const id = String(data?.id ?? "");
+            if (!id)
+                throw new Error(ctx.i18n.$t("TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED"));
+            await ctx.plugins.remove(id);
+            ctx.protocol.response(routerCtx, { removed: true });
+        }
+        catch (error) {
+            ctx.protocol.responseError(routerCtx, error);
+        }
+    });
+    ctx.protocol.on("plugin/capabilities", (routerCtx) => {
+        ctx.protocol.response(routerCtx, { api: mcsmanager_common_1.PLUGIN_API_VERSION });
+    });
+    ctx.protocol.on("plugin/list", (routerCtx) => {
+        const declared = new Set(settingsForm.declared());
+        ctx.protocol.response(routerCtx, ctx.plugins.inventory().map((record) => ({
+            ...record,
+            // So the panel can say "no configurable options" without a round trip.
+            hasSettings: declared.has(record.id)
+        })));
+    });
+    ctx.protocol.on("plugin/enabled", async (routerCtx, data) => {
+        try {
+            const payload = (data ?? {});
+            const id = String(payload.id ?? "");
+            const enabled = Boolean(payload.enabled);
+            if (!id)
+                throw new Error(ctx.i18n.$t("TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED"));
+            if (!enabled && id === SELF) {
+                throw new Error(ctx.i18n.$t("TXT_CODE_DAEMON_PLUGIN_SELF_DISABLE"));
+            }
+            if (!enabled && ESSENTIAL.has(id)) {
+                throw new Error(ctx.i18n.$t("TXT_CODE_DAEMON_PLUGIN_ESSENTIAL_DISABLE"));
+            }
+            ctx.protocol.response(routerCtx, await ctx.plugins.setEnabled(id, enabled));
+        }
+        catch (error) {
+            // The panel turns this into the error its page reports; an unhandled throw
+            // from an async handler would reach nobody, because `emitRouter` only
+            // catches the synchronous part.
+            ctx.protocol.responseError(routerCtx, error);
+        }
+    });
+    // A plugin installed from the market is an npm dependency of the daemon's
+    // installation project. npm runs on the machine that will load the plugin, so
+    // the panel only names the package and the version.
+    ctx.protocol.on("plugin/npm/install", async (routerCtx, data) => {
+        try {
+            const payload = (data ?? {});
+            const record = await (0, mcsmanager_common_1.installNpmPlugin)({
+                name: String(payload.name ?? ""),
+                pluginId: String(payload.pluginId ?? ""),
+                version: String(payload.version ?? ""),
+                side: "daemon"
+            });
+            ctx.protocol.response(routerCtx, record);
+        }
+        catch (error) {
+            ctx.protocol.responseError(routerCtx, error);
+        }
+    });
+    ctx.protocol.on("plugin/npm/uninstall", async (routerCtx, data) => {
+        try {
+            const pluginId = String(data?.pluginId ?? "");
+            const removed = await (0, mcsmanager_common_1.uninstallNpmPlugin)(pluginId);
+            ctx.protocol.response(routerCtx, { removed, pluginId });
+        }
+        catch (error) {
+            ctx.protocol.responseError(routerCtx, error);
+        }
+    });
+    // Re-scan the plugin directories for a plugin that arrived while the daemon
+    // was running. The panel reconnects after this response so protocol handlers
+    // from a newly loaded plugin are bound to a fresh socket.
+    ctx.protocol.on("plugin/reload", async (routerCtx) => {
+        try {
+            await ctx.plugins.reload();
+            ctx.protocol.response(routerCtx, ctx.plugins.inventory());
+        }
+        catch (error) {
+            ctx.protocol.responseError(routerCtx, error);
+        }
+    });
+    // The configuration of one of this daemon's plugins, described by the plugin
+    // itself. The panel renders the description; nothing about the form lives
+    // there, which is the only way a daemon plugin can have a settings page at all.
+    ctx.protocol.on("plugin/config", async (routerCtx, data) => {
+        try {
+            const id = String(data?.id ?? "");
+            if (!id)
+                throw new Error(ctx.i18n.$t("TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED"));
+            ctx.protocol.response(routerCtx, await settingsForm.read(id));
+        }
+        catch (error) {
+            ctx.protocol.responseError(routerCtx, error);
+        }
+    });
+    ctx.protocol.on("plugin/config/write", async (routerCtx, data) => {
+        try {
+            const payload = (data ?? {});
+            const id = String(payload.id ?? "");
+            if (!id)
+                throw new Error(ctx.i18n.$t("TXT_CODE_DAEMON_PLUGIN_ID_REQUIRED"));
+            const values = (payload.values ?? {});
+            ctx.protocol.response(routerCtx, await settingsForm.write(id, values));
+        }
+        catch (error) {
+            ctx.protocol.responseError(routerCtx, error);
+        }
+    });
+    ctx.protocol.on("plugin/groups", (routerCtx) => {
+        try {
+            const stored = ctx.storage.load(PLUGIN_GROUPS_CATEGORY, StoredPluginGroups, PLUGIN_GROUPS_ID);
+            ctx.protocol.response(routerCtx, stored?.groups ?? []);
+        }
+        catch (error) {
+            ctx.protocol.responseError(routerCtx, error);
+        }
+    });
+    ctx.protocol.on("plugin/groups/write", (routerCtx, data) => {
+        try {
+            const groups = normalizePluginGroups(data?.groups);
+            ctx.storage.store(PLUGIN_GROUPS_CATEGORY, PLUGIN_GROUPS_ID, { groups });
+            ctx.protocol.response(routerCtx, groups);
+        }
+        catch (error) {
+            ctx.protocol.responseError(routerCtx, error);
+        }
+    });
+}
+
+})();
+
+module.exports = __webpack_exports__;
+/******/ })()
+;