@elementspanel/panel 0.0.0-stage → 1.0.0

package/app.js

@@ -0,0 +1,2640 @@
+/******/ (() => { // 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 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);
+    }
+}
+GlobalVariable.map = new Map();
+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 {
+    constructor() {
+        this.listenMap = new Map();
+        this.disconnectHandlers = new Map();
+    }
+    requestForward(socket, instanceUuid) {
+        var _a;
+        const sockets = (_a = this.listenMap.get(instanceUuid)) !== null && _a !== void 0 ? _a : [];
+        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) {
+        var _a;
+        const remaining = (_a = this.listenMap
+            .get(instanceUuid)) === null || _a === void 0 ? void 0 : _a.filter((listener) => listener.id !== socket.id);
+        if (remaining === null || remaining === void 0 ? void 0 : 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) {
+        var _a;
+        for (const socket of (_a = this.listenMap.get(instanceUuid)) !== null && _a !== void 0 ? _a : []) {
+            if (socket.connected)
+                callback(socket);
+            else
+                this.cannelForward(socket, instanceUuid);
+        }
+    }
+    hasListenInstance(instanceUuid) {
+        var _a, _b;
+        return (_b = (_a = this.listenMap.get(instanceUuid)) === null || _a === void 0 ? void 0 : _a.some((socket) => socket.connected)) !== null && _b !== void 0 ? _b : 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 {
+    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) {
+    var _a, _b;
+    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 > ((_a = field.maxItems) !== null && _a !== void 0 ? _a : 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"
+                    ? (_b = field.options) === null || _b === void 0 ? void 0 : _b.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 === null || onWarning === void 0 ? void 0 : 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) {
+    var _a;
+    const configured = options.entryFields
+        .map((field) => manifest[field])
+        .find((entry) => typeof entry === "string" && entry.length > 0);
+    const candidates = configured ? [configured] : (_a = options.entryCandidates) !== null && _a !== void 0 ? _a : [];
+    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)) {
+    var _a;
+    // 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")) {
+        (_a = options.onWarning) === null || _a === void 0 ? void 0 : _a.call(options, `Plugin "${manifest.id}" has no valid entry module.`);
+        return null;
+    }
+    return { manifest, directory, folder, entry: entry !== null && entry !== void 0 ? 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) {
+    var _a;
+    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)) {
+                (_a = options.onWarning) === null || _a === void 0 ? void 0 : _a.call(options, `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) {
+    var _a;
+    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)) {
+                (_a = options.onWarning) === null || _a === void 0 ? void 0 : _a.call(options, `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 === null || error === void 0 ? void 0 : 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 = {}) {
+    var _a, _b;
+    const packageRoot = path_1.default.resolve((_a = options.packageRoot) !== null && _a !== void 0 ? _a : currentPackageRoot());
+    return {
+        packageRoot,
+        projectRoot: path_1.default.resolve((_b = options.projectRoot) !== null && _b !== void 0 ? _b : currentProjectRoot(packageRoot))
+    };
+}
+function projectManifestFile(projectRoot) {
+    return path_1.default.join(projectRoot, "package.json");
+}
+function readProjectManifest(projectRoot) {
+    var _a;
+    return ((_a = readJson(projectManifestFile(projectRoot))) !== null && _a !== void 0 ? _a : {
+        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) {
+    var _a;
+    return (_a = objectValue(manifest === null || manifest === void 0 ? void 0 : manifest.dependencies)) !== null && _a !== void 0 ? _a : {};
+}
+function mappingsOf(manifest) {
+    var _a, _b;
+    return (_b = objectValue((_a = objectValue(manifest === null || manifest === void 0 ? void 0 : manifest.elementspanel)) === null || _a === void 0 ? void 0 : _a.plugins)) !== null && _b !== void 0 ? _b : {};
+}
+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 === null || elements === void 0 ? void 0 : elements[side]);
+    const directory = stringValue(definition === null || definition === void 0 ? void 0 : 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) {
+    var _a;
+    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 !== null && side !== void 0 ? side : sides[0];
+    if (!sides.includes(target))
+        return undefined;
+    const directory = sideDirectory(packageRoot, metadata, target);
+    const folder = stringValue((_a = objectValue(elements[target])) === null || _a === void 0 ? void 0 : _a.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 = {}) {
+    var _a;
+    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 = (_a = hostDependencies[mapping.name]) !== null && _a !== void 0 ? _a : 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 !== null && side !== void 0 ? 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) => {
+        var _a, _b, _c;
+        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);
+        };
+        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.on("data", append);
+        (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.on("data", append);
+        const timer = setTimeout(() => {
+            var _a;
+            child.kill("SIGKILL");
+            reject(new Error(`npm ${(_a = args[0]) !== null && _a !== void 0 ? _a : ""} timed out.`));
+        }, 10 * 60 * 1000);
+        (_c = timer.unref) === null || _c === void 0 ? void 0 : _c.call(timer);
+        child.once("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.once("close", (code) => {
+            var _a;
+            clearTimeout(timer);
+            if (code === 0)
+                return resolve(output);
+            reject(new Error(`npm ${(_a = args[0]) !== null && _a !== void 0 ? _a : ""} failed (${code}): ${output.trim()}`));
+        });
+    });
+}
+const operations = new Map();
+function withProjectLock(projectRoot, operation) {
+    var _a;
+    const key = process.platform === "win32" ? projectRoot.toLowerCase() : projectRoot;
+    const previous = (_a = operations.get(key)) !== null && _a !== void 0 ? _a : 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 () => {
+        var _a;
+        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 = { ...((_a = objectValue(manifest.elementspanel)) !== null && _a !== void 0 ? _a : {}) };
+        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 () => {
+        var _a;
+        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 = { ...((_a = objectValue(manifest.elementspanel)) !== null && _a !== void 0 ? _a : {}) };
+        if (Object.keys(plugins).length)
+            elementspanel.plugins = plugins;
+        else
+            delete elementspanel.plugins;
+        manifest.elementspanel = elementspanel;
+        writeProjectManifest(projectRoot, manifest);
+        return record !== null && record !== void 0 ? 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 === null || data === void 0 ? void 0 : 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 === null || previous === void 0 ? void 0 : 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 {
+    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;
+        this.completed = false;
+        this.errMsg = {
+            timeoutErr: "task timeout!",
+            exitErr: "task error!",
+            startErr: "task start error!"
+        };
+    }
+    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() {
+        var _a;
+        return (_a = this.process) === null || _a === void 0 ? void 0 : _a.pid;
+    }
+    write(data) {
+        var _a, _b;
+        return (_b = (_a = this.process) === null || _a === void 0 ? void 0 : _a.stdin) === null || _b === void 0 ? void 0 : _b.write(iconv_lite_1.default.encode(data, this.code));
+    }
+    kill() {
+        var _a, _b;
+        if ((_a = this.process) === null || _a === void 0 ? void 0 : _a.pid)
+            killProcess((_b = this.process) === null || _b === void 0 ? void 0 : _b.pid, this.process);
+    }
+    status() {
+        return this.completed;
+    }
+    exitCode() {
+        var _a, _b;
+        return (_b = (_a = this.process) === null || _a === void 0 ? void 0 : _a.exitCode) !== null && _b !== void 0 ? _b : 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 {
+    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 {
+    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 {
+    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 {
+    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 (_a) {
+        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() {
+    var _a;
+    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 = (_a = infoTable["memavailable"]) !== null && _a !== void 0 ? _a : 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 {
+    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));
+    }
+}
+StorageSubsystem.DATA_PATH = path_1.default.resolve(process.cwd(), "data");
+StorageSubsystem.INDEX_PATH = path_1.default.join(StorageSubsystem.DATA_PATH, "Index");
+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) {
+    var _a;
+    const selfDefaultValue = (_a = self[key]) !== null && _a !== void 0 ? _a : 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;
+}
+
+
+/***/ },
+
+/***/ "./src/app/plugin/context.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ctx = void 0;
+const cordis_1 = __webpack_require__("cordis");
+/**
+ * The panel's cordis container, and the complete list of what a plugin can see.
+ *
+ * Every capability is a service on the context; every registration a plugin
+ * makes is an effect owned by that plugin's scope, so unloading a plugin undoes
+ * its contributions and no plugin ever writes cleanup code. `ctx.logger` and the
+ * timer helpers (`ctx.setTimeout`, `ctx.setInterval`, `ctx.sleep`,
+ * `ctx.throttle`, `ctx.debounce`) come with cordis itself.
+ *
+ * The declarations below are the API documentation: only `import type` here, so
+ * this module stays a leaf that core code can import without a cycle. The
+ * runtime values are provided by the foundation plugins (`storage`, `i18n`,
+ * and `runtime`).
+ */
+exports.ctx = new cordis_1.Context();
+
+
+/***/ },
+
+/***/ "./src/app/plugin/loader.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.loadPanelPlugins = loadPanelPlugins;
+exports.reloadPanelPlugins = reloadPanelPlugins;
+exports.loadPanelFoundationPlugin = loadPanelFoundationPlugin;
+exports.getLoadedPanelPlugins = getLoadedPanelPlugins;
+exports.getPanelFrontendManifest = getPanelFrontendManifest;
+exports.getPanelPluginInventory = getPanelPluginInventory;
+exports.setPanelPluginEnabled = setPanelPluginEnabled;
+exports.removePanelPlugin = removePanelPlugin;
+exports.configurePanelPlugin = configurePanelPlugin;
+const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+const path_1 = __importDefault(__webpack_require__("path"));
+const url_1 = __webpack_require__("url");
+const mcsmanager_common_1 = __webpack_require__("../common/src/index.ts");
+const cordis_1 = __webpack_require__("cordis");
+const context_1 = __webpack_require__("./src/app/plugin/context.ts");
+/**
+ * Turns the plugin directories into cordis plugins.
+ *
+ * Discovery is shared with the daemon and the frontend build
+ * (`mcsmanager-common`); everything past it is cordis: each plugin module is
+ * handed to `ctx.plugin()`, which resolves its `inject` list, calls `apply()`
+ * with a scope of its own, and undoes every effect that scope registered when it
+ * is disposed. A plugin that throws is isolated by cordis and reported through
+ * `ctx.logger`, so the panel keeps running.
+ */
+const logger = new cordis_1.Logger("plugin");
+const change = (0, mcsmanager_common_1.createPluginQueue)();
+const settle = (0, mcsmanager_common_1.trackPluginDisposal)(context_1.ctx);
+const unloading = new Set();
+const codeRevisions = new Map();
+const ENTRY_FIELDS = ["panel", "backend", "main", "entry"];
+const ENTRY_CANDIDATES = [
+    "src/index.js",
+    "src/index.cjs",
+    "src/index.mjs",
+    "src/panel.js",
+    "src/panel.cjs",
+    "src/panel.mjs"
+];
+const FOUNDATION_PLUGIN_IDS = new Set(["i18n", "storage", "runtime"]);
+const ESSENTIAL_PLUGIN_IDS = new Set(["i18n", "storage", "runtime", "console"]);
+const loaded = [];
+const frontendManifestWarnings = new Set();
+function warnFrontendManifest(message, error) {
+    const detail = error instanceof Error ? `${error.name}:${error.message}` : String(error || "");
+    const signature = `${message}\0${detail}`;
+    if (frontendManifestWarnings.has(signature))
+        return;
+    frontendManifestWarnings.add(signature);
+    if (error === undefined)
+        logger.warn(message);
+    else
+        logger.warn(message, error);
+}
+function discoverPanelPlugins(options) {
+    // Only npm packages are plugins now: the published runtime resolves its own
+    // dependencies, and a development checkout resolves the source packages that
+    // the side package ships. Legacy data/plugins and market_plugins directories
+    // are deliberately not read any more.
+    return (0, mcsmanager_common_1.applyPluginOverrides)((0, mcsmanager_common_1.discoverPluginsFromRoots)((0, mcsmanager_common_1.packagePluginRoots)("panel"), {
+        ...options,
+        includeDisabled: true
+    })).filter((plugin) => options.includeDisabled || plugin.manifest.enabled !== false);
+}
+/** Exposes the loader's own registry without pulling it into a plugin bundle. */
+function ensurePanelPluginService() {
+    if (context_1.ctx.get("plugins"))
+        return;
+    context_1.ctx.provide("plugins", undefined, true);
+    context_1.ctx.set("plugins", {
+        get loaded() {
+            return getLoadedPanelPlugins();
+        },
+        frontendManifest: getPanelFrontendManifest,
+        inventory: getPanelPluginInventory,
+        setEnabled: setPanelPluginEnabled,
+        remove: removePanelPlugin,
+        configure: configurePanelPlugin,
+        configuration: (id) => {
+            const manifest = findPlugin(id).manifest;
+            return {
+                id,
+                fields: (Array.isArray(manifest.configFields)
+                    ? manifest.configFields
+                    : []),
+                values: (manifest.config || {})
+            };
+        },
+        runExclusive: change,
+        reload: reloadPanelPlugins
+    });
+}
+/**
+ * The plugin object a module exports, whether as named exports or as `default`.
+ *
+ * Only an object counts: every function has `Function.prototype.apply`, so a
+ * module whose default export is a function would otherwise be mistaken for a
+ * plugin and then called with the context as `this`.
+ */
+function toModule(value, id) {
+    for (const candidate of [value, value === null || value === void 0 ? void 0 : value.default]) {
+        if (typeof candidate !== "object" || candidate === null)
+            continue;
+        if (typeof candidate.apply === "function")
+            return candidate;
+    }
+    logger.warn(`Panel plugin "${id}" must export an apply() function.`);
+    return undefined;
+}
+async function loadModule(entry) {
+    try {
+        // eval keeps webpack from trying to bundle files supplied at runtime.
+        const runtimeRequire = eval("require");
+        return runtimeRequire(entry);
+    }
+    catch (error) {
+        if ((error === null || error === void 0 ? void 0 : error.code) !== "ERR_REQUIRE_ESM")
+            throw error;
+        const dynamicImport = new Function("specifier", "return import(specifier)");
+        return dynamicImport((0, url_1.pathToFileURL)(entry).href);
+    }
+}
+/**
+ * Drops a plugin's entry module from the require cache, so the next `require()`
+ * of it runs the file that is on disk rather than the copy an earlier run left
+ * behind.
+ */
+function forgetCachedModule(entry) {
+    if (!entry)
+        return;
+    // eval keeps webpack from trying to bundle files supplied at runtime.
+    const runtimeRequire = eval("require");
+    delete runtimeRequire.cache[entry];
+}
+/** Requires one plugin's backend entry and hands it to cordis. */
+async function installPlugin(plugin) {
+    var _a;
+    const record = { ...plugin };
+    if (!plugin.entry)
+        return record;
+    try {
+        record.backendRevision = (0, mcsmanager_common_1.pluginDirectoryRevision)(path_1.default.dirname(plugin.entry));
+        (0, mcsmanager_common_1.validatePluginCompatibility)(plugin.manifest.elements);
+        const previousRevision = codeRevisions.get(plugin.manifest.id);
+        if (previousRevision && previousRevision !== record.backendRevision) {
+            record.restartRequired = true;
+            return record;
+        }
+        codeRevisions.set(plugin.manifest.id, record.backendRevision);
+        const module = toModule(await loadModule(plugin.entry), plugin.manifest.id);
+        if (!module)
+            throw new Error(`Plugin "${plugin.manifest.id}" must export apply().`);
+        // Plugins are applied one at a time, in `priority` order, and an async
+        // `apply()` is awaited before the next plugin starts.
+        //
+        // cordis catches a synchronous throw from `apply()` and cancels the scope
+        // itself, so the wrapper keeps a copy of it: without that, a plugin that
+        // failed on its first line would still be reported as loaded.
+        let applied;
+        let thrown;
+        // The manifest id is the plugin's name, so `ctx.name` — which is what
+        // appears in its log lines — always matches `plugin.json`.
+        record.fork = context_1.ctx.plugin({
+            ...module,
+            name: plugin.manifest.id,
+            apply: (...args) => {
+                try {
+                    return (applied = module.apply(...args));
+                }
+                catch (error) {
+                    thrown = error;
+                    throw error;
+                }
+            }
+        }, plugin.manifest.config);
+        if (thrown)
+            throw thrown;
+        await applied;
+        logger.info(`Panel plugin loaded: ${plugin.manifest.id}`);
+    }
+    catch (error) {
+        // Failure is atomic: whatever the plugin managed to register before it threw
+        // goes with its scope, so a half-loaded plugin never stays behind — a plugin
+        // that had already claimed the request guard, in particular.
+        record.error = error instanceof Error ? error : new Error(String(error));
+        (_a = record.fork) === null || _a === void 0 ? void 0 : _a.dispose();
+        record.fork = undefined;
+        logger.error(`Panel plugin failed to load: ${plugin.manifest.id}`, error);
+    }
+    return record;
+}
+/** Discovers, requires and installs every enabled plugin, in manifest order. */
+async function loadPanelPlugins() {
+    ensurePanelPluginService();
+    const discovered = discoverPanelPlugins({
+        entryFields: ENTRY_FIELDS,
+        entryCandidates: ENTRY_CANDIDATES,
+        onWarning: (message, error) => logger.warn(message, error)
+    });
+    for (const plugin of discovered) {
+        if (loaded.some((record) => record.manifest.id === plugin.manifest.id))
+            continue;
+        loaded.push(await installPlugin(plugin));
+    }
+    (0, mcsmanager_common_1.sortPlugins)(loaded);
+    return loaded;
+}
+/**
+ * Re-scans the plugin directories and reconciles them with what is running: a
+ * plugin that has appeared since startup is installed, and one whose directory
+ * is gone — or whose manifest now says `enabled: false` — is disposed.
+ *
+ * This is safe for newly installed, removed and disabled packaged plugins in a
+ * production process. It deliberately does not replace code that has already
+ * run: `installPlugin()` compares backend revisions and leaves a changed plugin
+ * in `restart-required` state instead.
+ *
+ * The browser half needs nothing here: Vite watches source checkouts, while a
+ * production browser receives the changed frontend manifest over plugin SSE.
+ */
+async function reloadPanelPlugins() {
+    return change(async () => {
+        ensurePanelPluginService();
+        const discovered = discoverPanelPlugins({
+            entryFields: ENTRY_FIELDS,
+            entryCandidates: ENTRY_CANDIDATES,
+            onWarning: (message, error) => logger.warn(message, error)
+        });
+        const installed = new Set(discovered.map((plugin) => plugin.manifest.id));
+        for (let index = loaded.length - 1; index >= 0; index--) {
+            const record = loaded[index];
+            if (installed.has(record.manifest.id))
+                continue;
+            await removeRunning(record.manifest.id);
+            logger.info(`Panel plugin unloaded: ${record.manifest.id}`);
+        }
+        for (const plugin of discovered) {
+            if (loaded.some((record) => record.manifest.id === plugin.manifest.id))
+                continue;
+            // A plugin installed, uninstalled and installed again would otherwise be
+            // served the module its first run left behind.
+            forgetCachedModule(plugin.entry);
+            loaded.push(await installPlugin(plugin));
+        }
+        (0, mcsmanager_common_1.sortPlugins)(loaded);
+        await settle();
+        return loaded;
+    });
+}
+/** Loads one of the small foundation plugins before feature plugins start. */
+async function loadPanelFoundationPlugin(id = "i18n") {
+    ensurePanelPluginService();
+    if (!FOUNDATION_PLUGIN_IDS.has(id)) {
+        throw new Error(`Panel plugin "${id}" is not a foundational plugin.`);
+    }
+    const existing = loaded.find((record) => record.manifest.id === id);
+    if (existing)
+        return existing;
+    const plugin = discoverPanelPlugins({
+        entryFields: ENTRY_FIELDS,
+        entryCandidates: ENTRY_CANDIDATES,
+        onWarning: (message, error) => logger.warn(message, error)
+    }).find((candidate) => candidate.manifest.id === id);
+    if (!(plugin === null || plugin === void 0 ? void 0 : plugin.entry))
+        throw new Error(`Panel foundation plugin not found: ${id}`);
+    const record = await installPlugin(plugin);
+    loaded.push(record);
+    (0, mcsmanager_common_1.sortPlugins)(loaded);
+    if (record.error)
+        throw record.error;
+    const capability = id === "i18n" ? "i18n" : id === "storage" ? "storage" : "settings";
+    if (!record.fork || !context_1.ctx.get(capability)) {
+        throw new Error(`Panel foundation plugin failed to initialize: ${id}`);
+    }
+    return record;
+}
+function getLoadedPanelPlugins() {
+    return loaded;
+}
+/**
+ * The frontend entries the browser can load. Read from the installed plugin
+ * directories rather than from what this process loaded, because a plugin may
+ * ship only a frontend.
+ */
+function getPanelFrontendManifest() {
+    const entries = [];
+    for (const plugin of discoverPanelPlugins({
+        entryFields: ["frontend", "ui"],
+        onWarning: warnFrontendManifest
+    })) {
+        // A packaged plugin serves its frontend from `<plugin>/frontend`, and only
+        // from there: the manifest must never point the browser at plugin sources.
+        if (!plugin.entry || !/^[a-zA-Z0-9_-]+$/.test(plugin.folder))
+            continue;
+        const frontendDirectory = path_1.default.resolve(plugin.directory, "frontend");
+        const inFrontendDirectory = (target) => target.startsWith(`${frontendDirectory}${path_1.default.sep}`) && fs_extra_1.default.existsSync(target);
+        if (!inFrontendDirectory(plugin.entry))
+            continue;
+        const revision = (0, mcsmanager_common_1.pluginDirectoryRevision)(frontendDirectory);
+        const toUrl = (target) => `./${plugin.folder}@${revision}/${path_1.default
+            .relative(plugin.directory, target)
+            .split(path_1.default.sep)
+            .join("/")}`;
+        const styles = Array.isArray(plugin.manifest.styles)
+            ? plugin.manifest.styles
+                .filter((style) => typeof style === "string")
+                .map((style) => path_1.default.resolve(plugin.directory, style))
+                .filter(inFrontendDirectory)
+                .map(toUrl)
+            : [];
+        entries.push({
+            // Backend configuration may contain credentials. Browser config is explicit.
+            metadata: (0, mcsmanager_common_1.createFrontendPluginMetadata)(plugin.manifest, {
+                restartRequired: pluginState(plugin, loaded.find((item) => item.manifest.id === plugin.manifest.id)) === "restart-required"
+            }),
+            directory: plugin.manifest.id,
+            assetDirectory: plugin.folder,
+            entry: toUrl(plugin.entry),
+            revision,
+            frontendDirectory,
+            styles
+        });
+    }
+    return entries;
+}
+const FRONTEND_FIELDS = ["frontend", "ui"];
+/**
+ * Every installed plugin, disabled ones included — a disabled plugin still has
+ * to be listed for the switch to turn it back on. Entry resolution is skipped on
+ * purpose: the inventory describes what is installed, not what compiled.
+ */
+function getPanelPluginInventory() {
+    return discoverPanelPlugins({
+        entryFields: [],
+        includeDisabled: true,
+        onWarning: (message, error) => logger.warn(message, error)
+    }).map((plugin) => {
+        var _a, _b, _c, _d, _e;
+        const running = loaded.find((item) => item.manifest.id === plugin.manifest.id);
+        const has = (fields) => fields.some((field) => typeof plugin.manifest[field] === "string");
+        return {
+            id: plugin.manifest.id,
+            version: plugin.manifest.version,
+            description: plugin.manifest.description,
+            priority: plugin.manifest.priority,
+            enabled: plugin.manifest.enabled !== false,
+            dual: plugin.manifest.dual === true,
+            sides: { backend: has(ENTRY_FIELDS), frontend: has(FRONTEND_FIELDS) },
+            running: pluginState(plugin, running) === "active",
+            state: pluginState(plugin, running),
+            removable: false,
+            error: ((_a = running === null || running === void 0 ? void 0 : running.error) === null || _a === void 0 ? void 0 : _a.message) ||
+                ((_c = (_b = running === null || running === void 0 ? void 0 : running.fork) === null || _b === void 0 ? void 0 : _b.runtime.error) === null || _c === void 0 ? void 0 : _c.message) ||
+                ((_e = (_d = running === null || running === void 0 ? void 0 : running.fork) === null || _d === void 0 ? void 0 : _d.error) === null || _e === void 0 ? void 0 : _e.message)
+        };
+    });
+}
+/** Persist the user override, then serialize disposal/activation and report both outcomes. */
+function setPanelPluginEnabled(id, enabled) {
+    return change(async () => {
+        var _a;
+        if (typeof enabled !== "boolean")
+            throw new Error("Invalid plugin enablement.");
+        if (ESSENTIAL_PLUGIN_IDS.has(id) && !enabled)
+            throw new Error(`The essential plugin "${id}" cannot be disabled.`);
+        const plugin = findPlugin(id);
+        (0, mcsmanager_common_1.writePluginOverride)(id, { enabled });
+        let failure;
+        try {
+            const existing = loaded.find((item) => item.manifest.id === id);
+            if (!enabled || (existing === null || existing === void 0 ? void 0 : existing.error) || ((_a = existing === null || existing === void 0 ? void 0 : existing.fork) === null || _a === void 0 ? void 0 : _a.runtime.status) === 3)
+                await removeRunning(id);
+            if (enabled && !loaded.some((item) => item.manifest.id === id)) {
+                forgetCachedModule(plugin.entry);
+                loaded.push(await installPlugin({ ...plugin, manifest: { ...plugin.manifest, enabled: true } }));
+                (0, mcsmanager_common_1.sortPlugins)(loaded);
+            }
+            await settle();
+        }
+        catch (error) {
+            failure = String(error);
+        }
+        return changedRecord(id, failure);
+    });
+}
+/**
+ * Plugins are npm dependencies now; the plugin manager does not delete files.
+ * An npm plugin is removed with npm, and a development source plugin cannot be
+ * removed from the running checkout at all.
+ */
+function removePanelPlugin(id) {
+    return change(async () => {
+        const plugin = findPlugin(id);
+        if ((0, mcsmanager_common_1.isPackagePlugin)(plugin.directory))
+            throw new Error("Npm plugins cannot be removed here; manage them with npm.");
+        throw new Error("Source plugins cannot be removed.");
+    });
+}
+function findPlugin(id) {
+    const plugin = discoverPanelPlugins({
+        entryFields: ENTRY_FIELDS,
+        entryCandidates: ENTRY_CANDIDATES,
+        includeDisabled: true
+    }).find((item) => item.manifest.id === id);
+    if (!plugin)
+        throw new Error(`Plugin not found: ${id}`);
+    return plugin;
+}
+async function removeRunning(id) {
+    var _a;
+    const index = loaded.findIndex((item) => item.manifest.id === id);
+    if (index < 0)
+        return;
+    const record = loaded[index];
+    unloading.add(id);
+    try {
+        (_a = record.fork) === null || _a === void 0 ? void 0 : _a.dispose();
+        await settle();
+    }
+    finally {
+        loaded.splice(loaded.indexOf(record), 1);
+        unloading.delete(id);
+    }
+}
+function pluginState(plugin, running) {
+    var _a, _b;
+    if (unloading.has(plugin.manifest.id))
+        return "unloading";
+    if (plugin.manifest.enabled === false)
+        return "disabled";
+    if ((running === null || running === void 0 ? void 0 : running.error) || ((_a = running === null || running === void 0 ? void 0 : running.fork) === null || _a === void 0 ? void 0 : _a.error) || ((_b = running === null || running === void 0 ? void 0 : running.fork) === null || _b === void 0 ? void 0 : _b.runtime.error))
+        return "failed";
+    if (!running || running.restartRequired)
+        return "restart-required";
+    if (!running.entry)
+        return "active";
+    if (running.backendRevision !== (0, mcsmanager_common_1.pluginDirectoryRevision)(path_1.default.dirname(running.entry)) ||
+        JSON.stringify(running.manifest.config) !== JSON.stringify(plugin.manifest.config))
+        return "restart-required";
+    const fork = running.fork;
+    if (!fork)
+        return "failed";
+    const state = fork.runtime.status === 2 ? fork.status : fork.runtime.status;
+    return (["pending", "loading", "active", "failed", "failed"][state] || "pending");
+}
+function changedRecord(id, failure) {
+    const record = getPanelPluginInventory().find((item) => item.id === id);
+    const application = failure || record.state === "failed"
+        ? "failed"
+        : record.state === "restart-required"
+            ? "restart-required"
+            : ["pending", "loading", "unloading"].includes(record.state)
+                ? "pending"
+                : "applied";
+    return { ...record, result: { saved: true, application, error: failure || record.error } };
+}
+/** Config replaces the package default as one user-owned layer. Validate before saving. */
+function configurePanelPlugin(id, config) {
+    return change(async () => {
+        var _a;
+        const plugin = findPlugin(id);
+        if (!config || typeof config !== "object" || Array.isArray(config))
+            throw new Error("Plugin config must be an object.");
+        (0, mcsmanager_common_1.validatePluginCompatibility)(plugin.manifest.elements);
+        const running = loaded.find((item) => item.manifest.id === id);
+        const replaced = plugin.entry &&
+            codeRevisions.has(id) &&
+            codeRevisions.get(id) !== (0, mcsmanager_common_1.pluginDirectoryRevision)(path_1.default.dirname(plugin.entry));
+        if (!replaced && typeof ((_a = running === null || running === void 0 ? void 0 : running.fork) === null || _a === void 0 ? void 0 : _a.runtime.schema) === "function")
+            running.fork.runtime.schema(config);
+        if (Array.isArray(plugin.manifest.configFields))
+            (0, mcsmanager_common_1.validatePluginSettings)(plugin.manifest.configFields, config);
+        (0, mcsmanager_common_1.writePluginOverride)(id, { config });
+        // Core network/storage configuration is applied on restart; never tear down the reply path.
+        if (replaced || ESSENTIAL_PLUGIN_IDS.has(id) || ["server", "config"].includes(id)) {
+            return {
+                ...getPanelPluginInventory().find((item) => item.id === id),
+                result: { saved: true, application: "restart-required" }
+            };
+        }
+        let failure;
+        try {
+            await removeRunning(id);
+            if (plugin.manifest.enabled !== false) {
+                loaded.push(await installPlugin({ ...plugin, manifest: { ...plugin.manifest, config } }));
+                (0, mcsmanager_common_1.sortPlugins)(loaded);
+                await settle();
+            }
+        }
+        catch (error) {
+            failure = String(error);
+        }
+        return changedRecord(id, failure);
+    });
+}
+
+
+/***/ },
+
+/***/ "crypto"
+(module) {
+
+module.exports = require("crypto");
+
+/***/ },
+
+/***/ "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");
+
+/***/ },
+
+/***/ "child_process"
+(module) {
+
+module.exports = require("child_process");
+
+/***/ },
+
+/***/ "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");
+
+/***/ },
+
+/***/ "url"
+(module) {
+
+module.exports = require("url");
+
+/***/ }
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// 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__;
+var __webpack_unused_export__;
+
+__webpack_unused_export__ = ({ value: true });
+const context_1 = __webpack_require__("./src/app/plugin/context.ts");
+const loader_1 = __webpack_require__("./src/app/plugin/loader.ts");
+async function main() {
+    await (0, loader_1.loadPanelFoundationPlugin)("i18n");
+    await (0, loader_1.loadPanelFoundationPlugin)("storage");
+    await (0, loader_1.loadPanelFoundationPlugin)("runtime");
+    await (0, loader_1.loadPanelPlugins)();
+    await context_1.ctx.start();
+}
+main().catch(async (error) => {
+    context_1.ctx.logger.error("Plugin startup failed:", error);
+    await context_1.ctx.stop();
+    process.exit(1);
+});
+
+})();
+
+/******/ })()
+;
+//# sourceMappingURL=app.js.map