@nsnanocat/preference-panes 1.1.1 → 1.1.3

package/dist/api.js

@@ -960,201 +960,6 @@
     	}
     }
 
-    /* https://github.com/ljharb/qs */
-    /**
-     * 轻量 `qs` 查询字符串工具。
-     * Lightweight `qs` query-string utilities.
-     *
-     * 说明:
-     * Notes:
-     * - 参考 `qs` 的 `parse` / `stringify` 接口设计
-     * - Modeled after the `qs` `parse` / `stringify` API
-     * - `parse` 保持当前项目原有 `$argument` 字符串解析语义
-     * - `parse` preserves the existing `$argument` string parsing semantics
-     * - `stringify` 基于项目内 `Lodash` 路径能力展开对象
-     * - `stringify` expands objects via the in-project `Lodash` path helpers
-     *
-     * 参考:
-     * Reference:
-     * - https://github.com/ljharb/qs
-     * - https://www.npmjs.com/package/qs
-     */
-    class qs {
-    	/**
-    	 * 将查询字符串解析为对象。
-    	 * Parse a query string into an object.
-    	 *
-    	 * @param {string | Record<string, unknown> | null | undefined} [query=""] 查询字符串或对象 / Query string or object.
-    	 * @returns {Record<string, unknown>}
-    	 */
-    	static parse(query) {
-    		let result = {};
-    		switch (typeof query) {
-    			case "string": {
-    				const source = query.replace(/^\?/, "");
-    				if (!source) break;
-    				const obj = Object.fromEntries(
-    					source
-    						.split("&")
-    						.filter(Boolean)
-    						.map(item => {
-    							const [rawKey = "", rawValue = ""] = item.split("=", 2);
-    							const key = qs.#decode(rawKey).replace(/\[([^\[\]]+)\]/g, ".$1");
-    							return [key, qs.#decode(rawValue).replace(/\"/g, "")];
-    						}),
-    				);
-    				Object.keys(obj).forEach(key => Lodash.set(result, key, obj[key]));
-    				break;
-    			}
-    			case "object": {
-    				switch (query) {
-    					case null:
-    						break;
-    					default: {
-    						const obj = {};
-    						Object.keys(query).forEach(key => Lodash.set(obj, key, query[key]));
-    						result = obj;
-    						break;
-    					}
-    				}
-    				break;
-    			}
-    			case "undefined":
-    				result = {};
-    				break;
-    		}
-    		return result;
-    	}
-
-    	/**
-    	 * 将对象序列化为查询字符串。
-    	 * Serialize an object into a query string.
-    	 *
-    	 * @param {Record<string, unknown>} [object={}] 输入对象 / Input object.
-    	 * @returns {string}
-    	 */
-    	static stringify(object = {}) {
-    		if (!object || typeof object !== "object") return "";
-
-    		const entries = [];
-    		Object.keys(object).forEach(key => qs.#collect(object, key, entries));
-
-    		if (entries.length === 0) return "";
-    		return entries
-    			.map(([key, value]) => `${qs.#encode(qs.#formatPath(key))}=${qs.#encode(value)}`)
-    			.join("&");
-    	}
-
-    	/**
-    	 * 收集待序列化的键值对。
-    	 * Collect key-value pairs for stringification.
-    	 *
-    	 * @param {Record<string, unknown>} object 输入对象 / Input object.
-    	 * @param {string} path 当前路径 / Current path.
-    	 * @param {[string, string][]} entries 输出数组 / Output entries.
-    	 * @returns {void}
-    	 */
-    	static #collect(object, path, entries) {
-    		const value = Lodash.get(object, path);
-    		if (value === undefined) return;
-    		if (value === null) {
-    			entries.push([path, ""]);
-    			return;
-    		}
-    		if (Array.isArray(value)) {
-    			value.forEach((item, index) => {
-    				if (item === undefined) return;
-    				qs.#collect(object, `${path}[${index}]`, entries);
-    			});
-    			return;
-    		}
-    		if (qs.#isPlainObject(value)) {
-    			Object.keys(value).forEach(key => qs.#collect(object, `${path}.${key}`, entries));
-    			return;
-    		}
-    		entries.push([path, String(value)]);
-    	}
-
-    	/**
-    	 * 使用 `Lodash.toPath` 规范化输出路径。
-    	 * Normalize output path via `Lodash.toPath`.
-    	 *
-    	 * @param {string} path 原始路径 / Raw path.
-    	 * @returns {string}
-    	 */
-    	static #formatPath(path) {
-    		const [head, ...tail] = Lodash.toPath(path);
-    		return tail.reduce((result, segment) => (/^\d+$/.test(segment) ? `${result}[${segment}]` : `${result}.${segment}`), head);
-    	}
-
-    	/**
-    	 * 判断值是否为普通对象。
-    	 * Check whether a value is a plain object.
-    	 *
-    	 * @param {unknown} value 输入值 / Input value.
-    	 * @returns {boolean}
-    	 */
-    	static #isPlainObject(value) {
-    		if (value === null || typeof value !== "object" || Array.isArray(value)) return false;
-    		const proto = Object.getPrototypeOf(value);
-    		return proto === null || proto === Object.prototype;
-    	}
-
-    	/**
-    	 * 编码查询字符串片段。
-    	 * Encode a query-string fragment.
-    	 *
-    	 * @param {string} value 原始值 / Raw value.
-    	 * @returns {string}
-    	 */
-    	static #encode(value) {
-    		return encodeURIComponent(value);
-    	}
-
-    	/**
-    	 * 解码查询字符串片段。
-    	 * Decode a query-string fragment.
-    	 *
-    	 * @param {string} value 编码值 / Encoded value.
-    	 * @returns {string}
-    	 */
-    	static #decode(value) {
-    		return decodeURIComponent(value.replace(/\+/g, " "));
-    	}
-    }
-
-    /**
-     * 统一 `$argument` 输入格式并展开深路径。
-     * Normalize `$argument` input format and expand deep paths.
-     *
-     * 平台差异:
-     * Platform differences:
-     * - Surge / Stash / Egern 常见为字符串参数: `a=1&b=2`
-     * - Surge / Stash / Egern usually pass string args: `a=1&b=2`
-     * - Loon 支持字符串和对象两种形态
-     * - Loon supports both string and object forms
-     * - Quantumult X / Shadowrocket 一般不提供 `$argument`
-     * - Quantumult X / Shadowrocket usually do not expose `$argument`
-     *
-     * 执行时机:
-     * Execution timing:
-     * - 该模块为即时执行模块，`import` 时立即处理全局 `$argument`
-     * - This module executes immediately and mutates global `$argument` on import
-     *
-     * 归一化规则补充:
-     * Normalization details:
-     * - 使用 `globalThis.$argument` 读写，避免运行环境下未声明变量引用问题
-     * - Read/write via `globalThis.$argument` to avoid undeclared variable access
-     * - 当 `$argument` 为 `null` 或 `undefined` 时，会重置为 `{}`
-     * - When `$argument` is `null` or `undefined`, it is normalized to `{}`
-     */
-    (() => {
-    	Console.debug("☑️ $argument");
-    	globalThis.$argument = qs.parse(globalThis.$argument);
-    	if (globalThis.$argument.LogLevel) Console.logLevel = globalThis.$argument.LogLevel;
-    	Console.debug("✅ $argument", `$argument: ${JSON.stringify(globalThis.$argument)}`);
-    })();
-
     /**
      * HTTP 状态码文本映射表。
      * HTTP status code to status text map.
@@ -1327,304 +1132,6 @@
     	}
     }
 
-    /**
-     * 统一请求参数。
-     * Unified request payload.
-     *
-     * @typedef {object} FetchRequest
-     * @property {string} url 请求地址 / Request URL.
-     * @property {string} [method] 请求方法 / HTTP method.
-     * @property {Record<string, any>} [headers] 请求头 / Request headers.
-     * @property {string|ArrayBuffer|ArrayBufferView|object} [body] 请求体 / Request body.
-     * @property {ArrayBuffer} [bodyBytes] 二进制请求体 / Binary request body.
-     * @property {number|string} [timeout] 超时（秒或毫秒）/ Timeout (seconds or milliseconds).
-     * @property {string} [policy] 指定策略 / Preferred policy.
-     * @property {boolean} [redirection] 是否跟随重定向 / Whether to follow redirects.
-     * @property {boolean} ["auto-redirect"] 平台重定向字段 / Platform redirect flag.
-     * @property {boolean|number|string} ["auto-cookie"] Worker / Node.js Cookie 开关 / Worker / Node.js Cookie toggle.
-     * @property {Record<string, any>} [opts] 平台扩展字段 / Platform extension fields.
-     */
-
-    /**
-     * 统一响应结构。
-     * Unified response payload.
-     *
-     * @typedef {object} FetchResponse
-     * @property {boolean} ok 请求是否成功 / Whether request is successful.
-     * @property {number} status 状态码 / HTTP status code.
-     * @property {number} [statusCode] 状态码别名 / Status code alias.
-     * @property {string} [statusText] 状态文本 / HTTP status text.
-     * @property {Record<string, any>} [headers] 响应头 / Response headers.
-     * @property {string|ArrayBuffer} [body] 响应体 / Response body.
-     * @property {ArrayBuffer} [bodyBytes] 二进制响应体 / Binary response body.
-     */
-
-    /**
-     * 跨平台 `fetch` 适配层。
-     * Cross-platform `fetch` adapter.
-     *
-     * 设计目标:
-     * Design goal:
-     * - 仿照 Web API `fetch`（`Window.fetch`）接口设计
-     * - Modeled after Web API `fetch` (`Window.fetch`)
-     * - 统一 VPN App、Worker 与 Node.js 环境中的请求调用
-     * - Unify request calls across VPN apps, Worker, and Node.js
-     *
-     * 功能:
-     * Features:
-     * - 统一 Quantumult X / Loon / Surge / Stash / Egern / Shadowrocket / Worker / Node.js 请求接口
-     * - Normalize request APIs across Quantumult X / Loon / Surge / Stash / Egern / Shadowrocket / Worker / Node.js
-     * - 统一返回体字段（`ok/status/statusText/body/bodyBytes`）
-     * - Normalize response fields (`ok/status/statusText/body/bodyBytes`)
-     *
-     * 与 Web `fetch` 的已知差异:
-     * Known differences from Web `fetch`:
-     * - 支持 `policy`、`auto-redirect` 等平台扩展字段
-     * - Supports platform extension fields like `policy` and `auto-redirect`
-     * - Worker / Node.js 共享基于 `fetch` 的请求分支
-     * - Worker / Node.js share the `fetch`-based request branch
-     * - Node.js ESM 的 `auto-cookie` 由 `fetch.node.mjs` 处理，本文件只使用宿主 `fetch`
-     * - Node.js ESM `auto-cookie` is handled by `fetch.node.mjs`; this module only uses the host `fetch`
-     * - 非浏览器平台通过 `$httpClient/$task` 实现，不是原生 Fetch 实现
-     * - Non-browser platforms use `$httpClient/$task` instead of native Fetch engine
-     * - 返回结构包含 `statusCode/bodyBytes` 等兼容字段
-     * - Response includes compatibility fields like `statusCode/bodyBytes`
-     *
-     * @link https://developer.mozilla.org/en-US/docs/Web/API/Window/fetch
-     * @link https://developer.mozilla.org/zh-CN/docs/Web/API/Window/fetch
-     * @async
-     * @param {FetchRequest|string} resource 请求对象或 URL / Request object or URL string.
-     * @param {Partial<FetchRequest>} [options={}] 追加参数 / Extra options.
-     * @returns {Promise<FetchResponse>}
-     */
-    async function fetch(resource, options = {}) {
-    	// 初始化参数。
-    	// Initialize request input.
-    	switch (typeof resource) {
-    		case "object":
-    			resource = { ...options, ...resource };
-    			break;
-    		case "string":
-    			resource = { ...options, url: resource };
-    			break;
-    		case "undefined":
-    		default:
-    			throw new TypeError(`${Function.name}: 参数类型错误, resource 必须为对象或字符串`);
-    	}
-    	// 自动判断请求方法。
-    	// Infer the HTTP method automatically.
-    	if (!resource.method) {
-    		resource.method = "GET";
-    		if (resource.body ?? resource.bodyBytes) resource.method = "POST";
-    	}
-    	// 移除需要由底层实现自动生成的请求头。
-    	// Remove headers that should be generated by the underlying runtime.
-    	delete resource.headers?.Host;
-    	delete resource.headers?.[":authority"];
-    	delete resource.headers?.["Content-Length"];
-    	delete resource.headers?.["content-length"];
-    	// 统一请求方法为小写，方便后续索引平台 API。
-    	// Normalize the method to lowercase for platform API lookups.
-    	const method = resource.method.toLocaleLowerCase();
-    	// 默认请求超时时间为 5 秒。
-    	// Default request timeout to 5 seconds.
-    	if (!resource.timeout) resource.timeout = 5;
-    	if (resource.timeout) {
-    		resource.timeout = Number.parseInt(resource.timeout, 10);
-    		// 统一先转换为秒，大于 500 视为毫秒输入。
-    		// Convert to seconds first and treat values above 500 as milliseconds.
-    		if (resource.timeout > 500) resource.timeout = Math.round(resource.timeout / 1000);
-    	}
-    	if (resource.timeout) {
-    		switch ($app) {
-    			case "Loon":
-    			case "Quantumult X":
-    			case "Worker":
-    			case "Node.js":
-    				// 这些平台要求毫秒，因此把秒重新换算为毫秒。
-    				// These platforms expect milliseconds, so convert seconds back to milliseconds.
-    				resource.timeout = resource.timeout * 1000;
-    				break;
-    		}
-    	}
-    	// 根据当前平台选择请求实现。
-    	// Select the request engine for the current platform.
-    	switch ($app) {
-    		case "Loon":
-    		case "Surge":
-    		case "Stash":
-    		case "Egern":
-    		case "Shadowrocket":
-    			// 转换通用请求参数到 `$httpClient` 语义。
-    			// Map shared request fields to `$httpClient` semantics.
-    			if (resource.policy) {
-    				switch ($app) {
-    					case "Loon":
-    						resource.node = resource.policy;
-    						break;
-    					case "Stash":
-    						Lodash.set(resource, "headers.X-Stash-Selected-Proxy", encodeURI(resource.policy));
-    						break;
-    					case "Shadowrocket":
-    						Lodash.set(resource, "headers.X-Surge-Proxy", resource.policy);
-    						break;
-    				}
-    			}
-    			if (typeof resource.redirection === "boolean") resource["auto-redirect"] = resource.redirection;
-    			// 优先把 `bodyBytes` 映射回 `$httpClient` 能接受的 `body`。
-    			// Prefer mapping `bodyBytes` back to the `body` field expected by `$httpClient`.
-    			if (resource.bodyBytes && !resource.body) {
-    				resource.body = resource.bodyBytes;
-    				resource.bodyBytes = undefined;
-    			}
-    			// 根据 `Accept` 推断是否需要二进制响应体。
-    			// Infer whether the response should be treated as binary from `Accept`.
-    			switch ((resource.headers?.Accept || resource.headers?.accept)?.split(";")?.[0]) {
-    				case "application/protobuf":
-    				case "application/x-protobuf":
-    				case "application/vnd.google.protobuf":
-    				case "application/vnd.apple.flatbuffer":
-    				case "application/grpc":
-    				case "application/grpc-web":
-    				case "application/grpc+proto":
-    				case "application/octet-stream":
-    					resource["binary-mode"] = true;
-    					break;
-    			}
-    			// 发送 `$httpClient` 请求并归一化返回结构。
-    			// Send the `$httpClient` request and normalize the response payload.
-    			return new Promise((resolve, reject) => {
-    				globalThis.$httpClient[method](resource, (error, response, body) => {
-    					if (error) reject(error);
-    					else {
-    						response.ok = /^2\d\d$/.test(response.status);
-    						response.statusCode = response.status;
-    						response.statusText = StatusTexts[response.status];
-    						if (body) {
-    							response.body = body;
-    							if (resource["binary-mode"] == true) response.bodyBytes = body;
-    						}
-    						resolve(response);
-    					}
-    				});
-    			});
-    		case "Quantumult X":
-    			// 转换 Quantumult X 专有请求参数。
-    			// Map request fields to Quantumult X specific options.
-    			if (resource.policy) Lodash.set(resource, "opts.policy", resource.policy);
-    			if (typeof resource["auto-redirect"] === "boolean") Lodash.set(resource, "opts.redirection", resource["auto-redirect"]);
-    			// Quantumult X 使用 `bodyBytes` 传输二进制请求体。
-    			// Quantumult X uses `bodyBytes` for binary request payloads.
-    			if (resource.body instanceof ArrayBuffer) {
-    				resource.bodyBytes = resource.body;
-    				resource.body = undefined;
-    			} else if (ArrayBuffer.isView(resource.body)) {
-    				resource.bodyBytes = resource.body.buffer.slice(resource.body.byteOffset, resource.body.byteLength + resource.body.byteOffset);
-    				resource.body = undefined;
-    			} else if (resource.body) resource.bodyBytes = undefined;
-    			// 发送请求，并用 `Promise.race` 提供统一超时保护。
-    			// Send the request and enforce timeout with `Promise.race`.
-    			return Promise.race([
-    				globalThis.$task.fetch(resource).then(
-    					response => {
-    						response.ok = /^2\d\d$/.test(response.statusCode);
-    						response.status = response.statusCode;
-    						response.statusText = StatusTexts[response.status];
-    						switch ((response.headers?.["Content-Type"] ?? response.headers?.["content-type"])?.split(";")?.[0]) {
-    							case "application/protobuf":
-    							case "application/x-protobuf":
-    							case "application/vnd.google.protobuf":
-    							case "application/vnd.apple.flatbuffer":
-    							case "application/grpc":
-    							case "application/grpc-web":
-    							case "application/grpc+proto":
-    							case "application/octet-stream":
-    								response.body = response.bodyBytes;
-    								break;
-    						}
-    						response.bodyBytes = undefined;
-    						return response;
-    					},
-    					reason => Promise.reject(reason.error),
-    				),
-    				new Promise((resolve, reject) => {
-    					setTimeout(() => {
-    						reject(new Error(`${Function.name}: 请求超时, 请检查网络后重试`));
-    					}, resource.timeout);
-    				}),
-    			]);
-    		case "Worker":
-    		case "Node.js":
-    		default: {
-    			let request;
-    			let timeout;
-    			let shouldWrapError = false;
-    			switch ($app) {
-    				case "Worker":
-    				case "Node.js":
-    					switch (typeof globalThis.fetch) {
-    						case "function":
-    							break;
-    						default:
-    							throw new Error(`${Function.name}: 当前运行环境不支持 Fetch API`);
-    					}
-    					// 将通用字段映射到 Worker / Node.js Fetch 语义。
-    					// Map shared fields to Worker / Node.js Fetch semantics.
-    					resource.redirect = resource.redirection ? "follow" : "manual";
-    					request = resource;
-    					timeout = resource.timeout;
-    					shouldWrapError = true;
-    					break;
-    				default: {
-    					// 未识别宿主也可使用完整标准 Fetch API；不将能力推断为宿主类型。
-    					// An unrecognized host may still use the complete standard Fetch API; capability does not imply a host type.
-    					if (typeof globalThis.fetch !== "function" || typeof globalThis.Headers !== "function" || typeof globalThis.Request !== "function" || typeof globalThis.Response !== "function") {
-    						throw new Error(`${Function.name}: 当前运行环境不支持 Fetch API`);
-    					}
-    					const { url, bodyBytes, redirection, timeout: _timeout, policy: _policy, "auto-redirect": _autoRedirect, "auto-cookie": _autoCookie, opts: _opts, ...fetchOptions } = resource;
-    					if (bodyBytes !== undefined && fetchOptions.body === undefined) fetchOptions.body = bodyBytes;
-    					fetchOptions.redirect = redirection ? "follow" : "manual";
-    					request = { url, ...fetchOptions };
-    					timeout = resource.timeout * 1000;
-    					break;
-    				}
-    			}
-    			const { url, ...options } = request;
-    			// 发起请求并归一化响应头、文本与二进制响应体。
-    			// Send the request and normalize headers, text, and binary response data.
-    			const responsePromise = globalThis.fetch(url, options).then(async response => {
-    				const bodyBytes = await response.arrayBuffer();
-    				let headers;
-    				try {
-    					headers = response.headers.raw();
-    				} catch {
-    					headers = Array.from(response.headers.entries()).reduce((acc, [key, value]) => {
-    						acc[key] = acc[key] ? [...acc[key], value] : [value];
-    						return acc;
-    					}, {});
-    				}
-    				return {
-    					ok: response.ok ?? /^2\d\d$/.test(response.status),
-    					status: response.status,
-    					statusCode: response.status,
-    					statusText: response.statusText,
-    					body: new TextDecoder("utf-8").decode(bodyBytes),
-    					bodyBytes: bodyBytes,
-    					headers: Object.fromEntries(Object.entries(headers).map(([key, value]) => [key, key.toLowerCase() !== "set-cookie" ? value.toString() : value])),
-    				};
-    			});
-    			return Promise.race([
-    				shouldWrapError ? responsePromise.catch(error => Promise.reject(error.message)) : responsePromise,
-    				new Promise((_resolve, reject) => {
-    					setTimeout(() => {
-    						reject(new Error(`${Function.name}: 请求超时, 请检查网络后重试`));
-    					}, timeout);
-    				}),
-    			]);
-    		}
-    	}
-    }
-
     /**
      * 跨平台持久化存储适配器。
      * Cross-platform persistent storage adapter.
@@ -1921,11 +1428,9 @@
         return parts;
     }
 
-    const MISSING = Symbol("missing");
-
     /**
-     * PreferencePanes 后端 API，只处理模块数据和持久化请求。
-     * PreferencePanes backend API handling only module data and persistence requests.
+     * PreferencePanes 后端 API，只提供通用持久化操作。
+     * PreferencePanes backend API providing generic persistence operations only.
      */
     class API {
         /**
@@ -1947,141 +1452,122 @@
         }
 
         /**
-         * 处理 `/api/{module}` 及其动作，不接管页面或静态资源。
-         * Handle `/api/{module}` and its actions without intercepting pages or static assets.
+         * 处理固定存储动作，不接管模块配置、页面或静态资源。
+         * Handle fixed storage actions without intercepting module configurations, pages, or static assets.
          * @param {import("./index.js").SettingsRequest} request 代理请求 / Proxy request.
          * @returns {Promise<import("./index.js").SettingsResponse | undefined>} API 响应或未接管 / API response or pass-through.
          */
         async handle(request) {
             const url = new URL(request.url);
-            const match = /^\/api\/([a-zA-Z0-9_-]+)(?:\/(get|set|delete))?\/?$/.exec(url.pathname);
-            if (!match) return;
-            const [, module, action] = match;
-            const configuration = `${url.origin}/configs/${module}`;
-            switch (true) {
-                case !action && request.method === "HEAD":
-                    return this.#probe(request, configuration);
-                case Boolean(action) && request.method === "POST":
-                    return this.#action(request, module, action, configuration);
-                default:
-                    return this.#response(request, 405, { error: "Use HEAD for module probes and POST for module actions" });
-            }
+            const action = /^\/api\/(get|set|delete)$/.exec(url.pathname)?.[1];
+            if (action) return this.#store(request, action);
+            return;
         }
 
-        async #probe(request, configuration) {
-            let result;
+        /**
+         * 使用唯一 form 字段中的完整 @root.path 执行存储操作。
+         * Execute a storage operation using the complete @root.path from the sole form field.
+         * @param {import("./index.js").SettingsRequest} request 代理请求 / Proxy request.
+         * @param {"get" | "set" | "delete"} action 存储动作 / Storage action.
+         * @returns {import("./index.js").SettingsResponse} 操作响应 / Operation response.
+         */
+        #store(request, action) {
+            const reply = (status, data) => this.#response(request, status, data);
+            if (request.method !== "POST") return reply(405, { error: "Use POST with a form body" });
+            const headers = Object.fromEntries(Object.entries(request.headers ?? {}).map(([key, value]) => [key.toLowerCase(), value]));
+            if (headers["content-type"]?.split(";")[0].trim().toLowerCase() !== "application/x-www-form-urlencoded") return reply(415, { error: "Expected application/x-www-form-urlencoded" });
+            if (typeof request.body !== "string" || request.body.length > 65536) return reply(400, { error: "Expected a form body up to 65536 characters" });
+            let parts, value;
             try {
-                result = await fetch({ url: configuration, method: "HEAD", timeout: 5000, headers: { Accept: "application/json" } });
+                const fields = request.body.split("&");
+                if (fields.length !== 1) throw new TypeError("Send exactly one storage key");
+                const separator = fields[0].indexOf("=");
+                if (separator < 0) throw new TypeError("Expected @root.path=value");
+                const key = decodeURIComponent(fields[0].slice(0, separator).replace(/\+/g, " "));
+                value = decodeURIComponent(fields[0].slice(separator + 1).replace(/\+/g, " "));
+                if (!key.startsWith("@")) throw new TypeError("Storage keys must start with @");
+                parts = validatePathParts(key.slice(1).split("."));
+                if (parts.length < 2) throw new TypeError("Specify a storage root and child path");
             } catch (error) {
-                return this.#response(request, 502, { error: error.message });
+                return reply(400, { error: error.message });
             }
-            const version = this.#header(result.headers, "x-preferencepanes-version");
-            return this.#response(request, result.statusCode ?? result.status, undefined, version ? { "X-PreferencePanes-Version": version } : {});
-        }
-
-        async #action(request, module, action, configuration) {
-            const payload = this.#jsonBody(request);
-            const target = await this.#load(module, configuration);
-            switch (action) {
-                case "get": {
-                    const value = Storage.getItem(payload?.scope ? this.#scopePath(target, payload.scope) : this.#storagePath(target, payload?.key), MISSING);
-                    return value === MISSING ? this.#response(request, 404, { error: "Stored path does not exist" }) : this.#response(request, 200, value);
-                }
-                case "set":
-                    if (!Object.hasOwn(payload ?? {}, "value")) throw Object.assign(new TypeError("A value is required"), { status: 400 });
-                    if (!Storage.setItem(this.#storagePath(target, payload.key), payload.value)) throw new Error("Storage write failed");
-                    return this.#response(request, 200, { saved: true });
-                case "delete": {
-                    const path = payload?.scope ? this.#scopePath(target, payload.scope) : this.#storagePath(target, payload?.key);
-                    if (!Storage.removeItem(path)) throw new Error("Storage write failed");
-                    return this.#response(request, 200, { deleted: true });
+            if (action === "set") {
+                try {
+                    value = JSON.parse(value);
+                } catch (error) {
+                    if (!(error instanceof SyntaxError)) throw error;
                 }
             }
-        }
-
-        async #load(module, configuration) {
-            let result;
+            const [storageKey, ...path] = parts;
             try {
-                result = await fetch({ url: configuration, method: "GET", timeout: 5000, headers: { Accept: "application/json" } });
-            } catch (error) {
-                throw Object.assign(new Error(`Configuration request failed: ${error.message}`), { status: 502 });
-            }
-            const status = result.statusCode ?? result.status;
-            if (status !== 200) throw Object.assign(new Error(`Configuration HTTP ${status}`), { status });
-            try {
-                const body = typeof result.body === "string" ? result.body : new TextDecoder().decode(result.body);
-                const boxjs = JSON.parse(body);
-                const apps = Array.isArray(boxjs) ? [{ settings: boxjs }] : (boxjs.apps ?? [boxjs]);
-                if (!Array.isArray(apps)) throw new TypeError("Expected BoxJS apps array");
-                const entries = [];
-                let storageKey;
-                for (const app of apps) {
-                    if (!app || !Array.isArray(app.settings)) throw new TypeError("Expected BoxJS settings array");
-                    for (const entry of app.settings) {
-                        if (typeof entry.id !== "string") throw new TypeError("BoxJS settings require string IDs");
-                        if (!entry.id.startsWith("@")) {
-                            if (Array.isArray(boxjs)) throw new TypeError("BoxJS settings require @root.path IDs");
-                            continue;
-                        }
-                        const [root, ...parts] = entry.id.slice(1).split(".");
-                        if (!root || root.startsWith("@") || parts.length < 2) throw new TypeError("A BoxJS setting must be below a literal storage root and module");
-                        validatePathParts(parts);
-                        if (parts[0] !== module) continue;
-                        if (storageKey && storageKey !== root) throw new TypeError(`A module must use one storage root: ${module}`);
-                        storageKey = root;
-                        entries.push(entry);
+                const root = Storage.getItem(storageKey, {});
+                if (!isRecord(root)) throw new TypeError("Stored root must be an object");
+                const parent = storageParent(root, path, action === "set");
+                const key = path.at(-1);
+                switch (action) {
+                    case "get": {
+                        const result = parent ? Lodash.get(parent, [key]) : undefined;
+                        return result === undefined ? reply(404, { error: "Stored path does not exist" }) : reply(200, result);
                     }
+                    case "set":
+                        Lodash.set(parent, [key], value);
+                        break;
+                    case "delete":
+                        if (parent) Lodash.unset(parent, [key]);
+                        break;
                 }
-                if (!entries.length) throw new TypeError(`No BoxJS settings for module: ${module}`);
-                return { entries, module, storageKey, version: this.#header(result.headers, "x-preferencepanes-version") };
-            } catch (error) {
-                throw Object.assign(new Error(`Invalid BoxJS: ${error.message}`), { status: 422 });
-            }
-        }
-
-        #jsonBody(request) {
-            const headers = Object.fromEntries(Object.entries(request.headers ?? {}).map(([key, value]) => [key.toLowerCase(), value]));
-            if (headers["content-type"]?.split(";")[0].trim().toLowerCase() !== "application/json") throw Object.assign(new TypeError("Expected application/json"), { status: 415 });
-            if (typeof request.body !== "string" || request.body.length > 65536) throw Object.assign(new TypeError("Expected a JSON body up to 65536 characters"), { status: 400 });
-            try {
-                return JSON.parse(request.body);
+                if (!Storage.setItem(storageKey, root)) throw new Error("Storage write failed");
+                return reply(200, action === "set" ? { saved: true } : { deleted: true });
             } catch (error) {
-                throw Object.assign(error, { status: 400 });
+                return reply(500, { error: error.message });
             }
         }
 
-        #storagePath(target, key) {
-            if (typeof key !== "string") throw Object.assign(new TypeError("A BoxJS field path is required"), { status: 400 });
-            const path = `@${target.storageKey}.${key}`;
-            if (!target.entries.some(entry => entry.id === path)) throw Object.assign(new TypeError(`Unknown BoxJS field: ${key}`), { status: 400 });
-            return path;
-        }
-
-        #scopePath(target, scope) {
-            switch (scope) {
-                case "settings":
-                    return `@${target.storageKey}.${target.module}.Settings`;
-                case "caches":
-                    return `@${target.storageKey}.${target.module}.Caches`;
-                case "module":
-                    return `@${target.storageKey}.${target.module}`;
-                default:
-                    throw Object.assign(new TypeError("Scope must be settings, caches or module"), { status: 400 });
-            }
-        }
-
-        #response(request, status, body, extraHeaders = {}) {
+        #response(request, status, body) {
             return {
                 status,
-                headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff", ...extraHeaders },
+                headers: { "Content-Type": "application/json; charset=utf-8", "Cache-Control": "no-store", "X-Content-Type-Options": "nosniff" },
                 body: request.method === "HEAD" ? "" : JSON.stringify(body),
             };
         }
+    }
+
+    /**
+     * 判断存储根是否为普通对象。
+     * Determine whether a storage root is a plain object.
+     * @param {unknown} value 待检查值 / Value to inspect.
+     * @returns {boolean} 是否为普通对象 / Whether this is a plain object.
+     */
+    function isRecord(value) {
+        return value !== null && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype;
+    }
 
-        #header(headers, name) {
-            const entry = Object.entries(headers ?? {}).find(([key]) => key.toLowerCase() === name);
-            return entry?.[1] === undefined ? undefined : String(entry[1]).trim();
+    /**
+     * 遍历父路径，并解码旧存储中的 JSON 字符串中间节点。
+     * Traverse parent paths and decode legacy intermediate nodes stored as JSON strings.
+     * @param {Record<string, unknown>} root 存储根 / Storage root.
+     * @param {string[]} parts 完整路径 / Complete path.
+     * @param {boolean} create 是否创建缺失节点 / Whether to create missing parents.
+     * @returns {object | undefined} 父节点或 undefined / Parent node or undefined.
+     */
+    function storageParent(root, parts, create) {
+        let parent = root;
+        for (const part of parts.slice(0, -1)) {
+            let next = Lodash.get(parent, [part]);
+            switch (typeof next) {
+                case "undefined":
+                    if (!create) return;
+                    next = {};
+                    break;
+                case "string":
+                    next = JSON.parse(next);
+                    break;
+            }
+            if (!isRecord(next) && !Array.isArray(next)) throw new TypeError("Stored parent is not an object or array");
+            Lodash.set(parent, [part], next);
+            parent = next;
         }
+        return parent;
     }
 
     new API().run();