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

package/daemon/backend/index.cjs

@@ -0,0 +1,3885 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ "../common/src/array.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.arrayUnique = arrayUnique;
+function arrayUnique(arr, felidName) {
+    if (!felidName)
+        return Array.from(new Set(arr));
+    const map = new Map();
+    return arr.filter((v) => !map.has(v[felidName]) && map.set(v[felidName], v));
+}
+
+
+/***/ },
+
+/***/ "../common/src/docker_utils.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.normalizeDockerArchitecture = normalizeDockerArchitecture;
+exports.normalizeDockerOS = normalizeDockerOS;
+exports.normalizeDockerPlatform = normalizeDockerPlatform;
+/**
+ * Normalizes Docker platform architecture names to standard format
+ * @param architecture The architecture string from Docker manifest
+ * @returns Normalized architecture string (amd64, arm64, arm, or original if not recognized)
+ */
+function normalizeDockerArchitecture(architecture) {
+    if (!architecture) {
+        return "amd64"; // default fallback
+    }
+    // Return original if not one of the standard architectures
+    return architecture;
+}
+/**
+ * Normalizes Docker platform OS name
+ * @param os The OS string from Docker manifest
+ * @returns Normalized OS string (defaults to "linux" if not provided)
+ */
+function normalizeDockerOS(os) {
+    return os || "linux";
+}
+/**
+ * Normalizes a Docker platform from manifest format to standard platform string
+ * @param platform Platform object from Docker manifest with os and architecture
+ * @returns Normalized platform string in format "os/arch" (e.g., "linux/amd64")
+ */
+function normalizeDockerPlatform(platform) {
+    const os = normalizeDockerOS(platform.os);
+    const arch = normalizeDockerArchitecture(platform.architecture);
+    return `${os}/${arch}`;
+}
+
+
+/***/ },
+
+/***/ "../common/src/global_variable.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+class GlobalVariable {
+    static map = new Map();
+    static set(k, v) {
+        GlobalVariable.map.set(k, v);
+    }
+    static get(k, def) {
+        if (GlobalVariable.map.has(k)) {
+            return GlobalVariable.map.get(k);
+        }
+        else {
+            return def;
+        }
+    }
+    static del(k) {
+        return GlobalVariable.map.delete(k);
+    }
+}
+exports["default"] = GlobalVariable;
+
+
+/***/ },
+
+/***/ "../common/src/index.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.StorageSubsystem = exports.MCServerStatus = exports.InstanceStreamListener = exports.GlobalVariable = exports.normalizeDockerPlatform = exports.normalizeDockerOS = exports.normalizeDockerArchitecture = exports.removeTrail = exports.uninstallNpmPlugin = exports.npmPluginRoots = exports.listNpmPlugins = exports.installNpmPlugin = exports.currentProjectRoot = exports.currentPackageRoot = exports.sortPlugins = exports.resolvePluginEntry = exports.readPluginManifest = exports.createFrontendPluginMetadata = exports.discoverPluginsFromRoots = exports.discoverPlugins = exports.arrayUnique = exports.toText = exports.toNumber = exports.toBoolean = exports.supposeValue = exports.isEmpty = exports.configureEntityParams = exports.systemInfo = exports.QueryWrapper = exports.QueryMapWrapper = exports.MySqlSource = exports.LocalFileSource = exports.killProcess = exports.ProcessWrapper = void 0;
+const global_variable_1 = __importDefault(__webpack_require__("../common/src/global_variable.ts"));
+exports.GlobalVariable = global_variable_1.default;
+const instance_stream_1 = __importDefault(__webpack_require__("../common/src/instance_stream.ts"));
+exports.InstanceStreamListener = instance_stream_1.default;
+const system_storage_1 = __importDefault(__webpack_require__("../common/src/system_storage.ts"));
+exports.StorageSubsystem = system_storage_1.default;
+const mcping_1 = __importDefault(__webpack_require__("../common/src/mcping.ts"));
+exports.MCServerStatus = mcping_1.default;
+var process_tools_1 = __webpack_require__("../common/src/process_tools.ts");
+Object.defineProperty(exports, "ProcessWrapper", ({ enumerable: true, get: function () { return process_tools_1.ProcessWrapper; } }));
+Object.defineProperty(exports, "killProcess", ({ enumerable: true, get: function () { return process_tools_1.killProcess; } }));
+var query_wrapper_1 = __webpack_require__("../common/src/query_wrapper.ts");
+Object.defineProperty(exports, "LocalFileSource", ({ enumerable: true, get: function () { return query_wrapper_1.LocalFileSource; } }));
+Object.defineProperty(exports, "MySqlSource", ({ enumerable: true, get: function () { return query_wrapper_1.MySqlSource; } }));
+Object.defineProperty(exports, "QueryMapWrapper", ({ enumerable: true, get: function () { return query_wrapper_1.QueryMapWrapper; } }));
+Object.defineProperty(exports, "QueryWrapper", ({ enumerable: true, get: function () { return query_wrapper_1.QueryWrapper; } }));
+var system_info_1 = __webpack_require__("../common/src/system_info.ts");
+Object.defineProperty(exports, "systemInfo", ({ enumerable: true, get: function () { return system_info_1.systemInfo; } }));
+var typecheck_1 = __webpack_require__("../common/src/typecheck.ts");
+Object.defineProperty(exports, "configureEntityParams", ({ enumerable: true, get: function () { return typecheck_1.configureEntityParams; } }));
+Object.defineProperty(exports, "isEmpty", ({ enumerable: true, get: function () { return typecheck_1.isEmpty; } }));
+Object.defineProperty(exports, "supposeValue", ({ enumerable: true, get: function () { return typecheck_1.supposeValue; } }));
+Object.defineProperty(exports, "toBoolean", ({ enumerable: true, get: function () { return typecheck_1.toBoolean; } }));
+Object.defineProperty(exports, "toNumber", ({ enumerable: true, get: function () { return typecheck_1.toNumber; } }));
+Object.defineProperty(exports, "toText", ({ enumerable: true, get: function () { return typecheck_1.toText; } }));
+var array_1 = __webpack_require__("../common/src/array.ts");
+Object.defineProperty(exports, "arrayUnique", ({ enumerable: true, get: function () { return array_1.arrayUnique; } }));
+__exportStar(__webpack_require__("../common/src/plugin_contract.ts"), exports);
+__exportStar(__webpack_require__("../common/src/plugin_overrides.ts"), exports);
+__exportStar(__webpack_require__("../common/src/plugin_lifecycle.ts"), exports);
+__exportStar(__webpack_require__("../common/src/plugin_revision.ts"), exports);
+__exportStar(__webpack_require__("../common/src/runtime_paths.ts"), exports);
+var plugin_manifest_1 = __webpack_require__("../common/src/plugin_manifest.ts");
+Object.defineProperty(exports, "discoverPlugins", ({ enumerable: true, get: function () { return plugin_manifest_1.discoverPlugins; } }));
+Object.defineProperty(exports, "discoverPluginsFromRoots", ({ enumerable: true, get: function () { return plugin_manifest_1.discoverPluginsFromRoots; } }));
+Object.defineProperty(exports, "createFrontendPluginMetadata", ({ enumerable: true, get: function () { return plugin_manifest_1.createFrontendPluginMetadata; } }));
+Object.defineProperty(exports, "readPluginManifest", ({ enumerable: true, get: function () { return plugin_manifest_1.readPluginManifest; } }));
+Object.defineProperty(exports, "resolvePluginEntry", ({ enumerable: true, get: function () { return plugin_manifest_1.resolvePluginEntry; } }));
+Object.defineProperty(exports, "sortPlugins", ({ enumerable: true, get: function () { return plugin_manifest_1.sortPlugins; } }));
+var plugin_npm_1 = __webpack_require__("../common/src/plugin_npm.ts");
+Object.defineProperty(exports, "currentPackageRoot", ({ enumerable: true, get: function () { return plugin_npm_1.currentPackageRoot; } }));
+Object.defineProperty(exports, "currentProjectRoot", ({ enumerable: true, get: function () { return plugin_npm_1.currentProjectRoot; } }));
+Object.defineProperty(exports, "installNpmPlugin", ({ enumerable: true, get: function () { return plugin_npm_1.installNpmPlugin; } }));
+Object.defineProperty(exports, "listNpmPlugins", ({ enumerable: true, get: function () { return plugin_npm_1.listNpmPlugins; } }));
+Object.defineProperty(exports, "npmPluginRoots", ({ enumerable: true, get: function () { return plugin_npm_1.npmPluginRoots; } }));
+Object.defineProperty(exports, "uninstallNpmPlugin", ({ enumerable: true, get: function () { return plugin_npm_1.uninstallNpmPlugin; } }));
+var string_utils_1 = __webpack_require__("../common/src/string_utils.ts");
+Object.defineProperty(exports, "removeTrail", ({ enumerable: true, get: function () { return string_utils_1.removeTrail; } }));
+var docker_utils_1 = __webpack_require__("../common/src/docker_utils.ts");
+Object.defineProperty(exports, "normalizeDockerArchitecture", ({ enumerable: true, get: function () { return docker_utils_1.normalizeDockerArchitecture; } }));
+Object.defineProperty(exports, "normalizeDockerOS", ({ enumerable: true, get: function () { return docker_utils_1.normalizeDockerOS; } }));
+Object.defineProperty(exports, "normalizeDockerPlatform", ({ enumerable: true, get: function () { return docker_utils_1.normalizeDockerPlatform; } }));
+
+
+/***/ },
+
+/***/ "../common/src/instance_stream.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+// Application instance data stream forwarding adapter
+class InstanceStreamListener {
+    listenMap = new Map();
+    disconnectHandlers = new Map();
+    requestForward(socket, instanceUuid) {
+        const sockets = this.listenMap.get(instanceUuid) ?? [];
+        if (sockets.some((listener) => listener.id === socket.id))
+            return;
+        sockets.push(socket);
+        this.listenMap.set(instanceUuid, sockets);
+        if (!this.disconnectHandlers.has(socket)) {
+            const disconnect = () => {
+                for (const uuid of this.listenMap.keys())
+                    this.cannelForward(socket, uuid);
+            };
+            this.disconnectHandlers.set(socket, disconnect);
+            socket.once("disconnect", disconnect);
+        }
+    }
+    cannelForward(socket, instanceUuid) {
+        const remaining = this.listenMap
+            .get(instanceUuid)
+            ?.filter((listener) => listener.id !== socket.id);
+        if (remaining?.length)
+            this.listenMap.set(instanceUuid, remaining);
+        else
+            this.listenMap.delete(instanceUuid);
+        if (![...this.listenMap.values()].some((sockets) => sockets.includes(socket))) {
+            const disconnect = this.disconnectHandlers.get(socket);
+            if (disconnect)
+                socket.off("disconnect", disconnect);
+            this.disconnectHandlers.delete(socket);
+        }
+    }
+    forward(instanceUuid, data) {
+        this.forwardViaCallback(instanceUuid, (socket) => socket.emit("instance/stdout", data));
+    }
+    forwardViaCallback(instanceUuid, callback) {
+        for (const socket of this.listenMap.get(instanceUuid) ?? []) {
+            if (socket.connected)
+                callback(socket);
+            else
+                this.cannelForward(socket, instanceUuid);
+        }
+    }
+    hasListenInstance(instanceUuid) {
+        return this.listenMap.get(instanceUuid)?.some((socket) => socket.connected) ?? false;
+    }
+}
+exports["default"] = InstanceStreamListener;
+
+
+/***/ },
+
+/***/ "../common/src/mcping.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const net_1 = __importDefault(__webpack_require__("net"));
+class PingMinecraftServer {
+    port;
+    host;
+    status;
+    client;
+    pending;
+    constructor(port, host) {
+        this.port = port;
+        this.host = host;
+        this.status = this.offlineStatus();
+    }
+    offlineStatus() {
+        return {
+            online: false,
+            host: this.host,
+            port: this.port,
+            version: "",
+            motd: "",
+            current_players: 0,
+            max_players: 0,
+            latency: 0
+        };
+    }
+    getStatus() {
+        if (this.pending)
+            return this.pending;
+        this.status = this.offlineStatus();
+        this.pending = new Promise((resolve, reject) => {
+            const startedAt = Date.now();
+            const client = net_1.default.connect({ host: this.host, port: this.port });
+            this.client = client;
+            let received = Buffer.alloc(0);
+            let settled = false;
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timeout);
+                client.destroy();
+                this.client = undefined;
+                if (error)
+                    reject(error);
+                else
+                    resolve(this.status);
+            };
+            const timeout = setTimeout(() => finish(new Error("Minecraft status request timed out")), 15000);
+            client.once("connect", () => client.write(Buffer.from([0xfe, 0x01])));
+            client.on("data", (chunk) => {
+                if (settled)
+                    return;
+                try {
+                    received = Buffer.concat([received, chunk]);
+                    // Legacy status packets contain an unsigned UTF-16 character count.
+                    if (received.length > 3 + 0xffff * 2)
+                        throw new Error("Minecraft status response is too large");
+                    if (received.length < 3)
+                        return;
+                    if (received[0] !== 0xff)
+                        throw new Error("Invalid Minecraft status packet");
+                    const length = 3 + received.readUInt16BE(1) * 2;
+                    if (received.length < length)
+                        return;
+                    const fields = Buffer.from(received.subarray(3, length))
+                        .swap16()
+                        .toString("utf16le")
+                        .split("\0");
+                    if (fields.length !== 6 ||
+                        fields[0] !== "§1" ||
+                        !/^\d+$/.test(fields[4]) ||
+                        !/^\d+$/.test(fields[5])) {
+                        throw new Error("Invalid Minecraft status response");
+                    }
+                    const currentPlayers = Number(fields[4]);
+                    const maxPlayers = Number(fields[5]);
+                    if (!Number.isSafeInteger(currentPlayers) || !Number.isSafeInteger(maxPlayers)) {
+                        throw new Error("Invalid Minecraft player count");
+                    }
+                    this.status = {
+                        host: this.host,
+                        port: this.port,
+                        online: true,
+                        version: fields[2],
+                        motd: fields[3],
+                        current_players: currentPlayers,
+                        max_players: maxPlayers,
+                        latency: Date.now() - startedAt
+                    };
+                    finish();
+                }
+                catch (error) {
+                    finish(error instanceof Error ? error : new Error(String(error)));
+                }
+            });
+            client.once("error", finish);
+            client.once("close", () => finish(received.length ? new Error("Incomplete Minecraft status response") : undefined));
+        }).finally(() => {
+            this.pending = undefined;
+        });
+        return this.pending;
+    }
+    asyncStatus() {
+        return this.getStatus();
+    }
+}
+exports["default"] = PingMinecraftServer;
+
+
+/***/ },
+
+/***/ "../common/src/plugin_contract.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.PLUGIN_SDK_VERSION = exports.PLUGIN_API_VERSION = void 0;
+exports.validatePluginCompatibility = validatePluginCompatibility;
+exports.resolvePluginDependencyOrder = resolvePluginDependencyOrder;
+exports.createPluginQueue = createPluginQueue;
+exports.validatePluginSettings = validatePluginSettings;
+/** Versioned contract shared by the host, plugin compiler and package registry. */
+exports.PLUGIN_API_VERSION = 1;
+exports.PLUGIN_SDK_VERSION = "1.0.0";
+/** Omitted metadata denotes a legacy package. Unknown versions never execute. */
+function validatePluginCompatibility(value) {
+    if (value === undefined)
+        return;
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid ElementsPanel plugin compatibility metadata.");
+    const contract = value;
+    if (contract.api !== exports.PLUGIN_API_VERSION || (contract.sdk !== undefined && contract.sdk !== 1))
+        throw new Error(`Unsupported ElementsPanel plugin API/SDK: ${JSON.stringify(value)}`);
+}
+/**
+ * Stable topological ordering shared by plugin hosts.
+ *
+ * Invalid nodes are kept out of `ordered`: direct missing dependencies are
+ * reported first, then anything depending on an invalid node, and finally
+ * cycles (plus nodes blocked behind a cycle). Independent nodes retain the
+ * caller's priority/id comparator.
+ */
+function resolvePluginDependencyOrder(items, options) {
+    const sorted = [...items].sort(options.compare);
+    const byId = new Map(sorted.map((item) => [options.id(item), item]));
+    const dependencies = new Map(sorted.map((item) => [
+        options.id(item),
+        [...new Set(options.dependencies(item) || [])].filter(Boolean)
+    ]));
+    const issues = new Map();
+    for (const item of sorted) {
+        const id = options.id(item);
+        const missing = dependencies.get(id).filter((dependency) => !byId.has(dependency));
+        if (!missing.length)
+            continue;
+        issues.set(id, {
+            type: "missing-dependency",
+            dependencies: missing,
+            message: `Missing frontend plugin dependencies: ${missing.join(", ")}`
+        });
+    }
+    const markUnavailable = () => {
+        let changed = false;
+        for (const item of sorted) {
+            const id = options.id(item);
+            if (issues.has(id))
+                continue;
+            const unavailable = dependencies.get(id).filter((dependency) => issues.has(dependency));
+            if (!unavailable.length)
+                continue;
+            issues.set(id, {
+                type: "dependency-unavailable",
+                dependencies: unavailable,
+                message: `Frontend plugin dependencies are unavailable: ${unavailable.join(", ")}`
+            });
+            changed = true;
+        }
+        return changed;
+    };
+    while (markUnavailable()) {
+        // Propagate direct graph failures before sorting the remaining nodes.
+    }
+    const candidates = sorted.filter((item) => !issues.has(options.id(item)));
+    const candidateIds = new Set(candidates.map(options.id));
+    const indegree = new Map(candidates.map((item) => [options.id(item), 0]));
+    const dependents = new Map();
+    for (const item of candidates) {
+        const id = options.id(item);
+        for (const dependency of dependencies.get(id)) {
+            if (!candidateIds.has(dependency))
+                continue;
+            indegree.set(id, indegree.get(id) + 1);
+            const bucket = dependents.get(dependency) || [];
+            bucket.push(item);
+            dependents.set(dependency, bucket);
+        }
+    }
+    const ready = candidates.filter((item) => indegree.get(options.id(item)) === 0);
+    ready.sort(options.compare);
+    const ordered = [];
+    while (ready.length) {
+        const item = ready.shift();
+        const id = options.id(item);
+        ordered.push(item);
+        for (const dependent of dependents.get(id) || []) {
+            const dependentId = options.id(dependent);
+            const next = indegree.get(dependentId) - 1;
+            indegree.set(dependentId, next);
+            if (next === 0) {
+                ready.push(dependent);
+                ready.sort(options.compare);
+            }
+        }
+    }
+    const unresolved = candidates.filter((item) => !ordered.includes(item));
+    if (unresolved.length) {
+        const unresolvedIds = new Set(unresolved.map(options.id));
+        for (const item of unresolved) {
+            const id = options.id(item);
+            const blockedBy = dependencies.get(id).filter((dependency) => unresolvedIds.has(dependency));
+            issues.set(id, {
+                type: "dependency-cycle",
+                dependencies: blockedBy,
+                message: `Frontend plugin dependency cycle: ${[id, ...blockedBy].join(" -> ")}`
+            });
+        }
+    }
+    return { ordered, issues };
+}
+/** A queue survives failures, so a failed change cannot block subsequent repairs. */
+function createPluginQueue() {
+    let tail = Promise.resolve();
+    return (operation) => {
+        const next = tail.then(operation);
+        tail = next.catch(() => undefined);
+        return next;
+    };
+}
+/** Validate the form contract on the server before invoking plugin-owned validation. */
+function validatePluginSettings(fields, values) {
+    if (!values || typeof values !== "object" || Array.isArray(values))
+        throw new Error("Invalid plugin settings.");
+    const input = values;
+    for (const field of fields) {
+        if (!field.key || field.type === "link")
+            continue;
+        const value = input[field.key];
+        if (value === undefined || value === null) {
+            if (field.required)
+                throw new Error(`${field.title || field.key}: required`);
+            continue;
+        }
+        if (field.type === "list") {
+            if (!Array.isArray(value) || value.length > (field.maxItems ?? 100))
+                throw new Error(`${field.title || field.key}: invalid list`);
+            for (const item of value)
+                validatePluginSettings(field.fields || [], item);
+            continue;
+        }
+        const valid = field.type === "number"
+            ? typeof value === "number" &&
+                Number.isFinite(value) &&
+                (field.min === undefined || value >= field.min) &&
+                (field.max === undefined || value <= field.max)
+            : field.type === "boolean"
+                ? typeof value === "boolean"
+                : field.type === "select"
+                    ? field.options?.some((option) => option.value === value)
+                    : typeof value === "string";
+        if (!valid)
+            throw new Error(`${field.title || field.key}: invalid value`);
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_lifecycle.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.trackPluginDisposal = trackPluginDisposal;
+/** Cordis 3 starts async disposers without awaiting them. Track them per host. */
+function trackPluginDisposal(ctx) {
+    const pending = new Set();
+    const failures = [];
+    const tracked = new WeakSet();
+    const scopes = new WeakSet();
+    const observe = (scope) => {
+        if (scopes.has(scope))
+            return;
+        scopes.add(scope);
+        const reset = scope.reset;
+        scope.reset = function () {
+            this.disposables = this.disposables.map((dispose) => {
+                if (tracked.has(dispose))
+                    return dispose;
+                const wrapper = (...args) => {
+                    let result;
+                    try {
+                        result = dispose(...args);
+                    }
+                    catch (error) {
+                        failures.push(error);
+                        throw error;
+                    }
+                    if (result && typeof result.then === "function") {
+                        const task = Promise.resolve(result)
+                            .catch((error) => {
+                            failures.push(error);
+                        })
+                            .finally(() => pending.delete(task));
+                        pending.add(task);
+                    }
+                    return result;
+                };
+                // Cordis marks persistent disposers with a symbol; preserve its semantics.
+                for (const key of Object.getOwnPropertySymbols(dispose))
+                    Object.defineProperty(wrapper, key, Object.getOwnPropertyDescriptor(dispose, key));
+                tracked.add(wrapper);
+                return wrapper;
+            });
+            return reset.call(this);
+        };
+    };
+    ctx.on("internal/runtime", observe);
+    ctx.on("internal/fork", observe);
+    return async () => {
+        do {
+            await ctx.events.flush();
+            await Promise.all([...pending]);
+        } while (pending.size);
+        if (failures.length) {
+            const errors = failures.splice(0);
+            throw new Error(`Plugin cleanup failed: ${errors.map(String).join("; ")}`);
+        }
+    };
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_manifest.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.createFrontendPluginMetadata = createFrontendPluginMetadata;
+exports.readPluginManifest = readPluginManifest;
+exports.resolvePluginEntry = resolvePluginEntry;
+exports.discoverPlugins = discoverPlugins;
+exports.discoverPluginsFromRoots = discoverPluginsFromRoots;
+exports.sortPlugins = sortPlugins;
+const node_fs_1 = __importDefault(__webpack_require__("node:fs"));
+const node_path_1 = __importDefault(__webpack_require__("node:path"));
+function stringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const result = value.filter((item) => typeof item === "string" && !!item.trim());
+    return result.length ? [...new Set(result.map((item) => item.trim()))] : undefined;
+}
+/**
+ * Redacts a full plugin manifest to the fields a browser is allowed to see.
+ * Backend `config` may contain credentials, so only `frontendConfig` crosses
+ * this boundary.
+ */
+function createFrontendPluginMetadata(manifest, extras = {}) {
+    const frontendInject = stringArray(manifest.frontendInject);
+    return {
+        id: manifest.id,
+        ...(manifest.version === undefined ? {} : { version: manifest.version }),
+        ...(manifest.description === undefined ? {} : { description: manifest.description }),
+        ...(manifest.priority === undefined ? {} : { priority: manifest.priority }),
+        ...(manifest.elements === undefined ? {} : { elements: manifest.elements }),
+        ...(frontendInject === undefined ? {} : { frontendInject }),
+        ...(manifest.frontendImmediate === undefined
+            ? {}
+            : { frontendImmediate: Boolean(manifest.frontendImmediate) }),
+        ...(manifest.frontendRequired === undefined
+            ? {}
+            : { frontendRequired: Boolean(manifest.frontendRequired) }),
+        ...(manifest.frontendConfig === undefined ? {} : { config: manifest.frontendConfig }),
+        ...(extras.restartRequired === undefined ? {} : extras)
+    };
+}
+const MANIFEST_FILES = ["plugin.json", "manifest.json", "package.json"];
+/** Reads the manifest of one plugin directory, or null if it has none. */
+function readPluginManifest(directory, onWarning, fallbackId = node_path_1.default.basename(directory)) {
+    for (const file of MANIFEST_FILES) {
+        const filePath = node_path_1.default.join(directory, file);
+        if (!node_fs_1.default.existsSync(filePath))
+            continue;
+        try {
+            const value = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+            if (!value || typeof value !== "object" || Array.isArray(value))
+                return null;
+            const id = typeof value.id === "string" ? value.id : fallbackId;
+            if (!id.trim())
+                return null;
+            return { ...value, id: id.trim() };
+        }
+        catch (error) {
+            onWarning?.(`Failed to read plugin manifest: ${filePath}`, error);
+            return null;
+        }
+    }
+    return null;
+}
+/**
+ * Resolves one plugin's entry module. Returns null when the manifest names an
+ * entry that does not exist, or when none of the fallback candidates is present.
+ * Paths that would escape the plugin directory are rejected.
+ */
+function resolvePluginEntry(directory, manifest, options) {
+    const configured = options.entryFields
+        .map((field) => manifest[field])
+        .find((entry) => typeof entry === "string" && entry.length > 0);
+    const candidates = configured ? [configured] : options.entryCandidates ?? [];
+    const root = node_path_1.default.resolve(directory);
+    for (const candidate of candidates) {
+        const entry = node_path_1.default.resolve(directory, candidate);
+        if (entry.startsWith(`${root}${node_path_1.default.sep}`) && node_fs_1.default.existsSync(entry))
+            return entry;
+    }
+    return null;
+}
+function discoverPluginDirectory(directory, options, folder = node_path_1.default.basename(directory)) {
+    // Npm packages expose a side directory; its name is not the public plugin id.
+    const manifest = readPluginManifest(directory, options.onWarning, folder);
+    if (!manifest)
+        return null;
+    if (manifest.enabled === false && !options.includeDisabled)
+        return null;
+    const entry = resolvePluginEntry(directory, manifest, options);
+    if (!entry && options.entryFields.some((field) => typeof manifest[field] === "string")) {
+        options.onWarning?.(`Plugin "${manifest.id}" has no valid entry module.`);
+        return null;
+    }
+    return { manifest, directory, folder, entry: entry ?? undefined };
+}
+/**
+ * Lists the usable plugins below `root`, in load order: ascending `priority`,
+ * then by id so the order is stable. Duplicate ids are dropped, and disabled
+ * ones too unless `includeDisabled` says otherwise. A plugin whose manifest names an entry that cannot be resolved is
+ * dropped too; one that names none keeps `entry` undefined, because a plugin may
+ * legitimately contribute to only one side of the panel.
+ */
+function discoverPlugins(root, options) {
+    if (!node_fs_1.default.existsSync(root))
+        return [];
+    const plugins = [];
+    const seenIds = new Set();
+    for (const item of node_fs_1.default.readdirSync(root, { withFileTypes: true })) {
+        if (!item.isDirectory())
+            continue;
+        const directory = node_path_1.default.join(root, item.name);
+        const plugin = discoverPluginDirectory(directory, options, item.name);
+        if (!plugin || seenIds.has(plugin.manifest.id)) {
+            if (plugin && seenIds.has(plugin.manifest.id)) {
+                options.onWarning?.(`Ignoring duplicate plugin id: ${plugin.manifest.id}`);
+            }
+            continue;
+        }
+        seenIds.add(plugin.manifest.id);
+        plugins.push(plugin);
+    }
+    return sortPlugins(plugins);
+}
+/**
+ * Discovers plugins from several roots while keeping the first root's plugin
+ * when ids collide. The built-in root is intentionally passed first by the
+ * panel and daemon loaders, so an installed market plugin cannot shadow a
+ * built-in npm dependency. A root can also force an installed project plugin
+ * into the disabled state; the user-owned override layer may enable it later.
+ */
+function discoverPluginsFromRoots(roots, options) {
+    const discovered = [];
+    const seenIds = new Set();
+    for (const root of roots) {
+        const isDirectPlugin = MANIFEST_FILES.some((file) => node_fs_1.default.existsSync(node_path_1.default.join(root.directory, file)));
+        const plugins = isDirectPlugin
+            ? [discoverPluginDirectory(root.directory, options, root.folder)]
+            : discoverPlugins(root.directory, options);
+        for (const plugin of plugins) {
+            if (!plugin)
+                continue;
+            const manifest = root.defaultEnabled === false ? { ...plugin.manifest, enabled: false } : plugin.manifest;
+            if (manifest.enabled === false && !options.includeDisabled)
+                continue;
+            if (seenIds.has(plugin.manifest.id)) {
+                options.onWarning?.(`Ignoring duplicate plugin id: ${plugin.manifest.id}`);
+                continue;
+            }
+            seenIds.add(plugin.manifest.id);
+            discovered.push({
+                ...plugin,
+                manifest,
+                ...(root.folder ? { folder: root.folder } : {})
+            });
+        }
+    }
+    return sortPlugins(discovered);
+}
+/** Load order: ascending `priority`, then by id so it never depends on the filesystem. */
+function sortPlugins(plugins) {
+    return plugins.sort((a, b) => (Number(a.manifest.priority) || 0) - (Number(b.manifest.priority) || 0) ||
+        a.manifest.id.localeCompare(b.manifest.id));
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_npm.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.currentPackageRoot = currentPackageRoot;
+exports.currentProjectRoot = currentProjectRoot;
+exports.npmPluginRoots = npmPluginRoots;
+exports.listNpmPlugins = listNpmPlugins;
+exports.installNpmPlugin = installNpmPlugin;
+exports.uninstallNpmPlugin = uninstallNpmPlugin;
+const child_process_1 = __webpack_require__("child_process");
+const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+const path_1 = __importDefault(__webpack_require__("path"));
+const module_1 = __webpack_require__("module");
+const PLUGIN_ID = /^[a-z][a-z0-9_-]{1,63}$/;
+const PACKAGE_NAME = /^(?:@[a-z0-9_.-]+\/)?epanel-plugin-[a-z0-9_.-]+$/;
+const VERSION = /^[0-9][^\s/]{0,63}$/;
+function readJson(filename) {
+    try {
+        const parsed = JSON.parse(fs_extra_1.default.readFileSync(filename, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch (error) {
+        if (error?.code === "ENOENT")
+            return null;
+        throw error;
+    }
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : "";
+}
+function currentPackageRoot() {
+    return path_1.default.resolve(process.env.EPANEL_PACKAGE_ROOT || process.cwd());
+}
+function currentProjectRoot(packageRoot = currentPackageRoot()) {
+    // The npm worker sets EPANEL_PROJECT_ROOT to the installation directory. In a
+    // development checkout the runtime package sits directly under the project.
+    if (process.env.EPANEL_PROJECT_ROOT)
+        return path_1.default.resolve(process.env.EPANEL_PROJECT_ROOT);
+    const scope = path_1.default.resolve(packageRoot, "..");
+    const nodeModules = path_1.default.dirname(scope);
+    if (path_1.default.basename(nodeModules) === "node_modules" && path_1.default.basename(scope).startsWith("@"))
+        return path_1.default.dirname(nodeModules);
+    return scope;
+}
+function npmPluginRoots(options = {}) {
+    const packageRoot = path_1.default.resolve(options.packageRoot ?? currentPackageRoot());
+    return {
+        packageRoot,
+        projectRoot: path_1.default.resolve(options.projectRoot ?? currentProjectRoot(packageRoot))
+    };
+}
+function projectManifestFile(projectRoot) {
+    return path_1.default.join(projectRoot, "package.json");
+}
+function readProjectManifest(projectRoot) {
+    return (readJson(projectManifestFile(projectRoot)) ?? {
+        private: true,
+        dependencies: {},
+        elementspanel: { plugins: {} }
+    });
+}
+function writeProjectManifest(projectRoot, manifest) {
+    fs_extra_1.default.writeFileSync(projectManifestFile(projectRoot), `${JSON.stringify(manifest, null, 2)}\n`);
+}
+function dependenciesOf(manifest) {
+    return objectValue(manifest?.dependencies) ?? {};
+}
+function mappingsOf(manifest) {
+    return objectValue(objectValue(manifest?.elementspanel)?.plugins) ?? {};
+}
+function pluginRecord(pluginId, name, source, packageRoot, directory, folder, version) {
+    return { pluginId, name, version, sides: [], directory, folder, packageRoot, source };
+}
+function readPackageEntry(packageRoot, name) {
+    const hostRequire = (0, module_1.createRequire)(path_1.default.join(packageRoot, "package.json"));
+    const manifestPath = hostRequire.resolve(`${name}/package.json`);
+    const metadata = readJson(manifestPath);
+    if (!metadata)
+        throw new Error(`Missing package metadata for ${name}.`);
+    return { root: path_1.default.dirname(manifestPath), metadata };
+}
+function sideDirectory(packageRoot, metadata, side) {
+    const elements = objectValue(metadata.elementspanel);
+    const definition = objectValue(elements?.[side]);
+    const directory = stringValue(definition?.directory);
+    if (!definition || !directory)
+        return undefined;
+    const target = path_1.default.resolve(packageRoot, directory);
+    const relative = path_1.default.relative(packageRoot, target);
+    if (relative === "" || relative.startsWith(`..${path_1.default.sep}`) || path_1.default.isAbsolute(relative))
+        return undefined;
+    return target;
+}
+function recordFromPackage(pluginId, name, source, packageRoot, metadata, side) {
+    const elements = objectValue(metadata.elementspanel);
+    if (!elements || elements.id !== pluginId)
+        return undefined;
+    const version = stringValue(metadata.version);
+    const sides = ["panel", "daemon"].filter((item) => Boolean(sideDirectory(packageRoot, metadata, item)));
+    if (!sides.length)
+        return undefined;
+    const target = side ?? sides[0];
+    if (!sides.includes(target))
+        return undefined;
+    const directory = sideDirectory(packageRoot, metadata, target);
+    const folder = stringValue(objectValue(elements[target])?.folder);
+    if (!directory || !folder)
+        return undefined;
+    return {
+        ...pluginRecord(pluginId, name, source, packageRoot, directory, folder, version),
+        sides
+    };
+}
+/**
+ * Every npm plugin the runtime can load for a side, built-in and project-installed.
+ *
+ * Built-in mappings win over a project mapping for the same id: a third-party
+ * package must not shadow a plugin that ships with the runtime. A project package
+ * that does not describe the requested side is skipped instead of failing, which
+ * is what lets a two-sided project share one dependency list between sides.
+ */
+function listNpmPlugins(side, options = {}) {
+    const { packageRoot, projectRoot } = npmPluginRoots(options);
+    const host = readJson(path_1.default.join(packageRoot, "package.json"));
+    if (!host)
+        throw new Error(`Missing runtime package metadata: ${packageRoot}`);
+    const project = path_1.default.resolve(projectRoot) === path_1.default.resolve(packageRoot) ? null : readProjectManifest(projectRoot);
+    const hostMappings = mappingsOf(host);
+    const projectMappings = mappingsOf(project);
+    const mappings = new Map();
+    for (const [pluginId, name] of Object.entries(projectMappings)) {
+        if (!PLUGIN_ID.test(pluginId) || typeof name !== "string" || !PACKAGE_NAME.test(name))
+            continue;
+        mappings.set(pluginId, { name, source: "project" });
+    }
+    for (const [pluginId, name] of Object.entries(hostMappings)) {
+        if (!PLUGIN_ID.test(pluginId) || typeof name !== "string" || !PACKAGE_NAME.test(name))
+            continue;
+        mappings.set(pluginId, { name, source: "bundled" });
+    }
+    const hostDependencies = dependenciesOf(host);
+    const projectDependencies = dependenciesOf(project);
+    const folders = new Set();
+    const records = [];
+    for (const [pluginId, mapping] of mappings) {
+        const declared = hostDependencies[mapping.name] ?? projectDependencies[mapping.name];
+        if (declared === undefined) {
+            if (options.skipInvalid)
+                continue;
+            throw new Error(`Missing npm plugin dependency: ${mapping.name}. Run npm install in the project directory.`);
+        }
+        let entry;
+        try {
+            entry = readPackageEntry(packageRoot, mapping.name);
+        }
+        catch (error) {
+            if (options.skipInvalid)
+                continue;
+            throw error;
+        }
+        const record = recordFromPackage(pluginId, mapping.name, mapping.source, entry.root, entry.metadata, side);
+        if (!record) {
+            if (options.skipInvalid || mapping.source === "project")
+                continue;
+            throw new Error(`Invalid ${side ?? "plugin"} entry in npm plugin ${mapping.name}.`);
+        }
+        const folder = record.folder;
+        if (folders.has(folder)) {
+            if (options.skipInvalid)
+                continue;
+            throw new Error(`Duplicate npm plugin asset directory: ${folder}.`);
+        }
+        folders.add(folder);
+        records.push(record);
+    }
+    return records;
+}
+function runNpm(args, cwd) {
+    return new Promise((resolve, reject) => {
+        const npmCLI = process.env.npm_execpath;
+        const invocation = npmCLI && /npm(?:-cli)?\.(?:c?js|mjs)$/.test(npmCLI)
+            ? { command: process.execPath, args: [npmCLI, ...args], shell: false }
+            : process.platform === "win32"
+                ? {
+                    command: process.env.ComSpec || "cmd.exe",
+                    args: ["/d", "/s", "/c", `npm ${args.map((item) => `"${item.replace(/"/g, '""')}"`).join(" ")}`],
+                    shell: false
+                }
+                : { command: "npm", args, shell: false };
+        const child = (0, child_process_1.spawn)(invocation.command, invocation.args, {
+            cwd,
+            shell: invocation.shell,
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...process.env, npm_config_update_notifier: "false" }
+        });
+        let output = "";
+        const append = (data) => {
+            output += data.toString();
+            if (output.length > 16000)
+                output = output.slice(-16000);
+        };
+        child.stdout?.on("data", append);
+        child.stderr?.on("data", append);
+        const timer = setTimeout(() => {
+            child.kill("SIGKILL");
+            reject(new Error(`npm ${args[0] ?? ""} timed out.`));
+        }, 10 * 60 * 1000);
+        timer.unref?.();
+        child.once("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.once("close", (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+                return resolve(output);
+            reject(new Error(`npm ${args[0] ?? ""} failed (${code}): ${output.trim()}`));
+        });
+    });
+}
+const operations = new Map();
+function withProjectLock(projectRoot, operation) {
+    const key = process.platform === "win32" ? projectRoot.toLowerCase() : projectRoot;
+    const previous = operations.get(key) ?? Promise.resolve();
+    const result = previous.then(operation);
+    const settled = result.then(() => { }, () => { });
+    operations.set(key, settled);
+    return result.finally(() => {
+        if (operations.get(key) === settled)
+            operations.delete(key);
+    });
+}
+/**
+ * Installs (or updates) one npm plugin as a project dependency.
+ *
+ * The version is pinned with `--save-exact`: the panel performs updates, so a
+ * later bare `npm install` must not silently move the plugin to another release.
+ */
+async function installNpmPlugin(options) {
+    const { name, pluginId, version, side } = options;
+    if (!PLUGIN_ID.test(pluginId))
+        throw new Error(`Invalid plugin id: ${pluginId}`);
+    if (!PACKAGE_NAME.test(name))
+        throw new Error(`Invalid npm plugin package: ${name}`);
+    if (!VERSION.test(version))
+        throw new Error(`Invalid plugin version: ${version}`);
+    const { packageRoot, projectRoot } = npmPluginRoots(options);
+    return withProjectLock(projectRoot, async () => {
+        const host = readJson(path_1.default.join(packageRoot, "package.json"));
+        if (!host)
+            throw new Error(`Missing runtime package metadata: ${packageRoot}`);
+        if (mappingsOf(host)[pluginId] !== undefined)
+            throw new Error(`BUNDLED:${pluginId}`);
+        const existing = mappingsOf(readProjectManifest(projectRoot))[pluginId];
+        if (existing !== undefined && existing !== name)
+            throw new Error(`Plugin id ${pluginId} is already installed as ${String(existing)}.`);
+        await fs_extra_1.default.ensureDir(projectRoot);
+        await runNpm(["install", `${name}@${version}`, "--save", "--save-exact", "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot);
+        let entry;
+        try {
+            entry = readPackageEntry(packageRoot, name);
+        }
+        catch (error) {
+            await runNpm(["uninstall", name, "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot).catch(() => { });
+            throw error;
+        }
+        const record = recordFromPackage(pluginId, name, "project", entry.root, entry.metadata, side);
+        if (!record) {
+            await runNpm(["uninstall", name, "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot).catch(() => { });
+            throw new Error(`The package ${name} does not provide a ${side} plugin named ${pluginId}.`);
+        }
+        if (record.version !== version) {
+            await runNpm(["uninstall", name, "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot).catch(() => { });
+            throw new Error(`The installed package ${name} is ${record.version}, expected ${version}.`);
+        }
+        const manifest = readProjectManifest(projectRoot);
+        const dependencies = { ...dependenciesOf(manifest), [name]: version };
+        const elementspanel = { ...(objectValue(manifest.elementspanel) ?? {}) };
+        const plugins = { ...mappingsOf(manifest), [pluginId]: name };
+        manifest.dependencies = dependencies;
+        manifest.elementspanel = { ...elementspanel, plugins };
+        writeProjectManifest(projectRoot, manifest);
+        return record;
+    });
+}
+/** Removes one project-installed npm plugin. Built-in packages are left alone. */
+async function uninstallNpmPlugin(pluginId, options = {}) {
+    if (!PLUGIN_ID.test(pluginId))
+        throw new Error(`Invalid plugin id: ${pluginId}`);
+    const { packageRoot, projectRoot } = npmPluginRoots(options);
+    return withProjectLock(projectRoot, async () => {
+        const host = readJson(path_1.default.join(packageRoot, "package.json"));
+        if (host && mappingsOf(host)[pluginId] !== undefined)
+            throw new Error(`BUNDLED:${pluginId}`);
+        const manifest = readProjectManifest(projectRoot);
+        const name = mappingsOf(manifest)[pluginId];
+        if (typeof name !== "string" || !PACKAGE_NAME.test(name))
+            return null;
+        const record = listNpmPlugins(undefined, { packageRoot, projectRoot, skipInvalid: true }).find((item) => item.pluginId === pluginId);
+        await runNpm(["uninstall", name, "--no-fund", "--no-audit", "--ignore-scripts"], projectRoot);
+        const plugins = { ...mappingsOf(manifest) };
+        delete plugins[pluginId];
+        const elementspanel = { ...(objectValue(manifest.elementspanel) ?? {}) };
+        if (Object.keys(plugins).length)
+            elementspanel.plugins = plugins;
+        else
+            delete elementspanel.plugins;
+        manifest.elementspanel = elementspanel;
+        writeProjectManifest(projectRoot, manifest);
+        return record ?? null;
+    });
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_overrides.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.pluginOverridesPath = pluginOverridesPath;
+exports.readPluginOverrides = readPluginOverrides;
+exports.validatePluginOverride = validatePluginOverride;
+exports.applyPluginOverrides = applyPluginOverrides;
+exports.writePluginOverride = writePluginOverride;
+const node_fs_1 = __importDefault(__webpack_require__("node:fs"));
+const node_path_1 = __importDefault(__webpack_require__("node:path"));
+const node_crypto_1 = __webpack_require__("node:crypto");
+function pluginOverridesPath() {
+    return node_path_1.default.resolve(process.cwd(), "data", "plugin-overrides.json");
+}
+/** Package defaults stay immutable; only the user's last layer lives in data. */
+function readPluginOverrides(filename = pluginOverridesPath()) {
+    let raw;
+    try {
+        raw = node_fs_1.default.readFileSync(filename, "utf8");
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return { version: 1, plugins: {} };
+        throw error;
+    }
+    const data = JSON.parse(raw);
+    if (data?.version !== 1 ||
+        !data.plugins ||
+        typeof data.plugins !== "object" ||
+        Array.isArray(data.plugins))
+        throw new Error("Invalid plugin-overrides.json");
+    for (const entry of Object.values(data.plugins))
+        validatePluginOverride(entry);
+    return data;
+}
+function validatePluginOverride(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new Error("Invalid plugin override.");
+    const entry = value;
+    if (entry.enabled !== undefined && typeof entry.enabled !== "boolean")
+        throw new Error("Invalid plugin enablement.");
+    if (entry.config !== undefined &&
+        (!entry.config || typeof entry.config !== "object" || Array.isArray(entry.config)))
+        throw new Error("Plugin config must be an object.");
+    if (Object.keys(value).some((key) => !["enabled", "config"].includes(key)))
+        throw new Error("Unknown plugin override field.");
+}
+function applyPluginOverrides(plugins, filename = pluginOverridesPath()) {
+    const overrides = readPluginOverrides(filename).plugins;
+    return plugins.map((plugin) => ({
+        ...plugin,
+        manifest: {
+            ...plugin.manifest,
+            ...(Object.prototype.hasOwnProperty.call(overrides, plugin.manifest.id)
+                ? overrides[plugin.manifest.id]
+                : {})
+        }
+    }));
+}
+/** Call inside the host's change queue; rename keeps readers off partial JSON. */
+function writePluginOverride(id, patch, filename = pluginOverridesPath()) {
+    validatePluginOverride(patch);
+    if (!id || ["__proto__", "constructor", "prototype"].includes(id))
+        throw new Error("Invalid plugin id.");
+    const data = readPluginOverrides(filename);
+    data.plugins[id] = {
+        ...(Object.prototype.hasOwnProperty.call(data.plugins, id) ? data.plugins[id] : {}),
+        ...patch
+    };
+    node_fs_1.default.mkdirSync(node_path_1.default.dirname(filename), { recursive: true });
+    const temporary = `${filename}.${(0, node_crypto_1.randomBytes)(8).toString("hex")}.tmp`;
+    try {
+        node_fs_1.default.writeFileSync(temporary, `${JSON.stringify(data, null, 2)}\n`, { mode: 0o600, flag: "wx" });
+        node_fs_1.default.renameSync(temporary, filename);
+    }
+    finally {
+        node_fs_1.default.rmSync(temporary, { force: true });
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/plugin_revision.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.pluginDirectoryRevision = pluginDirectoryRevision;
+const node_fs_1 = __importDefault(__webpack_require__("node:fs"));
+const node_path_1 = __importDefault(__webpack_require__("node:path"));
+const node_crypto_1 = __webpack_require__("node:crypto");
+const cache = new Map();
+/** One revision addresses the complete module graph, including CSS and nested chunks. */
+function pluginDirectoryRevision(directory) {
+    const files = [];
+    const walk = (root) => {
+        if (!node_fs_1.default.existsSync(root))
+            return;
+        for (const item of node_fs_1.default
+            .readdirSync(root, { withFileTypes: true })
+            .sort((a, b) => a.name.localeCompare(b.name))) {
+            const absolute = node_path_1.default.join(root, item.name);
+            if (item.isDirectory())
+                walk(absolute);
+            else if (item.isFile())
+                files.push({
+                    relative: node_path_1.default.relative(directory, absolute),
+                    absolute,
+                    stat: node_fs_1.default.statSync(absolute)
+                });
+        }
+    };
+    walk(directory);
+    const signature = JSON.stringify(files.map(({ relative, stat }) => [relative, stat.size, stat.mtimeMs, stat.ctimeMs]));
+    const previous = cache.get(directory);
+    if (previous?.signature === signature)
+        return previous.revision;
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    for (const file of files)
+        hash
+            .update(file.relative)
+            .update("\0")
+            .update(new Uint8Array(node_fs_1.default.readFileSync(file.absolute)))
+            .update("\0");
+    const revision = hash.digest("hex").slice(0, 24);
+    if (cache.size > 1024)
+        cache.clear();
+    cache.set(directory, { signature, revision });
+    return revision;
+}
+
+
+/***/ },
+
+/***/ "../common/src/process_tools.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.ProcessWrapper = exports.StartError = void 0;
+exports.killProcess = killProcess;
+const child_process_1 = __webpack_require__("child_process");
+const os_1 = __importDefault(__webpack_require__("os"));
+const child_process_2 = __importDefault(__webpack_require__("child_process"));
+const path_1 = __importDefault(__webpack_require__("path"));
+const events_1 = __importDefault(__webpack_require__("events"));
+const iconv_lite_1 = __importDefault(__webpack_require__("iconv-lite"));
+const process_1 = __importDefault(__webpack_require__("process"));
+class StartError extends Error {
+}
+exports.StartError = StartError;
+class ProcessWrapper extends events_1.default {
+    file;
+    args;
+    cwd;
+    timeout;
+    code;
+    option;
+    process;
+    pid;
+    lastExitCode;
+    completed = false;
+    errMsg = {
+        timeoutErr: "task timeout!",
+        exitErr: "task error!",
+        startErr: "task start error!"
+    };
+    constructor(file, args, cwd, timeout = 0, code = "utf-8", option = {}) {
+        super();
+        this.file = file;
+        this.args = args;
+        this.cwd = cwd;
+        this.timeout = timeout;
+        this.code = code;
+        this.option = option;
+    }
+    setErrMsg(errMsg) {
+        this.errMsg = errMsg;
+    }
+    start() {
+        if (this.process)
+            return Promise.reject(new Error("The process is already running"));
+        return new Promise((resolve, reject) => {
+            const stdoutDecoder = iconv_lite_1.default.decodeStream(this.code);
+            const stderrDecoder = iconv_lite_1.default.decodeStream(this.code);
+            let timeTask;
+            let settled = false;
+            let spawned = false;
+            const settle = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (timeTask)
+                    clearTimeout(timeTask);
+                if (error)
+                    reject(error);
+                else
+                    resolve(true);
+            };
+            const subProcess = child_process_2.default.spawn(this.file, this.args, {
+                stdio: "pipe",
+                windowsHide: true,
+                cwd: path_1.default.normalize(this.cwd),
+                ...this.option
+            });
+            this.process = subProcess;
+            this.pid = subProcess.pid;
+            this.lastExitCode = undefined;
+            this.completed = false;
+            const fail = (error) => {
+                if (settled)
+                    return;
+                settle(error);
+                if (subProcess.pid && subProcess.exitCode === null && subProcess.signalCode === null) {
+                    try {
+                        killProcess(subProcess.pid, subProcess);
+                    }
+                    catch (error) {
+                        console.error("[ProcessWrapper kill error]", error);
+                    }
+                }
+            };
+            subProcess.once("spawn", () => {
+                spawned = true;
+                this.emit("start", subProcess.pid);
+            });
+            for (const [source, decoder] of [
+                [subProcess.stdout, stdoutDecoder],
+                [subProcess.stderr, stderrDecoder]
+            ]) {
+                decoder.on("data", (text) => this.emit("data", text));
+                decoder.on("error", fail);
+                source.on("error", fail);
+                source.pipe(decoder);
+            }
+            subProcess.stdin.on("error", fail);
+            subProcess.once("error", (error) => {
+                fail(new Error(`${spawned ? this.errMsg.exitErr : this.errMsg.startErr} ${error.message}`));
+            });
+            subProcess.once("exit", (code) => {
+                this.lastExitCode = code;
+                this.emit("exit", code);
+            });
+            // `close` follows the final stdout/stderr data and also follows a failed spawn.
+            subProcess.once("close", (code) => {
+                this.lastExitCode = code;
+                this.completed = true;
+                this.process = undefined;
+                settle(code === 0 ? undefined : new Error(this.errMsg.exitErr));
+            });
+            if (this.timeout > 0) {
+                timeTask = setTimeout(() => {
+                    fail(new Error(this.errMsg.timeoutErr));
+                }, 1000 * this.timeout);
+            }
+        });
+    }
+    getPid() {
+        return this.process?.pid;
+    }
+    write(data) {
+        return this.process?.stdin?.write(iconv_lite_1.default.encode(data, this.code));
+    }
+    kill() {
+        if (this.process?.pid)
+            killProcess(this.process?.pid, this.process);
+    }
+    status() {
+        return this.completed;
+    }
+    exitCode() {
+        return this.process?.exitCode ?? this.lastExitCode;
+    }
+}
+exports.ProcessWrapper = ProcessWrapper;
+function killProcess(pid, process, signal) {
+    const numericPid = Number(pid);
+    if (!Number.isSafeInteger(numericPid) || numericPid <= 0) {
+        throw new Error("Invalid process ID");
+    }
+    try {
+        if (os_1.default.platform() === "win32") {
+            (0, child_process_1.execFileSync)("taskkill", ["/PID", String(numericPid), "/T", "/F"], { windowsHide: true });
+            return true;
+        }
+        return process_1.default.kill(numericPid, signal || "SIGKILL");
+    }
+    catch (err) {
+        return signal ? process.kill(signal) : process.kill("SIGKILL");
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/query_wrapper.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.QueryWrapper = exports.LocalFileSource = exports.MySqlSource = exports.QueryMapWrapper = void 0;
+function paginate(data, page, pageSize) {
+    if (!Number.isSafeInteger(page) || page < 1 || !Number.isSafeInteger(pageSize) || pageSize < 1) {
+        throw new RangeError("page and pageSize must be positive integers");
+    }
+    const start = (page - 1) * pageSize;
+    return {
+        page,
+        pageSize,
+        maxPage: Math.ceil(data.length / pageSize),
+        total: data.length,
+        data: data.slice(start, start + pageSize)
+    };
+}
+// Provide the MAP query interface used by the routing layer
+class QueryMapWrapper {
+    map;
+    constructor(map) {
+        this.map = map;
+    }
+    select(condition) {
+        const result = [];
+        this.map.forEach((v) => {
+            if (condition(v))
+                result.push(v);
+        });
+        return result;
+    }
+    page(data, page = 1, pageSize = 10) {
+        return paginate(data, page, pageSize);
+    }
+}
+exports.QueryMapWrapper = QueryMapWrapper;
+// MYSQL data source
+class MySqlSource {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    selectPage(condition, page, pageSize) {
+        return {
+            page,
+            pageSize,
+            maxPage: 0,
+            total: 0,
+            data: []
+        };
+    }
+    select(condition) {
+        return [];
+    }
+    update(condition, data) { }
+    delete(condition) { }
+    insert(data) { }
+}
+exports.MySqlSource = MySqlSource;
+// local file data source (embedded microdatabase)
+class LocalFileSource {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+    selectPage(condition, page = 1, pageSize = 10) {
+        return this.page(this.select(condition), page, pageSize);
+    }
+    page(data, page = 1, pageSize = 10) {
+        return paginate(data, page, pageSize);
+    }
+    select(condition = {}) {
+        const result = [];
+        const entries = Object.entries(condition);
+        this.data.forEach((v) => {
+            for (const [key, targetValue] of entries) {
+                const dataValue = v[key];
+                if (typeof targetValue === "string" &&
+                    targetValue.startsWith("%") &&
+                    targetValue.endsWith("%")) {
+                    if (typeof dataValue !== "string" || !dataValue.includes(targetValue.slice(1, -1)))
+                        return;
+                }
+                else if (targetValue !== dataValue) {
+                    return;
+                }
+            }
+            result.push(v);
+        });
+        return result;
+    }
+    update(condition, data) { }
+    delete(condition) { }
+    insert(data) { }
+}
+exports.LocalFileSource = LocalFileSource;
+// Provide the unified data query interface used by the routing layer
+class QueryWrapper {
+    dataSource;
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+    }
+    selectPage(condition, page = 1, pageSize = 10) {
+        return this.dataSource.selectPage(condition, page, pageSize);
+    }
+}
+exports.QueryWrapper = QueryWrapper;
+
+
+/***/ },
+
+/***/ "../common/src/runtime_paths.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.isPackagedRuntime = isPackagedRuntime;
+exports.packagePath = packagePath;
+exports.packagePluginRoots = packagePluginRoots;
+exports.isPackagePlugin = isPackagePlugin;
+exports.bundledToolPath = bundledToolPath;
+exports.ensureExecutable = ensureExecutable;
+const node_fs_1 = __importDefault(__webpack_require__("node:fs"));
+const node_os_1 = __importDefault(__webpack_require__("node:os"));
+const node_path_1 = __importDefault(__webpack_require__("node:path"));
+/** Set by the npm worker before any application module is loaded. */
+function isPackagedRuntime() {
+    return Boolean(process.env.EPANEL_PACKAGE_ROOT);
+}
+/** Code and bundled assets belong to the package; cwd always belongs to the user. */
+function packagePath(...parts) {
+    return node_path_1.default.resolve(process.env.EPANEL_PACKAGE_ROOT || process.cwd(), ...parts);
+}
+function npmPluginRoots(side) {
+    // The same resolver is used by the CLI before the bundled application starts.
+    // A development checkout keeps it in the repository, beside the side packages,
+    // so project-installed npm plugins work there as well.
+    const runtimeRequire = eval("require");
+    const resolver = isPackagedRuntime()
+        ? packagePath("runtime/npm-plugins.cjs")
+        : node_path_1.default.resolve(packagePath(), "..", "scripts", "runtime", "npm-plugins.cjs");
+    // A development process may run from a fixture directory without a runtime
+    // package; there is nothing to resolve in that case.
+    if (!node_fs_1.default.existsSync(node_path_1.default.join(packagePath(), "package.json")))
+        return [];
+    if (!isPackagedRuntime() && !node_fs_1.default.existsSync(resolver))
+        return [];
+    const { resolveNpmPlugins } = runtimeRequire(resolver);
+    return resolveNpmPlugins(packagePath(), side, { skipInvalid: true }).map((record) => ({
+        directory: record.directory,
+        ...(record.folder ? { folder: record.folder } : {}),
+        // Built-in packages are part of the runtime's default configuration. A
+        // project dependency is installed but remains dormant until the user
+        // enables it through the plugin configuration service.
+        defaultEnabled: record.defaultEnabled !== false
+    }));
+}
+function packagePluginRoots(side) {
+    const roots = isPackagedRuntime()
+        ? []
+        : [{ directory: packagePath("plugins"), defaultEnabled: true }];
+    // Project-installed npm plugins load in development too: they are dependencies
+    // of the development project, not of the published runtime package.
+    roots.push(...npmPluginRoots(side));
+    return roots;
+}
+function isPackagePlugin(directory) {
+    return npmPluginRoots().some((root) => {
+        const relative = node_path_1.default.relative(root.directory, node_path_1.default.resolve(directory));
+        return (relative === "" ||
+            (!relative.startsWith(`..${node_path_1.default.sep}`) && relative !== ".." && !node_path_1.default.isAbsolute(relative)));
+    });
+}
+function bundledToolPath(name) {
+    const platform = node_os_1.default.platform();
+    const arch = node_os_1.default.arch();
+    const suffix = platform === "win32" ? ".exe" : "";
+    const filename = `${name}_${platform}_${arch}${suffix}`;
+    // Published daemon packages download native tools into the installation's
+    // writable lib directory on first start. Development checkouts use the same
+    // repository-local sibling of data and logs.
+    const root = isPackagedRuntime() ? node_path_1.default.resolve(process.cwd(), "lib") : packagePath("lib");
+    const primary = node_path_1.default.join(root, filename);
+    // Zip-Tools names its Intel macOS binary "amd64", while Node reports "x64".
+    if (!node_fs_1.default.existsSync(primary) && name === "file_zip" && platform === "darwin" && arch === "x64") {
+        const alternate = node_path_1.default.join(root, "file_zip_darwin_amd64");
+        if (node_fs_1.default.existsSync(alternate))
+            return alternate;
+    }
+    return primary;
+}
+/** Published binaries already carry executable permissions, including in read-only installs. */
+function ensureExecutable(filename) {
+    if (node_os_1.default.platform() === "win32")
+        return;
+    try {
+        node_fs_1.default.accessSync(filename, node_fs_1.default.constants.X_OK);
+    }
+    catch {
+        node_fs_1.default.chmodSync(filename, 0o755);
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/string_utils.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.removeTrail = removeTrail;
+function removeTrail(origin, trail) {
+    if (origin.endsWith(trail)) {
+        return origin.slice(0, origin.length - trail.length);
+    }
+    else {
+        return origin;
+    }
+}
+
+
+/***/ },
+
+/***/ "../common/src/system_info.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.systemInfo = systemInfo;
+const os_1 = __importDefault(__webpack_require__("os"));
+const os_utils_1 = __importDefault(__webpack_require__("os-utils"));
+const fs_1 = __importDefault(__webpack_require__("fs"));
+// System details are updated every time
+const info = {
+    type: os_1.default.type(),
+    hostname: os_1.default.hostname(),
+    platform: os_1.default.platform(),
+    release: os_1.default.release(),
+    uptime: os_1.default.uptime(),
+    cwd: process.cwd(),
+    loadavg: os_1.default.loadavg(),
+    freemem: 0,
+    cpuUsage: 0,
+    memUsage: 0,
+    totalmem: 0,
+    processCpu: 0,
+    processMem: 0
+};
+let previousCpu = process.cpuUsage();
+let previousTime = process.hrtime.bigint();
+// periodically refresh the cache
+function refresh() {
+    const now = process.hrtime.bigint();
+    const cpu = process.cpuUsage();
+    const elapsed = Number(now - previousTime) / 1000;
+    info.processCpu =
+        elapsed > 0 ? (cpu.user - previousCpu.user + cpu.system - previousCpu.system) / elapsed : 0;
+    previousCpu = cpu;
+    previousTime = now;
+    info.uptime = os_1.default.uptime();
+    info.loadavg = os_1.default.loadavg();
+    info.processMem = process.memoryUsage().rss;
+    if (os_1.default.platform() === "linux") {
+        return setLinuxSystemInfo();
+    }
+    return otherSystemInfo();
+}
+refresh();
+setInterval(refresh, 3000).unref();
+function otherSystemInfo() {
+    info.freemem = os_1.default.freemem();
+    info.totalmem = os_1.default.totalmem();
+    info.memUsage = (os_1.default.totalmem() - os_1.default.freemem()) / os_1.default.totalmem();
+    os_utils_1.default.cpuUsage((p) => (info.cpuUsage = p));
+}
+function setLinuxSystemInfo() {
+    try {
+        // read memory data based on /proc/meminfo
+        const data = fs_1.default.readFileSync("/proc/meminfo", { encoding: "utf-8" });
+        const list = data.split("\n");
+        const infoTable = {};
+        list.forEach((line) => {
+            const kv = line.split(":");
+            if (kv.length === 2) {
+                const k = kv[0].replace(/ /gim, "").replace(/\t/gim, "").trim().toLowerCase();
+                let v = kv[1].replace(/ /gim, "").replace(/\t/gim, "").trim().toLowerCase();
+                v = v.replace(/kb/gim, "").replace(/mb/gim, "").replace(/gb/gim, "");
+                let vNumber = parseInt(v);
+                if (isNaN(vNumber))
+                    vNumber = 0;
+                infoTable[k] = vNumber;
+            }
+        });
+        const memAvailable = infoTable["memavailable"] ?? infoTable["memfree"];
+        const memTotal = infoTable["memtotal"];
+        info.freemem = memAvailable * 1024;
+        info.totalmem = memTotal * 1024;
+        info.memUsage = (info.totalmem - info.freemem) / info.totalmem;
+        os_utils_1.default.cpuUsage((p) => (info.cpuUsage = p));
+    }
+    catch (error) {
+        // If the reading is wrong, the default general reading method is automatically used
+        otherSystemInfo();
+    }
+}
+function systemInfo() {
+    return info;
+}
+
+
+/***/ },
+
+/***/ "../common/src/system_storage.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const crypto_1 = __webpack_require__("crypto");
+const path_1 = __importDefault(__webpack_require__("path"));
+const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+class StorageSubsystem {
+    static DATA_PATH = path_1.default.resolve(process.cwd(), "data");
+    static INDEX_PATH = path_1.default.join(StorageSubsystem.DATA_PATH, "Index");
+    resolvePath(name) {
+        if (typeof name !== "string" ||
+            !name ||
+            /[\0:]/.test(name) ||
+            path_1.default.isAbsolute(name) ||
+            path_1.default.win32.isAbsolute(name)) {
+            throw new Error(`Invalid storage path: ${name}`);
+        }
+        const target = path_1.default.resolve(StorageSubsystem.DATA_PATH, name);
+        const relative = path_1.default.relative(StorageSubsystem.DATA_PATH, target);
+        if (!relative ||
+            relative === ".." ||
+            relative.startsWith(`..${path_1.default.sep}`) ||
+            path_1.default.isAbsolute(relative)) {
+            throw new Error(`Invalid storage path: ${name}`);
+        }
+        const realRelative = path_1.default.relative(this.realPath(StorageSubsystem.DATA_PATH), this.realPath(target));
+        if (realRelative === ".." ||
+            realRelative.startsWith(`..${path_1.default.sep}`) ||
+            path_1.default.isAbsolute(realRelative)) {
+            throw new Error(`Invalid storage path: ${name}`);
+        }
+        return target;
+    }
+    realPath(target) {
+        if (fs_extra_1.default.existsSync(target))
+            return fs_extra_1.default.realpathSync(target);
+        const parent = path_1.default.dirname(target);
+        return parent === target ? target : path_1.default.join(this.realPath(parent), path_1.default.basename(target));
+    }
+    entityPath(category, uuid) {
+        if (typeof uuid !== "string" || !uuid || /[\\/\0:]/.test(uuid) || uuid.includes("..")) {
+            throw new Error(`UUID ${uuid} does not conform to specification`);
+        }
+        this.resolvePath(category);
+        return path_1.default.join(category, `${uuid}.json`);
+    }
+    writeFile(name, data) {
+        const targetPath = this.resolvePath(name);
+        fs_extra_1.default.ensureDirSync(path_1.default.dirname(targetPath));
+        const temporaryPath = `${targetPath}.${(0, crypto_1.randomUUID)()}.tmp`;
+        const mode = fs_extra_1.default.existsSync(targetPath) ? fs_extra_1.default.statSync(targetPath).mode : 0o600;
+        try {
+            fs_extra_1.default.writeFileSync(temporaryPath, data, { encoding: "utf8", flag: "wx", mode });
+            fs_extra_1.default.renameSync(temporaryPath, targetPath);
+        }
+        finally {
+            if (fs_extra_1.default.existsSync(temporaryPath))
+                fs_extra_1.default.unlinkSync(temporaryPath);
+        }
+    }
+    readFile(name) {
+        return fs_extra_1.default.readFileSync(this.resolvePath(name), "utf8");
+    }
+    readDir(dirName) {
+        const targetPath = this.resolvePath(dirName);
+        if (!fs_extra_1.default.existsSync(targetPath))
+            return [];
+        return fs_extra_1.default.readdirSync(targetPath).map((name) => path_1.default.join(dirName, name));
+    }
+    deleteFile(name) {
+        fs_extra_1.default.removeSync(this.resolvePath(name));
+    }
+    fileExists(name) {
+        return fs_extra_1.default.existsSync(this.resolvePath(name));
+    }
+    store(category, uuid, object) {
+        this.writeFile(this.entityPath(category, uuid), JSON.stringify(object, null, 4));
+    }
+    // Restore declared fields while keeping defaults for fields absent in older data.
+    defineAttr(target, object) {
+        for (const key of Object.keys(target)) {
+            if (!Object.prototype.hasOwnProperty.call(object, key) || object[key] === undefined)
+                continue;
+            const value = object[key];
+            if (value !== null &&
+                typeof value === "object" &&
+                !Array.isArray(value) &&
+                target[key] !== null &&
+                typeof target[key] === "object" &&
+                !Array.isArray(target[key])) {
+                this.defineAttr(target[key], value);
+            }
+            else {
+                target[key] = value;
+            }
+        }
+        return target;
+    }
+    load(category, classz, uuid) {
+        const file = this.entityPath(category, uuid);
+        if (!this.fileExists(file))
+            return null;
+        const object = JSON.parse(this.readFile(file));
+        if (!object || typeof object !== "object" || Array.isArray(object)) {
+            throw new Error(`Invalid stored entity: ${file}`);
+        }
+        return this.defineAttr(new classz(), object);
+    }
+    list(category) {
+        const directory = this.resolvePath(category);
+        if (!fs_extra_1.default.existsSync(directory))
+            return [];
+        return fs_extra_1.default
+            .readdirSync(directory, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => entry.name.slice(0, -5));
+    }
+    delete(category, uuid) {
+        this.deleteFile(this.entityPath(category, uuid));
+    }
+}
+exports["default"] = StorageSubsystem;
+
+
+/***/ },
+
+/***/ "../common/src/typecheck.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.configureEntityParams = configureEntityParams;
+exports.toText = toText;
+exports.toNumber = toNumber;
+exports.toBoolean = toBoolean;
+exports.isEmpty = isEmpty;
+exports.supposeValue = supposeValue;
+function configureEntityParams(self, args, key, typeFn) {
+    const selfDefaultValue = self[key] ?? null;
+    const v = args[key] != null ? args[key] : selfDefaultValue;
+    if (typeFn === Number) {
+        if (v === "" || v == null) {
+            self[key] = null;
+        }
+        else {
+            if (isNaN(Number(v)))
+                throw new Error(`ConfigureEntityParams Error: Expected type to be Number, but got ${typeof v}`);
+            self[key] = Number(v);
+        }
+        return;
+    }
+    if (typeFn === String) {
+        if (v == null) {
+            self[key] = null;
+        }
+        else {
+            self[key] = String(v);
+        }
+        return;
+    }
+    if (typeFn === Boolean) {
+        if (v == null) {
+            self[key] = false;
+        }
+        else {
+            self[key] = Boolean(v);
+        }
+        return;
+    }
+    if (typeFn) {
+        self[key] = typeFn(v);
+    }
+    else {
+        self[key] = v;
+    }
+}
+function toText(v) {
+    if (isEmpty(v))
+        return null;
+    return String(v);
+}
+function toNumber(v) {
+    if (isEmpty(v))
+        return null;
+    if (isNaN(Number(v)))
+        return null;
+    return Number(v);
+}
+function toBoolean(v) {
+    if (isEmpty(v))
+        return null;
+    return Boolean(v);
+}
+function isEmpty(v) {
+    return v === null || v === undefined;
+}
+function supposeValue(v, def) {
+    if (isEmpty(v))
+        return def;
+    return v;
+}
+
+
+/***/ },
+
+/***/ "./plugins/file/src/backend/file_router.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.registerFileEvents = registerFileEvents;
+const os_1 = __importDefault(__webpack_require__("os"));
+const file_service_1 = __webpack_require__("./plugins/file/src/backend/file_service.ts");
+const runtime_1 = __webpack_require__("./plugins/file/src/backend/runtime.ts");
+const upload_manager_1 = __importDefault(__webpack_require__("./plugins/file/src/backend/upload_manager.ts"));
+const url_1 = __webpack_require__("./plugins/file/src/backend/url.ts");
+/**
+ * Every `file/*` protocol event, plus the middleware that gates them.
+ *
+ * Registered from `apply()`, so all of it — the middleware included — leaves with
+ * the plugin. The middleware runs after `plugins/auth`'s, which loads first.
+ */
+function registerFileEvents() {
+    // Some routers operate router authentication middleware
+    (0, runtime_1.protocol)().use((event, ctx, data, next) => {
+        if (event.startsWith("file/")) {
+            const instanceUuid = data.instanceUuid;
+            const instance = (0, runtime_1.instances)().subsystem.getInstance(instanceUuid);
+            if (!instance) {
+                return (0, runtime_1.protocol)().error(ctx, event, {
+                    instanceUuid: instanceUuid,
+                    err: (0, runtime_1.$t)("TXT_CODE_file_router.instanceNotExist", { instanceUuid: instanceUuid })
+                });
+            }
+            if ([(0, runtime_1.instances)().Instance.STATUS_BUSY, (0, runtime_1.instances)().Instance.STATUS_STARTING].includes(instance.status()) &&
+                !["file/list", "file/status"].includes(event)) {
+                return (0, runtime_1.protocol)().error(ctx, event, {
+                    instanceUuid: instanceUuid,
+                    err: (0, runtime_1.$t)("TXT_CODE_bbedcf29")
+                });
+            }
+        }
+        next();
+    });
+    // List the files in the specified instance working directory
+    (0, runtime_1.protocol)().on("file/list", async (ctx, data) => {
+        try {
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            const { page, pageSize, target, fileName } = data;
+            fileManager.cd(target);
+            const overview = await fileManager.list(page, pageSize, fileName);
+            (0, runtime_1.protocol)().response(ctx, overview);
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    // Preview archive contents without extracting the archive
+    (0, runtime_1.protocol)().on("file/preview", async (ctx, data) => {
+        const maxFileTask = (0, runtime_1.settings)().config.maxFileTask;
+        const instance = (0, runtime_1.instances)().subsystem.getInstance(data.instanceUuid);
+        let taskStarted = false;
+        try {
+            if (!instance)
+                throw new Error((0, runtime_1.$t)("TXT_CODE_3bfb9e04"));
+            if (instance.info.fileLock >= maxFileTask) {
+                throw new Error((0, runtime_1.$t)("TXT_CODE_file_router.unzipLimit", {
+                    maxFileTask,
+                    fileLock: instance.info.fileLock
+                }));
+            }
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            instance.info.fileLock++;
+            runtime_1.fileTasks.count++;
+            taskStarted = true;
+            const entries = await fileManager.previewArchive(data.target, data.code);
+            (0, runtime_1.protocol)().response(ctx, { items: entries, total: entries.length });
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+        finally {
+            if (instance && taskStarted) {
+                instance.info.fileLock = Math.max(0, instance.info.fileLock - 1);
+                runtime_1.fileTasks.count = Math.max(0, runtime_1.fileTasks.count - 1);
+            }
+        }
+    });
+    // File chmod (only Linux)
+    (0, runtime_1.protocol)().on("file/chmod", async (ctx, data) => {
+        try {
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            const { chmod, target, deep } = data;
+            await fileManager.chmod(target, chmod, deep);
+            (0, runtime_1.protocol)().response(ctx, true);
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    (0, runtime_1.protocol)().on("file/chmod_batch", async (ctx, data) => {
+        try {
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            const { chmod, targets, deep: rawDeep } = data;
+            const deep = Boolean(rawDeep);
+            const results = [];
+            let success = 0;
+            let failed = 0;
+            for (const target of targets || []) {
+                const currentTarget = String(target);
+                try {
+                    await fileManager.chmod(currentTarget, chmod, deep);
+                    success += 1;
+                    results.push({
+                        target: currentTarget,
+                        success: true
+                    });
+                }
+                catch (error) {
+                    failed += 1;
+                    results.push({
+                        target: currentTarget,
+                        success: false,
+                        error: error?.message || String(error)
+                    });
+                }
+            }
+            (0, runtime_1.protocol)().response(ctx, {
+                success,
+                failed,
+                total: results.length,
+                results
+            });
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    // Query the status of the file management system
+    (0, runtime_1.protocol)().on("file/status", async (ctx, data) => {
+        try {
+            const instance = (0, runtime_1.instances)().subsystem.getInstance(data.instanceUuid);
+            if (!instance)
+                throw new Error((0, runtime_1.$t)("TXT_CODE_3bfb9e04"));
+            const downloads = (0, runtime_1.transfer)().downloads;
+            const downloadTasks = [];
+            if (downloads.task) {
+                downloadTasks.push({
+                    path: downloads.task.path,
+                    total: downloads.task.total,
+                    current: downloads.task.current,
+                    status: downloads.task.status,
+                    error: downloads.task.error
+                });
+            }
+            (0, runtime_1.protocol)().response(ctx, {
+                instanceFileTask: instance.info.fileLock ?? 0,
+                globalFileTask: runtime_1.fileTasks.count ?? 0,
+                downloadFileFromURLTask: downloads.downloadingCount,
+                downloadTasks,
+                platform: os_1.default.platform(),
+                isGlobalInstance: data.instanceUuid === (0, runtime_1.instances)().subsystem.GLOBAL_INSTANCE_UUID,
+                disks: (0, file_service_1.getWindowsDisks)()
+            });
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    // Create a new file
+    (0, runtime_1.protocol)().on("file/create-text", async (ctx, data) => {
+        try {
+            if (typeof data.target !== "string" ||
+                !data.target ||
+                data.target.length > 1024 ||
+                typeof data.text !== "string" ||
+                Buffer.byteLength(data.text, "utf8") > 64 * 1024 ||
+                /[\x00-\x08\x0b\x0c\x0e-\x1f\ufffd]/.test(data.text))
+                throw new Error("Invalid text file request");
+            const result = await (0, file_service_1.getFileManager)(data.instanceUuid).createTextFile(data.target, data.text);
+            (0, runtime_1.protocol)().response(ctx, result);
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    (0, runtime_1.protocol)().on("file/remove-file", async (ctx, data) => {
+        try {
+            if (typeof data.target !== "string" || !data.target || data.target.length > 1024)
+                throw new Error("Invalid file request");
+            const result = await (0, file_service_1.getFileManager)(data.instanceUuid).removeFile(data.target);
+            (0, runtime_1.protocol)().response(ctx, result);
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    (0, runtime_1.protocol)().on("file/touch", (ctx, data) => {
+        try {
+            const target = data.target;
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            fileManager.newFile(target);
+            (0, runtime_1.protocol)().response(ctx, true);
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    // Create a directory
+    (0, runtime_1.protocol)().on("file/mkdir", (ctx, data) => {
+        try {
+            const target = data.target;
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            fileManager.mkdir(target);
+            (0, runtime_1.protocol)().response(ctx, true);
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    // download a file from url
+    (0, runtime_1.protocol)().on("file/download_from_url", async (ctx, data) => {
+        try {
+            const url = data.url;
+            const fileName = data.fileName;
+            if (!(0, url_1.checkSafeUrl)(url) || (data.fallbackUrl && !(0, url_1.checkSafeUrl)(data.fallbackUrl))) {
+                (0, runtime_1.protocol)().responseError(ctx, (0, runtime_1.$t)("TXT_CODE_3fe1b194"), {
+                    disablePrint: true
+                });
+                return;
+            }
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            if (!fileManager.checkPath(fileName))
+                throw new Error("Access denied: Invalid destination");
+            const targetPath = fileManager.toAbsolutePath(fileName);
+            // Start download in background
+            const fallbackUrl = data.fallbackUrl;
+            const maxDownloadFromUrlFileCount = (0, runtime_1.settings)().config.maxDownloadFromUrlFileCount;
+            if ((data.ifIdle === true && (0, runtime_1.transfer)().downloads.downloadingCount > 0) ||
+                (maxDownloadFromUrlFileCount > 0 &&
+                    (0, runtime_1.transfer)().downloads.downloadingCount >= maxDownloadFromUrlFileCount)) {
+                (0, runtime_1.protocol)().responseError(ctx, (0, runtime_1.$t)("TXT_CODE_821a742e", {
+                    count: data.ifIdle === true ? 1 : maxDownloadFromUrlFileCount
+                }), {
+                    disablePrint: true
+                });
+                return;
+            }
+            (0, runtime_1.transfer)()
+                .downloads.downloadFromUrl(url, targetPath, fallbackUrl)
+                .catch((err) => {
+                (0, runtime_1.logger)().error(`Download failed: ${url} -> ${targetPath}`, err);
+            });
+            (0, runtime_1.protocol)().response(ctx, {});
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    // stop download from url
+    (0, runtime_1.protocol)().on("file/download_stop", (ctx, data) => {
+        try {
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            if (!fileManager.checkPath(data.fileName))
+                throw new Error("Access denied: Invalid destination");
+            const targetPath = fileManager.toAbsolutePath(data.fileName);
+            const result = (0, runtime_1.transfer)().downloads.stop(targetPath);
+            (0, runtime_1.protocol)().response(ctx, result);
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    // copy the file
+    (0, runtime_1.protocol)().on("file/copy", async (ctx, data) => {
+        try {
+            // [["a.txt","b.txt"],["cxz","zzz"]]
+            const targets = data.targets;
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            for (const target of targets) {
+                await fileManager.copy(target[0], target[1]);
+            }
+            (0, runtime_1.protocol)().response(ctx, true);
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    // move the file
+    (0, runtime_1.protocol)().on("file/move", async (ctx, data) => {
+        try {
+            // [["a.txt","b.txt"],["cxz","zzz"]]
+            const targets = data.targets;
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            for (const target of targets) {
+                await fileManager.move(target[0], target[1]);
+            }
+            (0, runtime_1.protocol)().response(ctx, true);
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    // Delete Files
+    (0, runtime_1.protocol)().on("file/delete", async (ctx, data) => {
+        try {
+            const targets = data.targets;
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            for (const target of targets) {
+                const path = fileManager.toAbsolutePath(target);
+                const uploadTask = upload_manager_1.default.getByPath(path);
+                if (uploadTask != undefined) {
+                    upload_manager_1.default.delete(uploadTask.id);
+                    await uploadTask.writer.stop();
+                }
+                else {
+                    // async delete
+                    await fileManager.delete(target);
+                }
+            }
+            (0, runtime_1.protocol)().response(ctx, true);
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    // edit file
+    (0, runtime_1.protocol)().on("file/edit", async (ctx, data) => {
+        try {
+            const target = data.target;
+            const text = data.text;
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            const result = await fileManager.edit(target, text);
+            (0, runtime_1.protocol)().response(ctx, result ? result : true);
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+    // compress/decompress the file
+    (0, runtime_1.protocol)().on("file/compress", async (ctx, data) => {
+        const maxFileTask = (0, runtime_1.settings)().config.maxFileTask;
+        try {
+            const source = data.source;
+            const targets = data.targets;
+            const type = data.type;
+            const code = data.code;
+            const fileManager = (0, file_service_1.getFileManager)(data.instanceUuid);
+            const instance = (0, runtime_1.instances)().subsystem.getInstance(data.instanceUuid);
+            if (!instance)
+                throw new Error((0, runtime_1.$t)("TXT_CODE_3bfb9e04"));
+            if (instance.info.fileLock >= maxFileTask) {
+                throw new Error((0, runtime_1.$t)("TXT_CODE_file_router.unzipLimit", {
+                    maxFileTask: maxFileTask,
+                    fileLock: instance.info.fileLock
+                }));
+            }
+            // Statistics of the number of tasks in a single instance file and the number of tasks in the entire daemon process
+            function fileTaskStart() {
+                if (instance) {
+                    instance.info.fileLock++;
+                    runtime_1.fileTasks.count++;
+                }
+            }
+            function fileTaskEnd() {
+                if (instance) {
+                    instance.info.fileLock--;
+                    runtime_1.fileTasks.count--;
+                }
+            }
+            // start decompressing or compressing the file
+            fileTaskStart();
+            try {
+                if (type === 1) {
+                    await fileManager.zip(source, targets, code);
+                }
+                else {
+                    await fileManager.unzip(source, targets, code);
+                }
+                (0, runtime_1.protocol)().response(ctx, true);
+            }
+            catch (error) {
+                throw error;
+            }
+            finally {
+                fileTaskEnd();
+            }
+        }
+        catch (error) {
+            (0, runtime_1.protocol)().responseError(ctx, error);
+        }
+    });
+}
+
+
+/***/ },
+
+/***/ "./plugins/file/src/backend/file_service.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.getFileManager = getFileManager;
+exports.getWindowsDisks = getWindowsDisks;
+const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+const system_file_1 = __importDefault(__webpack_require__("./plugins/file/src/backend/system_file.ts"));
+const runtime_1 = __webpack_require__("./plugins/file/src/backend/runtime.ts");
+const os_1 = __importDefault(__webpack_require__("os"));
+function getFileManager(instanceUuid) {
+    // Initialize a file manager for the instance, and assign codes, restrictions, etc.
+    const instance = (0, runtime_1.instances)().subsystem.getInstance(instanceUuid);
+    if (!instance)
+        throw new Error((0, runtime_1.$t)("TXT_CODE_file_router_service.instanceNotExit", { uuid: instanceUuid }));
+    const fileCode = instance.config?.fileCode;
+    return new system_file_1.default(instance.absoluteCwdPath(), fileCode);
+}
+let cacheDisks = [];
+function getWindowsDisks() {
+    if (os_1.default.platform() !== "win32")
+        return [];
+    if (cacheDisks.length > 0)
+        return cacheDisks;
+    const res = [];
+    // A - Z
+    for (let i = 65; i <= 90; i++) {
+        const letter = String.fromCharCode(i);
+        try {
+            if (fs_extra_1.default.existsSync(`${letter}:\\`))
+                res.push(letter);
+        }
+        catch (error) {
+            // ignore error
+        }
+    }
+    cacheDisks = res;
+    return res;
+}
+
+
+/***/ },
+
+/***/ "./plugins/file/src/backend/file_writer.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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+const path_1 = __importDefault(__webpack_require__("path"));
+const lockfile = __importStar(__webpack_require__("proper-lockfile"));
+const system_file_1 = __importDefault(__webpack_require__("./plugins/file/src/backend/system_file.ts"));
+const runtime_1 = __webpack_require__("./plugins/file/src/backend/runtime.ts");
+const upload_manager_1 = __importDefault(__webpack_require__("./plugins/file/src/backend/upload_manager.ts"));
+class FileWriter {
+    cwd;
+    filename;
+    size;
+    unzip;
+    zipCode;
+    path;
+    id;
+    releaseLock;
+    fd = null;
+    operations = Promise.resolve();
+    completed = false;
+    received = [];
+    lastUpdate = Date.now();
+    onFinish;
+    get cancellable() {
+        return !this.completed;
+    }
+    constructor(cwd, filename, size, unzip, zipCode, filePath) {
+        this.cwd = cwd;
+        this.filename = filename;
+        this.size = size;
+        this.unzip = unzip;
+        this.zipCode = zipCode;
+        if (!system_file_1.default.checkFileName(path_1.default.basename(this.filename)))
+            throw new Error("Access denied: Malformed file name");
+        if (!Number.isSafeInteger(size) || size < 0)
+            throw new Error("Invalid file size");
+        this.path = filePath;
+    }
+    static async getPath(cwd, dir, filename, overwrite) {
+        const fileManager = new system_file_1.default(cwd);
+        const ext = path_1.default.extname(filename);
+        const basename = path_1.default.basename(filename, ext);
+        let tempFileSaveName = basename + ext;
+        let counter = 1;
+        const checkFile = async (name) => {
+            const absolutePath = fileManager.toAbsolutePath(path_1.default.normalize(path_1.default.join(dir, name)));
+            const isLock = await lockfile
+                .check(absolutePath)
+                .then((isLock) => isLock)
+                .catch(() => false);
+            const isAccess = await fs_extra_1.default
+                .access(absolutePath)
+                .then(() => true)
+                .catch(() => false);
+            return isAccess && !isLock && !overwrite;
+        };
+        while (await checkFile(tempFileSaveName)) {
+            if (counter == 1) {
+                tempFileSaveName = `${basename}-copy${ext}`;
+            }
+            else {
+                tempFileSaveName = `${basename}-copy-${counter}${ext}`;
+            }
+            counter++;
+            if (counter > 100) {
+                throw new Error("Access denied: File name already exists!");
+            }
+        }
+        const fileSaveRelativePath = path_1.default.normalize(path_1.default.join(dir, tempFileSaveName));
+        if (!fileManager.checkPath(fileSaveRelativePath))
+            throw new Error("Access denied: Invalid destination");
+        return fileManager.toAbsolutePath(fileSaveRelativePath);
+    }
+    async init() {
+        if (this.fd != null)
+            return;
+        try {
+            // Lock before opening with w+: a competing upload must not truncate the file.
+            this.releaseLock = await lockfile.lock(this.path, { realpath: false });
+            this.fd = await fs_extra_1.default.open(this.path, "w+");
+            await fs_extra_1.default.ftruncate(this.fd, this.size);
+        }
+        catch (e) {
+            try {
+                await this.close();
+            }
+            finally {
+                await this.unlock();
+            }
+            throw e;
+        }
+    }
+    enqueue(operation) {
+        const pending = this.operations.then(operation);
+        this.operations = pending.catch(() => { });
+        return pending;
+    }
+    write(offset, chunk) {
+        return this.enqueue(async () => {
+            if (!Number.isSafeInteger(offset) || offset < 0 || offset + chunk.length > this.size) {
+                throw new Error("Write exceeds file size limit");
+            }
+            if (this.fd === null || this.completed)
+                throw new Error("File is not opened");
+            this.lastUpdate = Date.now();
+            let written = 0;
+            while (written < chunk.length) {
+                const { bytesWritten } = await fs_extra_1.default.write(this.fd, chunk, written, chunk.length - written, offset + written);
+                if (bytesWritten === 0)
+                    throw new Error("Unable to write upload chunk");
+                written += bytesWritten;
+            }
+            this.addWrittenRange(offset, offset + chunk.length);
+            if (this.isFullyCovered())
+                await this.finish(false);
+        });
+    }
+    done() {
+        return this.enqueue(() => this.finish(false));
+    }
+    stop() {
+        return this.enqueue(() => this.finish(true));
+    }
+    async close() {
+        const fd = this.fd;
+        this.fd = null;
+        if (fd != null)
+            await fs_extra_1.default.close(fd);
+    }
+    async unlock() {
+        const releaseLock = this.releaseLock;
+        this.releaseLock = undefined;
+        await releaseLock?.();
+    }
+    async finish(cancelled) {
+        if (this.completed)
+            return;
+        this.completed = true;
+        let failure;
+        try {
+            await this.close();
+            if (cancelled) {
+                await fs_extra_1.default.remove(this.path);
+                (0, runtime_1.logger)().info("Browser Upload Task Stopped:", this.path);
+            }
+            else {
+                (0, runtime_1.logger)().info("Browser Uploaded File:", this.path);
+                if (this.unzip) {
+                    const instanceFiles = new system_file_1.default(this.cwd);
+                    await instanceFiles.unzip(this.path, ".", this.zipCode);
+                    (0, runtime_1.logger)().info("File unzipped:", this.path);
+                }
+            }
+        }
+        catch (error) {
+            failure = error;
+            throw error;
+        }
+        finally {
+            try {
+                // Keep ownership until removal/extraction completes, so a newer upload
+                // cannot start using the same path while this task is still changing it.
+                await this.unlock();
+            }
+            catch (error) {
+                failure ||= error;
+                throw error;
+            }
+            finally {
+                if (this.id != null)
+                    upload_manager_1.default.delete(this.id);
+                this.onFinish?.(failure, cancelled);
+            }
+        }
+    }
+    addWrittenRange(start, end) {
+        if (start >= end)
+            return;
+        let i = 0;
+        let ranges = this.received;
+        while (i < ranges.length && ranges[i].end < start)
+            i++;
+        let mergeStart = start, mergeEnd = end;
+        let removeCount = 0;
+        while (i + removeCount < ranges.length && ranges[i + removeCount].start <= mergeEnd) {
+            mergeStart = Math.min(mergeStart, ranges[i + removeCount].start);
+            mergeEnd = Math.max(mergeEnd, ranges[i + removeCount].end);
+            removeCount++;
+        }
+        ranges.splice(i, removeCount, { start: mergeStart, end: mergeEnd });
+    }
+    isFullyCovered() {
+        return (this.received.length === 1 &&
+            this.received[0].start === 0 &&
+            this.received[0].end === this.size);
+    }
+}
+exports["default"] = FileWriter;
+
+
+/***/ },
+
+/***/ "./plugins/file/src/backend/filepath.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.checkFileName = checkFileName;
+exports.clearUploadFiles = clearUploadFiles;
+exports.normalizedJoin = normalizedJoin;
+const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+const os_1 = __importDefault(__webpack_require__("os"));
+const path_1 = __importDefault(__webpack_require__("path"));
+function checkFileName(fileName) {
+    return (typeof fileName === "string" &&
+        fileName.length > 0 &&
+        fileName !== "." &&
+        fileName !== ".." &&
+        !/[\\/|?*><;":\0]/.test(fileName));
+}
+function clearUploadFiles(file) {
+    if (!file)
+        return;
+    if (file instanceof Array) {
+        file.forEach((v) => {
+            fs_extra_1.default.remove(v.filepath, () => { });
+        });
+    }
+    else {
+        fs_extra_1.default.remove(file.filepath, () => { });
+    }
+}
+function normalizedJoin(...paths) {
+    if (os_1.default.platform() === "win32") {
+        return joinWin32(...paths);
+    }
+    return path_1.default.normalize(path_1.default.join(...paths));
+}
+function joinWin32(...paths) {
+    if (!paths.length)
+        return ".";
+    if (paths.length == 1)
+        return paths[0];
+    const parts = path_1.default.win32.parse(paths[1]);
+    let p;
+    if (parts.root) {
+        p = paths[1];
+    }
+    else {
+        p = path_1.default.normalize(path_1.default.join(paths[0], paths[1]));
+    }
+    if (paths.length <= 2)
+        return p;
+    return joinWin32(p, ...paths.slice(2));
+}
+
+
+/***/ },
+
+/***/ "./plugins/file/src/backend/http_router.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.registerHttpRoutes = registerHttpRoutes;
+const fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+const path_1 = __importDefault(__webpack_require__("path"));
+const file_writer_1 = __importDefault(__webpack_require__("./plugins/file/src/backend/file_writer.ts"));
+const filepath_1 = __webpack_require__("./plugins/file/src/backend/filepath.ts");
+const runtime_1 = __webpack_require__("./plugins/file/src/backend/runtime.ts");
+const system_file_1 = __importDefault(__webpack_require__("./plugins/file/src/backend/system_file.ts"));
+const upload_manager_1 = __importDefault(__webpack_require__("./plugins/file/src/backend/upload_manager.ts"));
+/**
+ * The upload and download HTTP routes.
+ *
+ * Both are authorized by a passport the panel registered over the protocol first
+ * — the server plugin issues those (`passport/register`) — and the upload routes
+ * sit behind the runtime plugin's upload middleware, which the web server mounts ahead of
+ * the body parser.
+ */
+function registerHttpRoutes() {
+    const router = (0, runtime_1.core)().koa.router();
+    // File download route
+    router.get("/download/:key/:fileName", async (ctx) => {
+        const key = ctx.params.key;
+        const paramsFileName = ctx.params.fileName;
+        try {
+            // Get the task from the task center
+            const mission = (0, runtime_1.transfer)().passports.getMission(key, "download");
+            if (!mission)
+                throw new Error((ctx.body = "Access denied: No task found"));
+            const instance = (0, runtime_1.instances)().subsystem.getInstance(mission.parameter.instanceUuid);
+            if (!instance)
+                throw new Error((0, runtime_1.$t)("TXT_CODE_http_router.instanceNotExist"));
+            if (!system_file_1.default.checkFileName(paramsFileName))
+                throw new Error((0, runtime_1.$t)("TXT_CODE_http_router.fileNameNotSpec"));
+            const cwd = instance.absoluteCwdPath();
+            const fileRelativePath = mission.parameter.fileName;
+            // Check for file cross-directory security risks
+            const fileManager = new system_file_1.default(cwd);
+            if (!fileManager.check(fileRelativePath))
+                throw new Error((ctx.body = "Access denied: Invalid destination"));
+            const fileAbsPath = fileManager.toAbsolutePath(fileRelativePath);
+            await (0, runtime_1.transfer)().sendFile(ctx, fileAbsPath);
+        }
+        catch (error) {
+            if (!ctx.res.headersSent) {
+                ctx.body = (0, runtime_1.$t)("TXT_CODE_http_router.downloadErr", { error: error.message });
+                ctx.status = 500;
+            }
+        }
+        finally {
+            (0, runtime_1.transfer)().passports.deleteMission(key);
+        }
+    });
+    // Old version upload route
+    router.post("/upload/:key", async (ctx) => {
+        const key = String(ctx.params.key);
+        const unzip = ctx.query.unzip === "true";
+        const zipCode = String(ctx.query.code);
+        const tmpFiles = ctx.request.files?.file;
+        try {
+            const mission = (0, runtime_1.transfer)().passports.getMission(key, "upload");
+            if (!mission)
+                throw new Error("Access denied: No task found");
+            const instance = (0, runtime_1.instances)().subsystem.getInstance(mission.parameter.instanceUuid);
+            if (!instance)
+                throw new Error("Access denied: No instance found");
+            const uploadDir = mission.parameter.uploadDir;
+            const cwd = instance.absoluteCwdPath();
+            if (tmpFiles) {
+                let uploadedFile;
+                if (tmpFiles instanceof Array) {
+                    uploadedFile = tmpFiles[0];
+                }
+                else if (tmpFiles) {
+                    uploadedFile = tmpFiles;
+                }
+                else {
+                    throw new Error("Empty File!");
+                }
+                const originFileName = uploadedFile.originalFilename || "";
+                if (!system_file_1.default.checkFileName(path_1.default.basename(originFileName)))
+                    throw new Error("Access denied: Malformed file name");
+                const fileManager = new system_file_1.default(cwd);
+                const ext = path_1.default.extname(originFileName);
+                const basename = path_1.default.basename(originFileName, ext);
+                let tempFileSaveName = basename + ext;
+                let counter = 1;
+                while (fs_extra_1.default.existsSync(fileManager.toAbsolutePath(path_1.default.normalize(path_1.default.join(uploadDir, tempFileSaveName)))) &&
+                    ctx.query.overwrite === "false") {
+                    if (counter == 1) {
+                        tempFileSaveName = `${basename}-copy${ext}`;
+                    }
+                    else {
+                        tempFileSaveName = `${basename}-copy-${counter}${ext}`;
+                    }
+                    counter++;
+                }
+                let fileSaveRelativePath = path_1.default.normalize(path_1.default.join(uploadDir, tempFileSaveName));
+                if (!fileManager.checkPath(fileSaveRelativePath))
+                    throw new Error("Access denied: Invalid destination");
+                const fileSaveAbsolutePath = fileManager.toAbsolutePath(fileSaveRelativePath);
+                await fs_extra_1.default.move(uploadedFile.filepath, fileSaveAbsolutePath, {
+                    overwrite: true
+                });
+                if (unzip) {
+                    const instanceFiles = new system_file_1.default(instance.absoluteCwdPath());
+                    await instanceFiles.unzip(fileSaveAbsolutePath, ".", zipCode);
+                }
+                ctx.body = "OK";
+                return;
+            }
+            ctx.body = "Access denied: No file found";
+            ctx.status = 500;
+        }
+        catch (error) {
+            ctx.body = error.message;
+            ctx.status = 500;
+        }
+        finally {
+            (0, runtime_1.transfer)().passports.deleteMission(key);
+            if (tmpFiles)
+                (0, filepath_1.clearUploadFiles)(tmpFiles);
+        }
+    });
+    router.post("/upload-new/:key", async (ctx) => {
+        const key = String(ctx.params.key);
+        const unzip = ctx.query.unzip === "true";
+        const zipCode = String(ctx.query.code);
+        const filename = String(ctx.query.filename);
+        const size = Number(ctx.query.size);
+        if (ctx.query.stop) {
+            const writer = upload_manager_1.default.get(key);
+            if (writer) {
+                await writer.stop();
+                upload_manager_1.default.delete(key);
+                ctx.body = "OK";
+                return;
+            }
+            else {
+                ctx.body = "Access denied: No task found";
+                ctx.status = 500;
+                return;
+            }
+        }
+        try {
+            const mission = (0, runtime_1.transfer)().passports.getMission(key, "upload");
+            if (!mission)
+                throw new Error("Access denied: No task found");
+            const instance = (0, runtime_1.instances)().subsystem.getInstance(mission.parameter.instanceUuid);
+            if (!instance)
+                throw new Error("Access denied: No instance found");
+            const uploadDir = mission.parameter.uploadDir;
+            const cwd = instance.absoluteCwdPath();
+            const overwrite = ctx.query.overwrite !== "false";
+            if (!Number.isSafeInteger(size) || size < 0)
+                throw new Error("Invalid file size");
+            const filePath = await file_writer_1.default.getPath(cwd, uploadDir, filename, overwrite);
+            let fr = upload_manager_1.default.getByPath(filePath);
+            if (fr && size != fr.writer.size) {
+                upload_manager_1.default.delete(fr.id);
+                await fr.writer.stop();
+                fr = undefined;
+            }
+            if (!fr) {
+                const fileWriter = new file_writer_1.default(cwd, filename, size, unzip, zipCode, filePath);
+                await fileWriter.init();
+                const id = upload_manager_1.default.add(fileWriter);
+                fr = { id, writer: fileWriter };
+                const tasks = (0, runtime_1.core)().get("backgroundTasks");
+                tasks?.runRequest(unzip ? "file/upload_extract" : "file/upload", {
+                    _taskOwner: mission.parameter._taskOwner,
+                    instanceUuid: mission.parameter.instanceUuid,
+                    fileName: filename
+                }, () => {
+                    tasks.progress(() => ({
+                        current: fileWriter.received.reduce((sum, range) => sum + range.end - range.start, 0),
+                        total: size,
+                        cancellable: fileWriter.cancellable
+                    }), () => { void fileWriter.stop().catch((err) => (0, runtime_1.core)().logger.warn(err)); });
+                    tasks.follow(new Promise((resolve, reject) => {
+                        fileWriter.onFinish = (error, cancelled) => {
+                            if (error)
+                                reject(error);
+                            else if (cancelled)
+                                reject(Object.assign(new Error("Upload cancelled"), { code: "ABORT_ERR" }));
+                            else
+                                resolve();
+                        };
+                    }));
+                });
+            }
+            if (size === 0)
+                await fr.writer.done();
+            ctx.body = {
+                data: {
+                    id: fr.id,
+                    received: fr.writer.received
+                },
+                status: 200
+            };
+            return;
+        }
+        catch (error) {
+            ctx.body = error.message;
+            ctx.status = 500;
+        }
+        finally {
+            (0, runtime_1.transfer)().passports.deleteMission(key);
+        }
+    });
+    router.post("/upload-piece/:id", async (ctx) => {
+        const id = String(ctx.params.id);
+        const offset = Number(ctx.query.offset);
+        const tmpFiles = ctx.request.files?.file;
+        try {
+            if (!tmpFiles) {
+                ctx.body = "Access denied: No file found";
+                ctx.status = 500;
+            }
+            let uploadedFile;
+            if (tmpFiles instanceof Array) {
+                uploadedFile = tmpFiles[0];
+            }
+            else if (tmpFiles) {
+                uploadedFile = tmpFiles;
+            }
+            else {
+                throw new Error("Empty File!");
+            }
+            const writer = upload_manager_1.default.get(id);
+            if (!writer)
+                throw new Error("Access denied: No task found");
+            const chunk = await fs_extra_1.default.readFile(uploadedFile.filepath);
+            await writer.write(offset, chunk);
+            ctx.body = "OK";
+            return;
+        }
+        catch (error) {
+            ctx.body = error.message;
+            ctx.status = 500;
+        }
+        finally {
+            (0, filepath_1.clearUploadFiles)(tmpFiles);
+        }
+    });
+}
+
+
+/***/ },
+
+/***/ "./plugins/file/src/backend/index.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.inject = void 0;
+exports.apply = apply;
+const i18n_1 = __webpack_require__("./plugins/file/src/i18n/index.ts");
+const file_router_1 = __webpack_require__("./plugins/file/src/backend/file_router.ts");
+const file_service_1 = __webpack_require__("./plugins/file/src/backend/file_service.ts");
+const http_router_1 = __webpack_require__("./plugins/file/src/backend/http_router.ts");
+const runtime_1 = __webpack_require__("./plugins/file/src/backend/runtime.ts");
+const system_file_1 = __importDefault(__webpack_require__("./plugins/file/src/backend/system_file.ts"));
+const upload_manager_1 = __importDefault(__webpack_require__("./plugins/file/src/backend/upload_manager.ts"));
+const settings_1 = __webpack_require__("./plugins/file/src/backend/settings.ts");
+// The daemon's file subsystem.
+//
+// Everything about reading and writing instance files lives here: the
+// `FileManager` that resolves and sandboxes a path, the chunked upload manager,
+// the fourteen `file/*` protocol events and the upload/download HTTP routes.
+//
+// The primitives are handed to the rest of the daemon as `ctx.files`, because
+// instance creation, the Java manager, SteamCMD and the mod service all need to
+// touch files too. Consumers resolve the service through their plugin context,
+// so removing this plugin removes the daemon's
+// ability to touch instance files rather than breaking the build.
+// File routes resolve the instance service when a request arrives. Keeping the
+// dependency lazy avoids a startup cycle: the instance plugin depends on the
+// file primitives, while the file routes only need instances at request time.
+exports.inject = {
+    i18n: { required: true },
+    settings: { required: true },
+    protocol: { required: true },
+    archive: { required: true },
+    transfer: { required: true },
+    koa: { required: true },
+    // File routes resolve the instance subsystem lazily to avoid a startup
+    // cycle: the instance plugin requires the file service in return.
+    instances: { required: false }
+};
+function apply(ctx) {
+    // Before anything else: the modules below read the logger, the configuration,
+    // the instances and `$t` through this handle.
+    (0, runtime_1.setPluginContext)(ctx);
+    ctx.i18n.define(i18n_1.localeMessages);
+    (0, settings_1.registerSettings)(ctx);
+    // `ctx.set()` from inside a plugin belongs to that plugin: the primitives — and
+    // with them the daemon's access to instance files — leave when it unloads.
+    ctx.set("files", {
+        FileManager: system_file_1.default,
+        uploads: upload_manager_1.default,
+        getFileManager: file_service_1.getFileManager,
+        getWindowsDisks: file_service_1.getWindowsDisks
+    });
+    (0, file_router_1.registerFileEvents)();
+    (0, http_router_1.registerHttpRoutes)();
+    // Chunked uploads hold open file handles and lock files, so they are stopped
+    // with the plugin. The daemon used to do this from its own shutdown path.
+    ctx.on("dispose", () => upload_manager_1.default.exit());
+}
+
+
+/***/ },
+
+/***/ "./plugins/file/src/backend/runtime.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.fileTasks = exports.instances = exports.$t = exports.transfer = exports.archive = exports.protocol = exports.settings = exports.logger = void 0;
+exports.setPluginContext = setPluginContext;
+exports.core = core;
+/**
+ * This plugin's private handle on its cordis context.
+ *
+ * The daemon core is bundled into `app.js`, so a plugin cannot import its
+ * singletons. The only channel is the context `apply()` receives, and this
+ * plugin is six modules deep — a `FileManager` throws translated errors, a
+ * `FileWriter` logs from inside a stream callback — so threading a parameter
+ * through all of them would say nothing the accessors below do not.
+ *
+ * A plugin with only a handful of such call sites should pass `ctx` as an
+ * argument instead.
+ */
+let context;
+function setPluginContext(value) {
+    context = value;
+}
+function core() {
+    if (!context)
+        throw new Error("The file plugin has not been initialized yet.");
+    return context;
+}
+/**
+ * `ctx.logger` is bound to this plugin's own cordis scope, so it is gone once
+ * that scope is disposed — and the disposer stops every upload, a path that
+ * logs. Shutting down must not fail on a log line.
+ */
+const SILENT = {
+    info() { },
+    warn() { },
+    error() { },
+    debug() { },
+    success() { },
+    extend: () => SILENT
+};
+const logger = () => core().logger ?? SILENT;
+exports.logger = logger;
+const settings = () => core().settings;
+exports.settings = settings;
+const protocol = () => core().protocol;
+exports.protocol = protocol;
+const archive = () => core().archive;
+exports.archive = archive;
+const transfer = () => core().transfer;
+exports.transfer = transfer;
+const $t = (key, options) => (core().get("i18n")?.$t(key, options) ?? key);
+exports.$t = $t;
+/**
+ * The file plugin can load before the instance plugin. `get()` avoids Cordis'
+ * undeclared-property warning while keeping the existing lazy dependency.
+ */
+const instances = () => {
+    const service = core().get("instances");
+    if (!service)
+        throw new Error("Instance access requires the daemon instance plugin.");
+    return service;
+};
+exports.instances = instances;
+/**
+ * How many file tasks are running across the whole daemon. It used to be
+ * `globalEnv` in the core's configuration module, read by nothing but the file
+ * routes, so it lives with them now.
+ */
+exports.fileTasks = { count: 0 };
+
+
+/***/ },
+
+/***/ "./plugins/file/src/backend/settings.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.registerSettings = registerSettings;
+function registerSettings(ctx) {
+    const config = ctx.settings.config;
+    const $t = ctx.i18n.$t;
+    const speedOptions = (current) => [...new Set([0, 5, 10, 16, 32, 64, 96, 128, 160, 240, 320, 480, current])].map((value) => ({
+        value,
+        label: value === 0
+            ? $t("TXT_CODE_e3a77a77")
+            : value < 16
+                ? `${value * 64}KB/s`
+                : `${value / 16}MB/s`
+    }));
+    ctx.inject(["settingsForm"], (settingsCtx) => settingsCtx.settingsForm.declare({
+        fields: () => [
+            {
+                key: "uploadSpeedRate",
+                type: "select",
+                title: $t("TXT_CODE_fde31068"),
+                description: $t("TXT_CODE_d8d19932"),
+                options: speedOptions(config.uploadSpeedRate)
+            },
+            {
+                key: "downloadSpeedRate",
+                type: "select",
+                title: $t("TXT_CODE_785a0fcf"),
+                description: $t("TXT_CODE_b9fc604c"),
+                options: speedOptions(config.downloadSpeedRate)
+            },
+            {
+                key: "maxDownloadFromUrlFileCount",
+                type: "number",
+                title: $t("TXT_CODE_a15fca22"),
+                description: $t("TXT_CODE_ecaf78a2"),
+                min: 0
+            }
+        ],
+        read: () => ({
+            uploadSpeedRate: config.uploadSpeedRate,
+            downloadSpeedRate: config.downloadSpeedRate,
+            maxDownloadFromUrlFileCount: config.maxDownloadFromUrlFileCount
+        }),
+        write: (values) => {
+            const count = values.maxDownloadFromUrlFileCount;
+            if (count != null && (!Number.isInteger(count) || Number(count) < 0)) {
+                throw new Error($t("TXT_CODE_ecaf78a2"));
+            }
+            if (values.uploadSpeedRate != null)
+                config.uploadSpeedRate = Number(values.uploadSpeedRate);
+            if (values.downloadSpeedRate != null)
+                config.downloadSpeedRate = Number(values.downloadSpeedRate);
+            if (count != null)
+                config.maxDownloadFromUrlFileCount = Number(count);
+            ctx.settings.save();
+        }
+    }));
+}
+
+
+/***/ },
+
+/***/ "./plugins/file/src/backend/system_file.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 fs_extra_1 = __importDefault(__webpack_require__("fs-extra"));
+const iconv_lite_1 = __importDefault(__webpack_require__("iconv-lite"));
+const mcsmanager_common_1 = __webpack_require__("../common/src/index.ts");
+const os_1 = __importDefault(__webpack_require__("os"));
+const path_1 = __importDefault(__webpack_require__("path"));
+const filepath_1 = __webpack_require__("./plugins/file/src/backend/filepath.ts");
+const runtime_1 = __webpack_require__("./plugins/file/src/backend/runtime.ts");
+/** Resolved per use: the module is required before `apply()` runs. */
+const ERROR_MSG_01 = () => (0, runtime_1.$t)("TXT_CODE_system_file.illegalAccess");
+const MAX_EDIT_SIZE = 1024 * 1024 * 5;
+class FileManager {
+    topPath;
+    fileCode;
+    cwd = ".";
+    constructor(topPath = "", fileCode) {
+        this.topPath = topPath;
+        this.fileCode = fileCode;
+        if (!path_1.default.isAbsolute(topPath)) {
+            this.topPath = path_1.default.normalize(path_1.default.join(process.cwd(), topPath));
+        }
+        else {
+            this.topPath = path_1.default.normalize(topPath);
+        }
+        if (!fileCode) {
+            this.fileCode = "utf-8";
+            if ((0, runtime_1.settings)().config.language === "zh_cn")
+                this.fileCode = "gbk";
+        }
+    }
+    isRootTopRath() {
+        return this.topPath === "/" || this.topPath === "\\";
+    }
+    toAbsolutePath(fileName = "") {
+        const topAbsolutePath = this.topPath;
+        if (path_1.default.normalize(fileName).indexOf(topAbsolutePath) === 0) {
+            const resolved = path_1.default.resolve(fileName);
+            this.assertInsideRoot(resolved);
+            return resolved;
+        }
+        let finalPath = "";
+        if (os_1.default.platform() === "win32") {
+            const reg = new RegExp("^[A-Za-z]{1}:[\\\\/]{1}");
+            if (reg.test(this.cwd)) {
+                finalPath = path_1.default.normalize(path_1.default.join(this.cwd, fileName));
+            }
+            else if (reg.test(fileName)) {
+                finalPath = path_1.default.normalize(fileName);
+            }
+        }
+        if (!finalPath) {
+            finalPath = path_1.default.normalize(path_1.default.join(this.topPath, this.cwd, fileName));
+        }
+        this.assertInsideRoot(finalPath);
+        return finalPath;
+    }
+    assertInsideRoot(target) {
+        if (this.isRootTopRath())
+            return;
+        const isInside = (root, candidate) => {
+            const relative = path_1.default.relative(root, candidate);
+            return (relative !== ".." && !relative.startsWith(`..${path_1.default.sep}`) && !path_1.default.isAbsolute(relative));
+        };
+        if (!isInside(this.topPath, target)) {
+            throw new Error(ERROR_MSG_01());
+        }
+        // New files need the same protection as existing files: resolve the nearest
+        // existing parent so a symlink/junction cannot escape an instance directory.
+        if (!fs_extra_1.default.existsSync(this.topPath))
+            return;
+        const realRoot = fs_extra_1.default.realpathSync(this.topPath);
+        let ancestor = target;
+        while (true) {
+            try {
+                fs_extra_1.default.lstatSync(ancestor);
+                break;
+            }
+            catch (error) {
+                if (error.code !== "ENOENT")
+                    throw error;
+            }
+            const parent = path_1.default.dirname(ancestor);
+            if (parent === ancestor)
+                throw new Error(ERROR_MSG_01());
+            ancestor = parent;
+        }
+        if (!isInside(realRoot, fs_extra_1.default.realpathSync(ancestor)))
+            throw new Error(ERROR_MSG_01());
+    }
+    checkPath(fileNameOrPath) {
+        if (this.isRootTopRath())
+            return true;
+        const destAbsolutePath = path_1.default.normalize(this.toAbsolutePath(fileNameOrPath));
+        const topAbsolutePath = path_1.default.normalize(this.topPath);
+        const destPath = destAbsolutePath.endsWith(path_1.default.sep)
+            ? destAbsolutePath.slice(0, -1)
+            : destAbsolutePath;
+        const topPath = topAbsolutePath.endsWith(path_1.default.sep)
+            ? topAbsolutePath.slice(0, -1)
+            : topAbsolutePath;
+        if (destPath.startsWith(topPath)) {
+            const parts = destPath.split(path_1.default.sep);
+            return topPath.split(path_1.default.sep).every((part, index) => {
+                return part === parts[index];
+            });
+        }
+        return false;
+    }
+    check(destPath) {
+        if (this.isRootTopRath())
+            return true;
+        return this.checkPath(destPath) && fs_extra_1.default.existsSync(this.toAbsolutePath(destPath));
+    }
+    cd(dirName) {
+        if (!this.check(dirName))
+            throw new Error(ERROR_MSG_01());
+        this.cwd = (0, filepath_1.normalizedJoin)(this.cwd, dirName);
+    }
+    async list(page, pageSize = 40, searchFileName) {
+        if (pageSize > 100 || pageSize <= 0 || page < 0)
+            throw new Error("Beyond the value limit");
+        // Use withFileTypes option to get file type directly, reducing stat calls
+        const dirents = await fs_extra_1.default.readdir(this.toAbsolutePath(), { withFileTypes: true });
+        // Filter search results and create basic file info with type
+        let filteredItems = dirents
+            .filter((dirent) => !searchFileName || dirent.name.toLowerCase().includes(searchFileName.toLowerCase()))
+            .map((dirent) => ({
+            name: dirent.name,
+            type: dirent.isFile() ? 1 : 0
+        }));
+        const total = filteredItems.length;
+        // Sort: directories first (type 0), then files (type 1), both alphabetically
+        filteredItems.sort((a, b) => {
+            if (a.type !== b.type)
+                return a.type - b.type;
+            return a.name.localeCompare(b.name);
+        });
+        const sliceStart = page * pageSize;
+        const sliceEnd = sliceStart + pageSize;
+        const targetItems = filteredItems.slice(sliceStart, sliceEnd);
+        const statPromises = targetItems.map(async (item) => {
+            try {
+                const info = await fs_extra_1.default.stat(this.toAbsolutePath(item.name));
+                const mode = parseInt(String(parseInt(info.mode?.toString(8), 10)).slice(-3));
+                return {
+                    name: item.name,
+                    size: info.isFile() ? info.size : 0,
+                    time: info.atime.toString(),
+                    mode,
+                    type: item.type
+                };
+            }
+            catch (error) {
+                return {
+                    name: item.name,
+                    size: 0,
+                    time: new Date().toString(),
+                    mode: 0,
+                    type: item.type
+                };
+            }
+        });
+        // Execute all stat operations concurrently
+        const resultList = await Promise.all(statPromises);
+        return {
+            items: resultList,
+            page,
+            pageSize,
+            total,
+            absolutePath: this.toAbsolutePath()
+        };
+    }
+    async chmod(fileName, chmodValue, deep) {
+        if (!this.check(fileName) || isNaN(parseInt(chmodValue)))
+            throw new Error(ERROR_MSG_01());
+        const absPath = this.toAbsolutePath(fileName);
+        const defaultPath = "/bin/chmod";
+        let file = "chmod";
+        if (fs_extra_1.default.existsSync(defaultPath))
+            file = defaultPath;
+        const params = [];
+        if (deep)
+            params.push("-R");
+        params.push(String(chmodValue));
+        params.push(absPath);
+        return await new mcsmanager_common_1.ProcessWrapper(file, params, ".", 60 * 10).start();
+    }
+    async readFile(fileName) {
+        if (!this.check(fileName))
+            throw new Error(ERROR_MSG_01());
+        const absPath = this.toAbsolutePath(fileName);
+        const buf = await fs_extra_1.default.readFile(absPath);
+        const text = iconv_lite_1.default.decode(buf, this.fileCode || "utf-8");
+        return text;
+    }
+    async writeFile(fileName, data) {
+        if (!this.check(fileName))
+            throw new Error(ERROR_MSG_01());
+        const absPath = this.toAbsolutePath(fileName);
+        const buf = iconv_lite_1.default.encode(data, this.fileCode || "utf-8");
+        return await fs_extra_1.default.writeFile(absPath, buf);
+    }
+    async newFile(fileName) {
+        // if (!FileManager.checkFileName(fileName)) throw new Error(ERROR_MSG_01());
+        if (!this.checkPath(fileName))
+            throw new Error(ERROR_MSG_01());
+        const target = this.toAbsolutePath(fileName);
+        await fs_extra_1.default.createFile(target);
+    }
+    /** Exclusive creation: never truncate an existing file or follow its symlink. */
+    async createTextFile(target, text) {
+        if (!this.checkPath(target))
+            throw new Error(ERROR_MSG_01());
+        const content = iconv_lite_1.default.encode(text, this.fileCode || "utf-8");
+        if (content.length > 64 * 1024)
+            throw new Error("File content exceeds 64 KiB");
+        await fs_extra_1.default.writeFile(this.toAbsolutePath(target), content, { flag: "wx" });
+        return true;
+    }
+    /** Unlink one regular file; never recursively remove directories. */
+    async removeFile(target) {
+        if (!this.check(target))
+            throw new Error(ERROR_MSG_01());
+        const absolute = this.toAbsolutePath(target);
+        if (!(await fs_extra_1.default.lstat(absolute)).isFile())
+            throw new Error("Expected a regular file");
+        await fs_extra_1.default.unlink(absolute);
+        return true;
+    }
+    async copy(target1, target2) {
+        if (!this.checkPath(target2) || !this.check(target1))
+            throw new Error(ERROR_MSG_01());
+        const targetPath = this.toAbsolutePath(target1);
+        target2 = this.toAbsolutePath(target2);
+        return await fs_extra_1.default.copy(targetPath, target2);
+    }
+    mkdir(target) {
+        if (!this.checkPath(target))
+            throw new Error(ERROR_MSG_01());
+        const targetPath = this.toAbsolutePath(target);
+        return fs_extra_1.default.mkdirSync(targetPath);
+    }
+    async delete(target) {
+        if (!this.check(target))
+            throw new Error(ERROR_MSG_01());
+        const targetPath = this.toAbsolutePath(target);
+        return new Promise((r, j) => {
+            fs_extra_1.default.remove(targetPath, (err) => {
+                if (!err)
+                    r(true);
+                else
+                    j(err);
+            });
+        });
+    }
+    async move(target, destPath) {
+        if (!this.check(target))
+            throw new Error(ERROR_MSG_01());
+        if (!this.checkPath(destPath))
+            throw new Error(ERROR_MSG_01());
+        const targetPath = this.toAbsolutePath(target);
+        destPath = this.toAbsolutePath(destPath);
+        await fs_extra_1.default.move(targetPath, destPath);
+    }
+    zipFileCheck(path) {
+        const fileInfo = fs_extra_1.default.statSync(path);
+        const MAX_ZIP_GB = (0, runtime_1.settings)().config.maxZipFileSize;
+        if (fileInfo.size > 1024 * 1024 * 1024 * MAX_ZIP_GB)
+            throw new Error((0, runtime_1.$t)("TXT_CODE_system_file.unzipLimit", { max: MAX_ZIP_GB }));
+    }
+    async unzip(sourceZip, destDir, code) {
+        if (!code)
+            code = this.fileCode;
+        if (!this.check(sourceZip) || !this.checkPath(destDir))
+            throw new Error(ERROR_MSG_01());
+        this.zipFileCheck(this.toAbsolutePath(sourceZip));
+        return await (0, runtime_1.archive)().decompress(this.toAbsolutePath(sourceZip), this.toAbsolutePath(destDir), code);
+    }
+    async previewArchive(sourceZip, code) {
+        if (!this.check(sourceZip))
+            throw new Error(ERROR_MSG_01());
+        this.zipFileCheck(this.toAbsolutePath(sourceZip));
+        return await (0, runtime_1.archive)().listArchiveEntries(this.toAbsolutePath(sourceZip), code || this.fileCode);
+    }
+    async zip(sourceZip, files, code) {
+        if (!code)
+            code = this.fileCode;
+        if (!this.checkPath(sourceZip))
+            throw new Error(ERROR_MSG_01());
+        const MAX_ZIP_GB = (0, runtime_1.settings)().config.maxZipFileSize;
+        const MAX_TOTAL_FIELS_SIZE = 1024 * 1024 * 1024 * MAX_ZIP_GB;
+        const sourceZipPath = this.toAbsolutePath(sourceZip);
+        const filesPath = [];
+        let totalSize = 0;
+        for (const iterator of files) {
+            if (this.check(iterator)) {
+                filesPath.push(this.toAbsolutePath(iterator));
+                try {
+                    totalSize += fs_extra_1.default.statSync(this.toAbsolutePath(iterator))?.size;
+                }
+                catch (error) { }
+            }
+        }
+        if (totalSize > MAX_TOTAL_FIELS_SIZE)
+            throw new Error((0, runtime_1.$t)("TXT_CODE_system_file.unzipLimit", { max: MAX_ZIP_GB }));
+        return await (0, runtime_1.archive)().compress(sourceZipPath, filesPath, code);
+    }
+    async edit(target, data) {
+        if (!this.check(target))
+            throw new Error(ERROR_MSG_01());
+        if (data || typeof data === "string") {
+            return await this.writeFile(target, data);
+        }
+        else {
+            const absPath = this.toAbsolutePath(target);
+            const info = fs_extra_1.default.statSync(absPath);
+            if (info.size > MAX_EDIT_SIZE) {
+                throw new Error((0, runtime_1.$t)("TXT_CODE_system_file.execLimit"));
+            }
+            return await this.readFile(target);
+        }
+    }
+    rename(target, newName) {
+        if (!this.check(target))
+            throw new Error(ERROR_MSG_01());
+        if (!this.checkPath(newName))
+            throw new Error(ERROR_MSG_01());
+        const targetPath = this.toAbsolutePath(target);
+        const newPath = this.toAbsolutePath(newName);
+        fs_extra_1.default.renameSync(targetPath, newPath);
+    }
+    static checkFileName(fileName) {
+        return (0, filepath_1.checkFileName)(fileName);
+    }
+}
+exports["default"] = FileManager;
+
+
+/***/ },
+
+/***/ "./plugins/file/src/backend/upload_manager.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+const uuid_1 = __webpack_require__("uuid");
+class UploadManager {
+    uploads = new Map();
+    static timeout = 60 * 60 * 1000; // 1 hour
+    cleanupTimer;
+    startCleanup() {
+        if (this.cleanupTimer)
+            return;
+        this.cleanupTimer = setInterval(async () => {
+            await this.clearExpired();
+        }, 5 * 60 * 1000 // 5 min
+        );
+        this.cleanupTimer.unref();
+    }
+    add(file) {
+        this.startCleanup();
+        const key = (0, uuid_1.v4)();
+        file.id = key;
+        this.uploads.set(key, file);
+        return key;
+    }
+    getUploads() {
+        return this.uploads.entries();
+    }
+    get(key) {
+        return this.uploads.get(key);
+    }
+    delete(key) {
+        return this.uploads.delete(key);
+    }
+    getByPath(path) {
+        for (const [id, writer] of this.uploads.entries()) {
+            if (writer.path == path) {
+                return { id, writer };
+            }
+        }
+        return undefined;
+    }
+    async clearExpired() {
+        const now = Date.now();
+        for (const [key, writer] of this.uploads.entries()) {
+            if (now - writer.lastUpdate > UploadManager.timeout) {
+                try {
+                    await writer.stop();
+                    this.uploads.delete(key);
+                }
+                catch (e) {
+                    console.error(`Failed to stop upload writer for key ${key}:`, e);
+                }
+            }
+        }
+    }
+    async exit() {
+        clearInterval(this.cleanupTimer);
+        this.cleanupTimer = undefined;
+        for (const [key, writer] of this.uploads.entries()) {
+            try {
+                await writer.stop();
+                this.uploads.delete(key);
+            }
+            catch (e) {
+                console.error(`Failed to stop upload writer for key ${key}:`, e);
+            }
+        }
+    }
+}
+const uploadManager = new UploadManager();
+exports["default"] = uploadManager;
+
+
+/***/ },
+
+/***/ "./plugins/file/src/backend/url.ts"
+(__unused_webpack_module, exports) {
+
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.checkSafeUrl = checkSafeUrl;
+function checkSafeUrl(url) {
+    try {
+        const urlObj = new URL(url);
+        if (!["http:", "https:"].includes(urlObj.protocol) || urlObj.username || urlObj.password) {
+            return false;
+        }
+        const hostname = urlObj.hostname.toLowerCase();
+        // Reject IPv6 addresses (IPv6 addresses are wrapped in brackets by URL object)
+        if (hostname.startsWith("[") && hostname.endsWith("]")) {
+            return false;
+        }
+        // Reject IPv4 address format
+        const ipv4Regex = /^(\d{1,3}\.){3}\d{1,3}$/;
+        if (ipv4Regex.test(hostname)) {
+            return false;
+        }
+        // Reject local domains and loopback addresses
+        const localDomains = ["localhost", "127.0.0.1", "0.0.0.0", "::1"];
+        if (localDomains.includes(hostname)) {
+            return false;
+        }
+        // Reject .local domains
+        if (hostname.endsWith(".local")) {
+            return false;
+        }
+        // Must contain at least one dot (ensure it's a valid domain, not a single word)
+        if (!hostname.includes(".")) {
+            return false;
+        }
+        // Domain must have at least a top-level domain (exclude single dot cases)
+        const parts = hostname.split(".");
+        if (parts.length < 2 || parts.some((part) => part.length === 0)) {
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/index.ts"
+(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.localeMessages = void 0;
+const de_DE_json_1 = __importDefault(__webpack_require__("./plugins/file/src/i18n/de_DE.json"));
+const en_US_json_1 = __importDefault(__webpack_require__("./plugins/file/src/i18n/en_US.json"));
+const es_ES_json_1 = __importDefault(__webpack_require__("./plugins/file/src/i18n/es_ES.json"));
+const fr_FR_json_1 = __importDefault(__webpack_require__("./plugins/file/src/i18n/fr_FR.json"));
+const ja_JP_json_1 = __importDefault(__webpack_require__("./plugins/file/src/i18n/ja_JP.json"));
+const ko_KR_json_1 = __importDefault(__webpack_require__("./plugins/file/src/i18n/ko_KR.json"));
+const pt_BR_json_1 = __importDefault(__webpack_require__("./plugins/file/src/i18n/pt_BR.json"));
+const ru_RU_json_1 = __importDefault(__webpack_require__("./plugins/file/src/i18n/ru_RU.json"));
+const th_TH_json_1 = __importDefault(__webpack_require__("./plugins/file/src/i18n/th_TH.json"));
+const tr_TR_json_1 = __importDefault(__webpack_require__("./plugins/file/src/i18n/tr_TR.json"));
+const zh_CN_json_1 = __importDefault(__webpack_require__("./plugins/file/src/i18n/zh_CN.json"));
+const zh_TW_json_1 = __importDefault(__webpack_require__("./plugins/file/src/i18n/zh_TW.json"));
+// The translated errors the file subsystem throws: path sandbox violations, the
+// per-instance task limit and the archive size limit. Registered at setup, so the
+// foundational `plugins/i18n` catalogue carries nothing file-specific.
+exports.localeMessages = {
+    de_de: de_DE_json_1.default,
+    en_us: en_US_json_1.default,
+    es_es: es_ES_json_1.default,
+    fr_fr: fr_FR_json_1.default,
+    ja_jp: ja_JP_json_1.default,
+    ko_kr: ko_KR_json_1.default,
+    pt_br: pt_BR_json_1.default,
+    ru_ru: ru_RU_json_1.default,
+    th_th: th_TH_json_1.default,
+    tr_tr: tr_TR_json_1.default,
+    zh_cn: zh_CN_json_1.default,
+    zh_tw: zh_TW_json_1.default
+};
+
+
+/***/ },
+
+/***/ "events"
+(module) {
+
+module.exports = require("events");
+
+/***/ },
+
+/***/ "fs-extra"
+(module) {
+
+module.exports = require("fs-extra");
+
+/***/ },
+
+/***/ "iconv-lite"
+(module) {
+
+module.exports = require("iconv-lite");
+
+/***/ },
+
+/***/ "os-utils"
+(module) {
+
+module.exports = require("os-utils");
+
+/***/ },
+
+/***/ "proper-lockfile"
+(module) {
+
+module.exports = require("proper-lockfile");
+
+/***/ },
+
+/***/ "uuid"
+(module) {
+
+module.exports = require("uuid");
+
+/***/ },
+
+/***/ "child_process"
+(module) {
+
+module.exports = require("child_process");
+
+/***/ },
+
+/***/ "crypto"
+(module) {
+
+module.exports = require("crypto");
+
+/***/ },
+
+/***/ "fs"
+(module) {
+
+module.exports = require("fs");
+
+/***/ },
+
+/***/ "module"
+(module) {
+
+module.exports = require("module");
+
+/***/ },
+
+/***/ "net"
+(module) {
+
+module.exports = require("net");
+
+/***/ },
+
+/***/ "node:crypto"
+(module) {
+
+module.exports = require("node:crypto");
+
+/***/ },
+
+/***/ "node:fs"
+(module) {
+
+module.exports = require("node:fs");
+
+/***/ },
+
+/***/ "node:os"
+(module) {
+
+module.exports = require("node:os");
+
+/***/ },
+
+/***/ "node:path"
+(module) {
+
+module.exports = require("node:path");
+
+/***/ },
+
+/***/ "os"
+(module) {
+
+module.exports = require("os");
+
+/***/ },
+
+/***/ "path"
+(module) {
+
+module.exports = require("path");
+
+/***/ },
+
+/***/ "process"
+(module) {
+
+module.exports = require("process");
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/de_DE.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_file_router.instanceNotExist":"Instanz {{instanceUuid}} existiert nicht","TXT_CODE_file_router.unzipLimit":"Die maximale Anzahl gleichzeitiger Dekomprimierungsaufgaben wurde überschritten. Maximal sind {{maxFileTask}} zulässig; derzeit werden {{fileLock}} Aufgaben ausgeführt.","TXT_CODE_file_router_service.instanceNotExit":"Instanz {{uuid}} existiert nicht","TXT_CODE_system_file.execLimit":"Maximale Dateibearbeitungsgrenze überschritten","TXT_CODE_system_file.illegalAccess":"Falscher Zugriffspfad","TXT_CODE_system_file.unzipLimit":"Die Dateidekomprimierung unterstützt nur die Dekomprimierung von Dateien bis zu {{max}} GB. Wenn Sie die Obergrenze ändern müssen, gehen Sie bitte zur Datei data/Config/global.json.","TXT_CODE_e3a77a77":"Unbegrenzt","TXT_CODE_fde31068":"Upload -Rate für Benutzerdatei","TXT_CODE_d8d19932":"Begrenzung pro HTTP","TXT_CODE_785a0fcf":"Benutzerdatei -Download -Rate","TXT_CODE_b9fc604c":"Limit pro HTTP -Anforderung, Maximale Datei -Download -Geschwindigkeit","TXT_CODE_a15fca22":"Maximale Downloads von URL","TXT_CODE_ecaf78a2":"0 für unbegrenzt"}');
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/en_US.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_file_router.instanceNotExist":"Instance {{instanceUuid}} does not exist","TXT_CODE_file_router.unzipLimit":"Exceeded the maximum number of concurrent decompression tasks. The maximum allowed is {{maxFileTask}}, and currently, {{fileLock}} tasks are in progress. Please be patient.","TXT_CODE_file_router_service.instanceNotExit":"Instance {{uuid}} does not exist","TXT_CODE_system_file.execLimit":"Exceeded maximum file editing limit","TXT_CODE_system_file.illegalAccess":"Illegal access path","TXT_CODE_system_file.unzipLimit":"File decompression only supports file up to {{max}}GB. To change this limit, please go to the data/Config/global.json file.","TXT_CODE_e3a77a77":"Unlimited","TXT_CODE_fde31068":"User file upload rate","TXT_CODE_d8d19932":"Limit per HTTP request, maximum file upload speed","TXT_CODE_785a0fcf":"User file download rate","TXT_CODE_b9fc604c":"Limit per HTTP request, maximum file download speed","TXT_CODE_a15fca22":"Maximum of download from URL","TXT_CODE_ecaf78a2":"Set to 0 to unlimited"}');
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/es_ES.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_file_router.instanceNotExist":"La instancia {{instanceUuid}} no existe","TXT_CODE_file_router.unzipLimit":"Se ha excedido el número máximo de tareas de descompresión simultáneas. El máximo permitido es {{maxFileTask}}. Actualmente hay {{fileLock}} tareas en progreso.","TXT_CODE_file_router_service.instanceNotExit":"La instancia {{uuid}} no existe","TXT_CODE_system_file.execLimit":"Se superó el límite máximo de edición de archivos","TXT_CODE_system_file.illegalAccess":"Ruta de acceso incorrecta","TXT_CODE_system_file.unzipLimit":"La descompresión de archivos solo admite la descompresión de archivos de hasta {{max}} GB. Si necesita cambiar el límite superior, vaya al archivo data/Config/global.json.","TXT_CODE_e3a77a77":"Ilimitado","TXT_CODE_fde31068":"Tasa de carga de archivo de usuario","TXT_CODE_d8d19932":"Límite por solicitud HTTP, velocidad máxima de carga de archivo","TXT_CODE_785a0fcf":"Tasa de descarga de archivos de usuario","TXT_CODE_b9fc604c":"Límite por solicitud HTTP, velocidad máxima de descarga de archivo","TXT_CODE_a15fca22":"Máximo de descargas desde URL","TXT_CODE_ecaf78a2":"Establecer en 0 para ilimitado"}');
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/fr_FR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_file_router.instanceNotExist":"L\'instance {{instanceUuid}} n\'existe pas","TXT_CODE_file_router.unzipLimit":"Le nombre maximum de tâches de décompression simultanées a été dépassé. Le maximum autorisé est de {{maxFileTask}}. Il y a actuellement {{fileLock}} tâches en cours.","TXT_CODE_file_router_service.instanceNotExit":"L\'instance {{uuid}} n\'existe pas","TXT_CODE_system_file.execLimit":"Limite maximale de modification de fichier dépassée","TXT_CODE_system_file.illegalAccess":"Mauvais chemin d\'accès","TXT_CODE_system_file.unzipLimit":"La décompression de fichiers ne prend en charge que la décompression de fichiers jusqu\'à {{max}} Go. Si vous devez modifier la limite supérieure, veuillez accéder au fichier data/Config/global.json.","TXT_CODE_e3a77a77":"Illimité","TXT_CODE_fde31068":"Taux de téléchargement de fichiers utilisateur","TXT_CODE_d8d19932":"Limite par demande HTTP, vitesse maximale de téléchargement de fichiers","TXT_CODE_785a0fcf":"Taux de téléchargement des fichiers utilisateur","TXT_CODE_b9fc604c":"Limite par demande HTTP, vitesse de téléchargement de fichiers maximum","TXT_CODE_a15fca22":"Maximum de téléchargements depuis l\'URL","TXT_CODE_ecaf78a2":"Mettre 0 pour illimité"}');
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/ja_JP.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_file_router.instanceNotExist":"インスタンス {{instanceUuid}} は存在しません","TXT_CODE_file_router.unzipLimit":"同時解凍タスクの最大数は {{maxFileTask}} を超えています。現在進行中のタスクは {{fileLock}} です。しばらくお待ちください。","TXT_CODE_file_router_service.instanceNotExit":"インスタンス {{uuid}} は存在しません","TXT_CODE_system_file.execLimit":"ファイル編集の最大制限を超えました","TXT_CODE_system_file.illegalAccess":"間違ったアクセスパス","TXT_CODE_system_file.unzipLimit":"ファイルの解凍では、最大 {{max}} GB のファイルの解凍のみがサポートされます。上限を変更する必要がある場合は、data/Config/global.json ファイルに移動してください。","TXT_CODE_e3a77a77":"無制限","TXT_CODE_fde31068":"ユーザーファイルのアップロードレート","TXT_CODE_d8d19932":"HTTPリクエストごとに制限、最大ファイルアップロード速度","TXT_CODE_785a0fcf":"ユーザーファイルのダウンロードレート","TXT_CODE_b9fc604c":"HTTP要求ごとに制限、最大ファイルのダウンロード速度","TXT_CODE_a15fca22":"URLからの最大ダウンロード数","TXT_CODE_ecaf78a2":"0で無制限に設定"}');
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/ko_KR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_file_router.instanceNotExist":"{{instanceUuid}} 인스턴스가 존재하지 않습니다.","TXT_CODE_file_router.unzipLimit":"동시 압축 해제 작업의 최대 개수는 {{maxFileTask}}개를 초과했습니다. 현재 진행 중인 작업은 {{fileLock}}개입니다.","TXT_CODE_file_router_service.instanceNotExit":"{{uuid}} 인스턴스가 존재하지 않습니다.","TXT_CODE_system_file.execLimit":"최대 파일 편집 제한을 초과했습니다.","TXT_CODE_system_file.illegalAccess":"잘못된 액세스 경로","TXT_CODE_system_file.unzipLimit":"파일 압축 해제는 최대 {{max}}GB까지의 파일 압축 해제만 지원합니다. 상한을 변경해야 하는 경우 data/Config/global.json 파일로 이동하세요.","TXT_CODE_e3a77a77":"제한 없는","TXT_CODE_fde31068":"사용자 파일 업로드 속도","TXT_CODE_d8d19932":"HTTP 요청 당 제한, 최대 파일 업로드 속도","TXT_CODE_785a0fcf":"사용자 파일 다운로드 속도","TXT_CODE_b9fc604c":"HTTP 요청 당 제한, 최대 파일 다운로드 속도","TXT_CODE_a15fca22":"URL 최대 다운로드 수","TXT_CODE_ecaf78a2":"0으로 설정 시 무제한"}');
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/pt_BR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_file_router.instanceNotExist":"A instância {{instanceUuid}} não existe","TXT_CODE_file_router.unzipLimit":"Excedido o número máximo de tarefas de descompressão simultâneas. O máximo permitido é {{maxFileTask}}, e atualmente, {{fileLock}} tarefas estão em andamento. Por favor, seja paciente.","TXT_CODE_file_router_service.instanceNotExit":"A instância {{uuid}} não existe","TXT_CODE_system_file.execLimit":"Limite máximo de edição de arquivos excedido","TXT_CODE_system_file.illegalAccess":"Caminho de acesso ilegal","TXT_CODE_system_file.unzipLimit":"A descompactação de arquivos suporta apenas arquivos de até {{max}}GB. Para alterar esse limite, vá até o arquivo data/Config/global.json.","TXT_CODE_e3a77a77":"Ilimitado","TXT_CODE_fde31068":"Taxa de upload de arquivos do usuário","TXT_CODE_d8d19932":"Limite por solicitação HTTP, velocidade máxima de upload do arquivo","TXT_CODE_785a0fcf":"Taxa de download de arquivos do usuário","TXT_CODE_b9fc604c":"Limite por solicitação HTTP, velocidade máxima de download de arquivo","TXT_CODE_a15fca22":"Máximo de downloads por URL","TXT_CODE_ecaf78a2":"Defina 0 para ilimitado"}');
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/ru_RU.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_file_router.instanceNotExist":"Экземпляр {{instanceUuid}} не существует","TXT_CODE_file_router.unzipLimit":"Превышено максимальное количество одновременных задач разархивирования. Максимально допустимое количество — {{maxFileTask}}, в настоящее время выполняется {{fileLock}} задач. Пожалуйста, будьте терпеливы.","TXT_CODE_file_router_service.instanceNotExit":"Экземпляр {{uuid}} не существует","TXT_CODE_system_file.execLimit":"Превышен лимит редактирования файлов","TXT_CODE_system_file.illegalAccess":"Незаконный путь доступа","TXT_CODE_system_file.unzipLimit":"Распаковка файлов поддерживается только для файлов до {{max}}GB. Чтобы изменить этот лимит, пожалуйста, перейдите в файл data/Config/global.json.","TXT_CODE_e3a77a77":"Неограничено","TXT_CODE_fde31068":"Пользовательская скорость загрузки файлов","TXT_CODE_d8d19932":"Ограничение на HTTP -запрос, максимальная скорость загрузки файлов","TXT_CODE_785a0fcf":"Пользовательская скорость загрузки файлов","TXT_CODE_b9fc604c":"Ограничение на HTTP -запрос, максимальная скорость загрузки файлов","TXT_CODE_a15fca22":"Максимум загрузок по URL","TXT_CODE_ecaf78a2":"0 - без ограничений"}');
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/th_TH.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_file_router.instanceNotExist":"ไม่พบอินสแตนซ์ {{instanceUuid}}","TXT_CODE_file_router.unzipLimit":"เกินจำนวนงานคลายการบีบอัดพร้อมกันสูงสุด อนุญาตสูงสุด {{maxFileTask}} งาน และขณะนี้มี {{fileLock}} งานกำลังดำเนินการ กรุณารอสักครู่","TXT_CODE_file_router_service.instanceNotExit":"ไม่พบอินสแตนซ์ {{uuid}}","TXT_CODE_system_file.execLimit":"เกินขีดจำกัดการแก้ไขไฟล์สูงสุด","TXT_CODE_system_file.illegalAccess":"เส้นทางการเข้าถึงไม่ถูกต้อง","TXT_CODE_system_file.unzipLimit":"การแตกไฟล์รองรับไฟล์ขนาดไม่เกิน {{max}}GB หากต้องการเปลี่ยนขีดจำกัดนี้ กรุณาไปที่ไฟล์ data/Config/global.json","TXT_CODE_e3a77a77":"ไม่จำกัด","TXT_CODE_fde31068":"อัตราการอัปโหลดไฟล์ผู้ใช้","TXT_CODE_d8d19932":"ขีด จำกัด ต่อคำขอ HTTP ความเร็วในการอัปโหลดไฟล์สูงสุด","TXT_CODE_785a0fcf":"อัตราการดาวน์โหลดไฟล์ผู้ใช้","TXT_CODE_b9fc604c":"ขีด จำกัด ต่อคำขอ HTTP ความเร็วในการดาวน์โหลดไฟล์สูงสุด","TXT_CODE_a15fca22":"จำนวนสูงสุดของการดาวน์โหลดจาก URL","TXT_CODE_ecaf78a2":"ตั้งเป็น 0 สำหรับไม่จำกัด"}');
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/tr_TR.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_file_router.instanceNotExist":"Örnek {{instanceUuid}} mevcut değil","TXT_CODE_file_router.unzipLimit":"Eşzamanlı dekompresyon görevlerinin maksimum sayısı aşıldı. İzin verilen maksimum sayı {{maxFileTask}} ve şu anda {{fileLock}} görevleri devam ediyor. Lütfen sabırlı olun.","TXT_CODE_file_router_service.instanceNotExit":"Örnek {{uuid}} mevcut değil","TXT_CODE_system_file.execLimit":"Maksimum dosya düzenleme sınırı aşıldı","TXT_CODE_system_file.illegalAccess":"Yasadışı erişim yolu","TXT_CODE_system_file.unzipLimit":"Dosya açma yalnızca {{max}}GB\'a kadar olan dosyaları destekler. Bu sınırı değiştirmek için lütfen data/Config/global.json dosyasına gidin.","TXT_CODE_e3a77a77":"Sınırsız","TXT_CODE_fde31068":"Kullanıcı Dosyası Yükleme Oranı","TXT_CODE_d8d19932":"HTTP isteği başına sınır, maksimum dosya yükleme hızı","TXT_CODE_785a0fcf":"Kullanıcı Dosyası İndirme Oranı","TXT_CODE_b9fc604c":"HTTP İsteği Başına Limit, Maksimum Dosya İndirme Hızı","TXT_CODE_a15fca22":"URL\'den maksimum indirme","TXT_CODE_ecaf78a2":"Sınırsız için 0\'a ayarla"}');
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/zh_CN.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_file_router.instanceNotExist":"实例 {{instanceUuid}} 不存在","TXT_CODE_file_router.unzipLimit":"超出最大同时解压缩任务量，最大准许{{maxFileTask}}个，目前有{{fileLock}}个任务正在进行，请耐心等待","TXT_CODE_file_router_service.instanceNotExit":"实例 {{uuid}} 不存在","TXT_CODE_system_file.execLimit":"超出最大文件编辑限制","TXT_CODE_system_file.illegalAccess":"非法访问路径","TXT_CODE_system_file.unzipLimit":"文件解压缩只支持最大 {{max}}GB 文件的解压缩，如需改变上限请前往 data/Config/global.json 文件","TXT_CODE_e3a77a77":"无限制","TXT_CODE_fde31068":"用户上传文件速率","TXT_CODE_d8d19932":"限制每个 HTTP 请求，上传文件最大速度","TXT_CODE_785a0fcf":"用户下载文件速率","TXT_CODE_b9fc604c":"限制每个 HTTP 请求，下载文件最大速度","TXT_CODE_a15fca22":"从URL下载文件最大任务数","TXT_CODE_ecaf78a2":"设置为 0 为无限制"}');
+
+/***/ },
+
+/***/ "./plugins/file/src/i18n/zh_TW.json"
+(module) {
+
+module.exports = /*#__PURE__*/JSON.parse('{"TXT_CODE_file_router.instanceNotExist":"實例 {{instanceUuid}} 不存在","TXT_CODE_file_router.unzipLimit":"超出最大同時解壓縮任務量，最大允許{{maxFileTask}}個，目前有{{fileLock}}個任務正在進行，請耐心等待","TXT_CODE_file_router_service.instanceNotExit":"實例 {{uuid}} 不存在","TXT_CODE_system_file.execLimit":"超出最大檔案編輯限制","TXT_CODE_system_file.illegalAccess":"錯誤存取路徑","TXT_CODE_system_file.unzipLimit":"檔案解壓縮只支援最大 {{max}}GB 檔案的解壓縮，如需改變上限請前往 data/Config/global.json 檔案","TXT_CODE_e3a77a77":"無限制","TXT_CODE_fde31068":"使用者上傳檔案速率","TXT_CODE_d8d19932":"限制每個 HTTP 請求，上傳檔案最大速度","TXT_CODE_785a0fcf":"使用者下載檔案速率","TXT_CODE_b9fc604c":"限制每個 HTTP 請求，下載檔案最大速度","TXT_CODE_a15fca22":"網址下載上限","TXT_CODE_ecaf78a2":"設為 0 表示無限制"}');
+
+/***/ }
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// 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;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	
+/******/ 	// startup
+/******/ 	// Load entry module and return exports
+/******/ 	// This entry module is referenced by other modules so it can't be inlined
+/******/ 	var __webpack_exports__ = __webpack_require__("./plugins/file/src/backend/index.ts");
+/******/ 	module.exports = __webpack_exports__;
+/******/ 	
+/******/ })()
+;